Add main function

src/error.rs

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

src/lexer.rs

@@ -1,34 +1,8 @@
 use lazy_static::lazy_static;
 use regex::Regex;
 
-#[derive(Debug, PartialEq)]
-pub struct LexerError {
-    message: String,
-}
-
-#[derive(Debug, PartialEq)]
-pub struct Token {
-    token_type: TokenType,
-    value: String,
-}
-
-impl Token {
-    pub fn new(token_type: TokenType, value: &str) -> Self {
-        Token {
-            token_type,
-            value: value.to_string(),
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum TokenType {
-    Identfiier,
-    Keyword,
-    Number,
-    Star,
-    String,
-}
+use crate::error::LexerError;
+use crate::token::{Token, TokenType};
 
 #[derive(Debug)]
 struct Matcher {
@@ -67,7 +41,6 @@ pub fn scan(input: &str) -> Result<Vec<Token>, LexerError> {
 
         for matcher in MATCHERS.iter() {
             if matcher.regex.is_match(&input[position..]) {
-                dbg!(&input[position..]);
                 if let Some(m) = matcher.regex.captures_iter(&input[position..]).next() {
                     let value = if m.len() > 1 { &m[1] } else { &m[0] };
                     position += value.len();

src/lib.rs

@@ -1 +1,3 @@
-mod lexer;
+pub mod error;
+pub mod lexer;
+pub mod token;

src/main.rs

@@ -1,3 +1,13 @@
-fn main() {
-    println!("Hello, world!");
+use elastic::lexer;
+
+use std::env;
+
+fn main() -> std::io::Result<()> {
+    let args: Vec<String> = env::args().into_iter().skip(1).collect();
+    let input = args.join(" ");
+    let tokens = lexer::scan(&input)?;
+    for token in tokens {
+        println!("{}", token);
+    }
+    Ok(())
 }

src/token.rs

@@ -0,0 +1,49 @@
+#[derive(Debug, PartialEq)]
+pub struct Token {
+    token_type: TokenType,
+    value: String,
+}
+
+impl Token {
+    pub fn new(token_type: TokenType, value: &str) -> Self {
+        Token {
+            token_type,
+            value: value.to_string(),
+        }
+    }
+}
+
+impl std::fmt::Display for Token {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            r#"{{ type: {}, value: "{}" }}"#,
+            self.token_type, self.value
+        )
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TokenType {
+    Identfiier,
+    Keyword,
+    Number,
+    Star,
+    String,
+}
+
+impl std::fmt::Display for TokenType {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TokenType::Identfiier => "Identifier",
+                TokenType::Keyword => "Keyword",
+                TokenType::Number => "Number",
+                TokenType::Star => "Star",
+                TokenType::String => "String",
+            }
+        )
+    }
+}