mini_kraken 0.1.04 → 0.1.09

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

@@ -25,37 +25,47 @@ module MiniKraken
 
       context 'Provided services:' do
         let(:parent) { Environment.new }
-      
+
         it 'should behave like a Fiber yielding a failure' do
           failing = DuckFiber.new(:failure)
           outcome = nil
           expect { outcome = failing.resume }.not_to raise_error
           expect(outcome).to eq(Failure)
-          
+
           # Only one result should be yielded
-          expect(failing.resume).to be_nil          
+          expect(failing.resume).to be_nil
         end
-        
+
         it 'should behave like a Fiber yielding a basic success' do
           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 
+        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) } 
+          tailored = DuckFiber.new(:custom) { Outcome.new(:"#s", parent) }
           outcome = nil
           expect { outcome = tailored.resume }.not_to raise_error
           expect(outcome).to eq(Outcome.new(:"#s", parent))
-          
+
           # Only one result should be yielded
-          expect(tailored.resume).to be_nil          
-        end         
+          expect(tailored.resume).to be_nil
+        end
       end # context
     end # describe
   end # module

data/spec/core/environment_spec.rb

@@ -4,7 +4,6 @@ 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/association'
 require_relative '../../lib/mini_kraken/core/outcome'
 
 # Load the class under test
@@ -38,7 +37,6 @@ module MiniKraken
           child = Environment.new(subject)
           expect(child.parent).to eq(subject)
         end
-
       end # context
 
       context 'Provided services:' do
@@ -66,8 +64,7 @@ module MiniKraken
 
         it 'should accept the addition of an association' do
           subject.add_var(var_a)
-          assoc = Association.new('a', pea)
-          subject.add_assoc(assoc)
+          assoc = subject.add_assoc('a', pea)
           expect(subject.associations.size).to eq(1)
           expect(subject.associations['a']).to eq([assoc])
         end
@@ -83,25 +80,21 @@ module MiniKraken
           subject.add_var(var_a)
 
           # Let's associate an atomic term...
-          assoc = Association.new('a', pea)
-          subject.add_assoc(assoc)
+          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
+        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
-          assoc = Association.new(var_a, var_b)
-          subject.add_assoc(assoc)
-
+          subject.add_assoc(var_a, var_b)
           expect(subject.fresh?(var_a)).to be_truthy
 
           # Now associate b with something ground...
-          assoc_b = Association.new(var_b, pea)
-          subject.add_assoc(assoc_b)
+          subject.add_assoc(var_b, pea)
 
           # b is no more fresh, so is ... a
           expect(subject.fresh?(var_b)).to be_falsey
@@ -110,12 +103,10 @@ module MiniKraken
 
         it 'should remove all associations' do
           subject.add_var(var_a)
-          assoc = Association.new(var_a, pea)
-          subject.add_assoc(assoc)
+          subject.add_assoc(var_a, pea)
 
           subject.add_var(var_b)
-          assoc = Association.new(var_b, pod)
-          subject.add_assoc(assoc)
+          subject.add_assoc(var_b, pod)
 
           subject.clear
           expect(subject.fresh?(var_a)).to be_truthy
@@ -125,30 +116,27 @@ module MiniKraken
         it 'should propagate associations up in the environment hierarchy' do
           parent = Environment.new
           parent.add_var(var_a)
-          # parent.add_var(var_c)
           instance = Environment.new(parent)
           instance.add_var(var_b)
-          # instance.add_var(var_c_bis) # Should shadow parent's c variable
 
           outcome = Outcome.new(:"#s", instance)
-          outcome.add_assoc(Association.new(var_a, pea))
-          outcome.add_assoc(Association.new(var_b, pod))
-          # outcome.add_assoc(Association.new(var_c_bis, pad))
-          expect(outcome.associations.size).to eq(2)          
-          
+          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)         
+          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(outcome.associations).to be_empty
           expect(parent.associations[var_b.name]).to be_nil
-          expect(parent.associations[var_a.name]).not_to be_nil          
+          expect(parent.associations[var_a.name]).not_to be_nil
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/core/equals_spec.rb

@@ -49,21 +49,21 @@ module MiniKraken
         let(:env) { Environment.new }
         let(:var_q) { build_var('q') }
         let(:ref_q) do
-          dummy = var_q # Force dependency
+          var_q # Force dependency
           build_var_ref('q')
         end
         let(:ref_q_bis) do
-          dummy = var_q # Force dependency
+          var_q # Force dependency
           build_var_ref('q')
         end
         let(:var_x) { build_var('x') }
         let(:ref_x) do
-          dummy = var_x  # Force dependency
+          var_x  # Force dependency
           build_var_ref('x')
         end
         let(:var_y) { build_var('y') }
         let(:ref_y) do
-          dummy = var_y  # Force dependency
+          var_y  # Force dependency
           build_var_ref('y')
         end
 
@@ -246,7 +246,7 @@ module MiniKraken
           result = solve_for(ref_x, ref_y)
 
           expect(result).to be_successful
-          expect(env.associations.size).to eq(2) # Symmetric association
+          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
@@ -285,7 +285,7 @@ module MiniKraken
           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)
@@ -297,7 +297,7 @@ module MiniKraken
 
           expect(result.resultant).to eq(:"#u")
           expect(result.associations).to be_empty
-        end        
+        end
       end # context
     end # describe
   end # module

data/spec/core/fail_spec.rb

@@ -3,7 +3,7 @@
 require_relative '../spec_helper' # Use the RSpec framework
 
 # Load the class under test
-require_relative '../../lib/mini_kraken/core/fail' 
+require_relative '../../lib/mini_kraken/core/fail'
 
 module MiniKraken
   module Core
@@ -14,7 +14,7 @@ module MiniKraken
         it 'should have one instance' do
           expect { Fail.instance }.not_to raise_error
         end
-        
+
         it 'should know its name' do
           expect(subject.name).to eq('fail')
         end
@@ -24,20 +24,20 @@ module MiniKraken
         it 'should unconditionally return a failure result' do
           args = double('fake-args')
           env = double('fake-env')
-          
+
           solver = nil
           expect { solver = subject.solver_for(args, env) }.not_to raise_error
-          
+
           # Solver should quack like a Fiber
           dummy_arg = double('dummy-stuff')
           result = solver.resume(dummy_arg)
           expect(result).to eq(Failure)
-          
+
           # Only one "solution", next 'resume' call should return nil
           result = solver.resume(dummy_arg)
-          expect(result).to be_nil          
+          expect(result).to be_nil
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/core/goal_spec.rb

@@ -22,15 +22,15 @@ module MiniKraken
         it 'should accept one nullary relation and empty argument array' do
           expect { Goal.new(nullary_relation, []) }.not_to raise_error
         end
-        
+
         it 'should accept one binary relation and 2-elements array' do
           expect { Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pod)]) }.not_to raise_error
-        end        
+        end
 
         it 'should know its relation' do
           expect(subject.relation).to eq(binary_relation)
         end
-        
+
         it 'should know its actual arguments' do
           expectations = [KSymbol.new(:pea), KSymbol.new(:pod)]
           expect(subject.actuals).to eq(expectations)
@@ -41,21 +41,21 @@ module MiniKraken
         it 'should fail if relation does not succeed' do
           solver = subject.attain(env)
           expect(solver.resume).not_to be_successful
-          
+
           # No more solution...
           expect(solver.resume).to be_nil
         end
-        
+
         it 'should succeed if relation succeeds' do
-          instance = Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pea)]) 
-          
+          instance = Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pea)])
+
           solver = instance.attain(env)
           expect(solver.resume).to be_successful
-          
+
           # No more solution...
           expect(solver.resume).to be_nil
-        end      
+        end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/core/k_symbol_spec.rb

@@ -20,12 +20,11 @@ module MiniKraken
         it 'should know its value' do
           expect(subject.value).to eq(a_value)
         end
-        
+
         it 'should know that it is a ground term' do
           env = double('mock-env')
-          visitees = double('fake-visitees')
           expect(subject.ground?(env)).to be_truthy
-        end        
+        end
       end # context
 
       context 'Provided services:' do
@@ -39,7 +38,7 @@ module MiniKraken
           expect(subject).not_to be_eql(another)
 
           # Different type, same value
-          yet_another = OpenStruct.new(:value => :pea)
+          yet_another = OpenStruct.new(value: :pea)
           expect(subject).not_to be_eql(yet_another)
         end
 
@@ -53,11 +52,11 @@ module MiniKraken
           expect(subject == another).to be_falsy
 
           # Same duck type, same value
-          yet_another = OpenStruct.new(:value => :pea)
+          yet_another = OpenStruct.new(value: :pea)
           expect(subject == yet_another).to be_truthy
 
           # Different duck type, different value
-          still_another = OpenStruct.new(:value => :pod)
+          still_another = OpenStruct.new(value: :pod)
           expect(subject == still_another).to be_falsy
 
           # Default Ruby representation, same value