mini_kraken 0.1.06 → 0.1.11

data/spec/core/conj2_spec.rb

@@ -66,15 +66,14 @@ module MiniKraken
         end
 
         it 'should yield success and set associations' do
-          # # Weird: this example succeeds if run alone...
-          # # Covers frame 1-51
-          # env.add_var(var_q)
-          # sub_goal = Goal.new(Equals.instance, [corn, ref_q])
-          # solver = subject.solver_for([succeeds, sub_goal], env)
-          # outcome = solver.resume
-          # expect(outcome).to be_successful
-          # expect(outcome.associations).not_to be_empty
-          # expect(outcome.associations['q'].first.value).to eq(corn)
+          # Covers frame 1-51
+          env.add_var(var_q)
+          sub_goal = Goal.new(Equals.instance, [corn, ref_q])
+          solver = subject.solver_for([succeeds, sub_goal], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations).not_to be_empty
+          expect(outcome.associations['q'].first.value).to eq(corn)
         end
 
         it 'should yield fails and set no associations' do

data/spec/core/cons_cell_spec.rb

@@ -58,6 +58,14 @@ module MiniKraken
           different = ConsCell.new(pea)
           expect(subject.eql?(different)).to be_falsey
         end
+
+        it 'should append another cons cell' do
+          instance = ConsCell.new(pea)
+          trail = ConsCell.new(pod)
+          instance.append(trail)
+          expect(instance.car).to eq(pea)
+          expect(instance.cdr).to eq(trail)
+        end
       end # context
     end # describe
   end # module

data/spec/core/def_relation_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/disj2'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/goal_template'
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+require_relative '../../lib/mini_kraken/core/environment'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/def_relation'
+
+module MiniKraken
+  module Core
+    describe DefRelation do
+      let(:tea) { KSymbol.new(:tea) }
+      let(:formal_t) { FormalArg.new('t') }
+      let(:t_ref) { FormalRef.new('t') }
+      let(:equals_tea) { GoalTemplate.new(Equals.instance, [tea, t_ref]) }
+      subject { DefRelation.new('teao', equals_tea, [formal_t]) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name, a goal template, formal args' do
+          expect { DefRelation.new('teao', equals_tea, [formal_t]) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('teao')
+        end
+
+        it 'should know its goal template' do
+          expect(subject.goal_template).to eq(equals_tea)
+        end
+
+        it 'should know its formals' do
+          expect(subject.formals).to eq([formal_t])
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:cup) { KSymbol.new(:cup) }
+        let(:ref_x) { VariableRef.new('x') }
+        let(:equals_cup) { GoalTemplate.new(Equals.instance, [cup, t_ref]) }
+        let(:g_template) { GoalTemplate.new(Disj2.instance, [equals_tea, equals_cup]) }
+        subject { DefRelation.new('teacup', g_template, [formal_t]) }
+        let(:env) { Environment.new }
+
+        it 'should provide solver for a single-node goal without var ref' do
+          defrel = DefRelation.new('teao', equals_tea, [formal_t])
+          solver = defrel.solver_for([tea], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          outcome = solver.resume
+          expect(outcome).to be_nil
+
+          solver = defrel.solver_for([cup], env)
+          outcome = solver.resume
+          expect(outcome).not_to be_successful
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+
+        it 'should provide solver for a single-node goal' do
+          defrel = DefRelation.new('teao', equals_tea, [formal_t])
+          env.add_var(Variable.new('x'))
+          solver = defrel.solver_for([ref_x], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(tea)
+
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+
+        it 'should provide solver for a single-node goal' do
+          env.add_var(Variable.new('x'))
+          solver = subject.solver_for([ref_x], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(tea)
+
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(ref_x.value(outcome)).to eq(cup)
+
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/disj2_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/fail'
+require_relative '../../lib/mini_kraken/core/succeed'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/environment'
+require_relative '../../lib/mini_kraken/core/variable'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/disj2'
+
+module MiniKraken
+  module Core
+    describe Disj2 do
+      subject { Disj2.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Disj2.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('disj2')
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:corn) { KSymbol.new(:corn) }
+        let(:meal) { KSymbol.new(:meal) }
+        let(:oil) { KSymbol.new(:oil) }
+        let(:olive) { KSymbol.new(:olive) }
+        let(:pea) { KSymbol.new(:pea) }
+        let(:fails) { Goal.new(Fail.instance, []) }
+        let(:succeeds) { Goal.new(Succeed.instance, []) }
+        let(:var_q) { Variable.new('q') }
+        let(:ref_q) { VariableRef.new('q') }
+        let(:env) do
+          e = Environment.new
+          e.add_var(var_q)
+          e
+        end
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
+        end
+
+        it 'should fails if both arguments fail' do
+          # Covers frame 1:55
+          solver = subject.solver_for([fails, fails], env)
+          expect(solver.resume).not_to be_successful
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if first argument succeeds' do
+          # Covers frame 1:56
+          subgoal = Goal.new(Equals.instance, [olive, ref_q])
+          solver = subject.solver_for([subgoal, fails], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations['q'].first.value).to eq(olive)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if second argument succeeds' do
+          # Covers frame 1:57
+          subgoal = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, subgoal], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield two solutions if both arguments succeed' do
+          # Covers frame 1:58
+          subgoal1 = Goal.new(Equals.instance, [olive, ref_q])
+          subgoal2 = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([subgoal1, subgoal2], env)
+
+          # First solution
+          outcome1 = solver.resume
+          expect(outcome1).to be_successful
+          expect(outcome1.associations['q'].first.value).to eq(olive)
+
+          # Second solution
+          outcome2 = solver.resume
+          expect(outcome2).to be_successful
+          expect(outcome2.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/duck_fiber_spec.rb

@@ -40,12 +40,23 @@ module MiniKraken
           succeeding = DuckFiber.new(:success)
           outcome = nil
           expect { outcome = succeeding.resume }.not_to raise_error
-          expect(outcome).to eq(BasicSuccess)
+          expect(outcome).to be_successful
+          expect(outcome.parent).to be_nil
 
           # Only one result should be yielded
           expect(succeeding.resume).to be_nil
         end
 
+        it 'should yield a distinct success object' do
+          instance1 = DuckFiber.new(:success)
+          outcome1 = instance1.resume
+
+          instance2 = DuckFiber.new(:success)
+          outcome2 = instance1.resume
+
+          expect(outcome1).not_to be_equal(outcome2)
+        end
+
         it 'should behave like a Fiber yielding a custom outcome' do
           tailored = DuckFiber.new(:custom) { Outcome.new(:"#s", parent) }
           outcome = nil

data/spec/core/equals_spec.rb

@@ -275,9 +275,9 @@ module MiniKraken
 
         it 'should unify composite terms with variables' do
           # Reasoned S2, frame 1:36
-          # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
-          expr1 = cons(cons(ref_q), ref_x)
-          expr2 = cons(cons(ref_x), pod)
+          # (run* q (fresh (x) (==  '(((,q)) ,x) `(((,x)) pod)))) ;; => ('pod)
+          expr1 = cons(cons(cons(ref_q)), ref_x)
+          expr2 = cons(cons(cons(ref_x)), pod)
 
           result = solve_for(expr1, expr2)
           # require 'debug'

data/spec/core/goal_template_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/disj2'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/formal_arg'
+require_relative '../../lib/mini_kraken/core/formal_ref'
+require_relative '../../lib/mini_kraken/core/goal'
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+# require_relative '../../lib/mini_kraken/core/environment'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/goal_template'
+
+
+module MiniKraken
+  module Core
+    describe GoalTemplate do
+      let(:tea) { KSymbol.new(:tea) }
+      let(:t_ref) { FormalRef.new('t') }
+      subject { GoalTemplate.new(Equals.instance, [tea, t_ref]) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a relation and args' do
+          expect { GoalTemplate.new(Equals.instance, [tea, t_ref]) }.not_to raise_error
+        end
+
+        it 'should know its relation' do
+          expect(subject.relation).to eq(Equals.instance)
+        end
+
+        it 'should know its arguments' do
+          expect(subject.args[0]).to eq(tea)
+          expect(subject.args[1]).to eq(t_ref)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:formal_t) { FormalArg.new('t') }
+        let(:cup) { KSymbol.new(:cup) }
+        let(:ref_x) { VariableRef.new('x') }
+        # let(:env) { Environment.new }
+
+        it 'should instantiate a single-node goal' do
+          expect(subject.instantiate([formal_t], [cup])).to be_kind_of(Goal)
+          goal = subject.instantiate([formal_t], [cup])
+          expect(goal.relation).to eq(Equals.instance)
+          expect(goal.actuals[0]).to eq(tea)
+          expect(goal.actuals[1]).to eq(cup)
+        end
+
+        it 'should instantiate a multiple-nodes goal' do
+          sub_tmp1 =  GoalTemplate.new(Equals.instance, [tea, t_ref])
+          sub_tmp2 =  GoalTemplate.new(Equals.instance, [cup, t_ref])
+          template =  GoalTemplate.new(Disj2.instance, [sub_tmp1, sub_tmp2])
+
+          goal = template.instantiate([formal_t], [ref_x])
+          expect(goal.relation).to eq(Disj2.instance)
+          subgoal1 = goal.actuals[0]
+          expect(subgoal1).to be_kind_of(Goal)
+          expect(subgoal1.relation).to eq(Equals.instance)
+          expect(subgoal1.actuals[0]).to eq(tea)
+          expect(subgoal1.actuals[1]).to eq(ref_x)
+          subgoal2 = goal.actuals[1]
+          expect(subgoal2).to be_kind_of(Goal)
+          expect(subgoal2.relation).to eq(Equals.instance)
+          expect(subgoal2.actuals[0]).to eq(cup)
+          expect(subgoal2.actuals[1]).to eq(ref_x)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/k_boolean_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'ostruct'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/k_boolean'
+
+module MiniKraken
+  module Core
+    describe KBoolean do
+      subject { KBoolean.new('#t') }
+
+      context 'Initialization:' do
+        it 'could be created with a Ruby true/false value' do
+          expect { KBoolean.new(true) }.not_to raise_error
+          expect { KBoolean.new(false) }.not_to raise_error
+        end
+
+        it 'could be created with a Ruby Symbol value' do
+          expect { KBoolean.new(:"#t") }.not_to raise_error
+          expect { KBoolean.new(:"#f") }.not_to raise_error
+        end
+
+        it 'could be created with a Ruby String value' do
+          expect { KBoolean.new('#t') }.not_to raise_error
+          expect { KBoolean.new('#f') }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(true)
+        end
+
+        it 'should know that it is a ground term' do
+          env = double('mock-env')
+          expect(subject.ground?(env)).to be_truthy
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether it is equal to another instance' do
+          # Same type, same value
+          other = KBoolean.new(true)
+          expect(subject).to be_eql(other)
+
+          other = KBoolean.new(:"#t")
+          expect(subject).to be_eql(other)
+
+          other = KBoolean.new('#t')
+          expect(subject).to be_eql(other)
+
+          # Same type, other value
+          another = KBoolean.new(false)
+          expect(subject).not_to be_eql(another)
+
+          # Same type, other value
+          another = KBoolean.new(:"#f")
+          expect(subject).not_to be_eql(another)
+
+          # Same type, other value
+          another = KBoolean.new('#f')
+          expect(subject).not_to be_eql(another)
+
+          # Different type, same value
+          yet_another = OpenStruct.new(value: true)
+          expect(subject).not_to be_eql(yet_another)
+        end
+
+        it 'should know whether it has same value than other object' do
+          # Same type, same value
+          other = KBoolean.new(true)
+          expect(subject == other).to be_truthy
+
+          other = KBoolean.new(:"#t")
+          expect(subject == other).to be_truthy
+
+          other = KBoolean.new('#t')
+          expect(subject == other).to be_truthy
+
+          # Same type, other value
+          another = KBoolean.new(false)
+          expect(subject == another).to be_falsy
+
+          another = KBoolean.new(:"#f")
+          expect(subject == another).to be_falsy
+
+          another = KBoolean.new('#f')
+          expect(subject == another).to be_falsy
+
+          # Same duck type, same value
+          yet_another = OpenStruct.new(value: true)
+          expect(subject == yet_another).to be_truthy
+
+          # Different duck type, different value
+          still_another = OpenStruct.new(value: false)
+          expect(subject == still_another).to be_falsy
+
+          # Default Ruby representation, same value
+          expect(subject == true).to be_truthy
+
+          # Default Ruby representation, different value
+          expect(subject == false).to be_falsy
+        end
+      end # context
+    end # describe
+  end # module
+end # module