Rename crate

Cargo.lock

 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
-name = "elastic"
+name = "itoa"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
+
+[[package]]
+name = "kappe"
 version = "0.1.0"
 dependencies = [
  "lazy_static",
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "itoa"
-version = "0.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"

Cargo.toml

 [package]
-name = "elastic"
+name = "kappe"
 version = "0.1.0"
 authors = ["Dylan Baker <dylan@simulacrum.party>"]
 edition = "2018"

Makefile

-elastic:
+kappe:
 	wasm-pack build --target web

src/compiler.rs

 
 use std::fmt::{Display, Formatter};
 
-use crate::error::ElasticError;
+use crate::error::KappeError;
 use crate::parser::{Field, Identifier, Select};
 
 #[derive(Debug, PartialEq)]
     }
 }
 
-pub fn compile(expr: Select) -> Result<Query, ElasticError> {
+pub fn compile(expr: Select) -> Result<Query, KappeError> {
     let field_names: Vec<Value> = expr
         .fields
         .iter()
     use crate::lexer::scan;
     use crate::parser::parse;
 
-    fn _compile(input: &str) -> Result<Query, ElasticError> {
+    fn _compile(input: &str) -> Result<Query, KappeError> {
         let tokens = scan(input).unwrap();
         let select = parse(tokens).unwrap();
         compile(select)

src/error.rs

 use std::{error::Error, fmt, fmt::Display};
 
 #[derive(Debug, PartialEq)]
-pub struct ElasticError {
+pub struct KappeError {
     pub message: String,
 }
 
-impl ElasticError {
+impl KappeError {
     pub fn new(message: &str) -> Self {
         Self {
             message: message.to_string(),
     }
 }
 
-impl Display for ElasticError {
+impl Display for KappeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", &self.message)
     }
 }
 
-impl Error for ElasticError {}
+impl Error for KappeError {}
 
-impl From<ElasticError> for std::io::Error {
-    fn from(e: ElasticError) -> Self {
+impl From<KappeError> for std::io::Error {
+    fn from(e: KappeError) -> Self {
         Self::new(std::io::ErrorKind::InvalidInput, e.message)
     }
 }

src/lexer.rs

 use lazy_static::lazy_static;
 use regex::Regex;
 
-use crate::error::ElasticError;
+use crate::error::KappeError;
 use crate::token::{Token, TokenType};
 
 #[derive(Debug)]
     ];
 }
 
-pub fn scan(input: &str) -> Result<Vec<Token>, ElasticError> {
+pub fn scan(input: &str) -> Result<Vec<Token>, KappeError> {
     let mut tokens: Vec<Token> = vec![];
     let mut position = 0;
 
         }
 
         if !matched {
-            return Err(ElasticError::new("Unrecognized sequence"));
+            return Err(KappeError::new("Unrecognized sequence"));
         }
     }
 

src/parser.rs

 use std::{iter::Peekable, slice::Iter};
 
-use crate::error::ElasticError;
+use crate::error::KappeError;
 use crate::token::{Token, TokenType};
 
 #[derive(Debug, PartialEq)]
     }
 }
 
-pub fn parse(tokens: Vec<Token>) -> Result<Select, ElasticError> {
+pub fn parse(tokens: Vec<Token>) -> Result<Select, KappeError> {
     parse_select_expression(&mut tokens.iter().peekable())
 }
 
-fn parse_select_expression(tokens: &mut Peekable<Iter<Token>>) -> Result<Select, ElasticError> {
+fn parse_select_expression(tokens: &mut Peekable<Iter<Token>>) -> Result<Select, KappeError> {
     eat(tokens, TokenType::Select)?;
     let fields = parse_fields(tokens)?;
     eat(tokens, TokenType::From)?;
     Ok(Select { fields, source })
 }
 
-fn parse_fields(tokens: &mut Peekable<Iter<Token>>) -> Result<Vec<Field>, ElasticError> {
+fn parse_fields(tokens: &mut Peekable<Iter<Token>>) -> Result<Vec<Field>, KappeError> {
     if current_token_is(tokens, TokenType::Star) {
         eat(tokens, TokenType::Star).and_then(|_| Ok(vec![Field::Star]))
     } else {
 fn eat<'a>(
     tokens: &'a mut Peekable<Iter<Token>>,
     token_type: TokenType,
-) -> Result<&'a Token, ElasticError> {
+) -> Result<&'a Token, KappeError> {
     match tokens.next() {
         Some(token) => {
             if token.token_type == token_type {
                 Ok(token)
             } else {
-                Err(ElasticError::new(&format!(
+                Err(KappeError::new(&format!(
                     "Expected {} but got {}",
                     token_type, token.token_type
                 )))
             }
         }
-        None => Err(ElasticError::new("Unexpected end of tokens")),
+        None => Err(KappeError::new("Unexpected end of tokens")),
     }
 }
 
     use super::*;
     use crate::lexer::scan;
 
-    fn _parse(input: &str) -> Result<Select, ElasticError> {
+    fn _parse(input: &str) -> Result<Select, KappeError> {
         let tokens = scan(input).unwrap();
         parse(tokens)
     }