porolog 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 255c18b94a31335781ec500cbec763b710def39e9b1c9e331b573e51b18da80e
+  data.tar.gz: d676680c7eea7d2fd3df0b3708fd7f09977ed92472616cdf44b3db2eede37688
+SHA512:
+  metadata.gz: 2f5018c1e104af58e1decd95f1d55647c6c51c7eb8bf38e3720feb4438d3c52fa24d9cfab000e5251d8160b2980d74234e56dd2c3f1a8991334e98276e519b44
+  data.tar.gz: 1b4e60c16c278e5c4f3f276545fc0c1e330b895f01c916f053217dd72df1f5f198c3b8feed2a3c5460e1de3f3238da3b5d481e0405de272ee28142361d6adb88

data/README.md

@@ -0,0 +1,119 @@
+# porolog
+
+Plain Old Ruby Objects Prolog
+
+## Introduction
+
+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 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.
+
+## Installation
+
+  gem install porolog
+
+## Usage
+
+### Basic Usage
+
+  require 'porolog'
+
+  prime = Predicate.new :prime
+
+  prime.(2).fact!
+  prime.(3).fact!
+  prime.(5).fact!
+  prime.(7).fact!
+
+  solutions = prime.(:X).solve
+
+  solutions.each do |solution|
+    puts "#{solution[:X]} is prime"
+  end
+
+
+### Common Usage
+
+  require 'porolog'
+
+  include Porolog
+
+  predicate :prime
+
+  prime(2).fact!
+  prime(3).fact!
+  prime(5).fact!
+  prime(7).fact!
+
+  solutions = prime(:X).solve
+
+  solutions.each do |solution|
+    puts "#{solution[:X]} is prime"
+  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
+
+  assert_scope        Scope[:default],  :default, []
+  assert_scope        Scope[:numbers],  :first,   [prime1]
+  assert_scope        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
+
+or
+
+  rake scope_test
+
+## Author
+
+Luis Esteban MSc MTeach

data/Rakefile

@@ -0,0 +1,40 @@
+#
+#   Rakefile    - Porolog Rakefile
+#
+#     2 May 2018
+#
+
+require 'rake/testtask'
+
+
+# -- Run All Tests Task --
+Rake::TestTask.new do |task|
+  task.libs    << 'test'
+  task.pattern  = 'test/porolog/*_test.rb'
+end
+
+# -- Create Separate Test Tasks --
+Dir['test/porolog/*_test.rb'].each do |test_file|
+  name = File.basename(test_file, '.rb')
+  Rake::TestTask.new(name) do |task|
+    task.verbose    = true
+    task.options    = '--verbose'
+    task.libs      << 'test'
+    task.pattern    = test_file
+    task.warning    = nil
+  end
+end
+
+# -- Tasks --
+task default: :test
+
+desc 'Help'
+task :help do
+  puts <<-EOF
+    Porolog is a Ruby library.
+    See README.md for more information.
+    Run
+      rake -T
+    for other tasks.
+  EOF
+end

data/bin/porolog

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+#
+#   bin/porolog   - Executable
+#
+#     Luis Esteban  19 April 2019
+#       created
+#
+
+require 'porolog'
+
+puts 'Sample Porolog Program'

data/lib/porolog/error.rb

@@ -0,0 +1,12 @@
+#
+#   lib/porolog/error.rb      - Plain Old Ruby Objects Prolog Engine -- Error
+#
+#     Luis Esteban   2 May 2018
+#       created
+#
+
+module Porolog
+
+  class PorologError < RuntimeError ; end
+
+end

data/lib/porolog/scope.rb

@@ -0,0 +1,68 @@
+#
+#   lib/porolog/scope.rb      - Plain Old Ruby Objects Prolog Engine -- Scope
+#
+#     Luis Esteban   2 May 2018
+#       created
+#
+
+# == Porolog::Scope ==
+#
+#   A Porolog::Scope is a container for Porolog::Predicates.
+#   Its purpose is to allow a Ruby program to contain multiple Prolog programs
+#   without the Prolog programs interfering with each other.
+#
+
+module Porolog
+
+  class Scope
+    
+    class ScopeError        < PorologError ; end
+    class NotPredicateError < ScopeError   ; end
+    
+    attr_reader :name
+    
+    @@scopes = {}
+    
+    def self.new(name)
+      @@scopes[name] || super
+    end
+    
+    def initialize(name)
+      @name       = name
+      @predicates = {}
+      
+      @@scopes[@name] = self
+    end
+    
+    def self.reset
+      @@scopes = {}
+      new(:default)
+    end
+    
+    reset
+    
+    def self.[](name)
+      @@scopes[name]
+    end
+    
+    def self.scopes
+      @@scopes.keys
+    end
+    
+    def [](name)
+      @predicates[name.to_sym]
+    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)
+      @predicates[name.to_sym] = predicate
+    end
+    
+    def predicates
+      @predicates.values
+    end
+    
+  end
+
+end

data/lib/porolog.rb

@@ -0,0 +1,16 @@
+#
+#   lib/porolog.rb      - Plain Old Ruby Objects Prolog Engine
+#
+#     Luis Esteban   2 May 2018
+#       created
+#
+
+module Porolog
+
+  VERSION      = '0.0.1'
+  VERSION_DATE = '2018-05-02'
+
+end
+
+require_relative 'porolog/error'
+require_relative 'porolog/scope'

data/test/porolog/scope_test.rb

@@ -0,0 +1,270 @@
+#
+#   test/porolog/scope_test.rb     - Test Suite for Porolog::Scope
+#
+#     Luis Esteban      2 May 2018
+#       created
+#
+
+require_relative '../test_helper'
+
+describe 'Porolog' do
+  
+  before(:all) do
+    reset
+  end
+  
+  describe 'Scope' do
+    
+    it 'should already declare the default scope' do
+      assert_equal        1,            Scope.scopes.size
+      assert_equal        [:default],   Scope.scopes
+      
+      assert_scope        Scope[:default], :default, []
+    end
+    
+    it 'should allow predicates with the same name to coexist in different scopes' do
+      skip 'until Predicate added'
+      
+      prime = prime1 = Predicate.new :prime, :first
+
+      prime.(2).fact!
+      prime.(3).fact!
+      prime.(5).fact!
+      prime.(7).fact!
+      prime.(11).fact!
+
+      prime = prime2 = 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        :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
+    end
+    
+    describe '.scopes' do
+      
+      it 'should return the names of all registered scopes' do
+        Scope.new :alpha
+        Scope.new :bravo
+        Scope.new :carly
+        
+        assert_equal        4,                                    Scope.scopes.size
+        assert_equal        [:default, :alpha, :bravo, :carly],   Scope.scopes
+      end
+      
+    end
+    
+    describe '.reset' do
+      
+      it 'should clear all scopes' do
+        skip 'until Predicate added'
+        
+        delta = Predicate.new :delta
+        
+        Scope.new :alpha
+        Scope.new :bravo
+        Scope.new :carly
+        
+        assert_equal        4,                                    Scope.scopes.size
+        assert_equal        [:default, :alpha, :bravo, :carly],   Scope.scopes
+        
+        assert_scope        Scope[:default],  :default, [delta]
+        assert_scope        Scope[:alpha],    :alpha,   []
+        assert_scope        Scope[:bravo],    :bravo,   []
+        assert_scope        Scope[:carly],    :carly,   []
+        
+        Scope.reset
+        
+        assert_equal        1,                                    Scope.scopes.size
+        assert_equal        [:default],                           Scope.scopes
+        
+        assert_scope        Scope[:default], :default, []
+        
+        assert_nil                                                Scope[:alpha]
+        assert_nil                                                Scope[:bravo]
+        assert_nil                                                Scope[:carly]
+      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
+        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
+        
+        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
+        
+        Scope.reset
+        
+        test_predicate3  = Predicate.new 'test_predicate3'
+        
+        assert_equal  [:default],                                                 Scope.scopes
+        assert_equal  [test_predicate3],                                          Scope[:default].predicates
+        assert_nil                                                                Scope[:scope1 ]
+        assert_nil                                                                Scope[:scope2 ]
+      end
+      
+    end
+    
+    describe '.[]' do
+      
+      it 'should provide access to a scope by name' do
+        alpha = Scope.new :alpha
+        bravo = Scope.new :bravo
+        carly = Scope.new :carly
+        
+        assert_equal  alpha,  Scope[:alpha]
+        assert_equal  bravo,  Scope[:bravo]
+        assert_equal  carly,  Scope[:carly]
+        assert_nil            Scope[:delta]
+      end
+      
+    end
+    
+    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
+        
+        assert_equal  2,                                Scope.scopes.size
+        assert_equal  1,                                Scope.scopes.count(:duplicate)
+        assert_equal  [:default, :duplicate],           Scope.scopes
+      end
+      
+    end
+    
+    describe '#initialize' do
+      
+      it 'should keep track of created scopes' do
+        Scope.new :alpha
+        Scope.new :bravo
+        Scope.new :carly
+        
+        assert_equal   [:default,:alpha,:bravo,:carly], Scope.scopes
+      end
+      
+      it 'should create scopes with no predicates' do
+        scope = Scope.new('test_scope_name')
+        
+        assert_respond_to   scope,              :predicates
+        assert_equal        [],                 scope.predicates
+      end
+      
+    end
+    
+    describe '#name' do
+      
+      it 'should create scopes with a name attribute' do
+        scope = Scope.new('test_scope_name')
+        
+        assert_respond_to   scope,              :name
+        assert_equal        'test_scope_name',  scope.name
+      end
+      
+    end
+    
+    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
+        
+        assert_respond_to   Scope[:test],                         :predicates
+        assert_equal        [test_predicate1,test_predicate2],    Scope[:test].predicates
+      end
+      
+    end
+    
+    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
+        
+        assert_includes     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_equal        test_predicate3,          Scope[:test][:test_predicate3]
+        assert_equal        test_predicate3,          Scope[:test]['test_predicate3']
+        assert_equal        test_predicate4,          Scope[:test]['test_predicate4']
+      end
+      
+    end
+    
+    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
+          
+          scope[:predicate] = 'predicate'
+        }
+        assert_equal error.message, '"predicate" is not a Predicate'
+      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
+        
+        scope[:predicate] = test_predicate
+        
+        assert_equal        3,                                    Scope.scopes.size
+        assert_equal        [:default, :test, :scope],            Scope.scopes
+        
+        assert_scope        Scope[:default],                      :default, []
+        assert_scope        Scope[:test],                         :test,    [test_predicate]
+        assert_scope        Scope[:scope],                        :scope,   [test_predicate]
+      end
+      
+    end
+    
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+#
+#   test/test_helper.rb     - Test Suite Helper for Porolog
+#
+#     Luis Esteban      2 May 2018
+#       created
+#
+
+require 'minitest/autorun'
+require 'porolog'
+
+include Porolog
+
+def reset
+  Scope.reset
+end
+
+def assert_scope(scope, name, predicates)
+  assert_instance_of  Scope,            scope
+  assert_equal        name,             scope.name
+  assert_equal        predicates,       scope.predicates
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: porolog
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Luis Esteban
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-02 00:00:00.000000000 Z
+dependencies: []
+description: Implements a Prolog inference engine using Plain Old Ruby Objects
+email:
+- luis.esteban.consulting@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/porolog
+- lib/porolog.rb
+- lib/porolog/error.rb
+- lib/porolog/scope.rb
+- test/porolog/scope_test.rb
+- test/test_helper.rb
+homepage: http://rubygems.org/gems/porolog
+licenses:
+- Unlicense
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Prolog using Plain Old Ruby Objects
+test_files:
+- test/test_helper.rb
+- test/porolog/scope_test.rb