porolog 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 255c18b94a31335781ec500cbec763b710def39e9b1c9e331b573e51b18da80e
-  data.tar.gz: d676680c7eea7d2fd3df0b3708fd7f09977ed92472616cdf44b3db2eede37688
+  metadata.gz: 595dfcb99ad8db28a4aa8b5a71b0f63c4e417dd4b2036ec0e7559c7bf0523438
+  data.tar.gz: dc8d09f758aea19d636bd593e3e6a9a9283027e44424ad6cc88ce78445afec64
 SHA512:
-  metadata.gz: 2f5018c1e104af58e1decd95f1d55647c6c51c7eb8bf38e3720feb4438d3c52fa24d9cfab000e5251d8160b2980d74234e56dd2c3f1a8991334e98276e519b44
-  data.tar.gz: 1b4e60c16c278e5c4f3f276545fc0c1e330b895f01c916f053217dd72df1f5f198c3b8feed2a3c5460e1de3f3238da3b5d481e0405de272ee28142361d6adb88
+  metadata.gz: 88889f2063831ca8b5a6358e96727c1ad3805a5721d6b39e6b931af584ea24ac12b5dc89bdf18eeff81eed1e93e04b8637f27a1fe62db2a08d126e1e208a16e1
+  data.tar.gz: c564320bd055721a1de3a4af742c81f69c51574c88a84207373208870655452508aed97c21c567ba4a0205d4ae4944f9e824fc5b206043facf112f9c799150bc

data/README.md

@@ -2,43 +2,72 @@
 
 Plain Old Ruby Objects Prolog
 
+[![Gem Version](https://badge.fury.io/rb/porolog.svg)](https://badge.fury.io/rb/porolog)
+[![Build Status](https://travis-ci.com/wizardofosmium/porolog.svg?branch=master)](https://travis-ci.com/wizardofosmium/porolog)
+
 ## Introduction
 
-porolog is a Prolog implementation using plain old Ruby objects with the aim that
+`porolog` is a Prolog implementation using plain old Ruby objects with the aim that
 logic queries can be called within a regular Ruby program.  The goal was not to
 implement a Prolog interpreter that is just implement in Ruby, but rather that
 a logic engine could be embedded in a larger program.
 
+The need that this gem aims to meet is to have a Ruby program interact with a Prolog
+program using native Ruby objects (POROs); hence the name Porolog.
 The goal was to implement a minimal logic engine in the style of Prolog where
 Ruby objects could be passed in and Ruby objects were passed back.
 
+## Dependencies
+
+The aim of `porolog` is to provide a logic engine with a minimal footprint.
+Thus `porolog` has no dependencies.
+
 ## Installation
 
-  gem install porolog
+```bash
+gem install porolog
+```
 
 ## Usage
 
+`porolog` is used by:
+
+* requiring the library within a Ruby program
+* defining facts and rules
+* solving goals
+
+It is entirely possible to create a Ruby program that is effectively just a Prolog program.
+
 ### Basic Usage
 
-  require 'porolog'
+Using `porolog` involves creating logic from facts and rules.
+An example, of the most basic usage uses just facts.
 
-  prime = Predicate.new :prime
+```ruby
+require 'porolog'
 
-  prime.(2).fact!
-  prime.(3).fact!
-  prime.(5).fact!
-  prime.(7).fact!
+prime = Porolog::Predicate.new :prime
 
-  solutions = prime.(:X).solve
+prime.(2).fact!
+prime.(3).fact!
+prime.(5).fact!
+prime.(7).fact!
 
-  solutions.each do |solution|
-    puts "#{solution[:X]} is prime"
-  end
+solutions = prime.(:X).solve
 
+solutions.each do |solution|
+  puts "#{solution[:X]} is prime"
+end
+```
 
 ### Common Usage
 
-  require 'porolog'
+Common usage is expected to be including Porolog in a class and encapsulating the engine defined.
+
+```ruby
+require 'porolog'
+
+class Numbers
 
   include Porolog
 
@@ -49,70 +78,88 @@ Ruby objects could be passed in and Ruby objects were passed back.
   prime(5).fact!
   prime(7).fact!
 
-  solutions = prime(:X).solve
+  def show_primes
+    solutions = prime(:X).solve
 
-  solutions.each do |solution|
-    puts "#{solution[:X]} is prime"
+    solutions.each do |solution|
+      puts "#{solution[:X]} is prime"
+    end
   end
 
-### Scope Usage
-
-The Scope class enables you to have multiple logic programs embedded in the same
-Ruby program.  A Scope object defines a scope for the predicates of a logic programme.
-
-  require 'porolog'
-
-  # -- Prime Numbers Predicate --
-  prime = prime1 = Predicate.new :prime, :numbers
-
-  prime.(2).fact!
-  prime.(3).fact!
-  prime.(5).fact!
-  prime.(7).fact!
-  prime.(11).fact!
-
-  # -- Pump Predicate --
-  prime = prime2 = Predicate.new :prime, :pumps
-
-  prime.('pump A').fact!
-  prime.('pump B').fact!
-  prime.('pump C').fact!
-  prime.('pump D').fact!
-
-  assert_equal        [:default,:numbers,:pumps],     Scope.scopes
+  def primes
+    prime(:X).solve_for(:X)
+  end
 
-  assert_scope        Scope[:default],  :default, []
-  assert_scope        Scope[:numbers],  :first,   [prime1]
-  assert_scope        Scope[:pumps],    :second,  [prime2]
+end
+```
 
-  assert_equal        :prime,     prime1.name
-  assert_equal        :prime,     prime2.name
+### Scope and Predicate Usage
 
-  solutions = [
-    { X:  2 },
-    { X:  3 },
-    { X:  5 },
-    { X:  7 },
-    { X: 11 },
-  ]
-  assert_equal        solutions,                prime1.(:X).solve
+A Predicate represents a Prolog predicate.  They form the basis for rules and queries.
 
-  solutions = [
-    { X: 'pump A' },
-    { X: 'pump B' },
-    { X: 'pump C' },
-    { X: 'pump D' },
-  ]
-  assert_equal        solutions,                prime2.(:X).solve
+The Scope class enables you to have multiple logic programs embedded in the same
+Ruby program.  A Scope object defines a scope for the predicates of a logic programme.
 
+```ruby
+require 'porolog'
+
+# -- Prime Numbers Predicate --
+prime = prime1 = Porolog::Predicate.new :prime, :numbers
+
+prime.(2).fact!
+prime.(3).fact!
+prime.(5).fact!
+prime.(7).fact!
+prime.(11).fact!
+
+# -- Pump Predicate --
+prime = prime2 = Porolog::Predicate.new :prime, :pumps
+
+prime.('pump A').fact!
+prime.('pump B').fact!
+prime.('pump C').fact!
+prime.('pump D').fact!
+
+# -- Assertions --
+assert_equal        [:default,:numbers,:pumps],     Scope.scopes
+
+assert_scope        Porolog::Scope[:default],  :default, []
+assert_scope        Porolog::Scope[:numbers],  :first,   [prime1]
+assert_scope        Porolog::Scope[:pumps],    :second,  [prime2]
+
+assert_equal        :prime,     prime1.name
+assert_equal        :prime,     prime2.name
+
+solutions = [
+  { X:  2 },
+  { X:  3 },
+  { X:  5 },
+  { X:  7 },
+  { X: 11 },
+]
+assert_equal        solutions,                prime1.(:X).solve
+
+solutions = [
+  { X: 'pump A' },
+  { X: 'pump B' },
+  { X: 'pump C' },
+  { X: 'pump D' },
+]
+assert_equal        solutions,                prime2.(:X).solve
+```
 
 ## Testing
 
-  rake test
+```bash
+rake test
+```
 
 or
 
-  rake scope_test
+```bash
+rake scope_test
+rake predicate_test
+```
 
 ## Author
 

data/lib/porolog/predicate.rb

@@ -0,0 +1,103 @@
+#
+#   lib/porolog/predicate.rb      - Plain Old Ruby Objects Prolog Engine -- Predicate
+#
+#     Luis Esteban   2 May 2018
+#       created
+#
+
+# Porolog::Predicate
+#
+#   A Porolog::Predicate corresponds to a Prolog predicate.
+#   It contains rules (Porolog::Rule) and belongs to a Porolog::Scope.
+#   When provided with arguments, it produces a Porolog::Arguments.
+#
+
+module Porolog
+  
+  class Predicate
+    
+    class PredicateError < PorologError   ; end
+    class NameError      < PredicateError ; end
+    
+    attr_reader :name, :rules
+    
+    @@current_scope        = Scope[:default]
+    @builtin_predicate_ids = {}
+    
+    def self.scope(scope_name = nil)
+      if scope_name
+        @@current_scope = Scope[scope_name] || Scope.new(scope_name)
+      else
+        @@current_scope
+      end
+    end
+    
+    def self.scope=(scope_name)
+      if scope_name
+        @@current_scope = Scope[scope_name] || Scope.new(scope_name)
+      end
+    end
+    
+    def self.reset
+      scope(:default)
+      @builtin_predicate_ids = {}
+    end
+    
+    def self.[](name)
+      @@current_scope[name]
+    end
+    
+    reset
+    
+    def initialize(name, scope_name = Predicate.scope.name)
+      @name  = name.to_sym
+      @rules = []
+      
+      raise NameError.new("Cannot name a predicate 'predicate'") if @name == :predicate
+      
+      scope = Scope[scope_name] || Scope.new(scope_name)
+      scope[@name] = self
+    end
+    
+    def self.new(*args)
+      name, _ = *args
+      scope[name.to_sym] || super
+    end
+    
+    def call(*args)
+      Arguments.new(self,args)
+    end
+    
+    def arguments(*args)
+      Arguments.new(self,args)
+    end
+    
+    def <<(rule)
+      @rules << rule
+    end
+    
+    def inspect
+      lines = []
+      
+      if @rules.size == 1
+        lines << "#{@name}:-#{@rules.first.inspect}"
+      else
+        lines << "#{@name}:-"
+        @rules.each do |rule|
+          lines << rule.inspect
+        end
+      end
+        
+      lines.join("\n")
+    end
+    
+    def self.builtin(key)
+      @builtin_predicate_ids[key] ||= 0
+      @builtin_predicate_ids[key]  += 1
+      
+      self.new("_#{key}_#{@builtin_predicate_ids[key]}")
+    end
+    
+  end
+
+end

data/lib/porolog/scope.rb

@@ -54,8 +54,7 @@ module Porolog
     end
     
     def []=(name,predicate)
-      # TODO: Uncomment when Porolog::Predicate has been added.
-      #raise NotPredicateError.new("#{predicate.inspect} is not a Predicate") unless predicate.is_a?(Predicate)
+      raise NotPredicateError.new("#{predicate.inspect} is not a Predicate") unless predicate.is_a?(Predicate)
       @predicates[name.to_sym] = predicate
     end
     

data/lib/porolog.rb

@@ -7,10 +7,28 @@
 
 module Porolog
 
-  VERSION      = '0.0.1'
-  VERSION_DATE = '2018-05-02'
-
+  VERSION      = '0.0.2'
+  VERSION_DATE = '2019-04-20'
+  
+  def predicate(*names)
+    names = [names].flatten
+    
+    predicates = names.map{|name|
+      method     = name.to_sym
+      predicate  = Predicate.new(name)
+      Object.class_eval{
+        define_method(method){|*args|
+          predicate.(*args)
+        }
+      }
+      predicate
+    }
+    
+    predicates.size > 1 && predicates || predicates.first
+  end
+  
 end
 
 require_relative 'porolog/error'
 require_relative 'porolog/scope'
+require_relative 'porolog/predicate'

data/test/porolog/predicate_test.rb

@@ -0,0 +1,335 @@
+#
+#   test/porolog/predicate_test.rb     - Test Suite for Porolog::Predicate
+#
+#     Luis Esteban      2 May 2018
+#       created
+#
+
+require_relative '../test_helper'
+
+describe 'Porolog' do
+  
+  before(:all) do
+    reset
+  end
+  
+  describe 'Predicate' do
+    
+    it 'should default to creating predicates in the default scope' do
+      assert_equal    :default,     Predicate.scope.name
+      
+      test = Predicate.new 'test'
+      
+      assert_includes Scope[:default].predicates, test
+    end
+    
+    describe '.scope' do
+      
+      it 'should return the current scope for new predicates' do
+        assert_equal  Scope[:default],    Predicate.scope
+        
+        alpha = Predicate.new 'alpha', :new_scope
+        
+        assert_equal  Scope[:default],    Predicate.scope
+        
+        Predicate.scope :new_scope
+        
+        assert_equal  Scope[:new_scope],  Predicate.scope
+        
+        bravo = Predicate.new 'bravo'
+        
+        assert_equal  [],                 Scope[:default  ].predicates
+        assert_equal  [alpha,bravo],      Scope[:new_scope].predicates
+      end
+    
+      it 'should allow predicate scope to be created and set' do
+        Predicate.scope :internal
+        assert_equal    :internal, Predicate.scope.name
+        
+        Predicate.new 'alpha'
+        
+        Predicate.scope :external
+        assert_equal    :external, Predicate.scope.name
+        
+        Predicate.new 'bravo'
+        
+        Predicate.scope :internal
+        assert_equal    :internal, Predicate.scope.name
+        
+        Predicate.new 'carly'
+        Predicate.new 'delta', :external
+        
+        assert_equal    :internal, Predicate.scope.name
+        
+        assert_equal  [:alpha,:carly], Scope[:internal].predicates.map(&:name)
+        assert_equal  [:bravo,:delta], Scope[:external].predicates.map(&:name)
+      end
+      
+    end
+    
+    describe '.scope=' do
+    
+      it 'should also allow predicate scope to be assigned' do
+        Predicate.scope = :internal
+        assert_equal      :internal, Predicate.scope.name
+        
+        alpha = Predicate.new 'alpha'
+        
+        Predicate.scope = :external
+        assert_equal      :external, Predicate.scope.name
+        
+        bravo = Predicate.new 'bravo'
+        
+        Predicate.scope = :internal
+        assert_equal      :internal, Predicate.scope.name
+        
+        carly = Predicate.new 'carly'
+        delta = Predicate.new 'delta', :external
+        
+        assert_equal      :internal, Predicate.scope.name
+        
+        assert_equal  [alpha,carly], Scope[:internal].predicates
+        assert_equal  [bravo,delta], Scope[:external].predicates
+      end
+      
+    end
+    
+    describe '.reset' do
+    
+      it 'should revert to the default scope when reset' do
+        Predicate.scope = :other
+        assert_equal      :other,       Predicate.scope.name
+        
+        Predicate.reset
+        assert_equal      :default,     Predicate.scope.name
+        
+        Predicate.scope :temporary
+        
+        alpha = Predicate.new   :alpha
+        
+        assert_equal    :temporary,     Predicate.scope.name
+        assert_equal    [alpha],        Predicate.scope.predicates
+        
+        Predicate.reset
+        
+        bravo = Predicate.new   :bravo
+        
+        assert_equal    :default,       Predicate.scope.name
+        assert_equal    [bravo],        Predicate.scope.predicates
+      end
+      
+    end
+    
+    describe '.[]' do
+      
+      it 'should return a predicate by name' do
+        alpha = Predicate.new   :alpha
+        
+        assert_equal    alpha,          Predicate[:alpha]
+      end
+      
+    end
+    
+    describe '.new' do
+      
+      it 'should create a new predicate' do
+        alpha = Predicate.new   :alpha
+        
+        assert_instance_of Predicate,   alpha
+      end
+      
+      it 'should not create a predicate if a predicate with the same name already exists in the scope but instead return the existing one' do
+        predicate1 = Predicate.new 'predicate1', :left
+        predicate2 = Predicate.new 'predicate1', :right
+        
+        refute_equal  predicate1, predicate2
+        
+        Predicate.scope :left
+        predicate3 = Predicate.new :predicate1
+        
+        assert_equal  predicate1, predicate3
+      end
+      
+    end
+    
+    describe '#initialize' do
+    
+      it 'can create predicates in different scopes' do
+        left  = Scope.new :left
+        #right = Scope.new :right   # Not explicitly creating scope :right
+        
+        assert_equal    left,           Predicate.scope(:left)
+        assert_equal    :left,          Predicate.scope.name
+        
+        left_test = Predicate.new 'left_test'
+        
+        assert_equal    :left,          Predicate.scope.name
+        refute_empty    left.predicates
+        assert_includes left.predicates, left_test
+        
+        right_test = Predicate.new 'right_test', :right
+        
+        assert_includes Scope[:right].predicates, right_test
+        assert_equal    :left,          Predicate.scope.name
+        
+        assert_equal    [left_test],    Scope[:left ].predicates
+        assert_equal    [right_test],   Scope[:right].predicates
+      end
+    
+      it 'should not create a Predicate named "predicate"' do
+        assert_raises Porolog::Predicate::NameError do
+          predicate :predicate
+        end
+        assert_raises Porolog::Predicate::NameError do
+          predicate 'predicate'
+        end
+        assert_raises Porolog::Predicate::NameError do
+          Predicate.new :predicate
+        end
+        assert_raises Porolog::Predicate::NameError do
+          Predicate.new 'predicate'
+        end
+      end
+      
+    end
+    
+    describe '#call' do
+    
+      it 'should create an Arguments when "called"' do
+        skip 'until Arguments added'
+        
+        p = Predicate.new :p
+        
+        arguments = p.(1,2,3)
+        
+        assert_instance_of  Arguments,            arguments
+        assert_equal        [1,2,3],              arguments.arguments
+        assert_equal        'p(1,2,3)',           arguments.inspect
+      end
+      
+    end
+    
+    describe '#arguments' do
+    
+      it 'should provide a convenience method to create an Arguments' do
+        skip 'until Arguments added'
+        
+        p = Predicate.new :p
+        
+        arguments = p.arguments(1,2,3)
+        
+        assert_instance_of  Arguments,            arguments
+        assert_equal        [1,2,3],              arguments.arguments
+        assert_equal        'p(1,2,3)',           arguments.inspect
+      end
+      
+    end
+    
+    describe '#name' do
+    
+      it 'should create predicates with a name attribute, which is converted to a Symbol' do
+        test_predicate = Predicate.new('test_predicate_name')
+        
+        assert_respond_to   test_predicate,         :name
+        assert_equal        :test_predicate_name,   test_predicate.name
+      end
+      
+    end
+    
+    describe '#rules' do
+    
+      it 'should create predicates with an empty set of rules' do
+        test_predicate = Predicate.new('test_predicate_name')
+        
+        assert_respond_to   test_predicate,         :rules
+        assert_equal        [],                     test_predicate.rules
+      end
+    
+      it 'should add new facts to a predicate' do
+        skip 'until Arguments added'
+        
+        alpha = Predicate.new 'alpha'
+        
+        alpha.('p','q').fact!
+        
+        assert_equal    1,                                  alpha.rules.size
+        assert_equal    true,                               alpha.rules.first.definition
+        assert_equal    '  alpha("p","q"):- true',          alpha.rules.first.inspect
+        assert_equal    'alpha:-  alpha("p","q"):- true',   alpha.inspect
+        
+        assert_predicate  alpha, :alpha, [alpha.rules.first]
+      end
+      
+      it 'should add new falicies to a predicate' do
+        skip 'until Arguments added'
+        
+        alpha = Predicate.new 'alpha'
+        
+        alpha.('p','q').falicy!
+        
+        assert_equal    1,                                  alpha.rules.size
+        assert_equal    false,                              alpha.rules.first.definition
+        assert_equal    '  alpha("p","q"):- false',         alpha.rules.first.inspect
+        assert_equal    'alpha:-  alpha("p","q"):- false',  alpha.inspect
+        
+        assert_predicate  alpha, :alpha, [alpha.rules.first]
+      end
+      
+    end
+    
+    describe '#inspect' do
+      
+      it 'should return a summary of the predicate' do
+        skip 'until Arguments added'
+        
+        alpha = Predicate.new 'alpha'
+        assert_equal    'alpha:-',  alpha.inspect
+        
+        alpha.(:x,:y) << [
+          alpha.(:x,:y),
+          alpha.(:y,:x),
+          :CUT
+        ]
+        assert_equal    'alpha:-  alpha(:x,:y):- [alpha(:x,:y), alpha(:y,:x), :CUT]',  alpha.inspect
+      end
+      
+    end
+    
+    describe '#<<' do
+      
+      it 'should add new rules to a predicate' do
+        skip 'until Arguments added'
+        
+        alpha = Predicate.new 'alpha'
+        
+        alpha.(:P,:Q) << [
+          alpha.(:P,:Q),
+          alpha.(:Q,:P),
+        ]
+        alpha.(:P,:Q) << [
+          alpha.(:P,:P),
+          alpha.(:Q,:Q),
+        ]
+        
+        assert_equal        2,                              alpha.rules.size
+        assert_instance_of  Array,                          alpha.rules.first.definition
+        assert_equal        2,                              alpha.rules.first.definition.size
+        
+        assert_arguments    alpha.rules.first.definition[0],  :alpha, [:P,:Q]
+        assert_arguments    alpha.rules.first.definition[1],  :alpha, [:Q,:P]
+        
+        assert_equal    '  alpha(:P,:Q):- [alpha(:P,:Q), alpha(:Q,:P)]',        alpha.rules.first.inspect
+        assert_equal    [
+          'alpha:-',
+          '  alpha(:P,:Q):- [alpha(:P,:Q), alpha(:Q,:P)]',
+          '  alpha(:P,:Q):- [alpha(:P,:P), alpha(:Q,:Q)]',
+        ].join("\n"),                                                           alpha.inspect
+        
+        assert_predicate  alpha, :alpha, [alpha.rules.first,alpha.rules.second]
+      end
+      
+    end
+    
+  end
+
+end

data/test/porolog/scope_test.rb

@@ -23,7 +23,7 @@ describe 'Porolog' do
     end
     
     it 'should allow predicates with the same name to coexist in different scopes' do
-      skip 'until Predicate added'
+      skip 'until Arguments added'
       
       prime = prime1 = Predicate.new :prime, :first
 
@@ -82,8 +82,6 @@ describe 'Porolog' do
     describe '.reset' do
       
       it 'should clear all scopes' do
-        skip 'until Predicate added'
-        
         delta = Predicate.new :delta
         
         Scope.new :alpha
@@ -111,8 +109,6 @@ describe 'Porolog' do
       end
       
       it 'should clear all scopes and start with a default scope when reset' do
-        skip 'until Predicate added'
-        
         test_predicate0  = Predicate.new 'test_predicate0'
         test_predicate11 = Predicate.new 'test_predicate11', :scope1
         test_predicate12 = Predicate.new 'test_predicate12', :scope1
@@ -201,8 +197,6 @@ describe 'Porolog' do
     describe '#predicates' do
       
       it 'should provide access to all the predicates of a scope' do
-        skip 'until Predicate added'
-        
         test_predicate1 = Predicate.new 'test_predicate1', :test
         test_predicate2 = Predicate.new 'test_predicate2', :test
         
@@ -215,8 +209,6 @@ describe 'Porolog' do
     describe '#[]' do
       
       it 'should provide access to a predicate of a scope by its name' do
-        skip 'until Predicate added'
-        
         test_predicate3 = Predicate.new 'test_predicate3', :test
         test_predicate4 = Predicate.new 'test_predicate4', :test
         
@@ -236,8 +228,6 @@ describe 'Porolog' do
     describe '#[]=' do
       
       it 'should raise an error when trying to put anthing but a Predicate in a Scope' do
-        skip 'until Predicate added'
-        
         error = assert_raises(Porolog::Scope::NotPredicateError){
           scope = Scope.new :scope
           
@@ -247,8 +237,6 @@ describe 'Porolog' do
       end
       
       it 'should allow an existing predicate to be assigned to a scope' do
-        skip 'until Predicate added'
-        
         test_predicate = Predicate.new 'test_predicate', :test
         
         scope = Scope.new :scope

data/test/test_helper.rb

@@ -12,6 +12,7 @@ include Porolog
 
 def reset
   Scope.reset
+  Predicate.reset
 end
 
 def assert_scope(scope, name, predicates)
@@ -19,3 +20,9 @@ def assert_scope(scope, name, predicates)
   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
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: porolog
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Luis Esteban
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-02 00:00:00.000000000 Z
+date: 2019-04-20 00:00:00.000000000 Z
 dependencies: []
 description: Implements a Prolog inference engine using Plain Old Ruby Objects
 email:
@@ -22,10 +22,12 @@ files:
 - bin/porolog
 - lib/porolog.rb
 - lib/porolog/error.rb
+- lib/porolog/predicate.rb
 - lib/porolog/scope.rb
+- test/porolog/predicate_test.rb
 - test/porolog/scope_test.rb
 - test/test_helper.rb
-homepage: http://rubygems.org/gems/porolog
+homepage: https://github.com/wizardofosmium/porolog
 licenses:
 - Unlicense
 metadata: {}
@@ -51,4 +53,5 @@ specification_version: 4
 summary: Prolog using Plain Old Ruby Objects
 test_files:
 - test/test_helper.rb
+- test/porolog/predicate_test.rb
 - test/porolog/scope_test.rb