mini_kraken 0.2.04 → 0.3.00

data/spec/{core → rela}/conde_spec.rb

@@ -4,16 +4,16 @@ require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../support/factory_atomic'
 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/context'
 require_relative '../../lib/mini_kraken/core/log_var'
 require_relative '../../lib/mini_kraken/core/log_var_ref'
+require_relative '../../lib/mini_kraken/rela/unify'
 
 # Load the class under test
-require_relative '../../lib/mini_kraken/core/conde'
+require_relative '../../lib/mini_kraken/rela/conde'
 
 module MiniKraken
-  module Core
+  module Rela
     describe Conde do
       include MiniKraken::FactoryAtomic # Use mix-in module
 
@@ -31,115 +31,119 @@ module MiniKraken
 
       context 'Provided services:' do
         let(:bean) { k_symbol(:bean) }
-        let(:corn) {k_symbol(:corn) }
+        let(:corn) { k_symbol(:corn) }
         let(:meal) { k_symbol(:meal) }
         let(:oil) { k_symbol(:oil) }
         let(:olive) { k_symbol(:olive) }
         let(:pea) { k_symbol(:pea) }
         let(:red) { k_symbol(:red) }
         let(:split) { k_symbol(:split) }
-        let(:fails) { Goal.new(Fail.instance, []) }
-        let(:succeeds) { Goal.new(Succeed.instance, []) }
-        let(:var_q) { LogVar.new('q') }
-        let(:var_x) { LogVar.new('x') }
-        let(:var_y) { LogVar.new('y') }
-        let(:ref_q) { LogVarRef.new('q') }
-        let(:ref_x) { LogVarRef.new('x') }
-        let(:ref_y) { LogVarRef.new('y') }
-        let(:env) do
-          e = Environment.new
-          e.add_var(var_q)
-          e.add_var(var_x)
-          e.add_var(var_y)
+        let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
+        let(:succeeds) { Core::Goal.new(Succeed.instance, []) }
+        let(:var_q) { Core::LogVar.new('q') }
+        let(:var_x) { Core::LogVar.new('x') }
+        let(:var_y) { Core::LogVar.new('y') }
+        let(:ref_q) { Core::LogVarRef.new('q') }
+        let(:ref_x) { Core::LogVarRef.new('x') }
+        let(:ref_y) { Core::LogVarRef.new('y') }
+        let(:ctx) do
+          e = Core::Context.new
+          e.add_vars(%w[q x y])
+
           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)
+          expect { subject.solver_for([succeeds, pea], ctx) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], ctx) }.to raise_error(err)
         end
 
         it 'should fail when all goals fail' do
-          solver = subject.solver_for([fails, fails, fails], env)
+          solver = subject.solver_for([fails, fails, fails], ctx)
           expect(solver.resume).not_to be_success
           expect(solver.resume).to be_nil
         end
 
         it 'yield success if first argument succeeds' do
-          subgoal = Goal.new(Equals.instance, [olive, ref_q])
-          solver = subject.solver_for([subgoal, fails, fails], env)
+          subgoal = Core::Goal.new(Unify.instance, [olive, ref_q])
+          solver = subject.solver_for([subgoal, fails, fails], ctx)
           outcome = solver.resume
+
           expect(outcome).to be_success
-          expect(outcome.associations['q'].first.value).to eq(olive)
+          sol = outcome.build_solution
+          expect(sol['q']).to eq(olive)
           expect(solver.resume).to be_nil
         end
 
         it 'yield success if second argument succeeds' do
-          subgoal = Goal.new(Equals.instance, [oil, ref_q])
-          solver = subject.solver_for([fails, subgoal, fails], env)
+          subgoal = Core::Goal.new(Unify.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, subgoal, fails], ctx)
           outcome = solver.resume
           expect(outcome).to be_success
-          expect(outcome.associations['q'].first.value).to eq(oil)
+          sol = outcome.build_solution
+          expect(sol['q']).to eq(oil)
           expect(solver.resume).to be_nil
         end
 
         it 'yield success if third argument succeeds' do
-          subgoal = Goal.new(Equals.instance, [oil, ref_q])
-          solver = subject.solver_for([fails, fails, subgoal], env)
+          subgoal = Core::Goal.new(Unify.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, fails, subgoal], ctx)
           outcome = solver.resume
           expect(outcome).to be_success
-          expect(outcome.associations['q'].first.value).to eq(oil)
+          expect(outcome.build_solution['q']).to eq(oil)
           expect(solver.resume).to be_nil
         end
 
         it 'yields three solutions if three goals succeed' do
           # Covers frame 1:58
-          subgoal1 = Goal.new(Equals.instance, [olive, ref_q])
-          subgoal2 = Goal.new(Equals.instance, [oil, ref_q])
-          subgoal3 = Goal.new(Equals.instance, [pea, ref_q])
-          solver = subject.solver_for([subgoal1, subgoal2, subgoal3, fails], env)
+          subgoal1 = Core::Goal.new(Unify.instance, [olive, ref_q])
+          subgoal2 = Core::Goal.new(Unify.instance, [oil, ref_q])
+          subgoal3 = Core::Goal.new(Unify.instance, [pea, ref_q])
+          solver = subject.solver_for([subgoal1, subgoal2, subgoal3, fails], ctx)
 
           # First solution
           outcome1 = solver.resume
           expect(outcome1).to be_success
-          expect(outcome1.associations['q'].first.value).to eq(olive)
+          expect(outcome1.build_solution['q']).to eq(olive)
 
           # Second solution
           outcome2 = solver.resume
           expect(outcome2).to be_success
-          expect(outcome2.associations['q'].first.value).to eq(oil)
+          expect(outcome2.build_solution['q']).to eq(oil)
 
           # Third solution
           outcome3 = solver.resume
           expect(outcome3).to be_success
-          expect(outcome3.associations['q'].first.value).to eq(pea)
+          expect(outcome3.build_solution['q']).to eq(pea)
 
           expect(solver.resume).to be_nil
         end
 
         it 'also use conjunctions for nested goals' do
           # Covers frame 1:88
-          subgoal1 = Goal.new(Equals.instance, [split, ref_x])
-          subgoal2 = Goal.new(Equals.instance, [pea, ref_y])
+          subgoal1 = Core::Goal.new(Unify.instance, [split, ref_x])
+          subgoal2 = Core::Goal.new(Unify.instance, [pea, ref_y])
           combo1 = [subgoal1, subgoal2]
 
-          subgoal3 = Goal.new(Equals.instance, [red, ref_x])
-          subgoal4 = Goal.new(Equals.instance, [bean, ref_y])
+          subgoal3 = Core::Goal.new(Unify.instance, [red, ref_x])
+          subgoal4 = Core::Goal.new(Unify.instance, [bean, ref_y])
           combo2 = [subgoal3, subgoal4]
-          solver = subject.solver_for([combo1, combo2], env)
+          solver = subject.solver_for([combo1, combo2], ctx)
 
           # First solution
           outcome1 = solver.resume
           expect(outcome1).to be_success
-          expect(outcome1.associations['x'].first.value).to eq(split)
-          expect(outcome1.associations['y'].first.value).to eq(pea)
+          solution1 = outcome1.build_solution
+          expect(solution1['x']).to eq(split)
+          expect(solution1['y']).to eq(pea)
 
           # Second solution
           outcome2 = solver.resume
           expect(outcome2).to be_success
-          expect(outcome2.associations['x'].first.value).to eq(red)
-          expect(outcome2.associations['y'].first.value).to eq(bean)
+          solution2 = outcome2.build_solution
+          expect(solution2['x']).to eq(red)
+          expect(solution2['y']).to eq(bean)
 
           expect(solver.resume).to be_nil
         end

data/spec/rela/conj2_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/all_core'
+
+require_relative '../support/factory_atomic'
+require_relative '../support/factory_composite'
+require_relative '../../lib/mini_kraken/rela/unify'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/rela/conj2'
+
+module MiniKraken
+  module Rela
+    describe Conj2 do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      include MiniKraken::FactoryComposite # Use mix-in module
+      subject { Conj2.instance }
+
+
+      def var(aName)
+        Core::LogVar.new(aName)
+      end
+
+      # Convenience method to factor out repeated statements
+      def solve(arg1, arg2)
+        solver = subject.solver_for([arg1, arg2], ctx)
+        solver.resume
+      end
+
+      context 'Initialization:' do
+        it 'should know its relation name' do
+          expect(subject.name).to eq('conj2')
+        end
+
+        it 'should know its arity (binary)' do
+          expect(subject.arity).to be_binary
+        end
+
+        it 'should be frozen' do
+          expect(subject).to be_frozen
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:ctx) { Core::Context.new }
+        let(:pea) { k_symbol(:pea) }
+        let(:corn) { k_symbol(:corn) }
+        let(:meal) { k_symbol(:meal) }
+        let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
+        let(:succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
+        let(:var_q) { var('q') }
+        let(:ref_q) { Core::LogVarRef.new('q') }
+
+        def unify(term1, term2)
+           Core::Goal.new(Unify.instance, [term1, term2])
+        end
+
+        before(:each) { ctx.add_vars('q') }
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], ctx) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], ctx) }.to raise_error(err)
+        end
+
+        it 'should yield one failure if one of the goal is fail' do
+          # Fail as first argument
+          solver = subject.solver_for([fails, succeeds], ctx)
+          expect(solver.resume).not_to be_success
+          expect(solver.resume).to be_nil
+
+          # Fail as second argument
+          solver = subject.solver_for([succeeds, fails], ctx)
+          expect(solver.resume).not_to be_success
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if both arguments are succeed goals' do
+          solver = subject.solver_for([succeeds, succeeds], ctx)
+          outcome = solver.resume
+          expect(outcome).to be_success
+          expect(outcome.blackboard).to be_empty
+          expect(solver.resume).to be_nil
+        end
+
+        it 'should yield success and set associations' do
+          solver = subject.solver_for([succeeds, unify(corn, ref_q)], ctx)
+          outcome = solver.resume
+          expect(outcome).to be_success
+          expect(outcome.blackboard).not_to be_empty
+          expect(outcome.associations_for('q').first.value).to eq(corn)
+        end
+
+        it 'should yield fails and set no associations' do
+          solver = subject.solver_for([fails, unify(corn, ref_q)], ctx)
+          outcome = solver.resume
+          expect(outcome).not_to be_success
+          expect(outcome.blackboard).to be_empty
+        end
+
+        it 'should yield fails when sub-goals are incompatible' do
+          sub_goal1 = unify(corn, ref_q)
+          sub_goal2 = unify(meal, ref_q)
+          solver = subject.solver_for([sub_goal1, sub_goal2], ctx)
+          outcome = solver.resume
+          expect(outcome).not_to be_success
+          expect(outcome.blackboard).to be_empty
+        end
+
+        it 'should yield success when sub-goals are same and successful' do
+          sub_goal1 = unify(corn, ref_q)
+          sub_goal2 = unify(ref_q, corn)
+          solver = subject.solver_for([sub_goal1, sub_goal2], ctx)
+          outcome = solver.resume
+          expect(outcome).to be_success
+          expect(outcome.blackboard).not_to be_empty
+          expect(outcome.associations_for('q').first.value).to eq(corn)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/rela/def_relation_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/all_core'
+
+require_relative '../support/factory_atomic'
+require_relative '../support/factory_composite'
+require_relative '../../lib/mini_kraken/rela/disj2'
+require_relative '../../lib/mini_kraken/rela/unify'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/rela/def_relation'
+
+module MiniKraken
+  module Rela
+    describe DefRelation do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      include MiniKraken::FactoryComposite # Use mix-in module
+
+      # (defrel (teacupo t) (disj2 (== 'tea t) (== 'cup t)))
+      let(:tea) { k_symbol(:tea) }
+      let(:cup) { k_symbol(:cup) }
+      let(:formal_t) { 't' }
+      let(:t_ref) { Core::LogVarRef.new('t') }
+      let(:equals_tea) { unify_goal(tea, t_ref) }
+      let(:equals_cup) { unify_goal(cup, t_ref) }
+      let(:goal_template) { disj2_goal(equals_tea, equals_cup) }
+      let(:ctx) { Core::Context.new }
+      let(:uuid_pattern) do
+        /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+      end
+
+      subject { DefRelation.new('teacupo', goal_template, [formal_t]) }
+
+      def unify_goal(term1, term2)
+        Core::Goal.new(Unify.instance, [term1, term2])
+      end
+
+      def disj2_goal(term1, term2)
+        Core::Goal.new(Disj2.instance, [term1, term2])
+      end
+
+      context 'Initialization:' do
+        it 'should be initialized with a name, a goal template, formal args' do
+          expect do
+            DefRelation.new('teacupo', goal_template, [formal_t])
+          end.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('teacupo')
+        end
+
+        it 'should know its goal expression' do
+          expect(subject.expression).to be_kind_of(Core::Goal)
+          expect(subject.expression.relation).to eq(Disj2.instance)
+
+          g1 = subject.expression.actuals[0]
+          expect(g1).to be_kind_of(Core::Goal)
+          expect(g1.relation).to eq(Unify.instance)
+          expect(g1.actuals[0]).to eq(tea)
+          expect(g1.actuals[1]).to be_kind_of(Core::LogVarRef)
+          expect(g1.actuals[1].name).to match(/^t_/)
+          expect(g1.actuals[1].name).to match(uuid_pattern)
+
+          g2 = subject.expression.actuals[1]
+          expect(g2).to be_kind_of(Core::Goal)
+          expect(g2.relation).to eq(Unify.instance)
+          expect(g2.actuals[0]).to eq(cup)
+          expect(g2.actuals[1]).to be_kind_of(Core::LogVarRef)
+          expect(g2.actuals[1].name).to match(/^t_/)
+          expect(g2.actuals[1].name).to match(uuid_pattern)
+        end
+
+        it 'should know its formals' do
+          expect(subject.formals[0]).to match(/^t_/)
+          expect(subject.formals[0]).to match(uuid_pattern)
+        end
+
+        it 'should bear an internal name' do
+          expect { subject.i_name }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should provide solver for a single-node goal without ref actual' do
+          defrel = DefRelation.new('teao', equals_tea, [formal_t])
+          solver = defrel.solver_for([tea], ctx)
+          outcome = solver.resume
+          expect(outcome).to be_success
+          outcome = solver.resume
+          expect(outcome).to be_nil
+
+          solver = defrel.solver_for([cup], ctx)
+          outcome = solver.resume
+          expect(outcome).not_to be_success
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+
+        it 'should provide solver for a multiple-nodes goal with ref actual' do
+          expr = disj2_goal(equals_tea, equals_cup)
+          defrel = DefRelation.new('teacupo', expr, [formal_t])
+          x_ref = Core::LogVarRef.new('x')
+          ctx.add_vars(['x'])
+          solver = defrel.solver_for([x_ref], ctx)
+          [tea, cup].each do |predicted|
+            outcome = solver.resume
+            expect(outcome).to be_success
+            sol = ctx.build_solution
+            expect(sol['x']).to eq(predicted)
+          end
+          outcome = solver.resume
+          expect(outcome).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/rela/disj2_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/all_core'
+
+require_relative '../support/factory_atomic'
+require_relative '../support/factory_composite'
+require_relative '../../lib/mini_kraken/rela/unify'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/rela/disj2'
+
+module MiniKraken
+  module Rela
+    describe Disj2 do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      include MiniKraken::FactoryComposite # Use mix-in module
+      subject { Disj2.instance }
+
+      def var(aName)
+        Core::LogVar.new(aName)
+      end
+
+      # Convenience method to factor out repeated statements
+      def solve(arg1, arg2)
+        solver = subject.solver_for([arg1, arg2], ctx)
+        solver.resume
+      end
+
+      context 'Initialization:' do
+        it 'should know its relation name' do
+          expect(subject.name).to eq('disj2')
+        end
+
+        it 'should know its arity (binary)' do
+          expect(subject.arity).to be_binary
+        end
+
+        it 'should be frozen' do
+          expect(subject).to be_frozen
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:ctx) { Core::Context.new }
+        let(:pea) { k_symbol(:pea) }
+        let(:corn) { k_symbol(:corn) }
+        let(:oil) { k_symbol(:oil) }
+        let(:olive) { k_symbol(:olive) }
+        let(:meal) { k_symbol(:meal) }
+        let(:fails) { Core::Goal.new(Core::Fail.instance, []) }
+        let(:succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
+        let(:var_q) { var('q') }
+        let(:ref_q) { Core::LogVarRef.new('q') }
+
+        def unify(term1, term2)
+           Core::Goal.new(Unify.instance, [term1, term2])
+        end
+
+        before(:each) { ctx.add_vars('q') }
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], ctx) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], ctx) }.to raise_error(err)
+        end
+
+
+        it 'should fails if both arguments fail' do
+          # Covers frame 1:55
+          solver = subject.solver_for([fails, fails], ctx)
+          expect(solver.resume).not_to be_success
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if first argument succeeds' do
+          # Covers frame 1:56
+          subgoal = Core::Goal.new(Unify.instance, [olive, ref_q])
+          solver = subject.solver_for([subgoal, fails], ctx)
+          outcome = solver.resume
+          expect(outcome).to be_success
+          expect(outcome.associations_for('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 = Core::Goal.new(Unify.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, subgoal], ctx)
+          outcome = solver.resume
+          expect(outcome).to be_success
+          expect(outcome.associations_for('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 = Core::Goal.new(Unify.instance, [olive, ref_q])
+          subgoal2 = Core::Goal.new(Unify.instance, [oil, ref_q])
+          solver = subject.solver_for([subgoal1, subgoal2], ctx)
+
+          # First solution
+          outcome1 = solver.resume
+          expect(outcome1).to be_success
+          expect(outcome1.associations_for('q').first.value).to eq(olive)
+
+          # Second solution
+          # require 'debug'
+          outcome2 = solver.resume
+          expect(outcome2).to be_success
+          expect(outcome2.associations_for('q').first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module