Merge pull request #3

Refactor into generic DataSource

Author: J-Cake

Cargo.toml

@@ -10,7 +10,6 @@ edition = "2021"
 nom = "7.1.3"
 nom-unicode = "0.3.0"
 backtrace = "0.3.74"
-smallvec = "2.0.0-alpha.7"
 
 [profile.dev]
 opt-level = 0

examples/parse.rs

@@ -1,90 +1,47 @@
-use std::{
-    cell::RefCell,
-    rc::Rc
-};
-use std::io::Write;
 use expression::{
+    eval::Object,
     Context,
-    DataSource,
-    Row,
-    eval::Object
+    DataSource
 };
+use std::io::Write;
 
-/// This struct implements a friendly way to represent a row of a table.
-/// The `Row` trait marks this structure with the necessary methods to be useful
-///
-/// This example uses interior mutability because `DataSource` trait works with owned types such as `Rc`s.
-#[derive(Clone)]
-struct ExampleRow {
-    inner: Rc<RefCell<RowInner>>
-}
-
-struct RowInner {
-    col1: String,
-    col2: f64
-}
-
-impl Row for ExampleRow {
-    fn fields(&self) -> impl Iterator<Item = impl AsRef<str>> + Clone {
-        vec!["col1", "col2"].into_iter()
-    }
-
-    fn get(&self, field: &str) -> Option<Object> {
-        let inner = self.inner.borrow();
-
-        match field {
-            "col1" => Some(Object::String(inner.col1.clone())),
-            "col2" => Some(Object::Number(inner.col2)),
-            _ => None
-        }
-    }
-}
-
-struct ExampleProvider<Rows: Row> {
-    columns: Vec<String>,
-    rows: Vec<Rows>,
+struct ExampleProvider {
+    values: Vec<String>
 }
 
-impl<Rows: Row + Clone> DataSource for ExampleProvider<Rows> {
-    type Rows = Rows;
-
-    fn list_columns(&self) -> impl Iterator<Item=impl AsRef<str>> {
-        self.columns.clone().into_iter()
-    }
-
-    fn rows(&self) -> impl Iterator<Item=Self::Rows> {
-        self.rows.iter()
-            .cloned()
-    }
-
-    fn row(&self, row: usize) -> Option<Self::Rows> {
-        self.rows.get(row)
-            .cloned()
-    }
+impl DataSource for ExampleProvider {
+    fn query(&self, query: impl AsRef<str>) -> Option<Object> {
+        let index = query.as_ref().parse::<usize>().ok()?;
 
-    fn num_rows(&self) -> usize {
-        self.rows.len()
+        self.values.get(index)
+            .map(|i| Object::String(i.clone()))
     }
 }
 
-pub fn main() {
-    let cx = Context::new(ExampleProvider::<ExampleRow> {
-        columns: vec![
-            "col1".to_owned(),
-            "col2".to_owned(),
-        ],
-        rows: vec![]
+pub fn main() -> std::io::Result<()> {
+    let cx = Context::new(ExampleProvider {
+        values: Vec::new()
     });
 
     let parser = cx.parse_context();
 
-    let program = std::env::args().nth(1).unwrap();
+    let mut buffer = String::new();
+
+    eprint!("> ");
+    std::io::stderr().flush()?;
 
-    print!("{}: ", &program);
-    std::io::stdout().flush().unwrap();
+    while let Ok(len) = std::io::stdin().read_line(&mut buffer) {
+        let program = buffer[0..len].trim();
 
-    match parser.parse(program) {
-        Ok(result) => println!("{:#?}", result),
-        Err(err) => println!("Error: {:?}", err)
+        match parser.parse(program) {
+            Ok(result) => println!("{:#?}", result),
+            Err(err) => println!("Error: {:?}", err)
+        }
+
+        eprint!("> ");
+        std::io::stderr().flush()?;
+        buffer.clear();
     }
+
+    Ok(())
 }

examples/repl.rs

@@ -0,0 +1,50 @@
+use std::io::Write;
+use expression::{
+    Context,
+    DataSource,
+    eval::Object
+};
+
+struct RowInner {
+    col1: String,
+    col2: f64
+}
+
+struct ExampleProvider {
+    values: Vec<String>
+}
+
+impl DataSource for ExampleProvider {
+    fn query(&self, query: impl AsRef<str>) -> Option<Object> {
+        let index = query.as_ref().parse::<usize>().ok()?;
+
+        self.values.get(index)
+            .map(|i| Object::String(i.clone()))
+    }
+}
+
+pub fn main() -> std::io::Result<()> {
+    let cx = Context::new(ExampleProvider {
+        values: vec![]
+    });
+
+    let mut buffer = String::new();
+
+    eprint!("> ");
+    std::io::stderr().flush()?;
+
+    while let Ok(len) = std::io::stdin().read_line(&mut buffer) {
+        let program = buffer[0..len].trim();
+
+        match cx.evaluate(program) {
+            Ok(result) => println!("{:#?}", result),
+            Err(err) => println!("Error: {:?}", err)
+        }
+
+        eprint!("> ");
+        std::io::stderr().flush()?;
+        buffer.clear();
+    }
+
+    Ok(())
+}