porolog 1.0.2 → 1.0.3

data/test/porolog/scope_test.rb

@@ -16,14 +16,14 @@ describe 'Porolog' do
   describe 'Scope' do
     
     it 'should already declare the default scope' do
-      assert_equal        1,            Scope.scopes.size
-      assert_equal        [:default],   Scope.scopes
+      assert_equal        1,            Porolog::Scope.scopes.size
+      assert_equal        [:default],   Porolog::Scope.scopes
       
-      assert_Scope        Scope[:default], :default, []
+      assert_Scope        Porolog::Scope[:default], :default, []
     end
     
     it 'should allow predicates with the same name to coexist in different scopes' do
-      prime = prime1 = Predicate.new :prime, :first
+      prime = prime1 = Porolog::Predicate.new :prime, :first
 
       prime.(2).fact!
       prime.(3).fact!
@@ -31,17 +31,17 @@ describe 'Porolog' do
       prime.(7).fact!
       prime.(11).fact!
 
-      prime = prime2 = Predicate.new :prime, :second
+      prime = prime2 = Porolog::Predicate.new :prime, :second
 
       prime.('pump A').fact!
       prime.('pump B').fact!
       prime.('pump C').fact!
       prime.('pump D').fact!
 
-      assert_equal        [:default,:first,:second],          Scope.scopes
-      assert_Scope        Scope[:default],  :default, []
-      assert_Scope        Scope[:first],    :first,   [prime1]
-      assert_Scope        Scope[:second],   :second,  [prime2]
+      assert_equal        [:default,:first,:second],            Porolog::Scope.scopes
+      assert_Scope        Porolog::Scope[:default],  :default,  []
+      assert_Scope        Porolog::Scope[:first],    :first,    [prime1]
+      assert_Scope        Porolog::Scope[:second],   :second,   [prime2]
       
       assert_equal        :prime,     prime1.name
       assert_equal        :prime,     prime2.name
@@ -67,12 +67,12 @@ describe 'Porolog' do
     describe '.scopes' do
       
       it 'should return the names of all registered scopes' do
-        Scope.new :alpha
-        Scope.new :bravo
-        Scope.new :carly
+        Porolog::Scope.new :alpha
+        Porolog::Scope.new :bravo
+        Porolog::Scope.new :carly
         
-        assert_equal        4,                                    Scope.scopes.size
-        assert_equal        [:default, :alpha, :bravo, :carly],   Scope.scopes
+        assert_equal        4,                                    Porolog::Scope.scopes.size
+        assert_equal        [:default, :alpha, :bravo, :carly],   Porolog::Scope.scopes
       end
       
     end
@@ -80,54 +80,54 @@ describe 'Porolog' do
     describe '.reset' do
       
       it 'should clear all scopes' do
-        delta = Predicate.new :delta
+        delta = Porolog::Predicate.new :delta
         
-        Scope.new :alpha
-        Scope.new :bravo
-        Scope.new :carly
+        Porolog::Scope.new :alpha
+        Porolog::Scope.new :bravo
+        Porolog::Scope.new :carly
         
-        assert_equal        4,                                    Scope.scopes.size
-        assert_equal        [:default, :alpha, :bravo, :carly],   Scope.scopes
+        assert_equal        4,                                    Porolog::Scope.scopes.size
+        assert_equal        [:default, :alpha, :bravo, :carly],   Porolog::Scope.scopes
         
-        assert_Scope        Scope[:default],  :default, [delta]
-        assert_Scope        Scope[:alpha],    :alpha,   []
-        assert_Scope        Scope[:bravo],    :bravo,   []
-        assert_Scope        Scope[:carly],    :carly,   []
+        assert_Scope        Porolog::Scope[:default],  :default,  [delta]
+        assert_Scope        Porolog::Scope[:alpha],    :alpha,    []
+        assert_Scope        Porolog::Scope[:bravo],    :bravo,    []
+        assert_Scope        Porolog::Scope[:carly],    :carly,    []
         
-        Scope.reset
+        Porolog::Scope.reset
         
-        assert_equal        1,                                    Scope.scopes.size
-        assert_equal        [:default],                           Scope.scopes
+        assert_equal        1,                                    Porolog::Scope.scopes.size
+        assert_equal        [:default],                           Porolog::Scope.scopes
         
-        assert_Scope        Scope[:default], :default, []
+        assert_Scope        Porolog::Scope[:default], :default,   []
         
-        assert_nil                                                Scope[:alpha]
-        assert_nil                                                Scope[:bravo]
-        assert_nil                                                Scope[:carly]
+        assert_nil                                                Porolog::Scope[:alpha]
+        assert_nil                                                Porolog::Scope[:bravo]
+        assert_nil                                                Porolog::Scope[:carly]
       end
       
       it 'should clear all scopes and start with a default scope when reset' do
-        test_predicate0  = Predicate.new 'test_predicate0'
-        test_predicate11 = Predicate.new 'test_predicate11', :scope1
-        test_predicate12 = Predicate.new 'test_predicate12', :scope1
-        test_predicate13 = Predicate.new 'test_predicate13', :scope1
-        test_predicate21 = Predicate.new 'test_predicate21', :scope2
-        test_predicate22 = Predicate.new 'test_predicate22', :scope2
-        test_predicate23 = Predicate.new 'test_predicate23', :scope2
+        test_predicate0  = Porolog::Predicate.new 'test_predicate0'
+        test_predicate11 = Porolog::Predicate.new 'test_predicate11', :scope1
+        test_predicate12 = Porolog::Predicate.new 'test_predicate12', :scope1
+        test_predicate13 = Porolog::Predicate.new 'test_predicate13', :scope1
+        test_predicate21 = Porolog::Predicate.new 'test_predicate21', :scope2
+        test_predicate22 = Porolog::Predicate.new 'test_predicate22', :scope2
+        test_predicate23 = Porolog::Predicate.new 'test_predicate23', :scope2
         
-        assert_equal  [:default, :scope1, :scope2],                               Scope.scopes
-        assert_equal  [test_predicate0],                                          Scope[:default].predicates
-        assert_equal  [test_predicate11, test_predicate12, test_predicate13],     Scope[:scope1 ].predicates
-        assert_equal  [test_predicate21, test_predicate22, test_predicate23],     Scope[:scope2 ].predicates
+        assert_equal  [:default, :scope1, :scope2],                               Porolog::Scope.scopes
+        assert_equal  [test_predicate0],                                          Porolog::Scope[:default].predicates
+        assert_equal  [test_predicate11, test_predicate12, test_predicate13],     Porolog::Scope[:scope1 ].predicates
+        assert_equal  [test_predicate21, test_predicate22, test_predicate23],     Porolog::Scope[:scope2 ].predicates
         
-        Scope.reset
+        Porolog::Scope.reset
         
-        test_predicate3  = Predicate.new 'test_predicate3'
+        test_predicate3  = Porolog::Predicate.new 'test_predicate3'
         
-        assert_equal  [:default],                                                 Scope.scopes
-        assert_equal  [test_predicate3],                                          Scope[:default].predicates
-        assert_nil                                                                Scope[:scope1 ]
-        assert_nil                                                                Scope[:scope2 ]
+        assert_equal  [:default],                                                 Porolog::Scope.scopes
+        assert_equal  [test_predicate3],                                          Porolog::Scope[:default].predicates
+        assert_nil                                                                Porolog::Scope[:scope1 ]
+        assert_nil                                                                Porolog::Scope[:scope2 ]
       end
       
     end
@@ -135,14 +135,14 @@ describe 'Porolog' do
     describe '.[]' do
       
       it 'should provide access to a scope by name' do
-        alpha = Scope.new :alpha
-        bravo = Scope.new :bravo
-        carly = Scope.new :carly
+        alpha = Porolog::Scope.new :alpha
+        bravo = Porolog::Scope.new :bravo
+        carly = Porolog::Scope.new :carly
         
-        assert_equal  alpha,  Scope[:alpha]
-        assert_equal  bravo,  Scope[:bravo]
-        assert_equal  carly,  Scope[:carly]
-        assert_nil            Scope[:delta]
+        assert_equal  alpha,  Porolog::Scope[:alpha]
+        assert_equal  bravo,  Porolog::Scope[:bravo]
+        assert_equal  carly,  Porolog::Scope[:carly]
+        assert_nil            Porolog::Scope[:delta]
       end
       
     end
@@ -150,14 +150,14 @@ describe 'Porolog' do
     describe '.new' do
     
       it 'should not create duplicate scopes (with the same name)' do
-        Scope.new :duplicate
-        Scope.new :duplicate
-        Scope.new :duplicate
-        Scope.new :duplicate
+        Porolog::Scope.new :duplicate
+        Porolog::Scope.new :duplicate
+        Porolog::Scope.new :duplicate
+        Porolog::Scope.new :duplicate
         
-        assert_equal  2,                                Scope.scopes.size
-        assert_equal  1,                                Scope.scopes.count(:duplicate)
-        assert_equal  [:default, :duplicate],           Scope.scopes
+        assert_equal  2,                                Porolog::Scope.scopes.size
+        assert_equal  1,                                Porolog::Scope.scopes.count(:duplicate)
+        assert_equal  [:default, :duplicate],           Porolog::Scope.scopes
       end
       
     end
@@ -165,15 +165,15 @@ describe 'Porolog' do
     describe '#initialize' do
       
       it 'should keep track of created scopes' do
-        Scope.new :alpha
-        Scope.new :bravo
-        Scope.new :carly
+        Porolog::Scope.new :alpha
+        Porolog::Scope.new :bravo
+        Porolog::Scope.new :carly
         
-        assert_equal   [:default,:alpha,:bravo,:carly], Scope.scopes
+        assert_equal   [:default,:alpha,:bravo,:carly], Porolog::Scope.scopes
       end
       
       it 'should create scopes with no predicates' do
-        scope = Scope.new('test_scope_name')
+        scope = Porolog::Scope.new('test_scope_name')
         
         assert_respond_to   scope,              :predicates
         assert_equal        [],                 scope.predicates
@@ -184,7 +184,7 @@ describe 'Porolog' do
     describe '#name' do
       
       it 'should create scopes with a name attribute' do
-        scope = Scope.new('test_scope_name')
+        scope = Porolog::Scope.new('test_scope_name')
         
         assert_respond_to   scope,              :name
         assert_equal        'test_scope_name',  scope.name
@@ -195,11 +195,11 @@ describe 'Porolog' do
     describe '#predicates' do
       
       it 'should provide access to all the predicates of a scope' do
-        test_predicate1 = Predicate.new 'test_predicate1', :test
-        test_predicate2 = Predicate.new 'test_predicate2', :test
+        test_predicate1 = Porolog::Predicate.new 'test_predicate1', :test
+        test_predicate2 = Porolog::Predicate.new 'test_predicate2', :test
         
-        assert_respond_to   Scope[:test],                         :predicates
-        assert_equal        [test_predicate1,test_predicate2],    Scope[:test].predicates
+        assert_respond_to   Porolog::Scope[:test],                :predicates
+        assert_equal        [test_predicate1,test_predicate2],    Porolog::Scope[:test].predicates
       end
       
     end
@@ -207,18 +207,18 @@ describe 'Porolog' do
     describe '#[]' do
       
       it 'should provide access to a predicate of a scope by its name' do
-        test_predicate3 = Predicate.new 'test_predicate3', :test
-        test_predicate4 = Predicate.new 'test_predicate4', :test
+        test_predicate3 = Porolog::Predicate.new 'test_predicate3', :test
+        test_predicate4 = Porolog::Predicate.new 'test_predicate4', :test
         
-        assert_includes     Scope[:test].predicates,  test_predicate3
+        assert_includes     Porolog::Scope[:test].predicates,  test_predicate3
         
-        assert_instance_of  Class,                    Scope
-        assert_instance_of  Scope,                    Scope[:test]
-        assert_instance_of  Predicate,                Scope[:test][:test_predicate3]
+        assert_instance_of  Class,                    Porolog::Scope
+        assert_instance_of  Porolog::Scope,           Porolog::Scope[:test]
+        assert_instance_of  Porolog::Predicate,       Porolog::Scope[:test][:test_predicate3]
         
-        assert_equal        test_predicate3,          Scope[:test][:test_predicate3]
-        assert_equal        test_predicate3,          Scope[:test]['test_predicate3']
-        assert_equal        test_predicate4,          Scope[:test]['test_predicate4']
+        assert_equal        test_predicate3,          Porolog::Scope[:test][:test_predicate3]
+        assert_equal        test_predicate3,          Porolog::Scope[:test]['test_predicate3']
+        assert_equal        test_predicate4,          Porolog::Scope[:test]['test_predicate4']
       end
       
     end
@@ -227,7 +227,7 @@ describe 'Porolog' do
       
       it 'should raise an error when trying to put anthing but a Predicate in a Scope' do
         error = assert_raises(Porolog::Scope::NotPredicateError){
-          scope = Scope.new :scope
+          scope = Porolog::Scope.new :scope
           
           scope[:predicate] = 'predicate'
         }
@@ -235,18 +235,18 @@ describe 'Porolog' do
       end
       
       it 'should allow an existing predicate to be assigned to a scope' do
-        test_predicate = Predicate.new 'test_predicate', :test
+        test_predicate = Porolog::Predicate.new 'test_predicate', :test
         
-        scope = Scope.new :scope
+        scope = Porolog::Scope.new :scope
         
         scope[:predicate] = test_predicate
         
-        assert_equal        3,                                    Scope.scopes.size
-        assert_equal        [:default, :test, :scope],            Scope.scopes
+        assert_equal        3,                                    Porolog::Scope.scopes.size
+        assert_equal        [:default, :test, :scope],            Porolog::Scope.scopes
         
-        assert_Scope        Scope[:default],                      :default, []
-        assert_Scope        Scope[:test],                         :test,    [test_predicate]
-        assert_Scope        Scope[:scope],                        :scope,   [test_predicate]
+        assert_Scope        Porolog::Scope[:default],             :default, []
+        assert_Scope        Porolog::Scope[:test],                :test,    [test_predicate]
+        assert_Scope        Porolog::Scope[:scope],               :scope,   [test_predicate]
       end
       
     end

data/test/porolog/tail_test.rb

@@ -18,24 +18,24 @@ describe 'Porolog' do
     describe '.new' do
       
       it 'creates an unknown tail when no value is provided' do
-        tail = Tail.new
+        tail = Porolog::Tail.new
         
-        assert_Tail               tail,             '*...'
-        assert_equal              UNKNOWN_TAIL,     tail.value
+        assert_Tail       tail,                     '*...'
+        assert_equal      Porolog::UNKNOWN_TAIL,    tail.value
       end
       
       it 'creates a tail with a value' do
-        tail = Tail.new [2,3,5,7,11,13]
+        tail = Porolog::Tail.new [2,3,5,7,11,13]
         
-        assert_Tail               tail,             '*[2, 3, 5, 7, 11, 13]'
-        assert_equal              [2,3,5,7,11,13],  tail.value
+        assert_Tail       tail,                     '*[2, 3, 5, 7, 11, 13]'
+        assert_equal      [2,3,5,7,11,13],          tail.value
       end
       
       it 'creates a tail with a variable' do
-        tail = Tail.new :x
+        tail = Porolog::Tail.new :x
         
-        assert_Tail               tail,             '*:x'
-        assert_equal              :x,               tail.value
+        assert_Tail       tail,                     '*:x'
+        assert_equal      :x,                       tail.value
       end
       
     end
@@ -51,10 +51,10 @@ describe 'Porolog' do
       end
       
       it 'returns its value' do
-        tail = Tail.new object
+        tail = Porolog::Tail.new object
         
-        assert_Tail               tail,             '*#<Object:0xXXXXXX>'
-        assert_equal              object,           tail.value
+        assert_Tail       tail,                     '*#<Object:0xXXXXXX>'
+        assert_equal      object,                   tail.value
       end
       
     end
@@ -62,7 +62,7 @@ describe 'Porolog' do
     describe '#inspect' do
       
       it 'returns a string showing a splat operation is implied' do
-        tail = Tail.new [2,3,5,7,11,13]
+        tail = Porolog::Tail.new [2,3,5,7,11,13]
         
         assert_equal      '*[2, 3, 5, 7, 11, 13]',  tail.inspect
       end
@@ -72,25 +72,25 @@ describe 'Porolog' do
     describe '#variables' do
       
       it 'returns an empty Array when it was created without arguments' do
-        tail = Tail.new
+        tail = Porolog::Tail.new
         
         assert_equal      [],                       tail.variables
       end
       
       it 'returns an empty Array when it was created with an Array of atomics' do
-        tail = Tail.new [2,3,5,7,11,13]
+        tail = Porolog::Tail.new [2,3,5,7,11,13]
         
         assert_equal      [],                       tail.variables
       end
       
       it 'returns an Array of Symbols when it was created with a Symbol' do
-        tail = Tail.new :t
+        tail = Porolog::Tail.new :t
         
         assert_equal      [:t],                     tail.variables
       end
       
       it 'returns an Array of Symbols when it was created with an Array with embedded Symbols' do
-        tail = Tail.new [2,3,:x,7,[:y,[:z]],13]
+        tail = Porolog::Tail.new [2,3,:x,7,[:y,[:z]],13]
         
         assert_equal      [:x,:y,:z],               tail.variables
       end
@@ -100,22 +100,22 @@ describe 'Porolog' do
     describe '#==' do
       
       it 'returns true for unknown tails' do
-        tail1 = Tail.new
-        tail2 = Tail.new
+        tail1 = Porolog::Tail.new
+        tail2 = Porolog::Tail.new
         
         assert            tail1 == tail2, name
       end
       
       it 'returns false for different symbols' do
-        tail1 = Tail.new :t
-        tail2 = Tail.new :x
+        tail1 = Porolog::Tail.new :t
+        tail2 = Porolog::Tail.new :x
         
         refute            tail1 == tail2, name
       end
       
       it 'returns true for equal values' do
-        tail1 = Tail.new 12.34
-        tail2 = Tail.new 12.34
+        tail1 = Porolog::Tail.new 12.34
+        tail2 = Porolog::Tail.new 12.34
         
         assert            tail1 == tail2, name
       end

data/test/porolog/value_test.rb

@@ -16,12 +16,12 @@ describe 'Porolog' do
   describe 'Value' do
     
     let(:goal) { new_goal :generic, [:m, :n] }
-    let(:v)    { Value.new 456.123, goal }
+    let(:v)    { Porolog::Value.new 456.123, goal }
     
     describe '.new' do
       
       it 'should create a new value' do
-        assert_instance_of  Value,      v
+        assert_instance_of  Porolog::Value,   v
       end
       
     end
@@ -29,22 +29,22 @@ describe 'Porolog' do
     describe '#initialize' do
       
       it 'should initialize value and goal' do
-        assert_equal        456.123,    v.value
-        assert_equal        goal,       v.goal
+        assert_equal        456.123,          v.value
+        assert_equal        goal,             v.goal
       end
       
       it 'should raise an error when a goal is not provided' do
-        assert_raises Value::GoalError do
-          Value.new 456.789, 'goal'
+        assert_raises Porolog::Value::GoalError do
+          Porolog::Value.new 456.789, 'goal'
         end
       end
       
       it 'should copy the value of another Value' do
-        other = Value.new 123.456, goal
-        v     = Value.new other,   goal
+        other = Porolog::Value.new 123.456, goal
+        v     = Porolog::Value.new other,   goal
         
-        refute_instance_of  Value,      v.value
-        assert_equal        123.456,    v.value
+        refute_instance_of  Porolog::Value,   v.value
+        assert_equal        123.456,          v.value
       end
       
     end
@@ -52,7 +52,7 @@ describe 'Porolog' do
     describe '#inspect' do
       
       it 'should show the goal and the value' do
-        assert_equal        'Goal1.456.123',                            v.inspect
+        assert_equal        'Goal1.456.123',  v.inspect
       end
       
     end
@@ -60,7 +60,7 @@ describe 'Porolog' do
     describe '#instantiations' do
       
       it 'should return no instantiations' do
-        assert_equal        [],                                         v.instantiations
+        assert_equal        [],               v.instantiations
       end
       
     end
@@ -90,19 +90,19 @@ describe 'Porolog' do
     
     describe '#remove' do
       
-      let(:predicate1) { Predicate.new :removal }
+      let(:predicate1) { Porolog::Predicate.new :removal }
       let(:arguments1) { predicate1.arguments(:m,:n) }
       let(:goal1)      { arguments1.goal }
       let(:goal2)      { arguments1.goal }
       let(:goal3)      { arguments1.goal }
       let(:goal4)      { arguments1.goal }
       
-      let(:variable1)  { Variable.new :x,  goal1 }
-      let(:variable2)  { Variable.new :y,  goal2 }
-      let(:variable3)  { Variable.new :z,  goal3 }
-      let(:variable4)  { Variable.new :a,  goal1 }
-      let(:value1)     { Value.new 'word', goal2 }
-      let(:value2)     { Value.new 'draw', goal4 }
+      let(:variable1)  { Porolog::Variable.new :x,  goal1 }
+      let(:variable2)  { Porolog::Variable.new :y,  goal2 }
+      let(:variable3)  { Porolog::Variable.new :z,  goal3 }
+      let(:variable4)  { Porolog::Variable.new :a,  goal1 }
+      let(:value1)     { Porolog::Value.new 'word', goal2 }
+      let(:value2)     { Porolog::Value.new 'draw', goal4 }
       
       before do
         reset
@@ -142,7 +142,6 @@ describe 'Porolog' do
       end
       
       it 'should remove all instantiations case 1: remove value1' do
-        
         value1.remove
         
         assert_Goal_variables     goal1,  { m: nil, n: nil, x: nil, a: 'draw' }, [
@@ -174,7 +173,6 @@ describe 'Porolog' do
       end
       
       it 'should remove all instantiations case 2: remove value2' do
-        
         value2.remove
         
         assert_Goal_variables     goal1,  { m: nil, n: nil, x: 'word', a: nil }, [
@@ -241,11 +239,11 @@ describe 'Porolog' do
     
     describe '#type' do
       
-      let(:float)   { Value.new 456.789,    goal }
-      let(:integer) { Value.new 456,        goal }
-      let(:string)  { Value.new 'average',  goal }
-      let(:array)   { Value.new [1,2,3],    goal }
-      let(:object)  { Value.new Object.new, goal }
+      let(:float)   { Porolog::Value.new 456.789,    goal }
+      let(:integer) { Porolog::Value.new 456,        goal }
+      let(:string)  { Porolog::Value.new 'average',  goal }
+      let(:array)   { Porolog::Value.new [1,2,3],    goal }
+      let(:object)  { Porolog::Value.new Object.new, goal }
       
       it 'should return atomic for Float' do
         assert_equal        :atomic,    float.type
@@ -272,22 +270,22 @@ describe 'Porolog' do
     describe '#==' do
       
       it 'should return false for Values of different types' do
-        v1 = Value.new 456.789,   goal
-        v2 = Value.new 'average', goal
+        v1 = Porolog::Value.new 456.789,   goal
+        v2 = Porolog::Value.new 'average', goal
         
         refute      v1 == v2,     "#{name}: #{v1.value.inspect} == #{v2.value.inspect}"
       end
       
       it 'should return false for Values of the same type but different values' do
-        v1 = Value.new 456.789,   goal
-        v2 = Value.new 123.456,   goal
+        v1 = Porolog::Value.new 456.789,   goal
+        v2 = Porolog::Value.new 123.456,   goal
         
         refute      v1 == v2,     "#{name}: #{v1.value.inspect} == #{v2.value.inspect}"
       end
       
       it 'should return true for Values of the same type and the same value' do
-        v1 = Value.new 456.789,   goal
-        v2 = Value.new 456.789,   goal
+        v1 = Porolog::Value.new 456.789,   goal
+        v2 = Porolog::Value.new 456.789,   goal
         
         assert      v1 == v2,     "#{name}: #{v1.value.inspect} == #{v2.value.inspect}"
       end
@@ -297,13 +295,13 @@ describe 'Porolog' do
     describe '#variables' do
       
       it 'should return an empty Array for a Float value' do
-        float = Value.new 456.789, goal
+        float = Porolog::Value.new 456.789, goal
         
         assert_equal        [],             float.variables
       end
       
       it 'should return an Array of Symbols for embedded Variables' do
-        array = Value.new [1, :b, 3, ['four', :e, 6], [[:g, 8]]], goal
+        array = Porolog::Value.new [1, :b, 3, ['four', :e, 6], [[:g, 8]]], goal
         
         assert_equal        [:b, :e, :g],   array.variables
       end