mini_kraken 0.1.03 → 0.1.08

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

data/spec/core/succeed_spec.rb

@@ -24,18 +24,18 @@ module MiniKraken
         it 'should unconditionally return a success 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(BasicSuccess)
-          
+
           # 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

data/spec/core/variable_ref_spec.rb

@@ -18,10 +18,6 @@ module MiniKraken
         it 'should know the name of a variable' do
           expect(subject.var_name).to eq('q')
         end
-
-        # it 'should be fresh by default' do
-          # expect(subject).to be_fresh
-        # end
       end # context
 
       context 'Provided services:' do

data/spec/core/vocabulary_spec.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/association'
 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 '../support/factory_methods'
 
 # Load the class under test
-require_relative '../../lib/mini_kraken/core/vocabulary'
+# frozen_string_literal: true
 
+require_relative '../../lib/mini_kraken/core/vocabulary'
 
 module MiniKraken
   module Core
-
     class TestVocabulary
       include Vocabulary
 
@@ -21,16 +21,20 @@ module MiniKraken
       end
     end # class
 
+    # Helper module that simulates an environment-like object.
     module VariableBearer
       attr_reader :vars
+      attr_accessor :ivars
 
       def init_var_bearer
         @vars = {}
+        @ivars = {}
         self
       end
 
       def add_var(aVarName)
-        vars[aVarName] = aVarName.hash # Just for testing purposes
+        vars[aVarName] = Variable.new(aVarName)
+        ivars[aVarName] = Set.new([aVarName])
       end
     end # module
 
@@ -75,11 +79,11 @@ module MiniKraken
 
         it 'should provide a walker over ancestors' do
           walker = subject.ancestor_walker
-          expect(walker).to be_kind_of(Fiber)
-          expect(walker.resume).to eq(subject)
-          expect(walker.resume).to eq(mother)
-          expect(walker.resume).to eq(grandma)
-          expect(walker.resume).to be_nil
+          expect(walker).to be_kind_of(Enumerator)
+          expect(walker.next).to eq(subject)
+          expect(walker.next).to eq(mother)
+          expect(walker.next).to eq(grandma)
+          expect(walker.next).to be_nil
         end
 
         it 'should know if a variable is defined' do
@@ -99,11 +103,12 @@ module MiniKraken
         it 'should allow the addition of associations' do
           grandma.add_var('q')
           expect(subject['q']).to be_empty
-          mother.add_assoc(Association.new('q', pea))
+          res_add = mother.add_assoc('q', pea)
+          expect(res_add).to be_kind_of(Association)
           expect(subject['q'].size).to eq(1)
           expect(subject['q'].first.value).to eq(pea)
 
-          subject.add_assoc(Association.new('q', ref_x))
+          subject.add_assoc('q', ref_x)
           expect(subject['q'].size).to eq(2)
           expect(subject['q'].first.value).to eq(ref_x)
           expect(subject['q'].last.value).to eq(pea)
@@ -111,8 +116,8 @@ module MiniKraken
 
         it 'should allow the deletion of associations' do
           grandma.add_var('q')
-          mother.add_assoc(Association.new('q', pea))
-          subject.add_assoc(Association.new('q', ref_x))
+          mother.add_assoc('q', pea)
+          subject.add_assoc('q', ref_x)
           expect(mother.associations.size).to eq(1)
           expect(subject.associations.size).to eq(1)
 
@@ -127,18 +132,18 @@ module MiniKraken
           grandma.add_var('q')
           grandma.add_var('x')
           expect(subject.fresh?(ref_q)).to be_truthy
-          subject.add_assoc(Association.new('q', ref_x)) # Dependency: q --> x
+          subject.add_assoc('q', ref_x) # Dependency: q --> x
           expect(subject.fresh?(ref_x)).to be_truthy
         end
 
         it 'should say not fresh when variable --> atomic value' do
           grandma.add_var('q')
           grandma.add_var('x')
-          subject.add_assoc(Association.new('q', ref_x)) # Dependency: q --> x
+          subject.add_assoc('q', ref_x) # Dependency: q --> x
           expect(subject.fresh?(ref_q)).to be_truthy
 
           # Associate with an atomic term
-          subject.add_assoc(Association.new('q', pea))
+          subject.add_assoc('q', pea)
           expect(subject.fresh?(ref_q)).to be_falsey
         end
 
@@ -147,16 +152,16 @@ module MiniKraken
 
           # Composite having only atomic terms as leaf elements
           expr = cons(pea, cons(pod))
-          subject.add_assoc(Association.new('q', expr))
+          subject.add_assoc('q', expr)
           expect(subject.fresh?(ref_q)).to be_falsey
         end
 
         it 'say not fresh when variable --> composite of atomics & bound var' do
           grandma.add_var('q')
           grandma.add_var('x')
-          subject.add_assoc(Association.new('x', pea)) # Dependency: x --> pea
+          subject.add_assoc('x', pea) # Dependency: x --> pea
           expr = cons(pea, cons(pod, cons(ref_x)))
-          subject.add_assoc(Association.new('q', expr))
+          subject.add_assoc('q', expr)
           expect(subject.fresh?(ref_q)).to be_falsey
         end
 
@@ -164,7 +169,7 @@ module MiniKraken
           grandma.add_var('q')
           grandma.add_var('x')
           expr = cons(pea, cons(pod, cons(ref_x)))
-          subject.add_assoc(Association.new('q', expr))
+          subject.add_assoc('q', expr)
           expect(subject.fresh?(ref_q)).to be_truthy
         end
 
@@ -173,13 +178,14 @@ module MiniKraken
           grandma.add_var('x')
 
           # Beware of cyclic structure
-          subject.add_assoc(Association.new('q', ref_x)) # Dependency: q --> x
-          subject.add_assoc(Association.new('x', ref_q)) # Dependency: x --> q
+          subject.add_assoc('q', ref_x) # Dependency: q --> x
+          subject.add_assoc('x', ref_q) # Dependency: x --> q
           expect(subject.fresh?(ref_x)).to be_truthy
           expect(subject.fresh?(ref_q)).to be_truthy
+          expect(subject.associations).to be_empty
 
           # Associate with an atomic term
-          subject.add_assoc(Association.new('x', pea))
+          subject.add_assoc('x', pea)
           expect(subject.fresh?(ref_q)).to be_falsey
         end
 
@@ -190,16 +196,16 @@ module MiniKraken
             expect(subject.get_rank('c')).to eq(2)
           end
         end
-        
+
         it 'should clear the rankings' do
           expect(subject.get_rank('a')).to eq(0)
           expect(subject.get_rank('z')).to eq(1)
-          
+
           subject.clear_rankings
           expect(grandma.rankings).to be_empty
 
-          expect(subject.get_rank('z')).to eq(0)    
-          expect(subject.get_rank('a')).to eq(1)          
+          expect(subject.get_rank('z')).to eq(0)
+          expect(subject.get_rank('a')).to eq(1)
         end
       end # context
     end # describe