rubylog 2.0pre1 → 2.0.0

data/lib/rubylog/context_modules/predicates.rb

@@ -1,4 +1,5 @@
 require 'rubylog/rule'
+require 'rubylog/dsl/indicators'
 
 
 module Rubylog
@@ -42,44 +43,9 @@ module Rubylog
           flatten.
           map{|str|str.split(" ")}.
           flatten.
-          map{|i| unhumanize_indicator(i)}.
+          map{|i| Rubylog::DSL::Indicators.unhumanize_indicator(i)}.
           each {|i| yield i }
       end
-
-
-      # Makes human-friendly output from the indicator
-      # For example, .and()
-      def humanize_indicator indicator
-        return indicator if String === indicator
-        functor, arity = indicator
-        if arity > 1
-          ".#{functor}(#{ ','*(arity-2) })"
-        elsif arity == 1
-          ".#{functor}"
-        elsif arity == 0
-          ":#{functor}"
-        end
-      end
-
-      # Makes internal representation from predicate indicator
-      #
-      # For example, <tt>.and()</tt> becomes <tt>[:and,2]</tt>
-      def unhumanize_indicator indicator
-        case indicator
-        when Array
-          indicator
-        when /\A:(\w+)\z/
-          [:"#{$1}",0]
-        when /\A\w*\.(\w+)\z/
-          [:"#{$1}",1]
-        when /\A\w*\.(\w+)\(\w*((,\w*)*)\)\z/
-          [:"#{$1}",$2.count(",")+2]
-        else
-          raise ArgumentError, "invalid indicator: #{indicator.inspect}"
-        end
-
-      end
-
     end
   end
 end

data/lib/rubylog/dsl/indicators.rb

@@ -0,0 +1,36 @@
+module Rubylog::DSL
+  module Indicators
+    # Makes human-friendly output from the indicator
+    # For example, .and()
+    def self.humanize_indicator indicator
+      return indicator if String === indicator
+      functor, arity = indicator
+      if arity > 1
+        ".#{functor}(#{ ','*(arity-2) })"
+      elsif arity == 1
+        ".#{functor}"
+      elsif arity == 0
+        ":#{functor}"
+      end
+    end
+
+    # Makes internal representation from predicate indicator
+    #
+    # For example, <tt>.and()</tt> becomes <tt>[:and,2]</tt>
+    def self.unhumanize_indicator indicator
+      case indicator
+      when Array
+        indicator
+      when /\A:(\w+)\z/
+        [:"#{$1}",0]
+      when /\A\w*\.(\w+)\z/
+        [:"#{$1}",1]
+      when /\A\w*\.(\w+)\(\w*((,\w*)*)\)\z/
+        [:"#{$1}",$2.count(",")+2]
+      else
+        raise ArgumentError, "invalid indicator: #{indicator.inspect}"
+      end
+
+    end
+  end
+end

data/lib/rubylog/dsl/variables.rb

@@ -15,7 +15,7 @@ module Rubylog::DSL
   #     A.is(5).map{A}                       # => [5]
   #     B.is(5).and(A.is([2,B])).map{A}      # => [[2,5]]
   #
-  # When variables do not have a value, it is not substituted.
+  # When a variable does not have a value, it is not substituted.
   #
   #     A.is(B).map{A}                       # => [B]
   #     B.is(C).and(A.is([2,B])).map{A}      # => [[2,C]]

data/lib/rubylog/errors.rb

@@ -19,8 +19,8 @@ module Rubylog
   end
 
   class ExistenceError < RubylogError
-    def initialize clause
-      super "Predicate #{clause.inspect} does not exist"
+    def initialize goal
+      super "Predicate #{goal.inspect} does not exist"
     end
   end
 

data/lib/rubylog/{clause.rb → goal.rb}

@@ -1,4 +1,4 @@
-module Rubylog::Clause
+module Rubylog::Goal
   # Clients should implement this method. 
   # Yields for each possible solution of the predicate
   def prove
@@ -12,7 +12,7 @@ module Rubylog::Clause
 
   def solve &block
     goal = rubylog_match_variables 
-    catch :cut do
+    catch :rubylog_cut do
       goal.prove { block.call_with_rubylog_variables(goal.rubylog_variables) if block }
     end
   end

data/lib/rubylog/mixins/proc.rb

@@ -1,7 +1,7 @@
 class Proc
 
-  # Clause methods
-  include Rubylog::Clause
+  # Goal methods
+  include Rubylog::Goal
 
   def prove
     yield if call_with_rubylog_variables

data/lib/rubylog/mixins/symbol.rb

@@ -14,8 +14,8 @@ class Symbol
   # Term methods
   include Rubylog::Term
 
-  # Clause methods
-  include Rubylog::Clause
+  # Goal methods
+  include Rubylog::Goal
 
   def prove
     predicate.call { yield }

data/lib/rubylog/procedure.rb

@@ -7,6 +7,10 @@ module Rubylog
       @rules = rules
     end
 
+    def inspect
+      "#{Rubylog::DSL::Indicators.humanize_indicator([functor,arity])}: #{@rules.inspect}"
+    end 
+
     def method_missing name, *args, &block
       @rules.send name, *args, &block
     end
@@ -14,7 +18,7 @@ module Rubylog
     # accepts the *args of the called structure
     def call *args
       # catch cuts
-      catch :cut do
+      catch :rubylog_cut do
 
         # for each rule
         each do |rule|

data/lib/rubylog/rule.rb

@@ -10,6 +10,10 @@ module Rubylog
       @body = body
     end
 
+    def inspect
+      "#{head.inspect}.if(#{body.inspect})"
+    end 
+
     # CompoundTerm methods
     include Rubylog::CompoundTerm
     def rubylog_clone &block

data/lib/rubylog/structure.rb

@@ -51,8 +51,8 @@ module Rubylog
     # Assertable methods
     include Rubylog::Assertable
 
-    # Clause methods
-    include Rubylog::Clause
+    # Goal methods
+    include Rubylog::Goal
 
     def prove
       count = 0

data/lib/rubylog/variable.rb

@@ -16,10 +16,12 @@ module Rubylog
     end
 
     def inspect
+      return "#{@name}=#{@value.inspect}" if @bound
+
       if @guards.empty?
         @name.to_s
       else
-        "#{@name}#{@guards}"
+        "#{@name}#{@guards.inspect}"
       end
     end
 
@@ -56,6 +58,7 @@ module Rubylog
     # values are variables, unifies them with the other being bound to the
     # receiver. If one of them is a variable, it gets bound to the other value.
     # If none of them is a variable, they are checked for equality with eql?.
+    # Succeeds if other is the same object as the receiver.
     #
     def rubylog_unify other
       # check if we are bound
@@ -71,11 +74,13 @@ module Rubylog
 
         # if the other is a variable
         if other.is_a? Rubylog::Variable
+          # succeed if same object
+          (yield; return) if self.equal? other
+
           # we union our guards with the other's
           other.append_guards guards do
-            # we bind the other to self (this order comes from
-            # inriasuite_spec#unify)
-            other.bind_to self do
+            # and bind to the other
+            bind_to other do
               yield
             end
           end
@@ -109,8 +114,8 @@ module Rubylog
       end
     end
 
-    # Clause methods
-    include Clause
+    # Goal methods
+    include Goal
 
     def prove
       v = rubylog_dereference
@@ -120,10 +125,25 @@ module Rubylog
       unless v.rubylog_variables
         v = v.rubylog_match_variables
       end
-      
-      catch :cut do
-        v.prove{yield}
+
+      caught_cut = false
+
+      catch :rubylog_cut do
+        v.prove do
+          # intercept cuts that come from the yield
+          catch :rubylog_no_cut do
+            catch :rubylog_cut do
+              yield
+              throw :rubylog_no_cut
+            end
+            caught_cut = true
+          end
+          break if caught_cut
+        end
       end
+
+      # pass through cut if one was caught from yield
+      throw :rubylog_cut if caught_cut
     end
 
 

data/lib/rubylog.rb

@@ -10,7 +10,7 @@ require 'rubylog/tracing'
 
 # interfaces
 require 'rubylog/term'
-require 'rubylog/clause'
+require 'rubylog/goal'
 require 'rubylog/assertable'
 require 'rubylog/compound_term'
 

data/rubylog.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "rubylog"
-  s.version = "2.0pre1"
+  s.version = "2.0.0"
 
-  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bern\u{e1}t Kall\u{f3}"]
-  s.date = "2013-05-02"
+  s.date = "2013-05-07"
   s.description = "Rubylog is a Prolog-like DSL for Ruby."
   s.email = "kallo.bernat@gmail.com"
   s.extra_rdoc_files = [
@@ -66,7 +66,6 @@ Gem::Specification.new do |s|
     "lib/rubylog/builtins/logic.rb",
     "lib/rubylog/builtins/reflection.rb",
     "lib/rubylog/builtins/term.rb",
-    "lib/rubylog/clause.rb",
     "lib/rubylog/compound_term.rb",
     "lib/rubylog/context.rb",
     "lib/rubylog/context_creation.rb",
@@ -77,10 +76,12 @@ Gem::Specification.new do |s|
     "lib/rubylog/context_modules/thats.rb",
     "lib/rubylog/default_context.rb",
     "lib/rubylog/dsl/array_splat.rb",
+    "lib/rubylog/dsl/indicators.rb",
     "lib/rubylog/dsl/primitives.rb",
     "lib/rubylog/dsl/thats.rb",
     "lib/rubylog/dsl/variables.rb",
     "lib/rubylog/errors.rb",
+    "lib/rubylog/goal.rb",
     "lib/rubylog/mixins/array.rb",
     "lib/rubylog/mixins/hash.rb",
     "lib/rubylog/mixins/kernel.rb",
@@ -185,6 +186,7 @@ Gem::Specification.new do |s|
     "spec/rubylog/context_modules/predicates_spec.rb",
     "spec/rubylog/context_modules/thats_spec.rb",
     "spec/rubylog/dsl/array_splat_spec.rb",
+    "spec/rubylog/dsl/indicators_spec.rb",
     "spec/rubylog/dsl/primitives_spec.rb",
     "spec/rubylog/errors_spec.rb",
     "spec/rubylog/interfaces/term_spec.rb",
@@ -193,6 +195,8 @@ Gem::Specification.new do |s|
     "spec/rubylog/mixins/proc_spec.rb",
     "spec/rubylog/mixins/string_spec.rb",
     "spec/rubylog/mixins/symbol_spec.rb",
+    "spec/rubylog/procedure_spec.rb",
+    "spec/rubylog/rule_spec.rb",
     "spec/rubylog/structure_spec.rb",
     "spec/rubylog/term_spec.rb",
     "spec/rubylog/tracing_spec.input",

data/spec/inriasuite_spec.rb

@@ -870,9 +870,7 @@ describe "inriasuite", :rubylog=>true do
     specify %(['='(X,1),[[X <-- 1]]].) do
       X.is(1).map{X}.should eql [1]
     end
-    specify %(['='(X,Y),[[Y <-- X]]].) do
-      X.is(Y).map{Y}.should eql [X]
-    end
+    specify %(['='(X,Y),[[Y <-- X]]].), pending: "This happens the other way around in Rubylog, X will be bound to Y."
     specify %([('='(X,Y),'='(X,abc)),[[X <-- abc, Y <-- abc]]].) do
       X.is(Y).and(X.is(:abc)).map{[X,Y]}.should eql [[:abc,:abc]]
     end

data/spec/integration/dsl_spec.rb

@@ -29,9 +29,9 @@ describe "Rubylog dsl", :rubylog=>true do
   end
 
   describe "variables" do
-    check A.is(ANY).and{ A == Rubylog::Variable.new(:A) }
+    check A.is(ANY).and{ A == Rubylog::Variable.new(:ANY) }
     check A.is(4)  .and{ A == 4 }
-    check B.is(A)  .and{ A == Rubylog::Variable.new(:B) and B == Rubylog::Variable.new(:B) }
+    check B.is(A)  .and{ A == Rubylog::Variable.new(:A) and B == Rubylog::Variable.new(:A) }
     check B.is(ANY).and{ A == Rubylog::Variable.new(:A) }
   end
 

data/spec/rubylog/builtins/logic_spec.rb

@@ -163,6 +163,29 @@ describe "logic builtins", :rubylog => true do
       :john.happy.if((:true.and :true).or :true)
       :john.should be_happy
     end
+
+    it "works after variable calls" do 
+      (A.is(:true).and A.and :cut!.and :fail).or(:true).true?.should be_false
+    end 
+
+    it "works after variable calls (control)" do 
+      (A.is(:true).and A.and :fail).or(:true).true?.should be_true
+    end 
+
+    it "works after variable calls (branch or)" do 
+      :john.happy.if A.is(:true).and A.and :cut!.and :fail
+      :john.happy.if :true
+      :john.should_not be_happy
+    end 
+
+    it "works after variable calls with multiple solutions of the variable" do 
+      (A.is(B.is(4).or(B.is(6))).and A.and :cut!).map{B}.should == [4]
+    end 
+
+    it "works after variable calls with multiple solutions of the variable (control)" do 
+      (A.is(B.is(4).or(B.is(6))).and A).map{B}.should == [4,6]
+    end 
+
   end
 
   describe "all,any,one,none,every" do
@@ -280,6 +303,13 @@ describe "logic builtins", :rubylog => true do
     end
 
     describe "every" do
+      specify "works as infix" do
+        :john.likes(X).every(:john.likes(X)).true?.should be_true
+        :john.likes(X).every(:jane.likes(X)).true?.should be_true
+        :john.likes(X).every(:jeff.likes(X)).true?.should_not be_true
+        :john.likes(X).every(:todd.likes(X)).true?.should_not be_true
+      end
+      
       specify "works like all" do
         every(:john.likes(X),:john.likes(X)).true?.should be_true
         every(:john.likes(X),:jane.likes(X)).true?.should be_true
@@ -331,6 +361,18 @@ describe "logic builtins", :rubylog => true do
         every(:john.likes(X), X.good.assumed).and(Y.good).map{Y}.should == [:beer, :water]
       end
 
+      specify "passes variables" do 
+        solve N.is(5).and K.in{1..N}.every {N.should eql 5}
+      end 
+
+      specify "passes variables" do 
+        solve N.is(5).and K.in{1..N}.every L.in{1..N}
+      end 
+
+      specify "passes variables if b contains the variable" do 
+        solve N.is(5).and every I.in{2..N}, K.is{N/I}
+      end 
+
     end
 
 

data/spec/rubylog/builtins/term_spec.rb

@@ -37,10 +37,6 @@ describe "Term builtins", :rubylog => true do
       (2.in [1,3,4]).to_a.should == []
     end
 
-    it "works with clauses" do
-      (A.likes(B).and B.in{:john.likes(X).map{X}}).map{[A,B]}.should == [[:john, :beer]]
-    end
-
     it "checks instatiation" do
       expect { 5.in(B).map{B} }.to raise_error Rubylog::InstantiationError
     end

data/spec/rubylog/context_modules/predicates_spec.rb

@@ -32,26 +32,4 @@ describe Rubylog::ContextModules::Predicates, :rubylog=>true do
     end
   end
 
-  describe "#humanize_indicator" do
-    specify { humanize_indicator([:fail,0]).should == ":fail" }
-    specify { humanize_indicator([:false,1]).should == ".false" }
-    specify { humanize_indicator([:and,2]).should == ".and()" }
-    specify { humanize_indicator([:splits,3]).should == ".splits(,)" }
-    specify { humanize_indicator([:is,4]).should == ".is(,,)" }
-  end
-
-  describe "#unhumanize_indicator" do
-    specify { unhumanize_indicator(":fail" ).should == [:fail,0] }
-    specify { unhumanize_indicator(".false" ).should == [:false,1] }
-    specify { unhumanize_indicator(".and()" ).should == [:and,2] }
-    specify { unhumanize_indicator(".splits(,)" ).should == [:splits,3] }
-    specify { unhumanize_indicator(".is(,,)" ).should == [:is,4] }
-
-    describe "with comment variables" do
-      specify { unhumanize_indicator("Predicate.false" ).should == [:false,1] }
-      specify { unhumanize_indicator("a.and(b)" ).should == [:and,2] }
-      specify { unhumanize_indicator("LIST.splits(HEAD,TAIL)" ).should == [:splits,3] }
-      specify { unhumanize_indicator("C.is(A,OP,B)" ).should == [:is,4] }
-    end
-  end
 end

data/spec/rubylog/context_modules/thats_spec.rb

@@ -32,7 +32,7 @@ describe "thats", :rubylog=>true do
   describe "files" do
     check {     "#{S[String, thats.start_with?(".")]}".filename_in(".").map{S}.include? ".gitignore" }
     check { not "#{S[String, thats.start_with?(".")]}". dirname_in(".").map{S}.include? "lib" }
-    check { "#{S[/\A(.*)\.rb/]}".filename_in("lib").map{S} == ["rubylog.rb"] }
+    specify { "#{S[/\A(.*)\.rb/]}".filename_in("lib").map{S}.should == ["rubylog.rb"] }
   end
 
   describe "factorial" do

data/spec/rubylog/dsl/indicators_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper" 
+
+describe Rubylog::DSL::Indicators do
+  describe "#humanize_indicator" do
+    specify { Rubylog::DSL::Indicators.humanize_indicator([:fail,0]).should == ":fail" }
+    specify { Rubylog::DSL::Indicators.humanize_indicator([:false,1]).should == ".false" }
+    specify { Rubylog::DSL::Indicators.humanize_indicator([:and,2]).should == ".and()" }
+    specify { Rubylog::DSL::Indicators.humanize_indicator([:splits,3]).should == ".splits(,)" }
+    specify { Rubylog::DSL::Indicators.humanize_indicator([:is,4]).should == ".is(,,)" }
+  end
+
+  describe "#unhumanize_indicator" do
+    specify { Rubylog::DSL::Indicators.unhumanize_indicator(":fail" ).should == [:fail,0] }
+    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".false" ).should == [:false,1] }
+    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".and()" ).should == [:and,2] }
+    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".splits(,)" ).should == [:splits,3] }
+    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".is(,,)" ).should == [:is,4] }
+
+    describe "with comment variables" do
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator("Predicate.false" ).should == [:false,1] }
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator("a.and(b)" ).should == [:and,2] }
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator("LIST.splits(HEAD,TAIL)" ).should == [:splits,3] }
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator("C.is(A,OP,B)" ).should == [:is,4] }
+    end
+  end
+end 

data/spec/rubylog/interfaces/term_spec.rb

@@ -23,50 +23,50 @@ describe "unification", :rubylog=>true do
     :john.rubylog_unify(:mary) { result = true }
     result.should == false
   end
-  it "works on clauses" do
+  it "works on structures" do
     result = false
     (:john.likes :beer).rubylog_unify(A.likes B) { result = true }
     result.should == true
   end
-  it "works on clauses with equal values" do
+  it "works on structures with equal values" do
     result = false
     (:john.likes :beer).rubylog_unify(:john.likes :beer) { result = true }
     result.should == true
   end
-  it "works on clauses with different values" do
+  it "works on structures with different values" do
     result = false
     (:john.likes :beer).rubylog_unify(:john.likes :milk) { result = true }
     result.should == false
   end
-  it "works on clauses with variables and equal values" do
+  it "works on structures with variables and equal values" do
     result = false
     (:john.likes :beer).rubylog_unify(X.likes :beer) { result = true }
     result.should == true
   end
-  it "works on clauses with variables and equal values #2" do
+  it "works on structures with variables and equal values #2" do
     result = false
     (:john.likes :beer).rubylog_unify(:john.likes DRINK) { result = true }
     result.should == true
   end
-  it "works on clauses with variables and different values" do
+  it "works on structures with variables and different values" do
     result = false
     (:john.likes :beer).rubylog_unify(X.likes :milk) { result = true }
     result.should == false
   end
-  it "works on clauses with variables and different values #2" do
+  it "works on structures with variables and different values #2" do
     result = false
     (:john.likes :beer).rubylog_unify(:jane.likes D) { result = true }
     result.should == false
   end
 
-  it "works on clauses with repeated variables #1" do
+  it "works on structures with repeated variables #1" do
     result = false
     (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :jane) { result = true }
     result.should == false
     (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :john) { result = true }
     result.should == true
   end
-  it "works on clauses with repeated variables #1" do
+  it "works on structures with repeated variables #1" do
     result = false
     (:john.likes :jane).rubylog_unify(A.likes(A).rubylog_match_variables) { result = true }
     result.should == false

data/spec/rubylog/mixins/array_spec.rb

@@ -34,7 +34,7 @@ describe Array, :rubylog=>true do
       a = A
       b = B
       can_unify [*a], [*b] do
-        b.value.should equal a
+        a.value.should equal b
       end
     end
 

data/spec/rubylog/procedure_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper" 
+require "rubylog/procedure" 
+
+describe Rubylog::Procedure, rubylog:true do
+  describe "#inspect" do 
+    it "returns a human-readable output" do 
+      predicate_for String, ".likes()"
+      A.likes(B).predicate.inspect.should == ".likes(): []"
+    end 
+  end 
+end 

data/spec/rubylog/rule_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'rubylog/rule'
+
+describe Rubylog::Rule, rubylog:true do
+  describe "#inspect" do 
+    it "returns a human-readable output" do 
+      predicate_for String, ".likes()"
+      A.likes(B).if B.is(:water)
+
+      A.likes(B).predicate[0].inspect.should == "A.likes(B).if(B.is(:water))"
+    end
+  end
+end 

data/spec/rubylog/variable_spec.rb

@@ -57,13 +57,13 @@ describe Rubylog::Variable, :rubylog=>true do
       end
     end
 
-    it "unifies with another unbound variable with the other gettin bound" do
+    it "unifies with another unbound variable with getting bound" do
       a=A
       b=B
       a.rubylog_unify(b) do
-        b.should be_bound
-        b.value.should equal a
-        a.should_not be_bound
+        a.should be_bound
+        a.value.should equal b
+        b.should_not be_bound
       end
     end
 
@@ -86,6 +86,23 @@ describe Rubylog::Variable, :rubylog=>true do
         end
       end
     end
+
+    it "unifies with self" do
+      a=A
+      a.rubylog_unify(a) do
+        a.should_not be_bound
+      end 
+    end 
+
+    it "unifies with another bound to self" do
+      a=A
+      b=B
+      a.rubylog_unify(b) do
+        b.rubylog_unify(a) do
+          b.should_not be_bound
+        end
+      end
+    end
   end
 
   describe "dereferencing" do