mini_kraken 0.2.04 → 0.3.00

data/spec/core/def_relation_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../support/factory_atomic'
-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/log_var_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
-      include MiniKraken::FactoryAtomic # Use mix-in module
-
-      # (defrel (teao t) (== 'tea t))
-      let(:tea) { k_symbol(: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) { Atomic::KSymbol.new(:cup) }
-        let(:ref_x) { LogVarRef.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_success
-          outcome = solver.resume
-          expect(outcome).to be_nil
-
-          solver = defrel.solver_for([cup], env)
-          outcome = solver.resume
-          expect(outcome).not_to be_success
-          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(LogVar.new('x'))
-          solver = defrel.solver_for([ref_x], env)
-          outcome = solver.resume
-          expect(outcome).to be_success
-          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(LogVar.new('x'))
-          solver = subject.solver_for([ref_x], env)
-          outcome = solver.resume
-          expect(outcome).to be_success
-          expect(ref_x.value(outcome)).to eq(tea)
-
-          outcome = solver.resume
-          expect(outcome).to be_success
-          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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-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/log_var'
-require_relative '../../lib/mini_kraken/core/log_var_ref'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/disj2'
-
-module MiniKraken
-  module Core
-    describe Disj2 do
-      include MiniKraken::FactoryAtomic # Use mix-in module    
-      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) { k_symbol(:corn) }
-        let(:meal) { k_symbol(:meal) }
-        let(:oil) { k_symbol(:oil) }
-        let(:olive) { k_symbol(:olive) }
-        let(:pea) { k_symbol(:pea) }
-        let(:fails) { Goal.new(Fail.instance, []) }
-        let(:succeeds) { Goal.new(Succeed.instance, []) }
-        let(:var_q) { LogVar.new('q') }
-        let(:ref_q) { LogVarRef.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_success
-          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_success
-          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_success
-          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_success
-          expect(outcome1.associations['q'].first.value).to eq(olive)
-
-          # Second solution
-          outcome2 = solver.resume
-          expect(outcome2).to be_success
-          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/environment_spec.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../support/factory_atomic'
-require_relative '../../lib/mini_kraken/core/log_var'
-require_relative '../../lib/mini_kraken/core/log_var_ref'
-require_relative '../../lib/mini_kraken/core/outcome'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/environment'
-
-module MiniKraken
-  module Core
-    describe Environment do
-      include MiniKraken::FactoryAtomic # Use mix-in module
-
-      subject { Environment.new }
-
-      context 'Initialization:' do
-        it 'should be initialized with an optional parent' do
-          expect { Environment.new }.not_to raise_error
-          parent = Environment.new
-          expect { Environment.new(parent) }.not_to raise_error
-        end
-
-        it "shouldn't have variable by default" do
-          expect(subject.vars).to be_empty
-        end
-
-        it "shouldn't have associations by default" do
-          expect(subject.associations).to be_empty
-        end
-
-        it 'shold know its parent (if any)' do
-          # Case: no parent
-          expect(subject.parent).to be_nil
-
-          # Case: there is a parent
-          child = Environment.new(subject)
-          expect(child.parent).to eq(subject)
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:var_a) { LogVar.new('a') }
-        let(:var_b) { LogVar.new('b') }
-        let(:var_c) { LogVar.new('c') }
-        let(:var_c_bis) { LogVar.new('c') }
-        let(:pea) { k_symbol(:pea) }
-        let(:pod) { k_symbol(:pod) }
-        let(:pad) { k_symbol(:pad) }
-
-        it 'should accept the addition of a variable' do
-          subject.add_var(var_a)
-          expect(subject.vars).not_to be_empty
-          expect(subject.vars['a']).to eq(var_a)
-        end
-
-        it 'should accept the addition of multiple variables' do
-          subject.add_var(var_a)
-          expect(subject.vars).not_to be_empty
-          subject.add_var(var_b)
-          expect(subject.vars['a']).to eq(var_a)
-          expect(subject.vars['b']).to eq(var_b)
-        end
-
-        it 'should accept the addition of an association' do
-          subject.add_var(var_a)
-          assoc = subject.add_assoc('a', pea)
-          expect(subject.associations.size).to eq(1)
-          expect(subject.associations['a']).to eq([assoc])
-        end
-
-        it 'should tell that a newborn variable is fresh' do
-          subject.add_var(var_a)
-
-          # By default, a variable is fresh...
-          expect(subject.fresh?(var_a)).to be_truthy
-        end
-
-        it "should tell variable associated with a literal value isn't fresh" do
-          subject.add_var(var_a)
-
-          # Let's associate an atomic term...
-          subject.add_assoc('a', pea)
-
-          expect(subject.fresh?(var_a)).to be_falsey
-        end
-
-        it 'should cope with a variable associated with another variable' do
-          subject.add_var(var_a)
-          subject.add_var(var_b)
-
-          # Let's associate a with (fresh) b
-          subject.add_assoc(var_a, var_b)
-          expect(subject.fresh?(var_a)).to be_truthy
-
-          # Now associate b with something ground...
-          subject.add_assoc(var_b, pea)
-
-          # b is no more fresh, so is ... a
-          expect(subject.fresh?(var_b)).to be_falsey
-          expect(subject.fresh?(var_a)).to be_falsey
-        end
-
-        it 'should remove all associations' do
-          subject.add_var(var_a)
-          subject.add_assoc(var_a, pea)
-
-          subject.add_var(var_b)
-          subject.add_assoc(var_b, pod)
-
-          subject.clear
-          expect(subject.fresh?(var_a)).to be_truthy
-          expect(subject.fresh?(var_a)).to be_truthy
-        end
-
-        it 'should propagate associations up in the environment hierarchy' do
-          parent = Environment.new
-          parent.add_var(var_a)
-          instance = Environment.new(parent)
-          instance.add_var(var_b)
-
-          outcome = Outcome.new(:"#s", instance)
-          outcome.add_assoc(var_a, pea)
-          outcome.add_assoc(var_b, pod)
-          expect(outcome.associations.size).to eq(2)
-
-          # Propagate: outcome -> .. -> instance
-          instance.propagate(outcome)
-          expect(outcome.associations.size).to eq(1)
-          expect(instance.associations[var_b.name]).not_to be_nil
-          expect(parent.associations[var_a.name]).to be_nil
-
-          # Propagate: outcome -> .. -> parent
-          parent.propagate(outcome)
-          expect(outcome.associations).to be_empty
-          expect(parent.associations[var_b.name]).to be_nil
-          expect(parent.associations[var_a.name]).not_to be_nil
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/equals_spec.rb

@@ -1,319 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/environment'
-
-require_relative '../support/factory_atomic'
-require_relative '../support/factory_methods'
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/equals'
-
-module MiniKraken
-  module Core
-    describe Equals do
-      include MiniKraken::FactoryAtomic # Use mix-in module
-      include FactoryMethods
-
-      subject { Equals.instance }
-
-      context 'Initialization:' do
-        it 'should be created without argument' do
-          expect { Equals.instance }.not_to raise_error
-        end
-
-        it 'should know its name' do
-          expect(subject.name).to eq('equals')
-        end
-      end # context
-
-      context 'Provided services:' do
-        def build_var(aName)
-          new_var = LogVar.new(aName)
-          env.add_var(new_var)
-          new_var
-        end
-
-        def build_var_ref(aName)
-          LogVarRef.new(aName)
-        end
-
-        def solve_for(arg1, arg2)
-          solver = subject.solver_for([arg1, arg2], env)
-          outcome = solver.resume
-          env.propagate(outcome)
-          outcome
-        end
-
-        let(:pea) { k_symbol(:pea) }
-        let(:pod) { k_symbol(:pod) }
-        let(:sample_cons) { Composite::ConsCell.new(pea) }
-        let(:a_composite) { Composite::ConsCell.new(pod) }
-        let(:env) { Environment.new }
-        let(:var_q) { build_var('q') }
-        let(:ref_q) do
-          var_q # Force dependency
-          build_var_ref('q')
-        end
-        let(:ref_q_bis) do
-          var_q # Force dependency
-          build_var_ref('q')
-        end
-        let(:var_x) { build_var('x') }
-        let(:ref_x) do
-          var_x  # Force dependency
-          build_var_ref('x')
-        end
-        let(:var_y) { build_var('y') }
-        let(:ref_y) do
-          var_y  # Force dependency
-          build_var_ref('y')
-        end
-
-
-        it 'should succeed for equal literal arguments' do
-          result = solve_for(pea, pea)
-
-          expect(result).to be_kind_of(Outcome)
-          expect(result.resultant).to eq(:"#s")
-          expect(result.associations).to be_empty
-          expect(var_q.fresh?(env)).to be_truthy
-        end
-
-        it 'should fail for inequal literal arguments' do
-          result = solve_for(pea, pod)
-
-          expect(result.resultant).to eq(:"#u")
-          expect(result.associations).to be_empty
-          expect(var_q.fresh?(env)).to be_truthy
-        end
-
-        it 'should fail for one left literal and one composite arguments' do
-          result = solve_for(pea, sample_cons)
-
-          expect(result.resultant).to eq(:"#u")
-          expect(result.associations).to be_empty
-          expect(var_q.fresh?(env)).to be_truthy
-        end
-
-        it 'should fail for one right literal and one composite arguments' do
-          # Reasoned S2, frame 1:44
-          # (== '(pea) 'pea) ;; => #u
-          result = solve_for(sample_cons, pea)
-
-          expect(result.resultant).to eq(:"#u")
-          expect(result.associations).to be_empty
-          expect(var_q.fresh?(env)).to be_truthy
-        end
-
-        it 'should succeed for a right-handed fresh argument' do
-          result = solve_for(pea, ref_q)
-
-          expect(result).to be_success
-          expect(env.associations.size).to eq(1)
-          expect(env.associations['q'].first.value).to eq(pea)
-          expect(var_q.fresh?(result)).to be_falsey
-          expect(ref_q.values(result).first).to eq(pea)
-        end
-
-        it 'should succeed for a left-handed fresh argument' do
-          result = solve_for(ref_q, pea)
-
-          expect(result).to be_success
-          expect(env.associations.size).to eq(1)
-          expect(env.associations['q'].first.value).to eq(pea)
-          expect(var_q.fresh?(result)).to be_falsey
-          expect(ref_q.values(result).first).to eq(pea)
-        end
-
-        it 'should succeed for a right-handed bound argument equal constant' do
-          ref_q.associate(pod, env)
-
-          result = solve_for(pod, ref_q)
-          expect(result).to be_success
-          expect(env.associations.size).to eq(1) # No new association
-          expect(ref_q.fresh?(result)).not_to be_truthy
-          expect(ref_q.values(result).first).to eq(pod)
-        end
-
-        it 'should succeed for a left-handed bound argument equal constant' do
-          ref_q.associate(pod, env)
-
-          result = solve_for(ref_q, pod)
-          expect(result).to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).to be_falsey
-          expect(ref_q.values(result).first).to eq(pod)
-        end
-
-        it 'should fail for a right-handed bound argument to a distinct literal' do
-          ref_q.associate(pod, env)
-
-          result = solve_for(pea, ref_q)
-          expect(result).not_to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).to be_falsey
-          expect(ref_q.values(result).first).to eq(pod)
-        end
-
-        it 'should fail for a left-handed bound argument to a distinct literal' do
-          ref_q.associate(pod, env)
-
-          result = solve_for(ref_q, pea)
-          expect(result).not_to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).to be_falsey
-          expect(ref_q.values(result).first).to eq(pod)
-        end
-
-        it 'should succeed for a composite and right-handed fresh argument' do
-          result = solve_for(sample_cons, ref_q)
-
-          expect(result).to be_success
-          expect(env.associations.size).to eq(1)
-          expect(ref_q.fresh?(result)).to be_falsey
-          expect(ref_q.values(result).first).to eq(sample_cons)
-        end
-
-        it 'should succeed for composite and left-handed fresh argument' do
-          result = solve_for(ref_q, sample_cons)
-
-          expect(result).to be_success
-          expect(env.associations.size).to eq(1)
-          expect(ref_q.fresh?(result)).to be_falsey
-          expect(ref_q.values(result).first).to eq(sample_cons)
-        end
-
-        it 'should succeed for a right-handed bound equal argument' do
-          ref_q.associate(sample_cons, env)
-          composite = Composite::ConsCell.new(pea)
-          result = solve_for(composite, ref_q)
-
-          expect(result).to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).not_to be_truthy
-          expect(ref_q.values(result).first).to eq(sample_cons)
-        end
-
-        it 'should succeed for a left-handed bound equal argument' do
-          ref_q.associate(sample_cons, env)
-          composite = Composite::ConsCell.new(pea)
-          result = solve_for(ref_q, composite)
-
-          expect(result).to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).not_to be_truthy
-          expect(ref_q.values(result).first).to eq(sample_cons)
-        end
-
-        it 'should succeed for a right-handed bound unequal argument' do
-          ref_q.associate(sample_cons, env)
-          composite = Composite::ConsCell.new(pod)
-          result = solve_for(composite, ref_q)
-
-          expect(result).to be_failure
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).not_to be_truthy
-          expect(ref_q.values(result).first).to eq(sample_cons)
-        end
-
-        it 'should succeed for a left-handed bound unequal argument' do
-          ref_q.associate(sample_cons, env)
-          composite = Composite::ConsCell.new(pod)
-          result = solve_for(ref_q, composite)
-
-          expect(result).not_to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).not_to be_truthy
-          expect(ref_q.values(result).first).to eq(sample_cons)
-        end
-
-        it 'should succeed for both identical fresh arguments' do
-          result = solve_for(ref_q, ref_q)
-
-          expect(result).to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).to be_truthy
-        end
-
-        it 'should succeed for both same fresh arguments' do
-          result = solve_for(ref_q, ref_q_bis)
-
-          expect(result).to be_success
-          expect(result.associations).to be_empty
-          expect(ref_q.fresh?(result)).to be_truthy
-          expect(ref_q_bis.fresh?(result)).to be_truthy
-        end
-
-        it 'should succeed for both distinct fresh arguments' do
-          result = solve_for(ref_x, ref_y)
-
-          expect(result).to be_success
-          expect(env.associations).to be_empty # Symmetric association
-          expect(ref_x.fresh?(result)).to be_truthy
-          expect(ref_y.fresh?(result)).to be_truthy
-        end
-
-        it 'should succeed for arguments bound to equal values' do
-          ref_x.associate(pea, env)
-          ref_y.associate(pea, env)
-          expect(ref_x.fresh?(env)).to be_falsey
-          expect(ref_y.fresh?(env)).to be_falsey
-
-          result = solve_for(ref_x, ref_y)
-          expect(result).to be_success
-          expect(result.associations).to be_empty
-        end
-
-        it 'should fail for arguments bound unequal values' do
-          ref_x.associate(pea, env)
-          ref_y.associate(pod, env)
-          expect(ref_x.fresh?(env)).to be_falsey
-          expect(ref_y.fresh?(env)).to be_falsey
-
-          result = solve_for(ref_x, ref_y)
-          expect(result).not_to be_success
-          expect(result.associations).to be_empty
-        end
-
-        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(cons(ref_q)), cons(ref_x))
-          expect(expr1.to_s).to eq('(((q)) x)')
-          expr2 = cons(cons(cons(ref_x)), cons(pod))
-          expect(expr2.to_s).to eq('(((x)) :pod)')
-
-          result = solve_for(expr1, expr2)
-          expect(result).to be_success
-          expect(ref_x.fresh?(env)).to be_falsey
-          expect(ref_q.fresh?(env)).to be_falsey
-        end
-
-        it 'should fail for one right literal and one composite arguments' do
-          # Reasoned S2, frame 1:46
-          # x associated to ('pea 'pod)
-          # (== '(,x) x) ;; => #u
-          expr1 = cons(pea, cons(pod))
-          ref_x.associate(expr1, env)
-          expr2 = cons(ref_x)
-          result = solve_for(expr2, ref_x)
-
-          expect(result.resultant).to eq(:"#u")
-          expect(result.associations).to be_empty
-        end
-
-        it 'should unify variables with a list' do
-          # Variant of Reasoned S2, frame 2:3
-          # (== (cons q x) '(a c o r n)) ;; q => :a, x => '(c o r n)
-          expr1 = cons(ref_q, ref_x)
-          acorn = cons(k_symbol(:a), cons(k_symbol(:c),
-            cons(k_symbol(:o), cons(k_symbol(:r), cons(k_symbol(:n))))))
-          result = solve_for(expr1, acorn)
-          expect(result.resultant).to eq(:"#s")
-          q_value = env.associations['q'].first.value
-          expect(q_value).to eq(:a)
-        end
-      end # context
-    end # describe
-  end # module
-end # module