mini_kraken 0.2.03 → 0.3.03

data/spec/composite/list_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/composite/list'
+
+module MiniKraken
+  module Composite
+    describe List do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+
+      let(:pea) { k_symbol(:pea) }
+      let(:pod) { k_symbol(:pod) }
+      let(:corn) { k_symbol(:corn) }
+
+      context 'Module as a factory:' do
+        subject { List }
+
+        it 'builds a pair wiht one argument (= one element proper list)' do
+          pair = subject.cons(pea)
+          expect(pair.car).to eq(pea)
+          expect(pair.cdr).to be_nil
+        end
+
+        it 'builds a pair with two explicit arguments' do
+          pair = subject.cons(pea, pod)
+          expect(pair.car).to eq(pea)
+          expect(pair.cdr).to eq(pod)
+        end
+
+        it 'builds a null list from an empty array' do
+          l = subject.make_list([])
+          expect(l).to be_kind_of(ConsCell)
+          expect(l).to be_null
+        end
+
+        it 'builds a proper list from an non-empty array' do
+          l = subject.make_list([pea, pod, corn])
+
+          expect(l.car).to eq(pea)
+          expect(l.cdr.car).to eq(pod)
+          expect(l.cdr.cdr.car).to eq(corn)
+          expect(l.cdr.cdr.cdr).to be_nil
+        end
+      end # context
+    end # describz
+  end # module
+end # module

data/spec/core/any_value_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/any_value'
+
+
+module MiniKraken
+  module Core
+    describe AnyValue do
+      let(:some_rank) { 2 }
+      subject { AnyValue.new(some_rank) }
+
+      context 'Initialization:' do
+        it "should be initialized with a variable's rank" do
+          expect { AnyValue.new(0) }.not_to raise_error
+        end
+
+        it 'should know its rank' do
+          expect(subject.rank).to eq(some_rank)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should compare itself to another instance' do
+          expect(subject ==  AnyValue.new(some_rank)).to be_truthy
+          expect(subject ==  AnyValue.new(1)).to be_falsey
+        end
+
+        it 'should compare itself to an integer' do
+          expect(subject == some_rank).to be_truthy
+          expect(subject == 1).to be_falsey
+        end
+
+        it 'should compare itself to a symbol' do
+          expect(subject == :_2).to be_truthy
+          expect(subject == :_1).to be_falsey
+        end
+
+        it 'should know its text representation' do
+          expect(subject.to_s).to eq('_2')
+        end
+
+        it 'should know that it represents a non-pinned variable' do
+          ctx = double('dummy-context')
+          expect(subject).not_to be_pinned(ctx)
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/core/arity_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/arity'
+
+module MiniKraken
+  module Core
+    describe Arity do
+      subject { Arity.new(0, 1) }
+
+      context 'Initialization:' do
+        it 'should be initialized with two integers' do
+          expect { Arity.new(0, 1) }.not_to raise_error
+        end
+
+        it 'should know its lower bound' do
+          expect(subject.low).to eq(0)
+        end
+
+        it 'should know its upper bound' do
+          expect(subject.high).to eq(1)
+        end
+      end # context
+
+      context 'Initialization:' do
+        it 'should know whether is is nullary' do
+          expect(subject).not_to be_nullary
+
+          instance = Arity.new(0, '*')
+          expect(instance).not_to be_nullary
+
+          instance = Arity.new(0, 0)
+          expect(instance).to be_nullary
+        end
+
+        it 'should know whether is is unary' do
+          expect(subject).not_to be_unary
+
+          instance = Arity.new(1, 2)
+          expect(instance).not_to be_unary
+
+          instance = Arity.new(1, 1)
+          expect(instance).to be_unary
+        end
+
+        it 'should know whether is is binary' do
+          expect(subject).not_to be_binary
+
+          instance = Arity.new(1, 2)
+          expect(instance).not_to be_binary
+
+          instance = Arity.new(2, 2)
+          expect(instance).to be_binary
+        end
+
+        it 'should know whether is is variadic' do
+          expect(subject).not_to be_variadic
+
+          instance = Arity.new(1, '*')
+          expect(instance).to be_variadic
+        end
+
+        it 'should know whether an integer fits the arity range' do
+          expect(subject.match?(0)).to be_truthy
+          expect(subject.match?(1)).to be_truthy
+          expect(subject.match?(2)).to be_falsey
+
+          instance = Arity.new(2, '*')
+          expect(instance.match?(1)).to be_falsey
+          expect(instance.match?(2)).to be_truthy
+          expect(instance.match?(42)).to be_truthy
+        end
+
+        it 'should know whether is equal to another arity' do
+          itself = subject # Renaming as workaround to Rubocop complaint
+          expect(subject == itself).to be_truthy
+
+          same = Arity.new(0, 1)
+          expect(subject == same).to be_truthy
+
+          same_low = Arity.new(0, 2)
+          expect(subject == same_low).to be_falsey
+
+          same_high = Arity.new(1, 1)
+          expect(subject == same_high).to be_falsey
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/association_copy_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/context'
+require_relative '../../lib/mini_kraken/core/log_var'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/association_copy'
+
+module MiniKraken
+  module Core
+    describe AssociationCopy do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+
+      let(:pea) { k_symbol(:pea) }
+      let(:q_assoc) { Association.new('q', pea) }
+      subject { AssociationCopy.new('q_x', q_assoc) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and an association' do
+          expect { AssociationCopy.new('q_x', q_assoc) }.not_to raise_error
+        end
+
+        it 'should be initialized with a variable and an association' do
+          q_x_var = LogVar.new('q_x')
+          expect { AssociationCopy.new(q_x_var, q_assoc) }.not_to raise_error
+        end
+
+        it 'should know the internal variable name' do
+          expect(subject.i_name).to eq('q_x')
+        end
+
+        it 'should know the associated value' do
+          expect(subject.value).to eq(pea)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:ctx) { Context.new }
+
+        it 'should tell whether the associated value is pinned' do
+          ctx.add_vars(%w[q x q_x])
+          expect(subject).to be_pinned(ctx)
+
+          a = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          instance = AssociationCopy.new(ctx.lookup('q_x'), a)
+          expect(instance).not_to be_pinned(ctx)
+        end
+
+        it 'should tell whether the associated value is floating' do
+          ctx.add_vars(%w[q x q_x])
+
+          expect(subject).not_to be_floating(ctx)
+        end
+
+        it 'should retrieve the dependencies in its value' do
+          expect(subject.dependencies(ctx)).to be_empty
+
+          ctx.add_vars(%w[q x q_x])
+          a = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          instance = AssociationCopy.new(ctx.lookup('q_x'), a)
+          expect(instance.dependencies(ctx).size).to eq(1)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/association_spec.rb

@@ -1,8 +1,10 @@
 # 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 '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/context'
+require_relative '../../lib/mini_kraken/core/log_var'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/core/association'
@@ -10,7 +12,9 @@ require_relative '../../lib/mini_kraken/core/association'
 module MiniKraken
   module Core
     describe Association do
-      let(:pea) { KSymbol.new(:pea) }
+      include MiniKraken::FactoryAtomic # Use mix-in module
+
+      let(:pea) { k_symbol(:pea) }
       subject { Association.new('q', pea) }
 
       context 'Initialization:' do
@@ -19,7 +23,7 @@ module MiniKraken
         end
 
         it 'should be initialized with a variable and a value' do
-          expect { Association.new(Variable.new('p'), pea) }.not_to raise_error
+          expect { Association.new(LogVar.new('p'), pea) }.not_to raise_error
         end
 
         it 'should know the variable name' do
@@ -32,6 +36,29 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        let(:ctx) { Context.new }
+
+        it 'should tell whether the associated value is pinned' do
+          ctx.add_vars(%w[q x])
+
+          expect(subject).to be_pinned(ctx)
+          instance = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          expect(instance).not_to be_pinned(ctx)
+        end
+
+        it 'should tell whether the associated value is floating' do
+          ctx.add_vars(%w[q x])
+
+          expect(subject).not_to be_floating(ctx)
+        end
+
+        it 'should retrieve the dependencies in its value' do
+          expect(subject.dependencies(ctx)).to be_empty
+
+          ctx.add_vars(%w[q x])
+          instance = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          expect(instance.dependencies(ctx).size).to eq(1)
+        end
       end # context
     end # describe
   end # module

data/spec/core/blackboard_spec.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
+require_relative '../../lib/mini_kraken/core/scope'
+require_relative '../../lib/mini_kraken/composite/cons_cell'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/blackboard'
+
+module MiniKraken
+  module Core
+    describe Blackboard do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      subject { Blackboard.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Blackboard.new }.not_to raise_error
+        end
+
+        it "shouldn't have internal name entry at initialization" do
+          expect(subject.i_name2moves).to be_empty
+        end
+
+        it 'should have an empty association queue at initialization' do
+          expect(subject.move_queue).to be_empty
+        end
+
+        it 'should be empty at initialization' do
+          expect(subject).to be_empty
+        end
+
+        it 'should be ready to assign a serial number' do
+          expect(subject.next_serial_num).to be_zero
+        end
+
+        it 'should have its resultant attribute un-initialized' do
+          expect(subject.resultant).to be_nil
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:a_ser_num) { 42 }
+        let(:pea) { k_symbol(:pea) }
+        let(:pod) { k_symbol(:pod) }
+        let(:x_assoc) { Core::Association.new('x', pea) }
+        let(:y_assoc) { Core::Association.new('y', pod) }
+        let(:z_assoc) { Core::Association.new('z', pea) }
+
+        def var_ref(aName)
+          LogVarRef.new(aName)
+        end
+
+        def cons(car, cdr = nil)
+          Composite::ConsCell.new(car, cdr)
+        end
+
+        it 'should allow the enqueuing of one association' do
+          expect { subject.enqueue_association(x_assoc) }.not_to raise_error
+          expect(subject.i_name2moves).not_to be_empty
+          expect(subject.move_queue).not_to be_empty
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].first).to eq(0)
+          expect(subject.last_move).to eq(x_assoc)
+        end
+
+        it 'should allow the enqueuing of multiple associations' do
+          expect(subject.enqueue_association(x_assoc)).to eq(x_assoc)
+          expect { subject.enqueue_association(y_assoc) }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(2)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['y']).to be_kind_of(Array)
+          expect(subject.i_name2moves['y'].first).to eq(1)
+          expect(subject.last_move).to eq(y_assoc)
+        end
+
+        it 'should allow the enqueuing of multiple associations for same i_name' do
+          subject.enqueue_association(x_assoc)
+
+          x_assoc_b = Core::Association.new('x', double('something'))
+          expect { subject.enqueue_association(x_assoc_b) }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(1)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].size).to eq(2)
+          expect(subject.i_name2moves['x'].last).to eq(1)
+          expect(subject.move_queue.pop).to eq(x_assoc_b)
+        end
+
+        it 'should allow the removal of the association at TOS position' do
+          subject.enqueue_association(x_assoc)
+          x_assoc_b = Core::Association.new('x', double('something'))
+          subject.enqueue_association(x_assoc_b)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves.size).to eq(1)
+
+          expect { subject.send(:dequeue_item) }.not_to raise_error
+          expect(subject.move_queue.size).to eq(1)
+          expect(subject.i_name2moves.size).to eq(1)
+
+          subject.send(:dequeue_item)
+          expect(subject.move_queue).to be_empty
+          expect(subject.i_name2moves).to be_empty
+        end
+
+        it 'should allow the enqueuing of a backtrack bookmark' do
+          subject.enqueue_association(x_assoc)
+
+          expect { subject.place_bt_point }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(1)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].size).to eq(1)
+          expect(subject.last_move).to be_kind_of(Bookmark)
+        end
+
+        it 'should allow the enqueuing of a scope bookmark' do
+          subject.enqueue_association(x_assoc)
+
+          expect { subject.enter_scope }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(1)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].size).to eq(1)
+          expect(subject.last_move).to be_kind_of(Bookmark)
+        end
+
+        it 'should allow the fusion of two unbound variables' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+          subject.enqueue_fusion(fusion)
+
+          expect(subject.move_queue.size).to eq(pre_size + 1)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          expect(subject.vars2cv[q_var.i_name]).to eq(q_x_var.i_name)
+          expect(subject.vars2cv[x_var.i_name]).to eq(q_x_var.i_name)
+        end
+
+        it 'should allow the fusion of one unbound and one floating variable' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          assoc_x = Association.new('x', cons(LogVarRef.new('y'), pea))
+          subject.enqueue_association(assoc_x)
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+
+          subject.enqueue_fusion(fusion)
+          expect(subject.move_queue.size).to eq(pre_size + 2)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          indices = subject.i_name2moves[q_x_var.i_name]
+          expect(indices.size).to eq(2) # 2 = 1 Fusion + 1 AssocCopy
+          new_assoc = subject.move_queue[indices.last]
+          expect(new_assoc.value).to eq(assoc_x.value)
+        end
+
+        it 'should allow the fusion of two floating variables' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          assoc_q = Association.new('x', cons(pod, var_ref('z')))
+          subject.enqueue_association(assoc_q)
+          assoc_x = Association.new('x', cons(var_ref('y'), pea))
+          subject.enqueue_association(assoc_x)
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+
+          subject.enqueue_fusion(fusion)
+          expect(subject.move_queue.size).to eq(pre_size + 3)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          indices = subject.i_name2moves[q_x_var.i_name]
+          expect(indices.size).to eq(3)
+          new_move1 = subject.move_queue[indices[0]]
+          expect(new_move1).to be_kind_of(Core::Fusion)
+          new_move2 = subject.move_queue[indices[1]]
+          expect(new_move2.value).to eq(assoc_q.value)
+          new_move3 = subject.move_queue[indices[2]]
+          expect(new_move3.value).to eq(assoc_x.value)
+        end
+
+        it 'should allow the removal of a fusion object at TOS position' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+          subject.enqueue_fusion(fusion)
+
+          expect(subject.move_queue.size).to eq(pre_size + 1)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          expect(subject.vars2cv[q_var.i_name]).to eq(q_x_var.i_name)
+          expect(subject.vars2cv[x_var.i_name]).to eq(q_x_var.i_name)
+
+          expect { subject.send(:dequeue_item) }.not_to raise_error
+          expect(subject.move_queue.size).to eq(pre_size)
+          expect(subject.i_name2moves).not_to be_include(q_x_var.i_name)
+          expect(subject.vars2cv[q_var.i_name]).to be_nil
+          expect(subject.vars2cv[x_var.i_name]).to be_nil
+        end
+
+        it 'should retrieve association for a given i_name (0 fusion)' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+
+          x_assoc_b = Core::Association.new('x', double('something'))
+          subject.enqueue_association(x_assoc_b)
+          expect(subject.associations_for('z')).to be_empty
+          expect(subject.associations_for('y').size).to eq(1)
+          expect(subject.associations_for('x').size).to eq(2)
+          expect(subject.associations_for('x').last).to eq(x_assoc_b)
+        end
+
+        it 'should retrieve association for a given i_name (1 fusion)' do
+          subject.enqueue_association(x_assoc)
+          expect(subject.associations_for('x').size).to eq(1)
+          expect(subject.associations_for('z').size).to eq(0)
+          expect(subject.associations_for('z', true).size).to eq(0)
+
+          x_z_var = LogVar.new('x_z')
+          fusion = Fusion.new(x_z_var.i_name, %w[x z])
+          subject.enqueue_fusion(fusion)
+          expect(subject.associations_for('z', true).size).to eq(1)
+          x_z_assoc = Core::Association.new(x_z_var.i_name, var_ref('y'))
+          subject.enqueue_association(x_z_assoc)
+          expect(subject.associations_for('z', false).size).to eq(0)
+          expect(subject.associations_for('z', true).size).to eq(2)
+          expect(subject.associations_for('x', false).size).to eq(1)
+          expect(subject.associations_for('x', true).size).to eq(2)
+        end
+
+        it 'should accept the succeeded notification' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.succeeded!
+          expect(subject).to be_success
+          expect(subject.move_queue.size).to eq(2)
+        end
+
+        it 'should accept the failed notification in absence of bookmarks' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.failed!
+          expect(subject).to be_failure
+          expect(subject.move_queue).to be_empty
+          expect(subject.i_name2moves).to be_empty
+        end
+
+        it 'should accept the failed notification with backtrack' do
+          x_assoc2 = Core::Association.new('x', pea)
+
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.place_bt_point
+          subject.enqueue_association(z_assoc)
+          subject.enqueue_association(x_assoc2)
+          expect(subject.i_name2moves['x'].size).to eq(2)
+
+          subject.failed!
+          expect(subject.resultant).to eq(:"#u")
+          expect(subject.last_move).to be_kind_of(Core::Bookmark)
+          expect(subject.i_name2moves.include?('z')).to be_falsey
+          expect(subject.i_name2moves['x'].size).to eq(1)
+        end
+
+        it 'should accept the failed notification on a bookmark' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.place_bt_point # Backtrack point bookmark added...
+
+          subject.enqueue_association(z_assoc)
+          subject.enter_scope # Scope bookmark
+
+          expect(subject.move_queue.size).to eq(5)
+
+          subject.failed!
+          expect(subject.resultant).to eq(:"#u")
+          expect(subject.move_queue.size).to eq(3) # 3 = 2 assocs + 1 bookmark
+        end
+      end # context
+    end # describe
+  end # module
+end # module