Adds basic vuejs functionnality, implements RecipeCategory custom field

cookbook/.env

@@ -0,0 +1 @@
+DATABASE_URL=db.sqlite3

cookbook/Cargo.toml

@@ -5,3 +5,6 @@ authors = ["artus <artus@landoftheunicorn.hd.free.fr>"]
 edition = "2018"
 
 [dependencies]
+libsqlite3-sys = { version = "*", features = ["bundled"] }
+diesel = { version = "1.4.1", features = ["sqlite"] }
+dotenv = "0.9.0"

cookbook/diesel.toml

@@ -0,0 +1,5 @@
+# For documentation on how to configure this file,
+# see diesel.rs/guides/configuring-diesel-cli
+
+[print_schema]
+file = "src/schema.rs"

cookbook/migrations/2019-01-27-201901_create_recipes/down.sql

@@ -0,0 +1,2 @@
+-- This file should undo anything in `up.sql`
+DROP TABLE recipes

cookbook/migrations/2019-01-27-201901_create_recipes/up.sql

@@ -0,0 +1,8 @@
+-- Your SQL goes here
+CREATE TABLE recipes (
+  id INTEGER PRIMARY KEY NOT NULL,
+  title VARCHAR NOT NULL,
+  category INTEGER NOT NULL,
+  ingredients TEXT NOT NULL,
+  preparation TEXT NOT NULL
+)

cookbook/migrations/2019-01-28-141711_create_ingredients/down.sql

@@ -0,0 +1,2 @@
+-- This file should undo anything in `up.sql`
+DROP TABLE ingredients

cookbook/migrations/2019-01-28-141711_create_ingredients/up.sql

@@ -0,0 +1,5 @@
+-- Your SQL goes here
+CREATE TABLE ingredients (
+  id INTEGER PRIMARY KEY NOT NULL,
+  alias VARCHAR NOT NULL
+)

cookbook/src/bin/show_recipes.rs

@@ -0,0 +1,22 @@
+extern crate cookbook;
+extern crate diesel;
+
+use self::cookbook::*;
+use self::models::*;
+use self::diesel::prelude::*;
+
+fn main() {
+    use cookbook::schema::recipes::dsl::*;
+
+    let conn = establish_connection();
+    let result = recipes
+        .load::<Recipe>(&conn)
+        .expect("Error loading recipes");
+
+    println!("Here are {} recipes :", result.len());
+    for rec in result {
+        println!("*************\n{}\n({:?})", rec.title, rec.category);
+        println!("-------------\n");
+        println!("{}", rec.ingredients);
+    }
+}

cookbook/src/bin/write_recipe.rs

@@ -0,0 +1,83 @@
+extern crate cookbook;
+extern crate diesel;
+
+use std::io::{Read, stdin};
+use diesel::SqliteConnection;
+use self::cookbook::*;
+use self::models::{NewRecipe, fields::RecipeCategory};
+
+struct CreateRecipe<'a> {
+    connection: &'a SqliteConnection,
+    title: &'a str,
+    category: Option<RecipeCategory>,
+    ingredients: String,
+}
+
+impl<'a> CreateRecipe<'a> {
+    fn new(conn: &'a SqliteConnection) -> Self {
+        CreateRecipe{
+            connection: conn,
+            title: "New recipe",
+            category: None,
+            ingredients: String::new(),
+        }
+    }
+
+    fn set_title(&mut self, title: &'a str) {
+        self.title = title;
+    }
+
+    fn add_ingredient(&mut self, name: String) {
+        use crate::ingredients::*;
+
+        // Check it exists or create
+        if let Some(_ingdt) = find(self.connection, &name) {
+            println!("=");
+        } else {
+            create(self.connection, &name);
+            println!("+{}", &name);
+        }
+
+        self.ingredients.push_str(&name);
+    }
+
+    /// Builds a NewRecipe instance from current data and insert it.
+    fn insert(self) {
+        let new_recipe = NewRecipe::new(self.title, 0, &self.ingredients, "");
+        match new_recipe.insert(self.connection) {
+            Ok(new) => println!("Added {}", new.title),
+            Err(e) => println!("Error: {}", e),
+        };
+    }
+}
+
+
+fn main() {
+    let conn = establish_connection();
+    let mut builder = CreateRecipe::new(&conn);
+
+    println!("Title : ");
+    let mut title = String::new();
+    stdin().read_line(&mut title).unwrap();
+    let title = &title[..(title.len() - 1)];
+    builder.set_title(title);
+
+    println!("Ingredients (empty line to finish): ");
+    loop {
+            let mut ingdts = String::new();
+            stdin().read_line(&mut ingdts).unwrap();
+            if &ingdts == "\r\n" {
+                break;
+            }
+            builder.add_ingredient(ingdts.clone());
+    }
+
+    builder.insert();
+}
+
+
+#[cfg(not(windows))]
+const EOF: &'static str = "CTRL+D";
+
+#[cfg(windows)]
+const EOF: &'static str = "CTRL+Z";

cookbook/src/lib.rs

@@ -1,16 +1,69 @@
-mod meal;
+#[macro_use]
-mod storage;
+extern crate diesel;
+extern crate dotenv;
+
+pub mod schema;
+pub mod models;
+
 mod importer;
 
-pub use self::meal::Meal;
+use diesel::prelude::*;
+use dotenv::dotenv;
+use std::env;
+use crate::models::{Recipe, NewRecipe};
 
-pub fn fetch_meals() -> Vec<Meal> {
+pub fn establish_connection() -> SqliteConnection {
-    vec![
+    dotenv().ok();
-        Meal::new("Raclette".to_string(), 800),
+
-        Meal::new("Soupe".to_string(), 400),
+    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set !");
-    ]
+    SqliteConnection::establish(&db_url)
+        .expect(&format!("Error connecting to {}", db_url))
 }
 
+pub mod recipes {
+    use crate::models::{Recipe, NewRecipe};
+    use super::{SqliteConnection, schema};
+    use super::diesel::prelude::*;
+
+    pub fn load_all(conn: &SqliteConnection) -> Vec<Recipe> {
+        use self::schema::recipes::dsl::*;
+        recipes.load::<Recipe>(conn)
+            .expect("Error loading recipe's list")
+    }
+}
+
+
+pub mod ingredients {
+    use crate::models::{Ingredient, NewIngredient};
+    use super::{SqliteConnection, schema};
+    use super::diesel::prelude::*;
+
+    pub fn find(conn: &SqliteConnection, name: &str) -> Option<Ingredient> {
+        use self::schema::ingredients::dsl::*;
+
+        let results = ingredients.filter(alias.like(name))
+            .limit(1)
+            .load::<Ingredient>(conn)
+            .expect("Error finding ingredient");
+
+        if !results.is_empty() {
+            Some(results.into_iter().nth(0).unwrap())
+        } else {
+            None
+        }
+    }
+
+    pub fn create(conn: &SqliteConnection, name: &str) -> usize {
+        use self::schema::ingredients;
+
+        diesel::insert_into(ingredients::table)
+            .values(&NewIngredient { alias: name })
+            .execute(conn)
+            .expect("Error inserting ingredient")
+    }
+}
+
+
 #[cfg(test)]
 mod tests {
     #[test]

cookbook/src/meal.rs

@@ -1,31 +0,0 @@
-
-/// An individual ingredient
-pub struct Ingredient {
-    name: String,
-}
-
-impl Ingredient {
-
-    pub(super) fn new(name: String) -> Ingredient {
-        Ingredient { name }
-    }
-}
-
-/// An ordered set of dishes
-#[derive(Debug,Clone)]
-pub struct Meal {
-    name: String,
-    nutritional_value: i32,
-}
-
-impl Meal {
-    pub(super) fn new(name: String, nutritional_value: i32) -> Meal {
-        Meal { name, nutritional_value }
-    }
-
-    pub fn nutritional_value(&self) -> i32 {
-        self.nutritional_value
-    }
-}
-
-

cookbook/src/models.rs

@@ -0,0 +1,107 @@
+use super::schema::recipes;
+use super::schema::ingredients;
+use super::diesel::prelude::*;
+
+pub mod fields {
+    use diesel::{
+        backend::Backend,
+        sqlite::Sqlite,
+        sql_types::SmallInt,
+        deserialize::{self, FromSql},
+        serialize::{self, Output, ToSql},
+    };
+    use std::io::Write;
+
+    /// All recipes have a single associated category
+    /// representing the main use of the resulting preparation.
+    ///
+    /// It is stored as Integer
+    #[derive(Debug, Clone, FromSqlRow, AsExpression)]
+    #[repr(i16)]
+    pub enum RecipeCategory {
+        Breakfast = 0,
+        Starter = 1,
+        MainCourse = 2,
+        Dessert = 3
+    }
+
+    impl RecipeCategory {
+        fn from_id(id: i16) -> Option<RecipeCategory> {
+            match id {
+                0 => Some(RecipeCategory::Breakfast),
+                1 => Some(RecipeCategory::Starter),
+                2 => Some(RecipeCategory::MainCourse),
+                3 => Some(RecipeCategory::Dessert),
+                _ => None,
+            }
+        }
+    }
+
+    impl FromSql<SmallInt, Sqlite> for RecipeCategory {
+        fn from_sql(bytes: Option<&<Sqlite as Backend>::RawValue>) -> deserialize::Result<Self> {
+            if let Some(result) = RecipeCategory::from_id(
+                <i16 as FromSql<SmallInt,Sqlite>>::from_sql(bytes)?)
+            { Ok(result) }
+            else { Err("Invalid RecipeCategory id".into()) }
+        }
+    }
+
+    impl ToSql<SmallInt, Sqlite> for RecipeCategory {
+        fn to_sql<W: Write>(&self, out: &mut Output<W, Sqlite>) -> serialize::Result {
+            let as_int = self.clone() as i16;
+            <i16 as ToSql<SmallInt, Sqlite>>::to_sql(&as_int, out)
+        }
+    }
+
+}
+
+
+/// Data for a recipe stored in DB
+#[derive(Debug, Clone, Queryable)]
+pub struct Recipe {
+    pub id: i32,
+    pub title: String,
+    pub category: fields::RecipeCategory,
+    pub ingredients: String,
+    pub preparation: String,
+}
+
+#[derive(Insertable)]
+#[table_name="recipes"]
+pub struct NewRecipe<'a> {
+    pub title: &'a str,
+    pub category: i16,
+    pub ingredients: &'a str,
+    pub preparation: &'a str,
+}
+
+impl<'a> NewRecipe<'a> {
+    pub fn new(title: &'a str, category: i16, ingredients: &'a str, preparation: &'a str) -> Self {
+        NewRecipe{
+            title,
+            category,
+            ingredients,
+            preparation,
+        }
+    }
+
+    pub fn insert(self, conn: &SqliteConnection) -> Result<Self, String> {
+        diesel::insert_into(recipes::table)
+            .values(&self)
+            .execute(conn)
+            .expect("Error inserting recipe");
+        Ok(self)
+    }
+}
+
+#[derive(Queryable)]
+pub struct Ingredient {
+    pub id: i32,
+    pub alias: String,
+}
+
+#[derive(Insertable)]
+#[table_name="ingredients"]
+pub struct NewIngredient<'a> {
+    pub alias: &'a str,
+}

cookbook/src/schema.rs

@@ -0,0 +1,21 @@
+table! {
+    ingredients (id) {
+        id -> Integer,
+        alias -> Text,
+    }
+}
+
+table! {
+    recipes (id) {
+        id -> Integer,
+        title -> Text,
+        category -> SmallInt,
+        ingredients -> Text,
+        preparation -> Text,
+    }
+}
+
+allow_tables_to_appear_in_same_query!(
+    ingredients,
+    recipes,
+);

cookbook/src/storage.rs

@@ -1,20 +0,0 @@
-//! Storage backend for persistent data
-//!
-use std::collections::HashMap;
-
-/// An entry in the storage
-struct Entry<T>(T);
-
-/// A storage container
-pub struct Storage<T> {
-    content: HashMap<String, Entry<T>>,
-}
-
-impl<T> Storage<T> {
-    pub(super) fn insert(&mut self, item: T) -> Result<(), ()> {
-    
-        Err(())
-    }
-}
-
-

planner/.env

@@ -0,0 +1 @@
+DATABASE_URL=../cookbook/db.sqlite3

planner/src/bin/weekly.rs

@@ -1,44 +1,84 @@
 //! The weekly menu planner
 //!
+extern crate cookbook;
+extern crate planner;
 
-use cookbook::{Meal, fetch_meals};
+use self::cookbook::*;
-use planner::solver::{Variables, Domain, solve_all};
+use self::cookbook::models::Recipe;
+use self::planner::solver::{Variables, Domain, Problem, Constraint};
 
+/// We want a mapping of the week meals (matin, midi, soir)
+///  Breakfast => RecipeCategory::Breakfast
+///  Lunch => RecipeCategory::MainCourse
+///  Dinner => RecipeCategory::MainCourse
+type Day = String;
+const DAYS: &[&str] = &["Lundi", "Mardi", "Mercredi"];
 
-fn generate_weekly_menu() -> String {
+enum Meals {
-    let assignments: Variables<Meal> = [
+    Breakfast(Day),
-        ("LundiMidi".to_string(), None), ("LundiSoir".to_string(), None),
+    Lunch(Day),
-        ("MardiMidi".to_string(), None), ("MardiSoir".to_string(), None),
+    Dinner(Day)
-        ("MercrediMidi".to_string(), None), ("MercrediSoir".to_string(), None),
+}
-    ].iter().cloned().collect();
+
-    let meals: Domain<Meal> = Domain::new(fetch_meals());
+impl Into<String> for Meals {
-    let validator = |vars: &Variables<Meal>| {
+    fn into(self) -> String {
-        let mut result = true;
+        match self {
-        for day in ["Lundi", "Mardi", "Mercredi"].into_iter() {
+            Meals::Breakfast(d) => format!("{}_Breakfast", d),
-            let all_day = vars.keys().filter(|k| k.starts_with(day));
+            Meals::Lunch(d) => format!("{}_Lunch", d),
-            let mut nutri_value = 0;
+            Meals::Dinner(d) => format!("{}_Dinner", d),
-            for key in all_day {
-                nutri_value += vars.get(key)
-                    .expect("no value here !")
-                    .expect("no meal there !")
-                    .nutritional_value()
-            }
-            println!("{} -> {}", day, nutri_value);
-            if nutri_value != 1200 { result = false; };
         }
-        println!("Validator returns {}", result);
+    }
-        result
+}
-    };
+/// associated with filters for Domain, depending on recipes RecipeCategory
+enum RecipeCategory {
+    Breakfast,
+    MainCourse
+}
+/// It may also contains an initial value for each variable
+fn generate_variables<V>(domain: &Domain<V>) -> Vec<(String, &Domain<V>, Option<&V>)> {
+    let mut vars = Vec::new();
+    for day in DAYS {
+       vars.push((Meals::Lunch(day.to_string()).into(), domain, None));
+       vars.push((Meals::Dinner(day.to_string()).into(), domain, None));
+    }
+    vars
+}
 
-    let solutions = solve_all(assignments, &meals, validator);
+fn ingredients_contains<'a>(assign: &Variables<'a,Recipe>) -> bool {
-    format!("{:#?}", solutions)
+       assign.get("Lundi_Lunch").unwrap().unwrap().ingredients.contains("Patates")
+    && !assign.get("Mardi_Lunch").unwrap().unwrap().ingredients.contains("Patates")
+}
+
+
+fn pretty_output(res: &Variables<Recipe>) -> String {
+    let mut repr = String::new();
+    for (var,value) in res {
+        let value = match value {
+            Some(rec) => &rec.title,
+            None => "---",
+        };
+        repr.push_str(&format!("{} => {}\n", var, value));
+    }
+    repr
+}
+
+fn get_planning_all_results() -> String {
+    let conn = establish_connection();
+    let possible_values = recipes::load_all(&conn);
+    let domain = Domain::new(possible_values);
+    let mut problem = Problem::build();
+    for (var, dom, ini) in generate_variables(&domain) {
+        problem = problem.add_variable(var, dom, ini);
+    }
+    let mut problem = problem
+        .add_constraint(
+            ingredients_contains
+        )
+        .finish();
+    let results = problem.solve_all();
+    format!("{}\nTotal = {}", pretty_output(&results.first().unwrap()), results.len())
 }
 
 fn main() {
-    println!("{}", generate_weekly_menu());
+    println!("{}", get_planning_all_results());
-}
-
-#[cfg(test)]
-mod tests {
-
 }

planner/src/solver.rs

@@ -13,17 +13,36 @@ enum Assignment<'a, V> {
     Clear(String)
 }
 
-
+type Domains<'a, V> = HashMap<String, &'a Domain<V>>;
 /// The domain of values that can be assigned to variables
 #[derive(Clone)]
 pub struct Domain<V> {
-    values: Vec<V>
+    pub values: Vec<V>
 }
 
 impl<V> Domain<V> {
     pub fn new(values: Vec<V>) -> Domain<V> {
         Domain { values }
     }
+
+    /// Returns a new domain with the given filter applied to inner values
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate planner;
+    /// # use planner::solver::Domain;
+    /// let domain = Domain::new(vec![1,2,3]);
+    /// fn even(i: &i32) -> bool { i % 2 == 0 };
+    /// assert_eq!(&domain.filter(even).values, &vec![2]);
+    /// ```
+    pub fn filter(&self, f: fn(&V) -> bool) -> Domain<V>
+        where V: std::clone::Clone
+    {
+        Domain {
+            values: self.values.iter().cloned().filter(f).collect(),
+        }
+    }
 }
 
 impl<V: fmt::Debug> fmt::Debug for Domain<V> {
@@ -33,64 +52,113 @@ impl<V: fmt::Debug> fmt::Debug for Domain<V> {
 }
 
 
-/// Returns all possible Updates for next assignements, prepended with
+pub type Constraint<'a,V> = fn(&Variables<'a,V>) -> bool;
-/// a Clear to ensure the variable is unset before when leaving the branch.
-fn assign_next<'a,'b, V>(assign: &'b Variables<'a, V>, domain: &'a Domain<V>) 
-    -> Option<Vec<Assignment<'a, V>>> 
-    where V: fmt::Debug 
-{
-    // Panics on empty domain
-    // If domain values are filtered, then the branch is a dead end
-    if domain.values.is_empty() { panic!("No values in domain : {:?}", domain); };
 
-    // TODO: should be able to inject a choosing strategy
+pub struct Problem<'a, V> {
-    if let Some((key,_)) = assign.iter().find(|(_, val)| val.is_none()) {
+    /// The initial assignements map
-        let mut updates = vec![Assignment::Clear(key.clone())];
+    variables: Variables<'a, V>,
-        // TODO: should be able to filter domain values (inference, pertinence)
+    /// Each variable has its associated domain
-        for value in domain.values.iter() {
+    domains: Domains<'a,V>,
-            updates.push(Assignment::Update(key.clone(), value));
+    /// Set of constraints to validate
+    constraints: Vec<Constraint<'a,V>>,
+}
+
+impl<'a,V> Problem<'a, V> {
+
+    pub fn build() -> ProblemBuilder<'a,V> {
+        ProblemBuilder::new()
+    }
+
+    /// Returns all possible Updates for next assignements, prepended with
+    /// a Clear to ensure the variable is unset before when leaving the branch.
+    fn _assign_next(&self) -> Option<Vec<Assignment<'a,V>>> {
+        // TODO: should be able to inject a choosing strategy
+        if let Some((key,_)) = self.variables.iter().find(|(_, val)| val.is_none()) {
+            let domain = self.domains.get(key).expect("No domain for variable !");
+            let mut updates = vec![Assignment::Clear(key.clone())];
+
+            if domain.values.is_empty() { panic!("No value in domain !"); }
+            // TODO: should be able to filter domain values (inference, pertinence)
+            for value in domain.values.iter() {
+                updates.push(Assignment::Update(key.clone(), value));
+            }
+            Some(updates)
+        } else { // End of assignements
+            None
         }
-        Some(updates)
+    }
-    } else { // End of assignements    
+
-        None
+    /// Checks that the current assignments doesn't violate any constraint
+    fn _is_valid(&self) -> bool {
+        for validator in self.constraints.iter() {
+            if validator(&self.variables) == false { return false; }
+        }
+        return true;
+    }
+
+    /// Visit all possible solutions, using a stack.
+    pub fn solve_all(&mut self) -> Vec<Variables<'a,V>>
+        where V: Clone + fmt::Debug
+    {
+        let mut solutions: Vec<Variables<V>> = vec![];
+        let mut stack: Vec<Assignment<'a, V>> = vec![];
+        stack.append(&mut self._assign_next().unwrap());
+        loop {
+            let node = stack.pop();
+            if node.is_none() { break; };
+            match node.unwrap() {
+                Assignment::Update(key, val) => {
+                    // Assign the variable and open new branches, if any.
+                    *self.variables.get_mut(&key).unwrap() = Some(val);
+                    // TODO: handle case of empty domain.values
+                    if let Some(mut nodes) = self._assign_next() {
+                        stack.append(&mut nodes);
+                    } else {
+                        // Assignements are completed
+                        if self._is_valid() {
+                            solutions.push(self.variables.clone());
+                        };
+                    };
+                },
+                Assignment::Clear(key) => {
+                    // We are closing this branch, unset the variable
+                    *self.variables.get_mut(&key).unwrap() = None;
+                },
+            };
+        };
+        solutions
     }
 }
 
-/// Visit all possible solutions, using a stack.
+pub struct ProblemBuilder<'a, V>(Problem<'a, V>);
-pub fn solve_all<'a, V>(
+
-    mut assign: Variables<'a, V>, 
+impl<'a, V> ProblemBuilder<'a, V> {
-    domain: &'a Domain<V>, 
+    fn new() -> ProblemBuilder<'a, V> {
-    is_valid: fn(&Variables<'a,V>) -> bool
+        ProblemBuilder(
-    ) -> Vec<Variables<'a, V>> 
+            Problem{
-    where V: Clone + fmt::Debug
+                variables: Variables::new(),
-{
+                domains: HashMap::new(),
-    let mut solutions: Vec<Variables<V>> = vec![];
+                constraints: Vec::new(),
-    let mut stack: Vec<Assignment<'a, V>> = vec![];
+            })
-    stack.append(&mut assign_next(&assign,domain).unwrap());
+    }
-    loop {
+
-        let node = stack.pop();
+    pub fn add_variable<S>(mut self, name: S, domain: &'a Domain<V>, value: Option<&'a V>) -> Self
-        if node.is_none() { break; };
+        where S: Into<String>
-        match node.unwrap() {
+    {
-            Assignment::Update(key, val) => {
+        let name = name.into();
-                // Assign the variable and open new branches, if any.
+        self.0.variables.insert(name.clone(), value);
-                *assign.get_mut(&key).unwrap() = Some(val);
+        self.0.domains.insert(name, domain);
-                // TODO: handle case of empty domain.values
+        self
-                if let Some(mut nodes) = assign_next(&assign, domain) {
+    }
-                    stack.append(&mut nodes);
+
-                } else {
+    pub fn add_constraint(mut self, cons: Constraint<'a,V>) -> Self {
-                    // Assignements are completed
+        self.0.constraints.push(cons);
-                    if is_valid(&assign) {
+        self
-                        solutions.push(assign.clone());
+    }
-                    };
+
-                };
+    pub fn finish(self) -> Problem<'a, V> {
-            },
+        self.0
-            Assignment::Clear(key) => {
+    }
-                // We are closing this branch, unset the variable
-                *assign.get_mut(&key).unwrap() = None;
-            },
-        };
-    };
-    solutions
 }
 
 
@@ -99,41 +167,40 @@ mod tests {
     #[test]
     fn test_solver_find_pairs() {
         use super::*;
-        // Find all pairs of two differents
-        let assign: Variables<i32> = [
-            ("Left".to_string(), None), 
-            ("Right".to_string(), None),
-            ].iter().cloned().collect();
         let domain = Domain::new(vec![1,2,3]);
-        let constraint = |assign: &Variables<i32>| {
+        let mut problem: Problem<_> = Problem::build()
-            assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            .add_variable(String::from("Left"), &domain, None)
-        };
+            .add_variable(String::from("Right"), &domain, None)
+            .add_constraint(|assign: &Variables<i32>| {
+                assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            })
+            .finish();
+
         let solutions: Vec<Variables<i32>> = vec![
             [("Left".to_string(), Some(&3)), ("Right".to_string(), Some(&3)),].iter().cloned().collect(),
             [("Left".to_string(), Some(&2)), ("Right".to_string(), Some(&2)),].iter().cloned().collect(),
             [("Left".to_string(), Some(&1)), ("Right".to_string(), Some(&1)),].iter().cloned().collect(),
         ];
 
-        assert_eq!(solve_all(assign, &domain, constraint), solutions);
+        assert_eq!(problem.solve_all(), solutions);
     }
 
     #[test]
     fn test_solver_find_pairs_with_initial() {
         use super::*;
-        // Find all pairs of two differents
-        let assign: Variables<i32> = [
-            ("Left".to_string(), None), 
-            ("Right".to_string(), Some(&2)),
-            ].iter().cloned().collect();
         let domain = Domain::new(vec![1,2,3]);
-        let constraint = |assign: &Variables<i32>| {
+        let mut problem: Problem<_> = Problem::build()
-            assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            .add_variable("Left".to_string(), &domain, None)
-        };
+            .add_variable("Right".to_string(), &domain, Some(&2))
+            .add_constraint( |assign: &Variables<i32>| {
+                assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            })
+            .finish();
+
         let solutions: Vec<Variables<i32>> = vec![
             [("Left".to_string(), Some(&2)), ("Right".to_string(), Some(&2)),].iter().cloned().collect(),
         ];
 
-        assert_eq!(solve_all(assign, &domain, constraint), solutions);
+        assert_eq!(problem.solve_all(), solutions);
      }
 }
-

web/index.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <script src="https://cdn.jsdelivr.net/npm/vue@2.5.22/dist/vue.js"></script>
+</head>
+<body>
+<div id="app">
+  <h1>Cook Assistant</h1>
+  <!-- Details View -->
+  <section v-if="active_view > -1">
+    <button @click="setActiveView(-1)">X close</button>
+    <h4>{{ items[active_view].title }}</h4>
+    <p>{{ categories[items[active_view].category].name }}</p>
+  </section>
+  <!-- Category List View -->
+  <section v-else>
+    <div v-if="active_category == -1">
+      <div v-for="c in categories" :key="c.id">
+        <button @click="setActiveCategory(c.id)">{{ c.name }}</button>
+      </div>
+    </div>
+    <div v-else>
+      <button @click="setActiveCategory(-1)"><< back</button>
+      <p>{{ categories[active_category].name }}</p>
+      <ul>
+        <li v-for="item in displayed" :key="item.id">
+          <a href="" @click.prevent="setActiveView(item.id)">{{ item.title }}</a>
+        </li>
+      </ul>
+    </div>
+  </section>
+</div>
+</body>
+<script type="text/javascript">
+
+  var app = new Vue({
+    el: '#app',
+    data: {
+      categories: [
+        {id: 0, name: "Petit-déjeuner"},
+        {id: 1, name: "Plat principal"},
+        {id: 2, name: "Dessert"}
+      ],
+      active_category: -1,
+      active_view: -1,
+      items: [
+        {id: 0, title: "Raclette", category: 1},
+        {id: 1, title: "Tartiflette", category: 1},
+        {id: 2, title: "Pancakes", category: 0},
+        {id: 3, title: "Crêpes", category: 2}
+      ],
+    },
+    methods: {
+      setActiveCategory: function(id) {
+        this.active_category = id;
+      },
+      setActiveView: function(id) {
+        this.active_view = id;
+      }
+    },
+    computed: {
+      displayed: function() {
+          return this.items.filter(
+            rec => rec.category == this.active_category
+          );
+      }
+    }
+  });
+</script>
+</html>