mini_kraken 0.2.03 → 0.3.03

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_factory_spec.rb

@@ -1,97 +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_methods'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/glue/fresh_env_factory'
-
-
-module MiniKraken
-  module Glue
-    describe FreshEnvFactory do
-      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) { Core::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::Variable)
-
-          # 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::VariableRef)
-          expect(goal.actuals[0].name).to eq('d')
-          expect(goal.actuals[1]).to be_kind_of(Core::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::Variable)
-
-          # Is the goal correctly built?
-          goal = created.goal
-          expect(goal.relation).to eq(Core::Equals.instance)
-          expect(goal.actuals[0]).to be_kind_of(Core::ConsCell)
-          expect(goal.actuals[0].car).to be_kind_of(Core::VariableRef)
-          expect(goal.actuals[0].car.name).to eq('q')
-          expect(goal.actuals[0].cdr).to be_kind_of(Core::VariableRef)
-          expect(goal.actuals[0].cdr.name).to eq('d')
-          expect(goal.actuals[1]).to be_kind_of(Core::ConsCell)
-          expect(goal.actuals[1].to_s).to eq('(:a :c :o :r :n)')
-        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