mini_kraken 0.2.03 → 0.3.03

data/lib/mini_kraken/glue/fresh_env.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../core/environment'
-require_relative '../core/conj2'
-require_relative '../core/goal_template'
-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 attempts 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
-
-      # @return [TrueClass, FalseClass] Do associations persist after goal exec?
-      attr_reader :persistent
-
-      # @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, persistence = true)
-        super()
-        @goal = valid_goal(aGoal)
-        theNames.each do |nm|
-          var = Core::Variable.new(nm)
-          add_var(var)
-        end
-        @persistent = persistence
-      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)
-        # require 'debug'
-        self.parent = aParent
-        goal.attain(self)
-      end
-
-      # Remove associations of variables of this environment, if
-      # persistence flag is set to false.
-      def prune(anOutcome)
-        return super(anOutcome) if persistent
-
-        vars.each_value do |v|
-          v_name = v.name
-          if anOutcome.associations.include?(v_name)
-            anOutcome.associations.delete(v_name)
-          end
-        end
-
-        anOutcome
-      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 Core::GoalTemplate
-            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
-          else
-            raise StandardError, "Cannot handle argumment type #{aGoal.class}"
-        end
-
-        result
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/glue/fresh_env_factory.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../core/environment'
-require_relative '../core/conj2'
-require_relative '../core/goal_template'
-require_relative '../core/variable'
-require_relative 'fresh_env'
-
-module MiniKraken
-  module Glue
-    # A combination of an Environment (= a scope for one or more variables)
-    # and a goal. It quacks like a Goal template object: when receiving the
-    # instantiate message, it creates a FreshEnv.
-    class FreshEnvFactory
-      # @return [Array<String>] The names of variables to be.
-      attr_reader :names
-
-      # @return [GoalTemplate] The goal template
-      attr_reader :goal_template
-
-      # @param theNames [Array<String>] The names of variables to build.
-      # @param aGoal [GoalTemplate, Array<Goal>] The goal template(s)
-      def initialize(theNames, aGoalTemplate)
-        @goal_template = valid_goal_template(aGoalTemplate)
-        @names = valid_names(theNames)
-      end
-
-      # Factory method: Create a goal object.
-      # @param formals [Array<FormalArg>] Array of formal arguments
-      # @param actuals [Array<GoalArg>] Array of actual arguments
-      # @return [Goal] instantiate a goal object given the actuals and environment
-      def instantiate(formals, actuals)
-        # require 'debug'
-        goal = goal_template.instantiate(formals, actuals)
-        FreshEnv.new(names, goal, false)
-      end
-
-      protected
-
-      def introspect
-        +", @names=[#{names.join(', ')}]"
-      end
-
-      private
-
-      def valid_names(theNames)
-        theNames
-      end
-
-      def valid_goal_template(aGoalTemplate)
-        result = nil
-
-        case aGoalTemplate
-          when FreshEnvFactory
-            result = aGoalTemplate
-          when Core::GoalTemplate
-            result = aGoalTemplate
-          # when Array # an Array of Goal?..
-            # goal_array = aGoalTemplate
-            # loop do
-              # conjunctions = []
-              # goal_array.each_slice(2) do |uno_duo|
-                # if uno_duo.size == 2
-                  # conjunctions << Core::GoalTemplate.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
-          else
-            raise StandardError, "Cannot handle argumment type #{aGoalTemplate.class}"
-        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_success
-          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_success
-          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_success
-          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_success
-          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_success
-          expect(outcome1.associations['q'].first.value).to eq(olive)
-
-          # Second solution
-          outcome2 = solver.resume
-          expect(outcome2).to be_success
-          expect(outcome2.associations['q'].first.value).to eq(oil)
-
-          # Third solution
-          outcome3 = solver.resume
-          expect(outcome3).to be_success
-          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_success
-          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_success
-          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