mini_kraken 0.1.01 → 0.1.02

data/spec/core/succeed_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/succeed'
+
+module MiniKraken
+  module Core
+    describe Succeed do
+      subject { Succeed.instance }
+
+      context 'Initialization:' do
+        it 'should have one instance' do
+          expect { Succeed.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('succeed')
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should unconditionally return a success result' do
+          args = double('fake-args')
+          env = double('fake-env')
+          
+          solver = nil
+          expect { solver = subject.solver_for(args, env) }.not_to raise_error
+          
+          # Solver should quack like a Fiber
+          dummy_arg = double('dummy-stuff')
+          result = solver.resume(dummy_arg)
+          expect(result).to eq(BasicSuccess)
+          
+          # Only one "solution", next 'resume' call should return nil
+          result = solver.resume(dummy_arg)
+          expect(result).to be_nil          
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/variable_ref_spec.rb

@@ -0,0 +1,31 @@
+# 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
+
+        # it 'should be fresh by default' do
+          # expect(subject).to be_fresh
+        # end
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/variable_spec.rb

@@ -1,27 +1,35 @@
 # 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' 
+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
+end # module

data/spec/core/vocabulary_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/association'
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+require_relative '../support/factory_methods'
+
+# Load the class under test
+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
+
+    module VariableBearer
+      attr_reader :vars
+
+      def init_var_bearer
+        @vars = {}
+        self
+      end
+
+      def add_var(aVarName)
+        vars[aVarName] = aVarName.hash # Just for testing purposes
+      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(Fiber)
+          expect(walker.resume).to eq(subject)
+          expect(walker.resume).to eq(mother)
+          expect(walker.resume).to eq(grandma)
+          expect(walker.resume).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
+          mother.add_assoc(Association.new('q', pea))
+          expect(subject['q'].size).to eq(1)
+          expect(subject['q'].first.value).to eq(pea)
+
+          subject.add_assoc(Association.new('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(Association.new('q', pea))
+          subject.add_assoc(Association.new('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(Association.new('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(Association.new('q', ref_x)) # Dependency: q --> x
+          expect(subject.fresh?(ref_q)).to be_truthy
+
+          # Associate with an atomic term
+          subject.add_assoc(Association.new('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(Association.new('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(Association.new('x', pea)) # Dependency: x --> pea
+          expr = cons(pea, cons(pod, cons(ref_x)))
+          subject.add_assoc(Association.new('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(Association.new('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(Association.new('q', ref_x)) # Dependency: q --> x
+          subject.add_assoc(Association.new('x', ref_q)) # Dependency: x --> q
+          expect(subject.fresh?(ref_x)).to be_truthy
+          expect(subject.fresh?(ref_q)).to be_truthy
+
+          # Associate with an atomic term
+          subject.add_assoc(Association.new('x', pea))
+          expect(subject.fresh?(ref_q)).to be_falsey
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/fresh_env_spec.rb

@@ -0,0 +1,36 @@
+# 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/k_symbol'
+
+# 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
+      subject { FreshEnv.new(['q'], sample_goal) }
+
+      context 'Initialization:' do
+        it 'should be initialized with an array of names' do
+          expect { FreshEnv.new(['q'], sample_goal) }.not_to raise_error
+        end
+
+        it 'should know its variables' do
+          expect(subject.vars['q']).not_to be_nil
+        end
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/glue/run_star_expression_spec.rb

@@ -0,0 +1,247 @@
+# 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/succeed'
+
+require_relative '../support/factory_methods'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/glue/run_star_expression'
+
+
+module MiniKraken
+  module Glue
+    describe RunStarExpression do
+      include FactoryMethods
+      let(:pea) { k_symbol(:pea) }
+      let(:pod) { k_symbol(:pod) }
+      let(:sample_goal) { equals_goal(pea, pod) }
+      subject { RunStarExpression.new('q', sample_goal) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and a goal' do
+          expect { RunStarExpression.new('q', sample_goal) }.not_to raise_error
+        end
+
+        it 'should know its variables' do
+          expect(subject.env.vars['q']).not_to be_nil
+          expect(subject.var.name).to eq('q')
+        end
+
+        it 'should know its goal' do
+          expect(subject.env.goal).to eq(sample_goal)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:ref_q) { Core::VariableRef.new('q') }
+        let(:ref_x) { Core::VariableRef.new('x') }
+
+        it "should return a null list with the fail goal" do
+          # Reasoned S2, frame 1:7
+          # (run* q #u) ;; => ()
+          failing = Core::Goal.new(Core::Fail.instance, [])
+          instance = RunStarExpression.new('q', failing)
+
+          expect(instance.run).to be_null
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+        end
+
+        it "should return a null list when a goal fails" do
+          # Reasoned S2, frame 1:10
+          # (run* q (== 'pea 'pod) ;; => ()
+
+          expect(subject.run).to be_null
+          expect(ref_q.fresh?(subject.env)).to be_truthy
+        end
+
+        it 'should unify the variable with the equals goal with symbol' do
+          goal = equals_goal(ref_q, pea)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:11
+          # (run* q (== q 'pea) ;; => (pea)
+          expect(instance.run.car).to eq(pea)
+          expect(ref_q.fresh?(instance.env)).to be_falsey
+        end
+
+        it 'should unify the righthand variable(s)' do
+          goal = equals_goal(pea, ref_q)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:12
+          # (run* q (== 'pea q) ;; => (pea)
+          expect(instance.run.car).to eq(pea)
+
+          # Reasoned S2, frame 1:15
+          expect(ref_q.fresh?(instance.env)).to be_falsey
+        end
+
+        it 'should return a null list with the succeed goal' do
+          success = Core::Goal.new(Core::Succeed.instance, [])
+          instance = RunStarExpression.new('q', success)
+
+          # (display (run* q succeed)) ;; => (_0)
+          # Reasoned S2, frame 1:16
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+
+          # Reasoned S2, frame 1:17
+          expect(result.car).to eq(any_value(0))
+        end
+
+        it 'should keep variable fresh when no unification occurs (I)' do
+          goal = equals_goal(pea, pea)
+          instance = RunStarExpression.new('q', goal)
+
+          # (display (run* q (== 'pea 'pea))) ;; => (_0)
+          # Reasoned S2, frame 1:19
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+          expect(result.car).to eq(any_value(0))
+        end
+
+        it 'should keep variable fresh when no unification occurs (III)' do
+          ref1_q = Core::VariableRef.new('q')
+          ref2_q = Core::VariableRef.new('q')
+          goal = equals_goal(ref1_q, ref2_q)
+          instance = RunStarExpression.new('q', goal)
+
+          # (display (run* q (== q q))) ;; => (_0)
+          # Reasoned S2, frame 1:20
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+          expect(result.car).to eq(any_value(0))
+        end
+
+        it 'should accept the nesting of sub-environment' do
+          goal = equals_goal(pea, ref_q)
+          fresh_env = FreshEnv.new(['x'], goal)
+          instance = RunStarExpression.new('q', fresh_env)
+
+          # Reasoned S2, frame 1:21..23
+          # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_falsey
+          expect(ref_x.fresh?(fresh_env)).to be_truthy
+          expect(result.car).to eq(pea)
+        end
+
+        it 'should unify nested variables' do
+          goal = equals_goal(pea, ref_x)
+          fresh_env = FreshEnv.new(['x'], goal)
+          instance = RunStarExpression.new('q', fresh_env)
+
+          # Reasoned S2, frame 1:24
+          # (run* q (fresh (x) (== 'pea x))) ;; => (_0)
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+          expect(ref_x.fresh?(fresh_env)).to be_falsey
+          expect(result.car).to eq(any_value(0))
+        end
+
+        it 'should accept expression with variables' do
+          goal = equals_goal(cons(ref_x), ref_q)
+          fresh_env = FreshEnv.new(['x'], goal)
+          instance = RunStarExpression.new('q', fresh_env)
+
+          # Reasoned S2, frame 1:25
+          # (run* q (fresh (x) (== (cons x '()) q))) ;; => ((_0))
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+          expect(ref_x.fresh?(fresh_env)).to be_truthy
+          expect(result.car).to eq(cons(any_value(0)))
+        end
+
+        it 'should accept fused variables' do
+          goal = equals_goal(ref_x, ref_q)
+          fresh_env = FreshEnv.new(['x'], goal)
+          instance = RunStarExpression.new('q', fresh_env)
+
+          # Reasoned S2, frame 1:31
+          # (run* q (fresh (x) (== x q))) ;; => (_0)
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+          expect(ref_x.fresh?(fresh_env)).to be_truthy
+          expect(result.car).to eq(any_value(0))
+        end
+
+        it 'should cope with complex equality expressions' do
+          expr1 = cons(cons(cons(pea)), pod)
+          expr2 = cons(cons(cons(pea)), pod)
+          goal = equals_goal(expr1, expr2)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:32
+          # (run* q (==  '(((pea)) pod) '(((pea)) pod))) ;; => (_0)
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+          expect(result.car).to eq(any_value(0))
+        end
+
+        it 'should unify complex equality expressions (I)' do
+          expr1 = cons(cons(cons(pea)), pod)
+          expr2 = cons(cons(cons(pea)), ref_q)
+          goal = equals_goal(expr1, expr2)
+          instance = RunStarExpression.new('q', goal)
+
+          # Beware: quasiquoting
+          # Reasoned S2, frame 1:33
+          # (run* q (==  '(((pea)) pod) `(((pea)) ,q))) ;; => ('pod)
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_falsey
+          expect(result.car).to eq(pod)
+        end
+
+        it 'should unify complex equality expressions (II)' do
+          expr1 = cons(cons(cons(ref_q)), pod)
+          expr2 = cons(cons(cons(pea)), pod)
+          goal = equals_goal(expr1, expr2)
+          instance = RunStarExpression.new('q', goal)
+
+          # Reasoned S2, frame 1:34
+          # (run* q (==  '(((,q)) pod) `(((pea)) pod))) ;; => ('pod)
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_falsey
+          expect(result.car).to eq(pea)
+        end
+
+        it 'should unify complex equality expressions (II)' do
+          expr1 = cons(cons(cons(ref_q)), pod)
+          expr2 = cons(cons(cons(ref_x)), pod)
+          goal = equals_goal(expr1, expr2)
+          fresh_env = FreshEnv.new(['x'], goal)
+          instance = RunStarExpression.new('q', fresh_env)
+
+          # Reasoned S2, frame 1:35
+          # (run* q (fresh (x) (==  '(((,q)) pod) `(((,x)) pod)))) ;; => (_0)
+          result = instance.run
+          expect(ref_q.fresh?(instance.env)).to be_truthy
+          expect(ref_x.fresh?(fresh_env)).to be_truthy
+          expect(result.car).to eq(any_value(0))
+        end
+
+        it 'should unify complex equality expressions (II)' do
+          # # Reasoned S2, frame 1:36
+          # # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
+          expr1 = cons(cons(cons(ref_q)), ref_x)
+          expr2 = cons(cons(cons(ref_x)), pod)
+          goal = equals_goal(expr1, expr2)
+          fresh_env = FreshEnv.new(['x'], goal)
+          instance = RunStarExpression.new('q', fresh_env)
+
+          result = instance.run
+
+          # Does propagate work correctly?
+          expect(ref_q.fresh?(instance.env)).to be_truthy # x isn't defined here
+          expect(ref_q.fresh?(fresh_env)).to be_falsey
+          expect(ref_x.fresh?(fresh_env)).to be_falsey
+          expect(result.car).to eq(pod)
+        end
+      end # context
+    end # describe
+  end # module
+end # module