mini_kraken 0.2.03 → 0.3.03

data/spec/core/equals_spec.rb

@@ -1,317 +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_methods'
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/equals'
-
-module MiniKraken
-  module Core
-    describe Equals do
-      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 = Variable.new(aName)
-          env.add_var(new_var)
-          new_var
-        end
-
-        def build_var_ref(aName)
-          VariableRef.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) { KSymbol.new(:pea) }
-        let(:pod) { KSymbol.new(:pod) }
-        let(:sample_cons) { ConsCell.new(pea) }
-        let(:a_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 = 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 = 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 = 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 = 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

data/spec/core/goal_template_spec.rb

@@ -1,74 +0,0 @@
-# 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/outcome_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/vocabulary'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/outcome'
-
-module MiniKraken
-  module Core
-    describe Outcome do
-      let(:voc) do
-        obj = Object.new
-        obj.extend(Vocabulary)
-        obj
-      end
-      subject { Outcome.new(:"#s", voc) }
-
-      context 'Initialization:' do
-        it 'should be created with a symbol and a vocabulary' do
-          expect { Outcome.new(:"#s", voc) }.not_to raise_error
-        end
-
-        it 'should know its resultant' do
-          expect(subject.resultant).to eq(:"#s")
-        end
-
-        it 'should know whether it represents a failure' do
-          expect(Outcome.new(:"#u")).to be_failure
-        end
-
-        it 'should know whether it represents a success' do
-          expect(subject).to be_success
-        end
-
-        it 'should know its parent' do
-          expect(subject.parent).to eq(voc)
-        end
-      end # context
-
-      context 'Provided services:' do
-        it 'should have a factory for failing outcome' do
-          instance = Outcome.failure(voc)
-          expect(instance.resultant).to eq(:"#u")
-          expect(instance.parent).to eq(voc)
-        end
-
-        it 'should have a factory for succeeding outcome' do
-          instance = Outcome.success(voc)
-          expect(instance.resultant).to eq(:"#s")
-          expect(instance.parent).to eq(voc)
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/variable_ref_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/variable_ref'
-
-module MiniKraken
-  module Core
-    describe VariableRef do
-      subject { VariableRef.new('q') }
-
-      context 'Initialization:' do
-        it 'should be initialized with the name of variable' do
-          expect { VariableRef.new('q') }.not_to raise_error
-        end
-
-        it 'should know the name of a variable' do
-          expect(subject.var_name).to eq('q')
-        end
-      end # context
-
-      context 'Provided services:' do
-        it 'knows its text representation' do
-          expect(subject.to_s).to eq('q')
-        end
-      end # context
-    end # describe
-  end # module
-end # module