mini_kraken 0.2.03 → 0.3.03

data/spec/core/conj2_spec.rb

@@ -1,114 +0,0 @@
-# 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/conj2'
-
-
-module MiniKraken
-  module Core
-    describe Conj2 do
-      subject { Conj2.instance }
-
-      context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Conj2.instance }.not_to raise_error
-        end
-
-        it 'should know its name' do
-          expect(subject.name).to eq('conj2')
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:env) { Environment.new }
-        let(:pea) { KSymbol.new(:pea) }
-        let(:corn) { KSymbol.new(:corn) }
-        let(:meal) { KSymbol.new(:meal) }
-        let(:fails) { Goal.new(Fail.instance, []) }
-        let(:succeeds) { Goal.new(Succeed.instance, []) }
-        let(:var_q) { Variable.new('q') }
-        let(:ref_q) { VariableRef.new('q') }
-
-        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 yield one failure if one of the goal is fail' do
-          # Fail as first argument
-          solver = subject.solver_for([fails, succeeds], env)
-          expect(solver.resume).not_to be_success
-          expect(solver.resume).to be_nil
-
-          # Fail as second argument
-          solver = subject.solver_for([succeeds, fails], env)
-          expect(solver.resume).not_to be_success
-          expect(solver.resume).to be_nil
-        end
-
-        it 'yield success if both arguments are succeed goals' do
-          # Covers frame 1-50
-          solver = subject.solver_for([succeeds, succeeds], env)
-          outcome = solver.resume
-          expect(outcome).to be_success
-          expect(outcome.associations).to be_empty
-          expect(solver.resume).to be_nil
-        end
-
-        it 'should yield success and set associations' do
-          # 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_success
-          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
-          # Covers frame 1-52
-          env.add_var(var_q)
-          sub_goal = Goal.new(Equals.instance, [corn, ref_q])
-          solver = subject.solver_for([fails, sub_goal], env)
-          outcome = solver.resume
-          expect(outcome).not_to be_success
-          expect(outcome.associations).to be_empty
-        end
-
-        it 'should yield fails when sub-goals are incompatible' do
-          # Covers frame 1-53
-          env.add_var(var_q)
-          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
-          sub_goal2 = Goal.new(Equals.instance, [meal, ref_q])
-          solver = subject.solver_for([sub_goal1, sub_goal2], env)
-          outcome = solver.resume
-          expect(outcome).not_to be_success
-          expect(outcome.associations).to be_empty
-        end
-
-        it 'should yield success when sub-goals are same and successful' do
-          # Covers frame 1-54
-          env.add_var(var_q)
-          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
-          sub_goal2 = Goal.new(Equals.instance, [corn, ref_q])
-          solver = subject.solver_for([sub_goal1, sub_goal2], env)
-          outcome = solver.resume
-          expect(outcome).to be_success
-          expect(outcome.associations).not_to be_empty
-          expect(outcome.associations['q'].first.value).to eq(corn)
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/cons_cell_spec.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/k_symbol'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/cons_cell'
-
-module MiniKraken
-  module Core
-    describe ConsCell do
-      let(:pea) { KSymbol.new(:pea) }
-      let(:pod) { KSymbol.new(:pod) }
-      let(:corn) { KSymbol.new(:corn) }
-      subject { ConsCell.new(pea, pod) }
-
-      context 'Initialization:' do
-        it 'could be initialized with one argument' do
-          expect { ConsCell.new(pea) }.not_to raise_error
-        end
-
-        it 'could be initialized with a second optional argument' do
-          expect { ConsCell.new(pea, pod) }.not_to raise_error
-        end
-
-        it 'should know its car child' do
-          expect(subject.car).to eq(pea)
-        end
-
-        it 'should know its cdr child' do
-          expect(subject.cdr).to eq(pod)
-        end
-
-        it 'should know its children' do
-          expect(subject.children).to eq([pea, pod])
-        end
-
-        it 'should know if it is empty (null)' do
-          expect(subject).not_to be_null
-          expect(ConsCell.new(nil, nil)).to be_null
-          expect(NullList).to be_null
-        end
-
-        it 'simplifies cdr if its referencing a null list' do
-          instance = ConsCell.new(pea, NullList)
-          expect(instance.car).to eq(pea)
-          expect(instance.cdr).to be_nil
-        end
-      end # context
-
-      context 'Provided services:' do
-        it 'should compare to itself' do
-          expect(subject.eql?(subject)).to be_truthy
-          synonym = subject
-          expect(subject == synonym).to be_truthy
-        end
-
-        it 'should compare to another instance' do
-          same = ConsCell.new(pea, pod)
-          expect(subject.eql?(same)).to be_truthy
-
-          different = ConsCell.new(pod, pea)
-          expect(subject.eql?(different)).to be_falsey
-
-          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
-
-        it 'should provide a list representation of itself' do
-          # Case of null list
-          expect(NullList.to_s).to eq '()'
-
-          # Case of one element proper list
-          cell = ConsCell.new(pea)
-          expect(cell.to_s).to eq '(:pea)'
-
-          # Case of two elements proper list
-          cell = ConsCell.new(pea, ConsCell.new(pod))
-          expect(cell.to_s).to eq '(:pea :pod)'
-
-          # Case of two elements improper list
-          expect(subject.to_s).to eq '(:pea . :pod)'
-
-          # Case of three elements proper list
-          cell = ConsCell.new(pea, ConsCell.new(pod, ConsCell.new(corn)))
-          expect(cell.to_s).to eq '(:pea :pod :corn)'
-
-          # Case of three elements improper list
-          cell = ConsCell.new(pea, ConsCell.new(pod, corn))
-          expect(cell.to_s).to eq '(:pea :pod . :corn)'
-
-          # Case of a nested list
-          cell = ConsCell.new(ConsCell.new(pea), ConsCell.new(pod))
-          expect(cell.to_s).to eq '((:pea) :pod)'
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/def_relation_spec.rb

@@ -1,97 +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/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
-      # (defrel (teao t) (== 'tea t))
-      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_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(Variable.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(Variable.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,99 +0,0 @@
-# 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_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,142 +0,0 @@
-# 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/variable'
-require_relative '../../lib/mini_kraken/core/variable_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
-      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) { Variable.new('a') }
-        let(:var_b) { Variable.new('b') }
-        let(:var_c) { Variable.new('c') }
-        let(:var_c_bis) { Variable.new('c') }
-        let(:pea) { KSymbol.new(:pea) }
-        let(:pod) { KSymbol.new(:pod) }
-        let(:pad) { KSymbol.new(: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