porolog 1.0.2 → 1.0.3

data/test/samples_test.rb

@@ -14,7 +14,7 @@ describe 'Porolog' do
   end
   
   it 'implements delete first predicate' do
-    predicate :delete
+    Porolog::predicate :delete
     
     delete(:X, [:X]/:T, :T).fact!
 
@@ -33,8 +33,8 @@ describe 'Porolog' do
   end
   
   it 'implements the delete predicate' do
-    builtin :write
-    predicate :delete
+    Porolog::builtin :write
+    Porolog::predicate :delete
     
     delete(:X, [:X]/:T, :T).fact!
     delete(:X, [:H]/:T, [:H]/:NT) << [
@@ -78,7 +78,7 @@ describe 'Porolog' do
   
   it 'implements the permutation predicate' do
     warn name
-    predicate :delete, :permutation
+    Porolog::predicate :delete, :permutation
     
     permutation([],[]).fact!
     permutation(:List, [:H]/:Permutation) << [
@@ -115,8 +115,8 @@ describe 'Porolog' do
   
   it 'solves the Einstein / Zebra riddle' do
     warn name
-    builtin :is, :member, :is_noteq
-    predicate :same, :not_same, :left, :beside, :houses
+    Porolog::builtin :is, :member, :is_noteq
+    Porolog::predicate :same, :not_same, :left, :beside, :houses
 
     same(:X,:X).fact!
 
@@ -209,8 +209,8 @@ describe 'Porolog' do
   end
   
   it 'instantiates lists using member and length builtin predicates' do
-    builtin :member, :length
-    predicate :lists
+    Porolog::builtin :member, :length
+    Porolog::predicate :lists
 
     lists(:L) << [
       member(:N,[1,2,3,4,5]),
@@ -238,8 +238,8 @@ describe 'Porolog' do
   end
   
   it 'implements a prime number search' do
-    builtin   :gtr, :is, :noteq, :between
-    predicate :prime, :search_prime
+    Porolog::builtin   :gtr, :is, :noteq, :between
+    Porolog::predicate :prime, :search_prime
 
     prime(2).fact!
     prime(3).fact!
@@ -271,7 +271,7 @@ describe 'Porolog' do
     ]
     
     assert_equal    known_primes,     prime(:number).solve_for(:number, max_solutions: 50)
-    assert_equal    3016,             Goal.goal_count
+    assert_equal    3016,             Porolog::Goal.goal_count
   end
     
 end

data/test/test_helper.rb

@@ -21,115 +21,110 @@ require 'mocha/minitest'
 require 'spy/integration'
 require 'porolog'
 
-include Porolog
-
-
 # -- Helpers --
 def reset
-  Scope.reset
-  Predicate.reset
-  Arguments.reset
-  Rule.reset
-  Goal.reset
-  Instantiation.reset
+  Porolog::Scope.reset
+  Porolog::Predicate.reset
+  Porolog::Arguments.reset
+  Porolog::Rule.reset
+  Porolog::Goal.reset
+  Porolog::Instantiation.reset
   Porolog::ANONYMOUS[0] = '_a'
 end
 
 def assert_Scope(scope, name, predicates)
-  assert_instance_of  Scope,            scope
-  assert_equal        name,             scope.name
-  assert_equal        predicates,       scope.predicates
+  assert_instance_of  Porolog::Scope,       scope
+  assert_equal        name,                 scope.name
+  assert_equal        predicates,           scope.predicates
 end
 
 def assert_Predicate(predicate, name, rules)
-  assert_instance_of  Predicate,        predicate
-  assert_equal        name,             predicate.name
-  assert_equal        rules,            predicate.rules
+  assert_instance_of  Porolog::Predicate,   predicate
+  assert_equal        name,                 predicate.name
+  assert_equal        rules,                predicate.rules
 end
 
 def assert_Arguments(arguments, predicate, args)
-  assert_instance_of  Arguments,        arguments
-  assert_equal        predicate,        arguments.predicate.name
-  assert_equal        args,             arguments.arguments
+  assert_instance_of  Porolog::Arguments,   arguments
+  assert_equal        predicate,            arguments.predicate.name
+  assert_equal        args,                 arguments.arguments
 end
 
 def assert_Rule(rule, predicate, arguments, definition)
-  assert_instance_of  Rule,             rule
-  assert_equal        predicate,        rule.arguments.predicate.name
-  assert_equal        arguments,        rule.arguments.arguments
-  assert_equal        definition,       rule.definition
+  assert_instance_of  Porolog::Rule,        rule
+  assert_equal        predicate,            rule.arguments.predicate.name
+  assert_equal        arguments,            rule.arguments.arguments
+  assert_equal        definition,           rule.definition
 end
 
-def assert_Goal(goal, predicate, arguments)#, definition)
-  assert_instance_of  Goal,                       goal
+def assert_Goal(goal, predicate, arguments)
+  assert_instance_of  Porolog::Goal,              goal
   assert_equal        predicate,                  goal.arguments.predicate.name
   assert_equal        goal.variablise(arguments), goal.arguments.arguments
-  # TODO: add definition
-  #assert_equal        definition,       goal.definition
 end
 
 def assert_Goal_variables(goal, hash, str)
-  assert_instance_of  Goal,             goal
-  assert_equal        hash,             goal.variables
-  assert_equal        str,              goal.inspect_variables
+  assert_instance_of  Porolog::Goal,        goal
+  assert_equal        hash,                 goal.variables
+  assert_equal        str,                  goal.inspect_variables
 end
 
 def assert_Value(value, value_value, goal)
-  assert_instance_of  Value,            value
-  assert_equal        value_value,      value.value
-  assert_equal        goal,             value.goal
+  assert_instance_of  Porolog::Value,       value
+  assert_equal        value_value,          value.value
+  assert_equal        goal,                 value.goal
 end
 
 def assert_Variable(variable, name, goal, instantiations, values)
-  assert_instance_of  Variable,         variable
-  assert_equal        name,             variable.name
-  assert_equal        goal,             variable.goal
-  assert_equal        instantiations,   variable.instantiations
-  assert_equal        values,           variable.values
+  assert_instance_of  Porolog::Variable,    variable
+  assert_equal        name,                 variable.name
+  assert_equal        goal,                 variable.goal
+  assert_equal        instantiations,       variable.instantiations
+  assert_equal        values,               variable.values
 end
 
 def assert_Instantiation(instantiation, variable1, variable2, index1, index2)
-  assert_instance_of  Instantiation,    instantiation
-  assert_includes     [Variable,Value], variable1.class
-  assert_includes     [Variable,Value], variable2.class
-  assert_equal        variable1,        instantiation.variable1
-  assert_equal        variable2,        instantiation.variable2
+  assert_instance_of  Porolog::Instantiation,               instantiation
+  assert_includes     [Porolog::Variable, Porolog::Value],  variable1.class
+  assert_includes     [Porolog::Variable, Porolog::Value],  variable2.class
+  assert_equal        variable1,                            instantiation.variable1
+  assert_equal        variable2,                            instantiation.variable2
   if index1
-    assert_equal      index1,           instantiation.index1
+    assert_equal      index1,                               instantiation.index1
   else
-    assert_nil                          instantiation.index1
+    assert_nil                                              instantiation.index1
   end
   if index2
-    assert_equal      index2,           instantiation.index2
+    assert_equal      index2,                               instantiation.index2
   else
-    assert_nil                          instantiation.index2
+    assert_nil                                              instantiation.index2
   end
 end
 
 def assert_Tail(tail, inspect)
-  assert_instance_of  Tail,             tail
-  assert_equal        inspect,          tail.inspect
+  assert_instance_of  Porolog::Tail,        tail
+  assert_equal        inspect,              tail.inspect
 end
 
 def assert_Array_with_Tail(array, head, inspect)
-  assert_instance_of  Array,            array
-  assert_equal        head.size + 1,    array.size
-  assert_equal        head,             array[0...head.size]
-  assert_Tail         array.last,       inspect
+  assert_instance_of  Array,                array
+  assert_equal        head.size + 1,        array.size
+  assert_equal        head,                 array[0...head.size]
+  assert_Tail         array.last,           inspect
 end
 
 def expect_unify_arrays_with_calls(no_tails, some_tails, all_tails)
-  expects(:unify_arrays_with_no_tails  ).times(no_tails)
-  expects(:unify_arrays_with_some_tails).times(some_tails)
-  expects(:unify_arrays_with_all_tails ).times(all_tails)
+  Porolog::expects(:unify_arrays_with_no_tails  ).times(no_tails)
+  Porolog::expects(:unify_arrays_with_some_tails).times(some_tails)
+  Porolog::expects(:unify_arrays_with_all_tails ).times(all_tails)
 end
 
 def assert_Unify_arrays(arrays, goals, merged, unifications = [])
-  result_merged, result_unifications = unify_arrays(*arrays, *goals)
+  result_merged, result_unifications = Porolog::unify_arrays(*arrays, *goals)
   
   unifications = unifications.map{|v1,v2,g1,g2|
-    assert_instance_of  Goal, g1
-    assert_instance_of  Goal, g2
+    assert_instance_of  Porolog::Goal, g1
+    assert_instance_of  Porolog::Goal, g2
     [g1.variablise(v1), g2.variablise(v2), g1, g2]
   }
   
@@ -138,7 +133,7 @@ def assert_Unify_arrays(arrays, goals, merged, unifications = [])
 end
 
 def refute_Unify_arrays(arrays, goals, log = [])
-  result = unify_arrays(*arrays, *goals)
+  result = Porolog::unify_arrays(*arrays, *goals)
   
   assert_nil      result
   
@@ -149,7 +144,7 @@ end
 
 
 def new_goal(predicate_name, *arguments_list)
-  predicate = Predicate.new(predicate_name)
+  predicate = Porolog::Predicate.new(predicate_name)
   arguments = predicate.arguments(*arguments_list)
   arguments.goal
 end
@@ -158,6 +153,6 @@ def assert_solutions(arguments, expected_solutions, goals: nil)
   solutions = arguments.solve
   
   assert_equal    expected_solutions,   solutions
-  assert_equal    goals,                Goal.goal_count   if goals
+  assert_equal    goals,                Porolog::Goal.goal_count   if goals
   solutions
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: porolog
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Luis Esteban
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-08 00:00:00.000000000 Z
+date: 2020-08-13 00:00:00.000000000 Z
 dependencies: []
 description: Implements a Prolog inference engine using Plain Old Ruby Objects
 email: