mini_kraken 0.2.02 → 0.3.02

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/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/k_symbol'
-require_relative '../../lib/mini_kraken/core/variable_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) { 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) { KSymbol.new(:cup) }
-        let(:ref_x) { VariableRef.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,48 +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 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/variable_ref_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/variable_ref'
-
-module MiniKraken
-  module Core
-    describe VariableRef do
-      subject { VariableRef.new('q') }
-
-      context 'Initialization:' do
-        it 'should be initialized with the name of variable' do
-          expect { VariableRef.new('q') }.not_to raise_error
-        end
-
-        it 'should know the name of a variable' do
-          expect(subject.var_name).to eq('q')
-        end
-      end # context
-
-      context 'Provided services:' do
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/variable_spec.rb

@@ -1,35 +0,0 @@
-# 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/variable'
-
-
-module MiniKraken
-  module Core
-    describe Variable do
-      let(:env) { Environment.new }
-      subject { Variable.new('q') }
-
-      context 'Initialization:' do
-        it 'should be initialized with a name' do
-          expect { Variable.new('q') }.not_to raise_error
-        end
-
-        it 'should know its name' do
-          expect(subject.name).to eq('q')
-        end
-
-        it 'should be fresh by default' do
-          env.add_var(subject)
-          expect(subject.fresh?(env)).to be_truthy
-        end
-      end # context
-
-      context 'Provided services:' do
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/vocabulary_spec.rb

@@ -1,219 +0,0 @@
-# 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 '../../lib/mini_kraken/core/variable_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 VariableBearer
-      attr_reader :vars
-      attr_accessor :ivars
-
-      def init_var_bearer
-        @vars = {}
-        @ivars = {}
-        self
-      end
-
-      def add_var(aVarName)
-        vars[aVarName] = Variable.new(aVarName)
-        ivars[aVarName] = Set.new([aVarName])
-      end
-    end # module
-
-    describe Vocabulary do
-      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) { KSymbol.new(:pea) }
-        let(:pod) { KSymbol.new(:pod) }
-        let(:ref_q) { VariableRef.new('q') }
-        let(:ref_x) { VariableRef.new('x') }
-        let(:grandma) do
-          voc = TestVocabulary.new
-          voc.extend(VariableBearer)
-          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(VariableBearer)
-          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_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/goal'
-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/core/succeed'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/glue/fresh_env'
-
-
-module MiniKraken
-  module Glue
-    describe FreshEnv do
-      let(:pea) { Core::KSymbol.new(:pea) }
-      let(:pod) { Core::KSymbol.new(:pod) }
-      let(:sample_goal) do
-        Core::Goal.new(Core::Equals.instance, [pea, pod])
-      end
-      let(:pea_goal) do
-        Core::Goal.new(Core::Equals.instance, [pea, pea])
-      end
-      let(:goal_succeeds) { Core::Goal.new(Core::Succeed.instance, []) }
-      let(:goal_fails) { Core::Goal.new(Core::Fail.instance, []) }
-      subject { FreshEnv.new(['q'], sample_goal) }
-
-      context 'Initialization:' do
-        it 'could be initialized with names and a goal' do
-          expect { FreshEnv.new(['q'], sample_goal) }.not_to raise_error
-        end
-
-        it 'could be  initialized with names and goals' do
-          expect { FreshEnv.new(%w[x y], [pea_goal, goal_succeeds]) }.not_to raise_error
-        end
-
-        it 'should know its variables' do
-          expect(subject.vars['q']).not_to be_nil
-
-          instance = FreshEnv.new(%w[x y], sample_goal)
-          expect(instance.vars['x']).not_to be_nil
-          expect(instance.vars['y']).not_to be_nil
-        end
-
-        it 'should know its goal' do
-          # Single goal at initialization
-          expect(subject.goal).to eq(sample_goal)
-
-          # Multiple goals at initialization
-          instance = FreshEnv.new(['q'], [pea_goal, goal_succeeds])
-          expect(instance.goal.relation.name).to eq('conj2')
-          expect(instance.goal.actuals[0]).to eq(pea_goal)
-          expect(instance.goal.actuals[1]).to eq(goal_succeeds)
-        end
-      end # context
-
-      context 'Provided services:' do
-      end # context
-    end # describe
-  end # module
-end # module