mini_kraken 0.2.02 → 0.3.02

data/spec/core/bookmark_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/bookmark'
+
+module MiniKraken
+  module Core
+    describe Bookmark do
+      let(:one_ser_num) { 42 }
+      let(:a_kind) { :scope }
+      subject { Bookmark.new(a_kind, one_ser_num) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a Symbol and an Integer' do
+          expect { Bookmark.new(a_kind, one_ser_num) }.not_to raise_error
+        end
+
+        it 'should know its kind' do
+          expect(subject.kind).to eq(a_kind)
+        end
+
+        it 'should know its serial number' do
+          expect(subject.ser_num).to eq(one_ser_num)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should compare to another instance' do
+          same = Bookmark.new(a_kind, one_ser_num)
+          expect(subject).to eq(same)
+
+          distinct = Bookmark.new(a_kind, 3)
+          expect(subject).not_to eq(distinct)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/context_spec.rb

@@ -0,0 +1,245 @@
+# 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/log_var'
+require_relative '../../lib/mini_kraken/composite/all_composite'
+
+require_relative '../support/factory_atomic'
+require_relative '../support/factory_methods'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/context'
+
+module MiniKraken
+  module Core
+    describe Context do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      subject { Context.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Context.new }.not_to raise_error
+        end
+
+        it 'should have an empty symbol table' do
+          expect(subject.symbol_table).to be_empty
+        end
+
+        it 'should have an empty blackboard' do
+          expect(subject.blackboard).to be_empty
+        end
+      end # context
+
+      context 'Provided services:' do
+        def var(aName)
+          LogVar.new(aName)
+        end
+
+        def cons(term1, term2 = nil)
+          Composite::ConsCell.new(term1, term2)
+        end
+
+        it 'should accept the addition of an entry in symbol table' do
+          subject.insert(var('x'))
+          expect(subject.symbol_table).not_to be_empty
+          expect(subject.symbol_table.current_scope.defns['x']).to be_kind_of(LogVar)
+        end
+
+        it 'should create one or more variables from name(s)' do
+          # Case: single name
+          subject.add_vars('x')
+          expect(subject.symbol_table).not_to be_empty
+          expect(subject.symbol_table.current_scope.defns['x']).to be_kind_of(LogVar)
+
+          # Case: multiple names
+          subject.add_vars(%w[y z])
+          expect(subject.symbol_table.current_scope.defns['y']).to be_kind_of(LogVar)
+          expect(subject.symbol_table.current_scope.defns['z']).to be_kind_of(LogVar)
+        end
+
+        it 'should accept the addition of an association to a given i_name' do
+          i_name_x = subject.insert(var('x'))
+          i_name_y = subject.insert(var('y'))
+
+          expect(subject.associations_for('x')).to be_empty
+          something = double('something')
+          assoc_x = subject.associate('x', something)
+          expect(subject.associations_for('x')).to eq([assoc_x])
+
+          thing = double('thing')
+          assoc_y = Association.new(i_name_y, thing)
+          subject.enqueue_association(assoc_y)
+          expect(subject.associations_for('y')).to eq([assoc_y])
+
+          blob = double('blob')
+          assoc2_x = Association.new(i_name_x, blob)
+          subject.enqueue_association(assoc2_x)
+          expect(subject.associations_for('x')).to eq([assoc_x, assoc2_x])
+
+          var_y = subject.lookup('y')
+          foo = double('bar')
+          assoc2_y = subject.associate(var_y, foo)
+          expect(subject.associations_for('y')).to eq([assoc_y, assoc2_y])
+        end
+
+        it 'should allow the fusion of two variables' do
+          symb_tbl = subject.symbol_table
+          i_name_q = subject.insert(var('q'))
+          symb_tbl.enter_scope(Core::Scope.new)
+          i_name_x = subject.insert(var('x'))
+
+          expect(subject.associations_for('q')).to be_empty
+          something = double('something')
+          assoc_x = subject.associate('x', something)
+          expect(subject.associations_for('x')).to eq([assoc_x])
+          pre_queue_size = subject.blackboard.move_queue.size
+          fusion = subject.fuse(%w[q x])
+
+          expect(fusion).to be_kind_of(Fusion)
+          expect(fusion.elements).to eq(%w[q x].map { |e| subject.lookup(e).i_name })
+          expect(subject.blackboard.move_queue.size).to eq(pre_queue_size + 2)
+          expect(subject.cv2vars).to be_include(fusion.i_name)
+          expect(subject.cv2vars[fusion.i_name]).to eq(fusion.elements)
+          expect(subject.blackboard.vars2cv[i_name_q]).to eq(fusion.i_name)
+          expect(subject.blackboard.vars2cv[i_name_x]).to eq(fusion.i_name)
+          expect(subject.associations_for('q')).not_to be_empty
+        end
+
+        it 'should allow the search of an entry based on its name' do
+          symb_tbl = subject.symbol_table
+          subject.add_vars(%w[q x])
+          symb_tbl.enter_scope(Core::Scope.new)
+          subject.add_vars(%w[q y])
+
+          # Search for unknown name
+          expect(subject.lookup('z')).to be_nil
+
+          # Search for existing unique names
+          expect(subject.lookup('y')).to eq(symb_tbl.current_scope.defns['y'])
+          expect(subject.lookup('x')).to eq(symb_tbl.root.defns['x'])
+
+          # Search for redefined name
+          expect(subject.lookup('q')).to eq(symb_tbl.current_scope.defns['q'])
+        end
+
+        it 'should determine the ranks of fresh variables' do
+          subject.add_vars(%w[x y z])
+
+          ref_y = LogVarRef.new('y')
+          subject.associate('x', ref_y)
+          subject.send(:calc_ranking)
+          expect(subject.ranking.size).to eq(2)
+          i_name_y = subject.lookup('y').i_name
+          expect(subject.ranking[i_name_y]).to eq(0)
+          i_name_z = subject.lookup('z').i_name
+          expect(subject.ranking[i_name_z]).to eq(1)
+        end
+
+        it 'should allow entering in a new scope' do
+          new_scope = Scope.new
+          expect { subject.enter_scope(new_scope) }.not_to raise_error
+          expect(subject.symbol_table.current_scope).to eq(new_scope)
+        end
+
+        it 'should allow leaving out current scope' do
+          subject.add_vars(%w[q x])
+          x_val = k_symbol(:foo)
+          assoc_x = subject.associate('x', x_val) # x => :foo
+          expect(subject.blackboard.move_queue.size).to eq(1)
+          new_scope = Scope.new
+          subject.enter_scope(new_scope) # Adds one bookmark
+          expect(subject.blackboard.move_queue.size).to eq(2)
+          subject.add_vars(%w[w x y z])
+
+          q_val = LogVarRef.new('x')
+          assoc_q = subject.associate('q', q_val)
+          w_val = k_symbol(:bar)
+          subject.associate('w', w_val)
+          x2_val = LogVarRef.new('z')
+          assoc2_x = subject.associate('x', x2_val)
+          y_val = k_symbol(:foobar)
+          subject.associate('y', y_val)
+          # x => :foo
+          # ------
+          # q => x
+          # w => :bar
+          # x => z
+          # y => :foobar
+          expect(subject.blackboard.i_name2moves.keys.size).to eq(5)
+          expect(subject.blackboard.move_queue.size).to eq(6)
+          # require 'debug'
+          expect { subject.leave_scope }.not_to raise_error
+          # Expected state:
+          # x => :foo
+          # q => x'
+          # x' => z
+          expect(subject.blackboard.move_queue.size).to eq(3)
+          symb_table = subject.symbol_table
+          expect(symb_table.current_scope).to eq(symb_table.root)
+          expect(subject.blackboard.i_name2moves.keys.size).to eq(3)
+          expect(subject.blackboard.move_queue).to eq([assoc_x, assoc_q, assoc2_x])
+        end
+
+        it 'should substitute values of associations (if needed)' do
+          subject.add_vars(%w[q x y z])
+
+          x_ref = LogVarRef.new('x')
+          foobar = Composite::ConsCell.new(k_symbol(:foo), k_symbol(:bar))
+          q_val = Composite::ConsCell.new(x_ref, foobar)
+          assoc_q = subject.associate('q', q_val)
+          subject.send(:calc_ranking)
+
+          expect(subject.send(:substitute, assoc_q).to_s).to eq('(_0 :foo . :bar)')
+        end
+
+        it 'should build a solution (atomic terms)' do
+          subject.add_vars(%w[x y z])
+
+          subject.succeeded!
+          sol = subject.build_solution
+          expect(sol.size).to eq(3)
+          expect(sol['x']).to eq(:_0)
+          expect(sol['y']).to eq(:_1)
+          expect(sol['z']).to eq(:_2)
+
+          foo = k_symbol(:foo)
+          subject.associate('x', foo)
+          sol = subject.build_solution
+          expect(sol.size).to eq(3)
+          expect(sol['x']).to eq(foo)
+          expect(sol['y']).to eq(:_0)
+          expect(sol['z']).to eq(:_1)
+
+          bar = k_symbol(:bar)
+          subject.associate('y', bar)
+          sol = subject.build_solution
+          expect(sol.size).to eq(3)
+          expect(sol['x']).to eq(foo)
+          expect(sol['y']).to eq(bar)
+          expect(sol['z']).to eq(:_0)
+        end
+
+        it 'should build a solution (composite terms)' do
+          subject.add_vars(['l'])
+          new_scope = Scope.new
+          subject.enter_scope(new_scope)
+          a = k_symbol(:a)
+          b = k_symbol(:b)
+          c = k_symbol(:c)
+          subject.add_vars(['d'])
+          d_ref = LogVarRef.new('d')
+          subject.associate('l', cons(cons(a, cons(b)), d_ref))
+          subject.associate('d', cons(c))
+
+          subject.succeeded!
+          sol = subject.build_solution
+          expect(sol.size).to eq(1)
+
+          # TODO: fix next line. Actual is: ((a :c))
+          expect(sol['l'].to_s).to eq('((:a :b) :c)')
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/core/core_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+require_relative '../../lib/mini_kraken/core/all_core'
+
+module MiniKraken
+  module Core
+    # Integration-in-the-small testing
+    describe 'Core Classes' do
+      let(:ctx) { Context.new }
+
+      context 'Executing nullary goals:' do
+        def var(aName)
+          LogVar.new(aName)
+        end
+
+        it 'should execute nullary fail goal' do
+          # Equivalent to frame 1:7
+          goal = Goal.new(Fail.instance, [])
+          ctx.insert(var('q'))
+          result = goal.achieve(ctx)
+          expect(result.resume).to eq(ctx)
+          expect(ctx).to be_failure
+          expect(ctx.associations_for('q')).to be_empty
+        end
+
+        it 'should execute nullary succeed goal' do
+          # Equivalent to frame 1:17
+          goal = Goal.new(Succeed.instance, [])
+          ctx.insert(var('q'))
+          result = goal.achieve(ctx)
+          expect(result.resume).to eq(ctx)
+          expect(ctx).to be_success
+          expect(ctx.associations_for('q')).to be_empty # RS: (_0)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/duck_fiber_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/environment'
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/core/duck_fiber'
@@ -9,62 +8,33 @@ require_relative '../../lib/mini_kraken/core/duck_fiber'
 module MiniKraken
   module Core
     describe DuckFiber do
-      subject { DuckFiber.new(:failure) }
+      let(:ctx) { Core::Context.new }
+      let(:callable) { -> { ctx.failed! } }
+      subject { DuckFiber.new(callable) }
 
       context 'Initialization:' do
-        it 'should be initialized with a symbol and an optional block' do
-          expect { DuckFiber.new(:failure) }.not_to raise_error
+        it 'could be initialized with a Proc' do
+          expect { DuckFiber.new(-> { ctx.failed }) }.not_to raise_error
+        end
 
-          expect { DuckFiber.new(:custom) { Outcome.new(:"#s") } }.not_to raise_error
+        it "could be initialized with an object that responds to 'call'" do
+          expect { DuckFiber.new(callable) }.not_to raise_error
         end
 
-        it 'should know its outcome' do
-          expect(subject.outcome).to eq(Failure)
+        it 'should know its callable object' do
+          expect(subject.callable).to eq(callable)
         end
       end # context
 
       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
-        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 be_successful
-          expect(outcome.parent).to be_nil
-
-          # Only one result should be yielded
-          expect(succeeding.resume).to be_nil
-        end
-
-        it 'should yield a distinct success object' do
-          instance1 = DuckFiber.new(:success)
-          outcome1 = instance1.resume
-
-          instance2 = DuckFiber.new(:success)
-          outcome2 = instance2.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) }
-          outcome = nil
-          expect { outcome = tailored.resume }.not_to raise_error
-          expect(outcome).to eq(Outcome.new(:"#s", parent))
+        it 'should behave like a Fiber yielding the given Context' do
+          result = nil
+          expect { result = subject.resume }.not_to raise_error
+          expect(result).to eq(ctx)
+          expect(ctx).to be_failure
 
           # Only one result should be yielded
-          expect(tailored.resume).to be_nil
+          expect(subject.resume).to be_nil
         end
       end # context
     end # describe

data/spec/core/fail_spec.rb

@@ -21,17 +21,16 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
-        it 'should unconditionally return a failure result' do
-          args = double('fake-args')
-          env = double('fake-env')
+        let(:ctx) { Context.new }
 
+        it 'should unconditionally return a failure result' do
           solver = nil
-          expect { solver = subject.solver_for(args, env) }.not_to raise_error
+          expect { solver = subject.solver_for([], ctx) }.not_to raise_error
 
-          # Solver should quack like a Fiber
+          # Solver quacks like a Fiber
           dummy_arg = double('dummy-stuff')
           result = solver.resume(dummy_arg)
-          expect(result).to eq(Failure)
+          expect(result).to be_failure
 
           # Only one "solution", next 'resume' call should return nil
           result = solver.resume(dummy_arg)

data/spec/core/goal_spec.rb

@@ -1,22 +1,31 @@
 # frozen_string_literal: true
 
 require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/environment'
-require_relative '../../lib/mini_kraken/core/equals'
 require_relative '../../lib/mini_kraken/core/fail'
-require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/atomic/k_symbol'
+
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/core/goal'
 
 module MiniKraken
   module Core
+    class DummyRelation < Relation
+      def initialize
+        super('dummy', 2)
+      end
+
+      def solver_for(_actuals, ctx)
+        DuckFiber.new(-> { ctx.succeeded! })
+      end
+    end
+
     describe Goal do
       let(:nullary_relation) { Fail.instance }
-      subject { Goal.new(nullary_relation, []) }
-      let(:binary_relation) { Equals.instance }
-      let(:env) { Environment.new }
-      subject { Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pod)]) }
+      let(:binary_relation) { DummyRelation.new }
+      let(:ctx) { Context.new }
+      let(:actuals) { [Atomic::KSymbol.new(:pea), Atomic::KSymbol.new(:pod)] }
+      subject { Goal.new(binary_relation, actuals) }
 
       context 'Initialization:' do
         it 'should accept one nullary relation and empty argument array' do
@@ -24,7 +33,7 @@ module MiniKraken
         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
+          expect { Goal.new(binary_relation, [Term.new, Term.new]) }.not_to raise_error
         end
 
         it 'should know its relation' do
@@ -32,25 +41,26 @@ module MiniKraken
         end
 
         it 'should know its actual arguments' do
-          expectations = [KSymbol.new(:pea), KSymbol.new(:pod)]
+          expectations = [Atomic::KSymbol.new(:pea), Atomic::KSymbol.new(:pod)]
           expect(subject.actuals).to eq(expectations)
         end
       end # context
 
       context 'Provided services:' do
         it 'should fail if relation does not succeed' do
-          solver = subject.attain(env)
-          expect(solver.resume).not_to be_successful
+          instance = Goal.new(nullary_relation, [])
+          solver = instance.achieve(ctx)
+          expect(solver.resume).not_to be_success
 
           # 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, actuals)
 
-          solver = instance.attain(env)
-          expect(solver.resume).to be_successful
+          solver = instance.achieve(ctx)
+          expect(solver.resume).to be_success
 
           # No more solution...
           expect(solver.resume).to be_nil