mini_kraken 0.2.02 → 0.3.02

data/lib/mini_kraken/glue/fresh_env.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../core/environment'
-require_relative '../core/conj2'
-require_relative '../core/variable'
-
-module MiniKraken
-  module Glue
-    # A combination of an Environment (= a scope for one or more variables)
-    # and a goal. It quacks like a Goal object: when receiving the attain message,
-    # it attempt to achieve its given goal.
-    # (fresh (x) (== 'pea q))
-    # Introduces the new variable 'x'
-    # Takes a list of names and a goal-like object
-    # Must respond to message attain(aPublisher, vars) and must return an Outcome
-    class FreshEnv < Core::Environment
-      # @return [Goal]
-      attr_reader :goal
-
-      # @param theNames [Array<String>] The variable names
-      # @param aGoal [Goal, Array<Goal>] The goal to achieve or the conjunction of them.
-      def initialize(theNames, aGoal)
-        super()
-        @goal = valid_goal(aGoal)
-        theNames.each { |nm| add_var(Core::Variable.new(nm)) }
-      end
-
-      # Attempt to achieve the goal given this environment
-      # @param aParent [Environment]
-      # @return [Fiber<Outcome>] A Fiber object that will generate the results.
-      def attain(aParent)
-        self.parent = aParent
-        goal.attain(self)
-      end
-
-      protected
-
-      def introspect
-        +", @vars=[#{vars.keys.join(', ')}]"
-      end
-
-      private
-
-      def valid_goal(aGoal)
-        result = nil
-
-        case aGoal
-          when Core::Goal
-            result = aGoal
-          when FreshEnv
-            result = aGoal
-          when Array # an Array of Goal?..
-            goal_array = aGoal
-            loop do
-              conjunctions = []
-              goal_array.each_slice(2) do |uno_duo|
-                if uno_duo.size == 2
-                  conjunctions << Core::Goal.new(Core::Conj2.instance, uno_duo)
-                else
-                  conjunctions << uno_duo[0]
-                end
-              end
-              if conjunctions.size == 1
-                result = conjunctions[0]
-                break
-              end
-              goal_array = conjunctions
-            end
-        end
-
-        result
-      end
-    end # class
-  end # module
-end # module

data/spec/core/association_walker_spec.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/mini_kraken/core/environment'
-require_relative '../support/factory_methods'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/association_walker'
-
-
-module MiniKraken
-  module Core
-    describe AssociationWalker do
-      include FactoryMethods
-
-      subject { AssociationWalker.new }
-
-      context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { AssociationWalker.new }.not_to raise_error
-        end
-
-        it "shouldn't have any visitee at initialization" do
-          expect(subject.visitees.size).to eq(0)
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:pea) { KSymbol.new(:pea) }
-        let(:pod) { KSymbol.new(:pod) }
-        let(:var_q) { Variable.new('q') }
-        let(:ref_q) { VariableRef.new('q') }
-        let(:var_x) { Variable.new('x') }
-        let(:ref_x) { VariableRef.new('x') }
-        let(:env) { Environment.new }
-
-        it 'should return composite when it has only atomic term(s)' do
-          expr1 = cons(pea)
-          expect(subject.walk_value(expr1, env)).to eq(expr1)
-
-          expr2 = cons(pea, pod)
-          expect(subject.walk_value(expr2, env)).to eq(expr2)
-        end
-
-        it 'should return composite when it has ground composite term(s)' do
-          expr1 = cons(pea, cons(pod))
-          expect(subject.walk_value(expr1, env)).to eq(expr1)
-
-          expr2 = cons(pea, cons(pod, cons(pea, cons(pod))))
-          expect(subject.walk_value(expr2, env)).to eq(expr2)
-        end
-
-        it 'should return nil when there is one fresh variable' do
-          env.add_var(var_q)
-          expr1 = cons(pea, cons(pod, ref_q))
-          expect(subject.walk_value(expr1, env)).to be_nil
-        end
-
-        it 'should return composite when it has ground composite term(s)' do
-          env.add_var(var_q)
-          env.add_assoc('q', pea)
-          expr1 = cons(pea, cons(pod, cons(ref_q)))
-          expect(subject.walk_value(expr1, env)).to eq(expr1)
-        end
-
-        it 'should return nil when no assocation exists' do
-          env.add_var(var_q)
-          env.add_assoc('q', pea)
-          env.add_var(var_x)
-
-          expect(subject.find_ground(var_x.name, env)).to be_nil
-        end
-
-        it 'should find an atomic term directly associated' do
-          env.add_var(var_q)
-          env.add_assoc('q', pea)
-
-          result = subject.find_ground(var_q.name, env)
-          expect(result).to eq(pea)
-        end
-
-        it 'should find an atomic term directly associated' do
-          env.add_var(var_q)
-          env.add_var(var_x)
-          env.add_assoc('q', ref_x)
-          env.add_assoc('x', pea)
-          expect(env['x']).not_to be_nil
-
-          result = subject.find_ground(var_q.name, env)
-          expect(result).to eq(pea)
-        end
-
-        it 'should cope with cyclic structures' do
-          env.add_var(var_q)
-          env.add_var(var_x)
-          env.add_assoc('q', ref_x)
-          env.add_assoc('x', pea)
-          env.add_assoc('x', ref_q)
-
-          result = subject.find_ground(var_q.name, env)
-          expect(result).to eq(pea)
-
-          result = subject.find_ground(var_x.name, env)
-          expect(result).to eq(pea)
-        end
-
-        it 'should cope with a composite with atomic terms only' do
-          env.add_var(var_q)
-          expr = cons(pea, cons(pod, cons(pea)))
-          env.add_assoc('q', expr)
-
-          result = subject.find_ground(var_q.name, env)
-          expect(result).to eq(expr)
-        end
-
-        it 'should cope with a composite with one fresh variable' do
-          env.add_var(var_q)
-          env.add_var(var_x)
-          expr = cons(pea, cons(pod, cons(ref_x)))
-          env.add_assoc('q', expr)
-
-          result = subject.find_ground(var_q.name, env)
-          expect(result).to be_nil
-        end
-
-        it 'should cope with a composite with one ground variable' do
-          env.add_var(var_q)
-          env.add_var(var_x)
-          expr = cons(pea, cons(pod, cons(ref_x)))
-          env.add_assoc('q', expr)
-          env.add_assoc('x', pod)
-
-          result = subject.find_ground(var_q.name, env)
-          expect(result).to eq(expr)
-        end
-
-        it 'should categorize a variable without association as free' do
-          env.add_var(var_q)
-          result = subject.determine_freshness(ref_q, env)
-          expect(result).to be_fresh
-          expect(result.associated).to be_nil
-        end
-
-        it 'should categorize a variable related to fresh variable as bound' do
-          env.add_var(var_q)
-          env.add_var(var_x)
-          env.add_assoc('q', ref_x)
-
-          result = subject.determine_freshness(ref_q, env)
-          expect(result).to be_bound
-          expect(result.associated).to eq(ref_x)
-        end
-
-        it 'should categorize a variable even in presence of fused var(s)' do
-          env.add_var(var_q)
-          env.add_var(var_x)
-          env.add_assoc('q', ref_x)
-          env.add_assoc('x', ref_q)
-          # q and x are fused...
-
-          result = subject.determine_freshness(ref_q, env)
-          expect(result).to be_fresh
-          expect(var_q.i_name).to eq(var_x.i_name)
-          expect(env.associations).to be_empty
-        end
-
-        it 'should categorize an atomic term as ground term' do
-          result = subject.determine_freshness(pea, env)
-          expect(result).to be_ground
-          expect(result.associated).to eq(pea)
-        end
-
-        it 'should categorize a composite term as ground term' do
-          # Ground composite: a composite where all members are ground
-          composite = cons(pea, cons(pod))
-          result = subject.determine_freshness(composite, env)
-          expect(result).to be_ground
-          expect(result.associated).to eq(composite)
-        end
-
-        it 'should categorize a composite term as bound term' do
-          # Bound composite: a composite where at least one member is fresh
-          env.add_var(var_q)
-          composite = cons(pea, cons(ref_q))
-          result = subject.determine_freshness(composite, env)
-          expect(result).to be_bound
-          expect(result.associated).to eq(composite)
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/conde_spec.rb

@@ -1,147 +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/fail'
-require_relative '../../lib/mini_kraken/core/succeed'
-require_relative '../../lib/mini_kraken/core/equals'
-require_relative '../../lib/mini_kraken/core/environment'
-require_relative '../../lib/mini_kraken/core/variable'
-require_relative '../../lib/mini_kraken/core/variable_ref'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/conde'
-
-module MiniKraken
-  module Core
-    describe Conde do
-      subject { Conde.instance }
-
-      context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Conde.instance }.not_to raise_error
-        end
-
-        it 'should know its name' do
-          expect(subject.name).to eq('conde')
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:bean) { KSymbol.new(:bean) }
-        let(:corn) { KSymbol.new(:corn) }
-        let(:meal) { KSymbol.new(:meal) }
-        let(:oil) { KSymbol.new(:oil) }
-        let(:olive) { KSymbol.new(:olive) }
-        let(:pea) { KSymbol.new(:pea) }
-        let(:red) { KSymbol.new(:red) }
-        let(:split) { KSymbol.new(:split) }
-        let(:fails) { Goal.new(Fail.instance, []) }
-        let(:succeeds) { Goal.new(Succeed.instance, []) }
-        let(:var_q) { Variable.new('q') }
-        let(:var_x) { Variable.new('x') }
-        let(:var_y) { Variable.new('y') }
-        let(:ref_q) { VariableRef.new('q') }
-        let(:ref_x) { VariableRef.new('x') }
-        let(:ref_y) { VariableRef.new('y') }
-        let(:env) do
-          e = Environment.new
-          e.add_var(var_q)
-          e.add_var(var_x)
-          e.add_var(var_y)
-          e
-        end
-
-        it 'should complain when one of its argument is not a goal' do
-          err = StandardError
-          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
-          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
-        end
-
-        it 'should fail when all goals fail' do
-          solver = subject.solver_for([fails, fails, fails], env)
-          expect(solver.resume).not_to be_successful
-          expect(solver.resume).to be_nil
-        end
-
-        it 'yield success if first argument succeeds' do
-          subgoal = Goal.new(Equals.instance, [olive, ref_q])
-          solver = subject.solver_for([subgoal, fails, fails], env)
-          outcome = solver.resume
-          expect(outcome).to be_successful
-          expect(outcome.associations['q'].first.value).to eq(olive)
-          expect(solver.resume).to be_nil
-        end
-
-        it 'yield success if second argument succeeds' do
-          subgoal = Goal.new(Equals.instance, [oil, ref_q])
-          solver = subject.solver_for([fails, subgoal, fails], env)
-          outcome = solver.resume
-          expect(outcome).to be_successful
-          expect(outcome.associations['q'].first.value).to eq(oil)
-          expect(solver.resume).to be_nil
-        end
-
-        it 'yield success if third argument succeeds' do
-          subgoal = Goal.new(Equals.instance, [oil, ref_q])
-          solver = subject.solver_for([fails, fails, subgoal], env)
-          outcome = solver.resume
-          expect(outcome).to be_successful
-          expect(outcome.associations['q'].first.value).to eq(oil)
-          expect(solver.resume).to be_nil
-        end
-
-        it 'yields three solutions if three goals succeed' do
-          # Covers frame 1:58
-          subgoal1 = Goal.new(Equals.instance, [olive, ref_q])
-          subgoal2 = Goal.new(Equals.instance, [oil, ref_q])
-          subgoal3 = Goal.new(Equals.instance, [pea, ref_q])
-          solver = subject.solver_for([subgoal1, subgoal2, subgoal3, fails], env)
-
-          # First solution
-          outcome1 = solver.resume
-          expect(outcome1).to be_successful
-          expect(outcome1.associations['q'].first.value).to eq(olive)
-
-          # Second solution
-          outcome2 = solver.resume
-          expect(outcome2).to be_successful
-          expect(outcome2.associations['q'].first.value).to eq(oil)
-
-          # Third solution
-          outcome3 = solver.resume
-          expect(outcome3).to be_successful
-          expect(outcome3.associations['q'].first.value).to eq(pea)
-
-          expect(solver.resume).to be_nil
-        end
-
-        it 'also use conjunctions for nested goals' do
-          # Covers frame 1:88
-          subgoal1 = Goal.new(Equals.instance, [split, ref_x])
-          subgoal2 = Goal.new(Equals.instance, [pea, ref_y])
-          combo1 = [subgoal1, subgoal2]
-
-          subgoal3 = Goal.new(Equals.instance, [red, ref_x])
-          subgoal4 = Goal.new(Equals.instance, [bean, ref_y])
-          combo2 = [subgoal3, subgoal4]
-          solver = subject.solver_for([combo1, combo2], env)
-
-          # First solution
-          outcome1 = solver.resume
-          expect(outcome1).to be_successful
-          expect(outcome1.associations['x'].first.value).to eq(split)
-          expect(outcome1.associations['y'].first.value).to eq(pea)
-
-          # Second solution
-          outcome2 = solver.resume
-          expect(outcome2).to be_successful
-          expect(outcome2.associations['x'].first.value).to eq(red)
-          expect(outcome2.associations['y'].first.value).to eq(bean)
-
-          expect(solver.resume).to be_nil
-        end
-      end # context
-    end # describe
-  end # module
-end # module

data/spec/core/conj2_spec.rb

@@ -1,114 +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/fail'
-require_relative '../../lib/mini_kraken/core/succeed'
-require_relative '../../lib/mini_kraken/core/equals'
-require_relative '../../lib/mini_kraken/core/environment'
-require_relative '../../lib/mini_kraken/core/variable'
-require_relative '../../lib/mini_kraken/core/variable_ref'
-
-# Load the class under test
-require_relative '../../lib/mini_kraken/core/conj2'
-
-
-module MiniKraken
-  module Core
-    describe Conj2 do
-      subject { Conj2.instance }
-
-      context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Conj2.instance }.not_to raise_error
-        end
-
-        it 'should know its name' do
-          expect(subject.name).to eq('conj2')
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:env) { Environment.new }
-        let(:pea) { KSymbol.new(:pea) }
-        let(:corn) { KSymbol.new(:corn) }
-        let(:meal) { KSymbol.new(:meal) }
-        let(:fails) { Goal.new(Fail.instance, []) }
-        let(:succeeds) { Goal.new(Succeed.instance, []) }
-        let(:var_q) { Variable.new('q') }
-        let(:ref_q) { VariableRef.new('q') }
-
-        it 'should complain when one of its argument is not a goal' do
-          err = StandardError
-          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
-          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
-        end
-
-        it 'should yield one failure if one of the goal is fail' do
-          # Fail as first argument
-          solver = subject.solver_for([fails, succeeds], env)
-          expect(solver.resume).not_to be_successful
-          expect(solver.resume).to be_nil
-
-          # Fail as second argument
-          solver = subject.solver_for([succeeds, fails], env)
-          expect(solver.resume).not_to be_successful
-          expect(solver.resume).to be_nil
-        end
-
-        it 'yield success if both arguments are succeed goals' do
-          # Covers frame 1-50
-          solver = subject.solver_for([succeeds, succeeds], env)
-          outcome = solver.resume
-          expect(outcome).to be_successful
-          expect(outcome.associations).to be_empty
-          expect(solver.resume).to be_nil
-        end
-
-        it 'should yield success and set associations' do
-          # Covers frame 1-51
-          env.add_var(var_q)
-          sub_goal = Goal.new(Equals.instance, [corn, ref_q])
-          solver = subject.solver_for([succeeds, sub_goal], env)
-          outcome = solver.resume
-          expect(outcome).to be_successful
-          expect(outcome.associations).not_to be_empty
-          expect(outcome.associations['q'].first.value).to eq(corn)
-        end
-
-        it 'should yield fails and set no associations' do
-          # Covers frame 1-52
-          env.add_var(var_q)
-          sub_goal = Goal.new(Equals.instance, [corn, ref_q])
-          solver = subject.solver_for([fails, sub_goal], env)
-          outcome = solver.resume
-          expect(outcome).not_to be_successful
-          expect(outcome.associations).to be_empty
-        end
-
-        it 'should yield fails when sub-goals are incompatible' do
-          # Covers frame 1-53
-          env.add_var(var_q)
-          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
-          sub_goal2 = Goal.new(Equals.instance, [meal, ref_q])
-          solver = subject.solver_for([sub_goal1, sub_goal2], env)
-          outcome = solver.resume
-          expect(outcome).not_to be_successful
-          expect(outcome.associations).to be_empty
-        end
-
-        it 'should yield success when sub-goals are same and successful' do
-          # Covers frame 1-54
-          env.add_var(var_q)
-          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
-          sub_goal2 = Goal.new(Equals.instance, [corn, ref_q])
-          solver = subject.solver_for([sub_goal1, sub_goal2], env)
-          outcome = solver.resume
-          expect(outcome).to be_successful
-          expect(outcome.associations).not_to be_empty
-          expect(outcome.associations['q'].first.value).to eq(corn)
-        end
-      end # context
-    end # describe
-  end # module
-end # module