mini_kraken 0.1.01 → 0.1.02

data/lib/mini_kraken/glue/fresh_env.rb

@@ -0,0 +1,31 @@
+require_relative '../core/environment'
+require_relative '../core/variable'
+
+module MiniKraken
+  module Glue
+    # (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>]
+      # @param aGoal [Goal]
+      def initialize(theNames, aGoal)
+        super()
+        @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
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -0,0 +1,43 @@
+require_relative '../core/any_value'
+require_relative '../core/cons_cell'
+require_relative 'fresh_env'
+
+module MiniKraken
+  module Glue
+    class RunStarExpression
+      attr_reader :env
+
+      # @param var_name [String]
+      # @param goal [Core::Goal]
+      def initialize(var_name, goal)
+        @env = FreshEnv.new([var_name], goal)
+      end
+
+      def var
+        env.vars.values.first
+      end
+
+      def run
+        result = nil
+        solver = env.goal.attain(env)
+        # require 'debug'        
+        loop do
+          outcome = solver.resume
+          break if outcome.nil?
+          env.clear
+          if result # ... more than one result...
+          else
+            if outcome.successful?
+              env.propagate(outcome)
+              result = Core::ConsCell.new(var.quote(outcome))
+            else
+              result = Core::NullList
+            end
+          end
+        end
+
+        result
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/version.rb

@@ -1,3 +1,3 @@
 module MiniKraken
-  VERSION = "0.1.01"
+  VERSION = '0.1.02'.freeze
 end

data/spec/core/association_spec.rb

@@ -0,0 +1,38 @@
+# 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'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/association'
+
+module MiniKraken
+  module Core
+    describe Association do
+      let(:pea) {KSymbol.new(:pea) }
+      subject { Association.new('q', pea) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and a value' do
+          expect { Association.new('q', pea) }.not_to raise_error
+        end
+        
+        it 'should be initialized with a variable and a value' do
+          expect { Association.new(Variable.new('p'), pea) }.not_to raise_error
+        end        
+
+        it 'should know the variable name' do
+          expect(subject.var_name).to eq('q')
+        end
+
+        it 'should know the associated value' do
+          expect(subject.value).to eq(pea)
+        end
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/association_walker_spec.rb

@@ -0,0 +1,191 @@
+# 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(Association.new('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(Association.new('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(Association.new('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(Association.new('q', ref_x))
+          env.add_assoc(Association.new('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(Association.new('q', ref_x))
+          env.add_assoc(Association.new('x', pea))
+          env.add_assoc(Association.new('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(Association.new('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(Association.new('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(Association.new('q', expr))
+          env.add_assoc(Association.new('x', pod))
+
+          result = subject.find_ground(var_q.name, env)
+          expect(result).to eq(expr)
+        end
+=begin
+=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(Association.new('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 cycle(s)' do
+          env.add_var(var_q)
+          env.add_var(var_x)
+          env.add_assoc(Association.new('q', ref_x))
+          env.add_assoc(Association.new('x', ref_q))
+
+          result = subject.determine_freshness(ref_q, env)
+          expect(result).to be_bound
+          expect(result.associated).to eq(ref_x)
+        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/cons_cell_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/k_symbol'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/cons_cell'
+
+module MiniKraken
+  module Core
+    describe ConsCell do
+      let(:pea) {KSymbol.new(:pea) }
+      let(:pod) {KSymbol.new(:pod) }
+      subject { ConsCell.new(pea, pod) }
+
+      context 'Initialization:' do
+        it 'could be initialized with one argument' do
+          expect { ConsCell.new(pea) }.not_to raise_error
+        end
+
+        it 'could be initialized with a second optional argument' do
+          expect { ConsCell.new(pea, pod) }.not_to raise_error
+        end
+
+        it 'should know its car child' do
+          expect(subject.car).to eq(pea)
+        end
+
+        it 'should know its cdr child' do
+          expect(subject.cdr).to eq(pod)
+        end
+
+        it 'should know its children' do
+          expect(subject.children).to eq([pea, pod])
+        end
+
+        it 'should know if it is empty (null)' do
+          expect(subject).not_to be_null
+          expect(ConsCell.new(nil, nil)).to be_null
+          expect(NullList).to be_null
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should compare to itself' do
+          expect(subject.eql?(subject)).to be_truthy
+          expect(subject == subject).to be_truthy
+        end
+
+        it 'should compare to another instance' do
+          same = ConsCell.new(pea, pod)
+          expect(subject.eql?(same)).to be_truthy
+
+          different = ConsCell.new(pod, pea)
+          expect(subject.eql?(different)).to be_falsey
+
+          different = ConsCell.new(pea)
+          expect(subject.eql?(different)).to be_falsey
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/duck_fiber_spec.rb

@@ -0,0 +1,62 @@
+# 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/duck_fiber'
+
+module MiniKraken
+  module Core
+    describe DuckFiber do
+      subject { DuckFiber.new(:failure) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a symbol and an optional block' do
+          expect { DuckFiber.new(:failure) }.not_to raise_error
+
+          expect { DuckFiber.new(:custom) { Outcome.new(:"#s") } }.not_to raise_error
+        end
+
+        it 'should know its outcome' do
+          expect(subject.outcome).to eq(Failure)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:parent) { Environment.new }
+      
+        it 'should behave like a Fiber yielding a failure' do
+          failing = DuckFiber.new(:failure)
+          outcome = nil
+          expect { outcome = failing.resume }.not_to raise_error
+          expect(outcome).to eq(Failure)
+          
+          # Only one result should be yielded
+          expect(failing.resume).to be_nil          
+        end
+        
+        it 'should behave like a Fiber yielding a basic success' do
+          succeeding = DuckFiber.new(:success)
+          outcome = nil
+          expect { outcome = succeeding.resume }.not_to raise_error
+          expect(outcome).to eq(BasicSuccess)
+          
+          # Only one result should be yielded
+          expect(succeeding.resume).to be_nil
+        end 
+
+        it 'should behave like a Fiber yielding a custom outcome' do
+          
+          tailored = DuckFiber.new(:custom) { Outcome.new(:"#s", parent) } 
+          outcome = nil
+          expect { outcome = tailored.resume }.not_to raise_error
+          expect(outcome).to eq(Outcome.new(:"#s", parent))
+          
+          # Only one result should be yielded
+          expect(tailored.resume).to be_nil          
+        end         
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/environment_spec.rb

@@ -0,0 +1,154 @@
+# 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 '../../lib/mini_kraken/core/association'
+require_relative '../../lib/mini_kraken/core/outcome'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/environment'
+
+module MiniKraken
+  module Core
+    describe Environment do
+      subject { Environment.new }
+
+      context 'Initialization:' do
+        it 'should be initialized with an optional parent' do
+          expect { Environment.new }.not_to raise_error
+          parent = Environment.new
+          expect { Environment.new(parent) }.not_to raise_error
+        end
+
+        it "shouldn't have variable by default" do
+          expect(subject.vars).to be_empty
+        end
+
+        it "shouldn't have associations by default" do
+          expect(subject.associations).to be_empty
+        end
+
+        it 'shold know its parent (if any)' do
+          # Case: no parent
+          expect(subject.parent).to be_nil
+
+          # Case: there is a parent
+          child = Environment.new(subject)
+          expect(child.parent).to eq(subject)
+        end
+
+      end # context
+
+      context 'Provided services:' do
+        let(:var_a) { Variable.new('a') }
+        let(:var_b) { Variable.new('b') }
+        let(:var_c) { Variable.new('c') }
+        let(:var_c_bis) { Variable.new('c') }
+        let(:pea) { KSymbol.new(:pea) }
+        let(:pod) { KSymbol.new(:pod) }
+        let(:pad) { KSymbol.new(:pad) }
+
+        it 'should accept the addition of a variable' do
+          subject.add_var(var_a)
+          expect(subject.vars).not_to be_empty
+          expect(subject.vars['a']).to eq(var_a)
+        end
+
+        it 'should accept the addition of multiple variables' do
+          subject.add_var(var_a)
+          expect(subject.vars).not_to be_empty
+          subject.add_var(var_b)
+          expect(subject.vars['a']).to eq(var_a)
+          expect(subject.vars['b']).to eq(var_b)
+        end
+
+        it 'should accept the addition of an association' do
+          subject.add_var(var_a)
+          assoc = Association.new('a', pea)
+          subject.add_assoc(assoc)
+          expect(subject.associations.size).to eq(1)
+          expect(subject.associations['a']).to eq([assoc])
+        end
+
+        it 'should tell that a newborn variable is fresh' do
+          subject.add_var(var_a)
+
+          # By default, a variable is fresh...
+          expect(subject.fresh?(var_a)).to be_truthy
+        end
+
+        it "should tell variable associated with a literal value isn't fresh" do
+          subject.add_var(var_a)
+
+          # Let's associate an atomic term...
+          assoc = Association.new('a', pea)
+          subject.add_assoc(assoc)
+
+          expect(subject.fresh?(var_a)).to be_falsey
+        end
+
+        it "should cope with a variable associated with another variable" do
+          subject.add_var(var_a)
+          subject.add_var(var_b)
+
+          # Let's associate a with (fresh) b
+          assoc = Association.new(var_a, var_b)
+          subject.add_assoc(assoc)
+
+          expect(subject.fresh?(var_a)).to be_truthy
+
+          # Now associate b with something ground...
+          assoc_b = Association.new(var_b, pea)
+          subject.add_assoc(assoc_b)
+
+          # b is no more fresh, so is ... a
+          expect(subject.fresh?(var_b)).to be_falsey
+          expect(subject.fresh?(var_a)).to be_falsey
+        end
+
+        it 'should remove all associations' do
+          subject.add_var(var_a)
+          assoc = Association.new(var_a, pea)
+          subject.add_assoc(assoc)
+
+          subject.add_var(var_b)
+          assoc = Association.new(var_b, pod)
+          subject.add_assoc(assoc)
+
+          subject.clear
+          expect(subject.fresh?(var_a)).to be_truthy
+          expect(subject.fresh?(var_a)).to be_truthy
+        end
+
+        it 'should propagate associations up in the environment hierarchy' do
+          parent = Environment.new
+          parent.add_var(var_a)
+          # parent.add_var(var_c)
+          instance = Environment.new(parent)
+          instance.add_var(var_b)
+          # instance.add_var(var_c_bis) # Should shadow parent's c variable
+
+          outcome = Outcome.new(:"#s", instance)
+          outcome.add_assoc(Association.new(var_a, pea))
+          outcome.add_assoc(Association.new(var_b, pod))
+          # outcome.add_assoc(Association.new(var_c_bis, pad))
+          expect(outcome.associations.size).to eq(2)          
+          
+          # Propagate: outcome -> .. -> instance
+          instance.propagate(outcome)         
+          expect(outcome.associations.size).to eq(1)
+          expect(instance.associations[var_b.name]).not_to be_nil
+          expect(parent.associations[var_a.name]).to be_nil
+          
+          # Propagate: outcome -> .. -> parent
+          parent.propagate(outcome)
+          expect(outcome.associations).to be_empty 
+          expect(parent.associations[var_b.name]).to be_nil
+          expect(parent.associations[var_a.name]).not_to be_nil          
+        end
+      end # context
+    end # describe
+  end # module
+end # module