mini_kraken 0.2.02 → 0.3.02

data/spec/core/log_var_ref_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/context'
+require_relative '../../lib/mini_kraken/core/log_var'
+require_relative '../../lib/mini_kraken/atomic/k_symbol'
+require_relative '../../lib/mini_kraken/composite/cons_cell'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/log_var_ref'
+
+
+module MiniKraken
+  module Core
+    describe LogVarRef do
+      let(:ctx) { Context.new }
+      let(:foo) { Atomic::KSymbol.new(:foo) }
+      subject { LogVarRef.new('q') }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name' do
+          expect { LogVarRef.new('q') }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('q')
+        end
+
+        it 'should not know the internal name of the variable' do
+          expect(subject.i_name).to be_nil
+        end
+      end # context
+
+      context 'Provided services:' do
+        def var(aName)
+          LogVar.new(aName)
+        end
+
+        it 'should know whether its variable is unbound or not' do
+          v = var('q')
+          ctx.insert(v)
+          expect(subject).to be_unbound(ctx)
+          ctx.associate('q', double('something'))
+          expect(subject).not_to be_unbound(ctx)
+        end
+
+        it 'should know whether its variable is floating or not' do
+          ctx.add_vars(%w[q x])
+          expect(subject).not_to be_floating(ctx)
+
+          x_ref = LogVarRef.new('x')
+          ctx.associate('q', x_ref)
+          expect(subject).to be_floating(ctx)
+        end
+
+        it 'should know whether its variable is pinned or not' do
+          ctx.add_vars(%w[q x])
+          expect(subject).not_to be_pinned(ctx)
+
+          x_ref = LogVarRef.new('x')
+          ctx.associate('q', x_ref)
+          expect(subject).not_to be_pinned(ctx)
+
+          ctx.associate('x', foo)
+          expect(subject).to be_pinned(ctx)
+        end
+
+        it 'should return its variable as its sole dependency' do
+          ctx.add_vars('q')
+
+          expect(subject.i_name).to be_nil
+          expect(subject.dependencies(ctx).size).to eq(1)
+          v = ctx.lookup(subject.name)
+          expect(subject.i_name).to eq(v.i_name)
+          expect(subject.dependencies(ctx).to_a).to eq([v.i_name])
+        end
+
+        it 'should duplicate itself when its variable has no value' do
+          substitutions = { 'z' => foo }
+
+          result = subject.dup_cond(substitutions)
+          expect(result).to be_kind_of(LogVarRef)
+          expect(result.name).to eq(subject.name)
+        end
+
+        it 'should replace itself when its variable has an atomic value' do
+          substitutions = { 'q' => foo }
+
+          result = subject.dup_cond(substitutions)
+          expect(result).to eq(:foo)
+        end
+
+        it 'should replace itself when its variable has an atomic value' do
+          x_ref = LogVarRef.new('x')
+          substitutions = { 'q' => x_ref, 'x' => foo }
+
+          # The substitutions are chained
+          result = subject.dup_cond(substitutions)
+          expect(result).to be_kind_of(Atomic::KSymbol)
+          expect(result).to eq(:foo)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/log_var_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/log_var'
+
+
+module MiniKraken
+  module Core
+    describe LogVar do
+      subject { LogVar.new('q') }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name' do
+          expect { LogVar.new('q') }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('q')
+        end
+
+        it 'should have a frozen label' do
+          expect(subject.label).to be_frozen
+        end
+
+        it 'should know its default internal name' do
+          # By default: internal name == label
+          expect(subject.i_name).to eq(subject.label)
+        end
+
+        it 'should have a nil suffix' do
+          expect(subject.suffix).to be_nil
+        end
+      end # context
+
+      context 'Provided service:' do
+        let(:sample_suffix) { 'sample-suffix' }
+        it 'should have a label equal to its user-defined name' do
+          expect(subject.label).to eq(subject.name)
+        end
+
+        it 'should accept a suffix' do
+          expect { subject.suffix = sample_suffix }.not_to raise_error
+          expect(subject.suffix).to eq(sample_suffix)
+        end
+
+        it 'should calculate its internal name' do
+          # Rule: empty suffix => internal name == label
+          subject.suffix = ''
+          expect(subject.i_name).to eq(subject.label)
+
+          # Rule: suffix starting underscore: internal name = label + suffix
+          subject.suffix = '_10'
+          expect(subject.i_name).to eq(subject.label + subject.suffix)
+
+          # Rule: ... otherwise: internal name == suffix
+          subject.suffix = sample_suffix
+          expect(subject.i_name).to eq(subject.suffix)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/nullary_relation_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/nullary_relation'
+
+
+module MiniKraken
+  module Core
+    describe NullaryRelation do
+      subject { NullaryRelation.new('fail') }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name' do
+          expect { NullaryRelation.new('fail') }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('fail')
+        end
+
+        it 'should know its zero arity' do
+          expect(subject.arity).to be_nullary
+        end
+
+        it 'should be frozen' do
+          expect(subject).to be_frozen
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/parametrized_tem_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/relation'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/parametrized_term'
+
+module MiniKraken
+  module Core
+    describe ParametrizedTerm do
+      let(:specif) { Relation.new('disj2', 2) }
+      let(:arg1) { Term.new }
+      let(:arg2) { Term.new }
+      let(:arg3) { Term.new }
+      subject { ParametrizedTerm.new(specif, [arg1, arg2]) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a specification and actuals' do
+          expect { ParametrizedTerm.new(specif, [arg1, arg2]) }.not_to raise_error
+        end
+
+        it 'should fail when number of arguments out of arity range' do
+          err = StandardError
+          err_msg = 'Count of arguments (3) is out of allowed range (2, 2).'
+          expect { ParametrizedTerm.new(specif, [arg1, arg2, arg3]) }.to raise_error(err, err_msg)
+        end
+
+        it 'should know its specification' do
+          expect(subject.specification).to eq(specif)
+        end
+
+        it 'should know its actuals' do
+          expect(subject.actuals).to eq([arg1, arg2])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/relation_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/relation'
+
+
+module MiniKraken
+  module Core
+    describe Relation do
+      subject { Relation.new('caro', 2) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and an arity' do
+          expect { Relation.new('caro', Arity.new(2, 2)) }.not_to raise_error
+        end
+
+        it 'should be initialized with a name and an integer' do
+          expect { Relation.new('caro', 2) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('caro')
+        end
+
+        it 'should know its arity' do
+          expect(subject.arity).to eq(Arity.new(2, 2))
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/scope_spec.rb

@@ -0,0 +1,73 @@
+# 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/core/scope'
+
+module MiniKraken
+  module Core
+    describe Scope do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      let(:mother) { Scope.new }
+      subject { Scope.new(mother) }
+
+      def var(aName)
+        LogVar.new(aName)
+      end
+
+      context 'Initialization:' do
+        it 'could be initialized without argument' do
+          expect { Scope.new }.not_to raise_error
+        end
+
+        it 'could be initialized with a parent scope' do
+          expect { Scope.new(mother) }.not_to raise_error
+        end
+
+        it "shouldn't have definitions by default" do
+          expect(subject.defns).to be_empty
+        end
+
+        it 'should know its parent (if any)' do
+          expect(subject.parent).to eq(mother)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of a variable' do
+          subject.insert(var('a'))
+          expect(subject.defns).not_to be_empty
+          var_a = subject.defns['a']
+          expect(var_a).to be_kind_of(Core::LogVar)
+          expect(var_a.label).to eq('a')
+        end
+
+        it 'should accept the addition of multiple variables' do
+          subject.insert(var('a'))
+          expect(subject.defns).not_to be_empty
+
+          subject.insert(var('b'))
+          var_b = subject.defns['b']
+          expect(var_b).to be_kind_of(Core::LogVar)
+          expect(var_b.label).to eq('b')
+        end
+
+        it 'should set the suffix of just created variable' do
+          subject.insert(var('a'))
+          var_a = subject.defns['a']
+          expect(var_a.suffix).to eq("_#{subject.object_id.to_s(16)}")
+        end
+
+        it 'should complain when variable names collide' do
+          subject.insert(var('c'))
+          expect(subject.defns['c']).to be_kind_of(Core::LogVar)
+          err = StandardError
+          err_msg = "Variable with name 'c' already exists."
+          expect { subject.insert(var('c')) }.to raise_error(err, err_msg)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/solver_adapter_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'singleton'
+
+require_relative '../../lib/mini_kraken/core/context'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/solver_adapter'
+
+
+module MiniKraken
+  module Core
+    describe SolverAdapter do
+      let(:ctx) { Context.new }
+      let(:fib) { make_fiber(ctx, true, true, false, nil) }
+      let(:blk) do
+        lambda do |adapter, _context|
+          adapter.adaptee.resume
+        end
+      end
+      subject { SolverAdapter.new(fib, &blk) }
+
+      # Factory method.
+      def make_fiber(ctx, *args)
+        Fiber.new do
+          signature = *args
+          signature.each do |outcome|
+            if outcome
+              Fiber.yield ctx.succeeded!
+              next
+            elsif outcome.nil?
+              Fiber.yield nil
+              break
+            else
+              Fiber.yield ctx.failed!
+              next
+            end
+          end
+        end
+      end
+
+      context 'Initialization:' do
+        it 'should be initialized with a Fiber-like object' do
+          expect { SolverAdapter.new(fib, &blk) }.not_to raise_error
+        end
+
+        it 'should know its adaptee' do
+          expect(subject.adaptee).to eq(fib)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should respond to the resume message' do
+          result = subject.resume(ctx)
+          expect(result).to be_success
+
+          result = subject.resume(ctx)
+          expect(result).to be_success
+
+          result = subject.resume(ctx)
+          expect(result).to be_failure
+
+          result = subject.resume(ctx)
+          expect(result).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/specification_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/specification'
+
+
+module MiniKraken
+  module Core
+    describe Specification do
+      subject { Specification.new('cons', 2) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and an arity' do
+          expect { Specification.new('cons', Arity.new(2, 2)) }.not_to raise_error
+        end
+
+        it 'should be initialized with a name and an integer' do
+          expect { Specification.new('cons', 2) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('cons')
+        end
+
+        it 'should know its arity' do
+          expect(subject.arity).to be_binary
+        end
+      end # context
+
+      context 'Provided services:' do
+        it "should complain when number of arguments does't fit arity" do
+          dummy_arg = double('dummy-stuff')
+
+          err = StandardError
+          err_msg = 'Count of arguments (1) is out of allowed range (2, 2).'
+          expect { subject.check_arity([dummy_arg]) }.to raise_error(err, err_msg)
+        end
+      end
+    end # describe
+  end # module
+end # module