cycr 0.0.3 → 0.0.4

data/cycr.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name = "cycr"
-  s.version = "0.0.3"
+  s.version = "0.0.4"
   s.date = "2010-10-19"
   s.summary = "Ruby client for the (Open)Cyc server"
   s.email = "apohllo@o2.pl"
-  s.homepage = "http://www.opencyc.org"
+  s.homepage = "http://github.com/apohllo/cycr"
   s.require_path = "lib"
   s.description = "Ruby wrapper for (Open)Cyc server and ontology"
   s.has_rdoc = false

data/lib/cycr/builder.rb

@@ -0,0 +1,33 @@
+module Cyc
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT License
+  #
+  # This class is used to capture calls to the Cyc client, to allow
+  # nested calls, like
+  # 
+  # cyc.with_any_mt do
+  #   comment :Collection
+  # end
+  class Builder
+    def initialize
+      reset
+    end
+
+    def reset
+      @query = ""
+    end
+
+    def to_cyc
+      @query
+    end
+
+    def method_missing(name,*args,&block)
+      @query << "(" << name.to_s.gsub("_","-") << " "
+      @query << args.map{|a| a.to_cyc}.join(" ")
+      if block
+        self.instance_exec(&block)
+      end
+      @query << ")"
+    end
+  end
+end

data/lib/cycr/client.rb

@@ -18,6 +18,7 @@ module Cyc
       @pid = Process.pid
       @parser = Parser.new
       @mts_cache = {}
+      @builder = Builder.new
 
       # read domains mapings
 #      talk(File.read(File.join(
@@ -75,27 +76,9 @@ module Cyc
       @conn = nil
     end
 
-    NART_QUERY =<<-END
-      (clet ((result ())
-        (call-value :call)) 
-        (pif (listp call-value)
-          (cdolist (el call-value) 
-            (pif (nart-p el) 
-              (cpush (nart-id el) result) 
-              (cpush el result))) 
-          (pif (nart-p call-value)
-              (cpush (nart-id call-value) result)
-              (cpush call-value result)))
-        result)
-    END
-
-
     # Sends message +msg+ directly to the Cyc server and receives 
     # the answer. 
     def talk(msg, options={})
-      #conn.puts(msg.respond_to?(:to_cyc) ? msg.to_cyc : msg)
-      msg = NART_QUERY.sub(/:call/,msg) if options[:nart]
-
       send_message(msg)
       receive_answer(options)
     end
@@ -125,12 +108,12 @@ module Cyc
         end
       end
       # XXX ignore some potential asynchronous answers
-      answer = answer.split("\n")[-1]
+      # XXX check if everything works ok
+      #answer = answer.split("\n")[-1]
       answer = answer.sub(/(\d\d\d) (.*)/,"\\2")
       if($1.to_i == 200)
         begin
           result = @parser.parse(answer,options[:stack])
-          result = options[:nart] ? substitute_narts(result) : result
         rescue Parser::ContinueParsing => ex
           result = ex.stack
           current_result = result
@@ -148,49 +131,21 @@ module Cyc
           puts $2.sub(/^"/,"").sub(/"$/,"") + "\n" +
             @last_message
         else
-          puts "unknown error!"
+          puts "Unknown error! #{answer}"
         end
         nil
       end
     end
 
 
-    def method_missing(name,*args)
-      #"_missing_method_#{name}"
-      method_name = name.to_s.gsub("_","-").sub(/-nart$/,"")
-      options = {}
-      def method_name.to_cyc(quote=false)
-        self
-      end
-      options[:nart] = true if name.to_s =~ /_nart$/
-        talk(([method_name] + args).to_cyc,options)
-    end
-
-    DENOTATION_QUERY =<<-END 
-      (nart-denotation-mapper ":word")
-    END
-
-    def denotation_mapper(name)
-      send_message(DENOTATION_QUERY.sub(/:word/,name))
-      receive_answer(:nart => true)
-    end
-
-
-    # Finds collection with given name. The name has to
-    # be the name of the exact name of the constant.
-    def find_collection(name)
-      term = self.find_constant(name)
-      Collection.new(term, self) unless term.nil?
+    def method_missing(name,*args,&block)
+      @builder.reset
+      @builder.send(name,*args,&block)
+      talk(@builder.to_cyc)
     end
 
 protected
 
-    def substitute_narts(terms)
-      unless terms.nil?
-        terms.collect{|t| t.is_a?(String) ? Cyc::Nart.new(t,self) : t}
-      end
-    end
-
     def relevant_mts(term)
       @mts_cache[term] ||= 
         (mts = self.term_mts(term)
@@ -201,8 +156,5 @@ protected
            []
          end)
     end
-
-    def with_reconnect
-    end
   end
 end

data/lib/cycr/extensions.rb

@@ -1,25 +1,23 @@
 class String
-  def to_cyc(quote = false)
-    #self =~ /_missing_method_(.*)/ ? "#{$1.gsub("_","-")}" : "\"#{self}\""
+  def to_cyc
     "\"#{self}\""
   end
 end
 
 class Symbol
-  def to_cyc(quote = false)
-    (quote ? "'" : "") + "#\$#{self}"
+  def to_cyc
+    "#\$#{self}"
   end
 end
 
 class Array
-  def to_cyc(quote = false)
-    (quote ? "'" : "") + 
-      "("+map{|e| e.to_cyc(quote)}.join(" ")+")"
+  def to_cyc
+    "'("+map{|e| e.to_cyc}.join(" ")+")"
   end
 end
 
 class Fixnum
-  def to_cyc(quote = false)
+  def to_cyc
     to_s
   end
 end

data/lib/cycr/sexpr.rex

@@ -8,7 +8,7 @@ macro
   INPUT_CHARACTER       [^\r\n\"\(\):& ]
   WHITE_SPACE           [\ \t\f\r\n] | \r\n
   SYMBOL                :[^<>\r\n\"\(\):&\ ]+
-  CYC_SYMBOL            \#\$[a-zA-Z0-9-]+
+  CYC_SYMBOL            \#\$[a-zA-Z0-9:_-]+
   ATOM                  [^\r\n\"\(\):&\ ]+
   OPEN_PAR              \(
   CLOSE_PAR             \)
@@ -37,13 +37,13 @@ rule
                         {QUOTE}           { state = :STRING; @str = ""; [:in_string] }
                         # whitespace 
                         {WHITE_SPACE}     # ignore 
-  :STRING               {QUOTE}           { state = nil; [:string,@str] }
   :STRING               [^\n\r\"\\]+      { @str << text; [:in_string]}
-  :STRING               \t               { @str << '\t'; [:in_string] }
-  :STRING               \n               { @str << '\n'; [:in_string] }
-  :STRING               \r               { @str << '\r'; [:in_string] }
-  :STRING               \\"              { @str << '\"'; [:in_string] }
-  :STRING               \\                { @str << '\\'; [:in_string] }
+  :STRING               \t               { @str << "\t"; [:in_string] }
+  :STRING               \n               { @str << "\n"; [:in_string] }
+  :STRING               \r               { @str << "\n"; [:in_string] }
+  :STRING               \\"              { @str << '"'; [:in_string] }
+  :STRING               \\                { @str << "\\"; [:in_string] }
+  :STRING               {QUOTE}           { state = nil; [:string,@str] }
   # error fallback 
                         .|\n              { raise "Illegal character <#{text}>" }
 inner

data/lib/cycr/sexpr.rex.rb

@@ -76,7 +76,7 @@ class SExpressionLexer
         when (text = ss.scan(/:[^<>\r\n\"\(\):&\ ]+/))
            @rex_tokens.push action { [:symbol,text] }
 
-        when (text = ss.scan(/\#\$[a-zA-Z0-9-]+/))
+        when (text = ss.scan(/\#\$[a-zA-Z0-9:_-]+/))
            @rex_tokens.push action { [:cyc_symbol,text] }
 
         when (text = ss.scan(/[^\r\n\"\(\):&\ ]+/))
@@ -98,26 +98,26 @@ class SExpressionLexer
 
       when :STRING
         case
-        when (text = ss.scan(/\"/))
-           @rex_tokens.push action { state = nil; [:string,@str] }
-
         when (text = ss.scan(/[^\n\r\"\\]+/))
            @rex_tokens.push action { @str << text; [:in_string]}
 
         when (text = ss.scan(/\t/))
-           @rex_tokens.push action { @str << '\t'; [:in_string] }
+           @rex_tokens.push action { @str << "\t"; [:in_string] }
 
         when (text = ss.scan(/\n/))
-           @rex_tokens.push action { @str << '\n'; [:in_string] }
+           @rex_tokens.push action { @str << "\n"; [:in_string] }
 
         when (text = ss.scan(/\r/))
-           @rex_tokens.push action { @str << '\r'; [:in_string] }
+           @rex_tokens.push action { @str << "\n"; [:in_string] }
 
         when (text = ss.scan(/\\"/))
-           @rex_tokens.push action { @str << '\"'; [:in_string] }
+           @rex_tokens.push action { @str << '"'; [:in_string] }
 
         when (text = ss.scan(/\\/))
-           @rex_tokens.push action { @str << '\\'; [:in_string] }
+           @rex_tokens.push action { @str << "\\"; [:in_string] }
+
+        when (text = ss.scan(/\"/))
+           @rex_tokens.push action { state = nil; [:string,@str] }
 
         else
           text = ss.string[ss.pos .. -1]

data/spec/client.rb

@@ -18,13 +18,6 @@ describe Cyc::Client do
     @client.constant_count.should_not == nil
   end
 
-  it "should allow to find 'Cat' collection" do
-    cat = @client.find_collection("Cat")
-    cat.should_not == nil
-    cat.should be_instance_of(Cyc::Collection)
-    cat.symbol.should == :Cat
-  end
-
   it "should allow multiple processes to use the client" do 
     parent_pid = Process.pid
     if fork

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cycr
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Aleksander Pohl
@@ -50,7 +50,7 @@ files:
 - lib/cycr/parser.rb
 - lib/cycr/domains.lisp
 - lib/cycr/sexpr.flex
-- lib/cycr/nart.rb
+- lib/cycr/builder.rb
 - lib/cycr/constants.rb
 - lib/cycr/collection.rb
 - lib/cycr/sexpr.rex.rb
@@ -62,7 +62,7 @@ files:
 - spec/client.rb
 - spec/assertion.rb
 has_rdoc: true
-homepage: http://www.opencyc.org
+homepage: http://github.com/apohllo/cycr
 licenses: []
 
 post_install_message: 

data/lib/cycr/nart.rb

@@ -1,21 +0,0 @@
-module Cyc
-  class Nart
-    attr_accessor :id, :value
-    def initialize(id, cyc)  
-      @id = id.to_i
-      @value = cyc.find_nart_by_id @id
-    end
-
-    def to_cyc(quote=false)
-      "(find-nart-by-id #{@id})"
-    end
-
-    def to_s
-      "NART[#{@id}]: #{@value.inspect} "
-    end
-
-    def self.find_by_name(name,cyc)
-      self.new(name.match(/^NART\[([^\]]+)\]/)[1],cyc)
-    end
-  end
-end