mini_kraken 0.2.04 → 0.3.00

data/spec/core/goal_template_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/atomic/k_symbol'
-require_relative '../../lib/mini_kraken/core/disj2'
-require_relative '../../lib/mini_kraken/core/equals'
-require_relative '../../lib/mini_kraken/core/formal_arg'
-require_relative '../../lib/mini_kraken/core/formal_ref'
-require_relative '../../lib/mini_kraken/core/goal'
-require_relative '../../lib/mini_kraken/core/log_var_ref'
-# require_relative '../../lib/mini_kraken/core/environment'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/goal_template'
-
-
-module MiniKraken
-  module Core
-    describe GoalTemplate do
-      let(:tea) { Atomic::KSymbol.new(:tea) }
-      let(:t_ref) { FormalRef.new('t') }
-      subject { GoalTemplate.new(Equals.instance, [tea, t_ref]) }
-
-      context 'Initialization:' do
-        it 'should be initialized with a relation and args' do
-          expect { GoalTemplate.new(Equals.instance, [tea, t_ref]) }.not_to raise_error
-        end
-
-        it 'should know its relation' do
-          expect(subject.relation).to eq(Equals.instance)
-        end
-
-        it 'should know its arguments' do
-          expect(subject.args[0]).to eq(tea)
-          expect(subject.args[1]).to eq(t_ref)
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:formal_t) { FormalArg.new('t') }
-        let(:cup) { Atomic::KSymbol.new(:cup) }
-        let(:ref_x) { LogVarRef.new('x') }
-        # let(:env) { Environment.new }
-
-        it 'should instantiate a single-node goal' do
-          expect(subject.instantiate([formal_t], [cup])).to be_kind_of(Goal)
-          goal = subject.instantiate([formal_t], [cup])
-          expect(goal.relation).to eq(Equals.instance)
-          expect(goal.actuals[0]).to eq(tea)
-          expect(goal.actuals[1]).to eq(cup)
-        end
-
-        it 'should instantiate a multiple-nodes goal' do
-          sub_tmp1 =  GoalTemplate.new(Equals.instance, [tea, t_ref])
-          sub_tmp2 =  GoalTemplate.new(Equals.instance, [cup, t_ref])
-          template =  GoalTemplate.new(Disj2.instance, [sub_tmp1, sub_tmp2])
-
-          goal = template.instantiate([formal_t], [ref_x])
-          expect(goal.relation).to eq(Disj2.instance)
-          subgoal1 = goal.actuals[0]
-          expect(subgoal1).to be_kind_of(Goal)
-          expect(subgoal1.relation).to eq(Equals.instance)
-          expect(subgoal1.actuals[0]).to eq(tea)
-          expect(subgoal1.actuals[1]).to eq(ref_x)
-          subgoal2 = goal.actuals[1]
-          expect(subgoal2).to be_kind_of(Goal)
-          expect(subgoal2.relation).to eq(Equals.instance)
-          expect(subgoal2.actuals[0]).to eq(cup)
-          expect(subgoal2.actuals[1]).to eq(ref_x)
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/outcome_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/vocabulary'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/outcome'
-
-module MiniKraken
-  module Core
-    describe Outcome do
-      let(:voc) do
-        obj = Object.new
-        obj.extend(Vocabulary)
-        obj
-      end
-      subject { Outcome.new(:"#s", voc) }
-
-      context 'Initialization:' do
-        it 'should be created with a symbol and a vocabulary' do
-          expect { Outcome.new(:"#s", voc) }.not_to raise_error
-        end
-
-        it 'should know its resultant' do
-          expect(subject.resultant).to eq(:"#s")
-        end
-
-        it 'should know whether it represents a failure' do
-          expect(Outcome.new(:"#u")).to be_failure
-        end
-
-        it 'should know whether it represents a success' do
-          expect(subject).to be_success
-        end
-
-        it 'should know its parent' do
-          expect(subject.parent).to eq(voc)
-        end
-      end # context
-
-      context 'Provided services:' do
-        it 'should have a factory for failing outcome' do
-          instance = Outcome.failure(voc)
-          expect(instance.resultant).to eq(:"#u")
-          expect(instance.parent).to eq(voc)
-        end
-
-        it 'should have a factory for succeeding outcome' do
-          instance = Outcome.success(voc)
-          expect(instance.resultant).to eq(:"#s")
-          expect(instance.parent).to eq(voc)
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/vocabulary_spec.rb

@@ -1,220 +0,0 @@
-# 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'
-require_relative '../../lib/mini_kraken/core/log_var_ref'
-require_relative '../support/factory_methods'
-
-# Load the class under test
-# frozen_string_literal: true
-
-require_relative '../../lib/mini_kraken/core/vocabulary'
-
-module MiniKraken
-  module Core
-    class TestVocabulary
-      include Vocabulary
-
-      def initialize(aParent = nil)
-        init_vocabulary(aParent)
-      end
-    end # class
-
-    # Helper module that simulates an environment-like object.
-    module LogVarBearer
-      attr_reader :vars
-      attr_accessor :ivars
-
-      def init_var_bearer
-        @vars = {}
-        @ivars = {}
-        self
-      end
-
-      def add_var(aVarName)
-        vars[aVarName] = LogVar.new(aVarName)
-        ivars[aVarName] = Set.new([aVarName])
-      end
-    end # module
-
-    describe Vocabulary do
-      include MiniKraken::FactoryAtomic # Use mix-in module
-      include FactoryMethods
-
-      let(:parent) { TestVocabulary.new }
-      subject { TestVocabulary.new }
-
-      context 'Initialization:' do
-        it 'could be initialized without a parent' do
-          expect { TestVocabulary.new }.not_to raise_error
-        end
-
-        it 'could be initialized with a parent' do
-          expect { TestVocabulary.new(parent) }.not_to raise_error
-        end
-
-        it 'should know its parent (if any)' do
-          expect(subject.parent).to be_nil
-          instance = TestVocabulary.new(parent)
-          expect(instance.parent).to eq(parent)
-        end
-
-        it 'should have no associations at initialization' do
-          expect(subject.associations).to be_empty
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:pea) { k_symbol(:pea) }
-        let(:pod) { k_symbol(:pod) }
-        let(:ref_q) { LogVarRef.new('q') }
-        let(:ref_x) { LogVarRef.new('x') }
-        let(:grandma) do
-          voc = TestVocabulary.new
-          voc.extend(LogVarBearer)
-          voc.init_var_bearer
-        end
-        let(:mother) { TestVocabulary.new(grandma) }
-        subject { TestVocabulary.new(mother) }
-
-        it 'should provide a walker over ancestors' do
-          walker = subject.ancestor_walker
-          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
-          expect(subject.include?('q')).to be_falsey
-          grandma.add_var('x')
-          expect(subject.include?('q')).to be_falsey
-          expect(grandma.include?('x')).to be_truthy
-          expect(mother.include?('x')).to be_truthy
-          expect(subject.include?('x')).to be_truthy
-          subject.extend(LogVarBearer)
-          subject.init_var_bearer
-          subject.add_var('y')
-          expect(subject.include?('y')).to be_truthy
-          expect(mother.include?('y')).to be_falsey
-        end
-
-        it 'should allow the addition of associations' do
-          grandma.add_var('q')
-          expect(subject['q']).to be_empty
-          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('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)
-        end
-
-        it 'should allow the deletion of associations' do
-          grandma.add_var('q')
-          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)
-
-          subject.clear
-          expect(subject.associations).to be_empty
-
-          mother.clear
-          expect(mother.associations).to be_empty
-        end
-
-        it 'should say fresh when a variable has no association at all' do
-          grandma.add_var('q')
-          grandma.add_var('x')
-          expect(subject.fresh?(ref_q)).to be_truthy
-          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('q', ref_x) # Dependency: q --> x
-          expect(subject.fresh?(ref_q)).to be_truthy
-
-          # Associate with an atomic term
-          subject.add_assoc('q', pea)
-          expect(subject.fresh?(ref_q)).to be_falsey
-        end
-
-        it 'should say not fresh when variable --> composite of atomics' do
-          grandma.add_var('q')
-
-          # Composite having only atomic terms as leaf elements
-          expr = cons(pea, cons(pod))
-          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('x', pea) # Dependency: x --> pea
-          expr = cons(pea, cons(pod, cons(ref_x)))
-          subject.add_assoc('q', expr)
-          expect(subject.fresh?(ref_q)).to be_falsey
-        end
-
-        it 'say not fresh when variable --> composite of atomics & fresh var' do
-          grandma.add_var('q')
-          grandma.add_var('x')
-          expr = cons(pea, cons(pod, cons(ref_x)))
-          subject.add_assoc('q', expr)
-          expect(subject.fresh?(ref_q)).to be_truthy
-        end
-
-        it 'say not fresh when variables are fused & one is ground' do
-          grandma.add_var('q')
-          grandma.add_var('x')
-
-          # Beware of cyclic structure
-          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('x', pea)
-          expect(subject.fresh?(ref_q)).to be_falsey
-        end
-
-        it 'should rank names sequentially' do
-          2.times do
-            expect(subject.get_rank('a')).to eq(0)
-            expect(subject.get_rank('z')).to eq(1)
-            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)
-        end
-
-        it 'should provide a String representation of itself' do
-          expectation = +"#<#{subject.class}:#{subject.object_id.to_s(16)} @parent="
-          expectation << "#<#{subject.parent.class}:#{subject.parent.object_id.to_s(16)}>>"
-          expect(subject.inspect).to eq(expectation)
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/glue/fresh_env_factory_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/mini_kraken/core/equals'
-require_relative '../../lib/mini_kraken/core/formal_arg'
-require_relative '../../lib/mini_kraken/core/formal_ref'
-require_relative '../../lib/mini_kraken/core/goal_template'
-
-require_relative '../support/factory_atomic'
-require_relative '../support/factory_methods'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/glue/fresh_env_factory'
-
-
-module MiniKraken
-  module Glue
-    describe FreshEnvFactory do
-      include MiniKraken::FactoryAtomic # Use mix-in module
-      include FactoryMethods
-
-      # (fresh (d) (== d r))
-      let(:r_formal_ref) { Core::FormalRef.new('r') }
-      let(:d_ref) { var_ref('d') }
-      let(:sample_goal_t) do
-        Core::GoalTemplate.new(Core::Equals.instance, [d_ref, r_formal_ref])
-      end
-      subject { FreshEnvFactory.new(['d'], sample_goal_t) }
-
-      context 'Initialization:' do
-        it 'should be initialized with names and a goal template' do
-          expect { FreshEnvFactory.new(['d'], sample_goal_t) }.not_to raise_error
-        end
-
-        it 'should know the variable names' do
-          expect(subject.names).to eq(['d'])
-        end
-
-        it 'should know the goal template' do
-          expect(subject.goal_template).to eq(sample_goal_t)
-        end
-      end # context
-
-      context 'Factory for FreshEnv instances' do
-        # (defrel (caro r a)
-        #   (fresh (d)
-        #   (== (cons a d) r)))
-        # ;; r, a are formal args, they part of caro signature
-        # ;; d is a formal ref argument
-        let(:pea) { k_symbol(:pea) }
-        let(:q_ref) { var_ref('q') }
-        let(:r_formal) { Core::FormalRef.new('r') }
-        let(:a_formal) { Core::FormalRef.new('a') }
-        let(:t_param1) { Composite::ConsCell.new(a_formal, d_ref) }
-        let(:other_goal_t) do
-          Core::GoalTemplate.new(Core::Equals.instance, [t_param1, r_formal])
-        end
-
-        # (fresh (d) (== d r))
-        it 'should build FreshEnv instance with simple goal' do
-          created = subject.instantiate([r_formal], [pea])
-
-          # Are variables correctly built?
-          expect(created).to be_kind_of(FreshEnv)
-          expect(created.vars['d']).to be_kind_of(Core::LogVar)
-
-          # Is the goal correectly built?
-          goal = created.goal
-          expect(goal.relation).to eq(Core::Equals.instance)
-          expect(goal.actuals[0]).to be_kind_of(Core::LogVarRef)
-          expect(goal.actuals[0].name).to eq('d')
-          expect(goal.actuals[1]).to be_kind_of(Atomic::KSymbol)
-          expect(goal.actuals[1]).to eq(:pea)
-        end
-
-        it 'should build FreshEnv instance with goal' do
-          instance = FreshEnvFactory.new(['d'], other_goal_t)
-          acorn = cons(k_symbol(:a), cons(k_symbol(:c), cons(k_symbol(:o),
-            cons(k_symbol(:r), cons(k_symbol(:n))))))
-          created = instance.instantiate([r_formal, a_formal], [acorn, q_ref])
-
-          # Are variables correctly built?
-          expect(created).to be_kind_of(FreshEnv)
-          expect(created.vars['d']).to be_kind_of(Core::LogVar)
-
-          # Is the goal correctly built?
-          goal = created.goal
-          expect(goal.relation).to eq(Core::Equals.instance)
-          expect(goal.actuals[0]).to be_kind_of(Composite::ConsCell)
-          expect(goal.actuals[0].car).to be_kind_of(Core::LogVarRef)
-          expect(goal.actuals[0].car.name).to eq('q')
-          expect(goal.actuals[0].cdr).to be_kind_of(Core::LogVarRef)
-          expect(goal.actuals[0].cdr.name).to eq('d')
-          expect(goal.actuals[1]).to be_kind_of(Composite::ConsCell)
-          expect(goal.actuals[1].to_s).to eq('(:a :c :o :r :n)')
-        end
-      end # context
-    end # describe
-  end # module
-end # module