mini_kraken 0.2.04 → 0.3.00

data/lib/mini_kraken/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniKraken
-  VERSION = '0.2.04'
+  VERSION = '0.3.00'
 end

data/spec/atomic/atomic_term_spec.rb

@@ -28,19 +28,19 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
-        it 'should know that it is a ground term' do
-          env = double('mock-env')
-          expect(subject.ground?(env)).to be_truthy
+        it 'should know that it is a pinned term' do
+          ctx = double('mock-ctx')
+          expect(subject.pinned?(ctx)).to be_truthy
         end
 
-        it 'should know that it is not a fresh term' do
-          env = double('mock-env')
-          expect(subject.fresh?(env)).to be_falsy
+        it 'should know that it is not a floating term' do
+          ctx = double('mock-ctx')
+          expect(subject.floating?(ctx)).to be_falsy
         end
 
-        it 'should know its freshness' do
-          env = double('mock-env')
-          expect(subject.freshness(env).degree).to eq(:ground)
+        it 'should know that it is not an unbound term' do
+          ctx = double('mock-ctx')
+          expect(subject.unbound?(ctx)).to be_falsy
         end
 
         it 'performs data value comparison' do
@@ -76,19 +76,22 @@ module MiniKraken
         end
 
         it 'returns itself when receiving quote message' do
-          env = double('mock-env')
-          expect(subject.quote(env)).to eq(subject)
+          ctx = double('mock-ctx')
+          expect(subject.quote(ctx)).to eq(subject)
+        end
+
+        it 'should know it has no dependency on variable(s)' do
+          ctx = double('mock-ctx')
+          expect(subject.dependencies(ctx)).to be_empty
+        end
+
+        it 'should dup itself' do
+          substitutions = double('fake-substitutions')
+          duplicate = subject.dup_cond(substitutions)
+          expect(duplicate).to eq(subject) # same value
+          expect(duplicate).not_to be_equal(subject) # different object ids
         end
       end # context
-=begin
-      # An atomic term is by definition a ground term: since it doesn't contain
-      # any bound variable (in Prolog sense).
-      # @param _env [Vocabulary]
-      # @return [Freshness]
-      def freshness(_env)
-        Freshness.new(:ground, self)
-      end
-=end
     end # describe
   end # module
 end # module

data/spec/atomic/k_symbol_spec.rb

@@ -20,11 +20,6 @@ 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')
-          expect(subject.ground?(env)).to be_truthy
-        end
       end # context
 
       context 'Provided services:' do

data/spec/composite/cons_cell_spec.rb

@@ -2,6 +2,9 @@
 
 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/composite/cons_cell'
@@ -14,6 +17,7 @@ module MiniKraken
       let(:pea) { k_symbol(:pea) }
       let(:pod) { k_symbol(:pod) }
       let(:corn) { k_symbol(:corn) }
+      let(:ctx) { Core::Context.new }
       subject { ConsCell.new(pea, pod) }
 
       context 'Initialization:' do
@@ -25,6 +29,10 @@ module MiniKraken
           expect { ConsCell.new(pea, pod) }.not_to raise_error
         end
 
+        it 'could be initialized as null list' do
+          expect { ConsCell.null }.not_to raise_error
+        end
+
         it 'should know its car child' do
           expect(subject.car).to eq(pea)
         end
@@ -33,6 +41,7 @@ module MiniKraken
           expect(subject.cdr).to eq(pod)
         end
 
+
         it 'should know its children' do
           expect(subject.children).to eq([pea, pod])
         end
@@ -40,6 +49,7 @@ module MiniKraken
         it 'should know if it is empty (null)' do
           expect(subject).not_to be_null
           expect(ConsCell.new(nil, nil)).to be_null
+          expect(ConsCell.null).to be_null
           expect(NullList).to be_null
         end
 
@@ -68,6 +78,14 @@ module MiniKraken
           expect(subject.eql?(different)).to be_falsey
         end
 
+        it 'should set_car! another cons cell' do
+          instance = ConsCell.new(pea)
+          head = ConsCell.new(pod)
+          instance.set_car!(head)
+          expect(instance.car).to eq(head)
+          expect(instance.cdr).to be_nil
+        end
+
         it 'should set_cdr! another cons cell' do
           instance = ConsCell.new(pea)
           trail = ConsCell.new(pod)
@@ -76,6 +94,37 @@ module MiniKraken
           expect(instance.cdr).to eq(trail)
         end
 
+        it 'should set a member to some term' do
+          instance = ConsCell.null
+          head = ConsCell.new(pea)
+          trail = ConsCell.new(pod)
+          instance.set!(:car, head)
+          instance.set!(:cdr, trail)
+          expect(instance.car).to eq(head)
+          expect(instance.cdr).to eq(trail)
+        end
+
+        it 'should know whether it is pinned or not' do
+          # Case: all pair members are atomic items
+          expect(subject).to be_pinned(ctx)
+
+          # Case: cdr is nil
+          instance = ConsCell.new(pea)
+          expect(instance).to be_pinned(ctx)
+
+          # Case: embedded composite
+          nested = ConsCell.new(ConsCell.new(pod, pea), ConsCell.new(pea))
+          expect(nested).to be_pinned(ctx)
+
+          ctx.add_vars('q')
+          nested.set_cdr!(Core::LogVarRef.new('q'))
+          expect(nested).not_to be_pinned(ctx)
+          expect(nested).to be_floating(ctx)
+
+          ctx.associate('q', ConsCell.new(pea))
+          expect(nested).to be_pinned(ctx)
+        end
+
         it 'should provide a list representation of itself' do
           # Case of null list
           expect(NullList.to_s).to eq '()'
@@ -91,6 +140,11 @@ module MiniKraken
           # Case of two elements improper list
           expect(subject.to_s).to eq '(:pea . :pod)'
 
+          # Case of one element plus null list
+          cell = ConsCell.new(pea)
+          cell.set_cdr!(ConsCell.null)
+          expect(cell.to_s).to eq '(:pea)'
+
           # 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)'
@@ -103,6 +157,68 @@ module MiniKraken
           cell = ConsCell.new(ConsCell.new(pea), ConsCell.new(pod))
           expect(cell.to_s).to eq '((:pea) :pod)'
         end
+
+        it 'should know its dependencies' do
+          # Case: no var ref...
+          lst = ConsCell.new(ConsCell.new(pod, pea), ConsCell.new(pea))
+          expect(lst.dependencies(ctx)).to be_empty
+
+          # Case: multiple var refs
+          ctx.add_vars(%w[q x])
+          q_ref = Core::LogVarRef.new('q')
+          x_ref = Core::LogVarRef.new('x')
+          list2 = ConsCell.new(ConsCell.new(q_ref, pea), ConsCell.new(x_ref))
+          expect(list2.dependencies(ctx).size).to eq(2)
+          q_var = ctx.lookup('q')
+          x_var = ctx.lookup('x')
+          predicted = Set.new([q_var.i_name, x_var.i_name])
+          expect(list2.dependencies(ctx)).to eq(predicted)
+        end
+
+        it 'should, as list with atomic terms, provide an expanded copy' do
+          # Case of a list of atomic terms
+          lst = ConsCell.new(ConsCell.new(ConsCell.new(pea), pod))
+          representation = lst.to_s
+
+          copy = lst.expand(ctx, {})
+          expect(copy.to_s).to eq(representation)
+        end
+
+        it 'should, as list with variable refs, provide an expanded copy' do
+          # Case of a list of variable refs
+          ctx.add_vars(['x'])
+          x_ref = Core::LogVarRef.new('x')
+          x_var = ctx.lookup('x')
+          ctx.associate('x', Core::AnyValue.new(0))
+          lst = ConsCell.new(x_ref, ConsCell.new(x_ref))
+          substitutions = {}
+          substitutions[x_var.i_name] = Core::AnyValue.new(0)
+
+          copy = lst.expand(ctx, substitutions)
+          expect(copy.to_s).to eq('(_0 _0)')
+        end
+
+        it 'should provide a duplicate with variable replaced by their value' do
+          q_ref = Core::LogVarRef.new('q')
+          x_ref = Core::LogVarRef.new('x')
+          y_ref = Core::LogVarRef.new('y')
+          substitutions = {
+            'q' => ConsCell.new(pea, ConsCell.new(x_ref, y_ref)),
+            'x' => pod,
+            'y' => corn
+          }
+
+          # Basic case: variable ref points to an atomic value
+          expr = ConsCell.new(pea, x_ref)
+          duplicate = expr.dup_cond(substitutions)
+          expect(duplicate.to_s).to eq('(:pea . :pod)')
+
+          expr = ConsCell.new(pod, ConsCell.new(q_ref, y_ref))
+          duplicate = expr.dup_cond(substitutions)
+          expect(duplicate.car).to eq(pod)
+          expect(duplicate.cdr.car.to_s).to eq('(:pea :pod . :corn)')
+          expect(duplicate.to_s).to eq('(:pod (:pea :pod . :corn) . :corn)')
+        end
       end # context
     end # describe
   end # module

data/spec/composite/cons_cell_visitor_spec.rb

@@ -29,7 +29,7 @@ module MiniKraken
 
       context 'proper list visiting:' do
         it 'can visit a null list' do
-          null_list = ConsCell.new(nil)
+          null_list = ConsCell.null
           visitor = subject.df_visitor(null_list)
           expect(visitor.resume).to eq([:car, null_list])
           expect(visitor.resume).to eq([:car, nil])
@@ -89,6 +89,7 @@ module MiniKraken
 
         it 'can visit a three elements improper list' do
           l_improper = ConsCell.new(pea, ConsCell.new(pod, corn))
+          expect(l_improper.to_s).to eq('(:pea :pod . :corn)')
           visitor = subject.df_visitor(l_improper)
           expect(visitor.resume).to eq([:car, l_improper])
           expect(visitor.resume).to eq([:car, pea])
@@ -97,6 +98,18 @@ module MiniKraken
           expect(visitor.resume).to eq([:cdr, corn])
           expect(visitor.resume).to eq([:stop, nil])
         end
+
+        it 'smurch' do
+          composite = ConsCell.new(ConsCell.new(ConsCell.new(pea)), pod)
+          visitor = subject.df_visitor(composite)
+          expect(visitor.resume).to eq([:car, composite])
+          expect(visitor.resume).to eq([:car, composite.car])
+          expect(visitor.resume).to eq([:car, composite.car.car])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, pod])
+        end
       end # context
 
       context 'Skip visit of children of a ConsCell:' do
@@ -128,9 +141,9 @@ module MiniKraken
 
       context 'Circular structures visiting:' do
         it 'should cope with a circular graph' do
-          second_cell = ConsCell.new(pod)
+          second_cell = ConsCell.new(pea)
           first_cell = ConsCell.new(pea, second_cell)
-          second_cell.instance_variable_set(:@car, first_cell) # Ugly!
+          second_cell.set_car!(first_cell)
 
           visitor = subject.df_visitor(first_cell)
           expect(visitor.resume).to eq([:car, first_cell])

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,91 @@
+# 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
+          expect(subject == subject).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