mini_kraken 0.1.01 → 0.1.02

data/spec/core/equals_spec.rb

@@ -0,0 +1,289 @@
+# 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/equals'
+
+module MiniKraken
+  module Core
+    describe Equals do
+      include FactoryMethods
+
+      subject { Equals.instance }
+
+      context 'Initialization:' do
+        it 'should be created without argument' do
+          expect { Equals.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('equals')
+        end
+      end # context
+
+      context 'Provided services:' do
+        def build_var(aName)
+          new_var = Variable.new(aName)
+          env.add_var(new_var)
+          new_var
+        end
+
+        def build_var_ref(aName)
+          VariableRef.new(aName)
+        end
+
+        def solve_for(arg1, arg2)
+          solver = subject.solver_for([arg1, arg2], env)
+          outcome = solver.resume
+          env.propagate(outcome)
+          outcome
+        end
+
+        let(:pea) { KSymbol.new(:pea) }
+        let(:pod) { KSymbol.new(:pod) }
+        let(:sample_cons) { ConsCell.new(pea, nil) }
+        let(:a_composite) { ConsCell.new(pod) }
+        let(:env) { Environment.new }
+        let(:var_q) { build_var('q') }
+        let(:ref_q) do
+          dummy = var_q # Force dependency
+          build_var_ref('q')
+        end
+        let(:ref_q_bis) do
+          dummy = var_q # Force dependency
+          build_var_ref('q')
+        end
+        let(:var_x) { build_var('x') }
+        let(:ref_x) do
+          dummy = var_x  # Force dependency
+          build_var_ref('x')
+        end
+        let(:var_y) { build_var('y') }
+        let(:ref_y) do
+          dummy = var_y  # Force dependency
+          build_var_ref('y')
+        end
+
+
+        it 'should succeed for equal literal arguments' do
+          result = solve_for(pea, pea)
+
+          expect(result).to be_kind_of(Outcome)
+          expect(result.resultant).to eq(:"#s")
+          expect(result.associations).to be_empty
+          expect(var_q.fresh?(env)).to be_truthy
+        end
+
+        it 'should fail for inequal literal arguments' do
+          result = solve_for(pea, pod)
+
+          expect(result.resultant).to eq(:"#u")
+          expect(result.associations).to be_empty
+          expect(var_q.fresh?(env)).to be_truthy
+        end
+
+        it 'should fail for one left literal and one composite arguments' do
+          result = solve_for(pea, sample_cons)
+
+          expect(result.resultant).to eq(:"#u")
+          expect(result.associations).to be_empty
+          expect(var_q.fresh?(env)).to be_truthy
+        end
+
+        it 'should fail for one right literal and one composite arguments' do
+          result = solve_for(sample_cons, pea)
+
+          expect(result.resultant).to eq(:"#u")
+          expect(result.associations).to be_empty
+          expect(var_q.fresh?(env)).to be_truthy
+        end
+
+        it 'should succeed for a right-handed fresh argument' do
+          result = solve_for(pea, ref_q)
+
+          expect(result).to be_successful
+          expect(env.associations.size).to eq(1)
+          expect(env.associations['q'].first.value).to eq(pea)
+          expect(var_q.fresh?(result)).to be_falsey
+          expect(ref_q.values(result).first).to eq(pea)
+        end
+
+        it 'should succeed for a left-handed fresh argument' do
+          result = solve_for(ref_q, pea)
+
+          expect(result).to be_successful
+          expect(env.associations.size).to eq(1)
+          expect(env.associations['q'].first.value).to eq(pea)
+          expect(var_q.fresh?(result)).to be_falsey
+          expect(ref_q.values(result).first).to eq(pea)
+        end
+
+        it 'should succeed for a right-handed bound argument equal constant' do
+          ref_q.associate(pod, env)
+
+          result = solve_for(pod, ref_q)
+          expect(result).to be_successful
+          expect(env.associations.size).to eq(1) # No new association
+          expect(ref_q.fresh?(result)).not_to be_truthy
+          expect(ref_q.values(result).first).to eq(pod)
+        end
+
+        it 'should succeed for a left-handed bound argument equal constant' do
+          ref_q.associate(pod, env)
+
+          result = solve_for(ref_q, pod)
+          expect(result).to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).to be_falsey
+          expect(ref_q.values(result).first).to eq(pod)
+        end
+
+        it 'should fail for a right-handed bound argument to a distinct literal' do
+          ref_q.associate(pod, env)
+
+          result = solve_for(pea, ref_q)
+          expect(result).not_to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).to be_falsey
+          expect(ref_q.values(result).first).to eq(pod)
+        end
+
+        it 'should fail for a left-handed bound argument to a distinct literal' do
+          ref_q.associate(pod, env)
+
+          result = solve_for(ref_q, pea)
+          expect(result).not_to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).to be_falsey
+          expect(ref_q.values(result).first).to eq(pod)
+        end
+
+        it 'should succeed for a composite and right-handed fresh argument' do
+          result = solve_for(sample_cons, ref_q)
+
+          expect(result).to be_successful
+          expect(env.associations.size).to eq(1)
+          expect(ref_q.fresh?(result)).to be_falsey
+          expect(ref_q.values(result).first).to eq(sample_cons)
+        end
+
+        it 'should succeed for composite and left-handed fresh argument' do
+          result = solve_for(ref_q, sample_cons)
+
+          expect(result).to be_successful
+          expect(env.associations.size).to eq(1)
+          expect(ref_q.fresh?(result)).to be_falsey
+          expect(ref_q.values(result).first).to eq(sample_cons)
+        end
+
+        it 'should succeed for a right-handed bound equal argument' do
+          ref_q.associate(sample_cons, env)
+          composite = ConsCell.new(pea)
+          result = solve_for(composite, ref_q)
+
+          expect(result).to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).not_to be_truthy
+          expect(ref_q.values(result).first).to eq(sample_cons)
+        end
+
+        it 'should succeed for a left-handed bound equal argument' do
+          ref_q.associate(sample_cons, env)
+          composite = ConsCell.new(pea)
+          result = solve_for(ref_q, composite)
+
+          expect(result).to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).not_to be_truthy
+          expect(ref_q.values(result).first).to eq(sample_cons)
+        end
+
+        it 'should succeed for a right-handed bound unequal argument' do
+          ref_q.associate(sample_cons, env)
+          composite = ConsCell.new(pod)
+          result = solve_for(composite, ref_q)
+
+          expect(result).not_to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).not_to be_truthy
+          expect(ref_q.values(result).first).to eq(sample_cons)
+        end
+
+        it 'should succeed for a left-handed bound unequal argument' do
+          ref_q.associate(sample_cons, env)
+          composite = ConsCell.new(pod)
+          result = solve_for(ref_q, composite)
+
+          expect(result).not_to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).not_to be_truthy
+          expect(ref_q.values(result).first).to eq(sample_cons)
+        end
+
+        it 'should succeed for both identical fresh arguments' do
+          result = solve_for(ref_q, ref_q)
+
+          expect(result).to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).to be_truthy
+        end
+
+        it 'should succeed for both same fresh arguments' do
+          result = solve_for(ref_q, ref_q_bis)
+
+          expect(result).to be_successful
+          expect(result.associations).to be_empty
+          expect(ref_q.fresh?(result)).to be_truthy
+          expect(ref_q_bis.fresh?(result)).to be_truthy
+        end
+
+        it 'should succeed for both distinct fresh arguments' do
+          result = solve_for(ref_x, ref_y)
+
+          expect(result).to be_successful
+          expect(env.associations.size).to eq(2) # Symmetric association
+          expect(ref_x.fresh?(result)).to be_truthy
+          expect(ref_y.fresh?(result)).to be_truthy
+        end
+
+        it 'should succeed for arguments bound to equal values' do
+          ref_x.associate(pea, env)
+          ref_y.associate(pea, env)
+          expect(ref_x.fresh?(env)).to be_falsey
+          expect(ref_y.fresh?(env)).to be_falsey
+
+          result = solve_for(ref_x, ref_y)
+          expect(result).to be_successful
+          expect(result.associations).to be_empty
+        end
+
+        it 'should fail for arguments bound unequal values' do
+          ref_x.associate(pea, env)
+          ref_y.associate(pod, env)
+          expect(ref_x.fresh?(env)).to be_falsey
+          expect(ref_y.fresh?(env)).to be_falsey
+
+          result = solve_for(ref_x, ref_y)
+          expect(result).not_to be_successful
+          expect(result.associations).to be_empty
+        end
+
+        it 'should unify composite terms with variables' do
+          # Reasoned S2, frame 1:36
+          # (run* q (fresh (x) (==  '(((,q)) (,x)) `(((,x)) pod)))) ;; => ('pod)
+          expr1 = cons(cons(ref_q), ref_x)
+          expr2 = cons(cons(ref_x), pod)
+
+          result = solve_for(expr1, expr2)
+          # require 'debug'
+          expect(result).to be_successful
+          expect(ref_x.fresh?(env)).to be_falsey
+          expect(ref_q.fresh?(env)).to be_falsey
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/fail_spec.rb

@@ -21,6 +21,22 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        it 'should unconditionally return a failure 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(Failure)
+          
+          # 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

data/spec/core/goal_spec.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/environment'
+require_relative '../../lib/mini_kraken/core/equals'
 require_relative '../../lib/mini_kraken/core/fail'
+require_relative '../../lib/mini_kraken/core/k_symbol'
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/core/goal'
@@ -9,26 +12,49 @@ require_relative '../../lib/mini_kraken/core/goal'
 module MiniKraken
   module Core
     describe Goal do
-      let(:a_relation) { Fail.instance }
-      subject { Goal.new(a_relation, []) }
+      let(:nullary_relation) { Fail.instance }
+      subject { Goal.new(nullary_relation, []) }
+      let(:binary_relation) { Equals.instance }
+      let(:env) { Environment.new }
+      subject { Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pod)]) }
 
       context 'Initialization:' do
-        it 'should accept one goal and argument array' do
-          expect { Goal.new(a_relation, []) }.not_to raise_error
+        it 'should accept one nullary relation and empty argument array' do
+          expect { Goal.new(nullary_relation, []) }.not_to raise_error
         end
+        
+        it 'should accept one binary relation and 2-elements array' do
+          expect { Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pod)]) }.not_to raise_error
+        end        
 
         it 'should know its relation' do
-          expect(subject.relation).to eq(a_relation)
+          expect(subject.relation).to eq(binary_relation)
+        end
+        
+        it 'should know its actual arguments' do
+          expectations = [KSymbol.new(:pea), KSymbol.new(:pod)]
+          expect(subject.actuals).to eq(expectations)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should attain its intended purpose' do
-          pub = double('fake-publisher')
-          expect(pub).to receive(:broadcast_entry).with(subject, [])
-          expect(pub).to receive(:broadcast_exit).with(subject, [], [])
-          expect(subject.attain(pub, [])).to eq([])
+        it 'should fail if relation does not succeed' do
+          solver = subject.attain(env)
+          expect(solver.resume).not_to be_successful
+          
+          # No more solution...
+          expect(solver.resume).to be_nil
         end
+        
+        it 'should succeed if relation succeeds' do
+          instance = Goal.new(binary_relation, [KSymbol.new(:pea), KSymbol.new(:pea)]) 
+          
+          solver = instance.attain(env)
+          expect(solver.resume).to be_successful
+          
+          # No more solution...
+          expect(solver.resume).to be_nil
+        end      
       end # context
     end # describe
   end # module

data/spec/core/k_symbol_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'ostruct'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/k_symbol'
+
+module MiniKraken
+  module Core
+    describe KSymbol do
+      let(:a_value) { :pea }
+      subject { KSymbol.new(a_value) }
+
+      context 'Initialization:' do
+        it 'should be created with a Ruby symbol' do
+          expect { KSymbol.new(a_value) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(a_value)
+        end
+        
+        it 'should know that it is a ground term' do
+          env = double('mock-env')
+          visitees = double('fake-visitees')
+          expect(subject.ground?(env)).to be_truthy
+        end        
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether it is equal to another instance' do
+          # Same type, same value
+          other = KSymbol.new(a_value)
+          expect(subject).to be_eql(other)
+
+          # Same type, other value
+          another = KSymbol.new(:pod)
+          expect(subject).not_to be_eql(another)
+
+          # Different type, same value
+          yet_another = OpenStruct.new(:value => :pea)
+          expect(subject).not_to be_eql(yet_another)
+        end
+
+        it 'should know whether it has same value than other object' do
+          # Same type, same value
+          other = KSymbol.new(a_value)
+          expect(subject == other).to be_truthy
+
+          # Same type, other value
+          another = KSymbol.new(:pod)
+          expect(subject == another).to be_falsy
+
+          # Same duck type, same value
+          yet_another = OpenStruct.new(:value => :pea)
+          expect(subject == yet_another).to be_truthy
+
+          # Different duck type, different value
+          still_another = OpenStruct.new(:value => :pod)
+          expect(subject == still_another).to be_falsy
+
+          # Default Ruby representation, same value
+          expect(subject == :pea).to be_truthy
+
+          # Default Ruby representation, different value
+          expect(subject == :pod).to be_falsy
+        end
+      end # context
+    end # describe
+  end # module
+end # module