cycr 0.0.3

data/Rakefile

@@ -0,0 +1,23 @@
+task :default => [:install]
+
+$gem_name = "cycr"
+
+desc "Build the gem"
+task :build do
+  sh "gem build #$gem_name.gemspec"
+end
+
+desc "Install the library at local machnie"
+task :install => :build do 
+  sh "sudo gem install #$gem_name -l"
+end
+
+desc "Uninstall the library from local machnie"
+task :uninstall do
+  sh "sudo gem uninstall #$gem_name"
+end
+
+desc "Clean"
+task :clean do
+  sh "rm #$gem_name*.gem" 
+end

data/cycr.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = "cycr"
+  s.version = "0.0.3"
+  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.require_path = "lib"
+  s.description = "Ruby wrapper for (Open)Cyc server and ontology"
+  s.has_rdoc = false
+  s.authors = ['Aleksander Pohl']
+  s.files = ["Rakefile", "cycr.gemspec", 'lib/cycr.rb'] +
+    Dir.glob("lib/**/*")
+  s.test_files = Dir.glob("spec/**/*")
+  s.rdoc_options = ["--main", "README.txt"]
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.txt"]
+  s.add_dependency("rspec", [">= 1.2.9"])
+end
+

data/lib/cycr/assertion.rb

@@ -0,0 +1,14 @@
+module Cyc
+  class Assertion
+    attr_reader :formula, :microtheory
+
+    def initialize(formula,microtheory)
+      @formula = formula
+      @microtheory = microtheory
+    end
+
+    def to_s
+      "#{@formula} : #{@microtheory}"
+    end
+  end
+end

data/lib/cycr/client.rb

@@ -0,0 +1,208 @@
+require 'net/telnet'
+
+module Cyc
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT License
+  #
+  # This class is the implementation of the Cyc server client. 
+  class Client
+    # If set to true, all communication with the server is logged
+    # to standard output
+    attr_accessor :debug
+    attr_reader :host, :port
+    # Creates new Client. 
+    def initialize(host="localhost",port="3601",debug=false)
+      @debug = debug
+      @host = host
+      @port = port
+      @pid = Process.pid
+      @parser = Parser.new
+      @mts_cache = {}
+
+      # read domains mapings
+#      talk(File.read(File.join(
+#        File.dirname(__FILE__), 'domains.lisp')))
+
+      # read utility functions
+      talk(File.read(File.join(
+        File.dirname(__FILE__), 'words_reader.lisp')))
+
+      # wait untill files are processed
+      send_message("(define end-of-routines () ())")
+      while answer = receive_answer do
+        break if answer =~ /END-OF-ROUTINES/
+      end
+    end
+
+    # (Re)connects to the cyc server.
+    def reconnect
+      @pid = Process.pid
+      @conn = Net::Telnet.new("Port" => @port, "Telnetmode" => false,
+                              "Timeout" => 600, "Host" => @host)
+    end
+
+    # Returns the connection object. Ensures that the pid of current
+    # process is the same as the pid, the connection was initialized with.
+    # 
+    # If the block is given, the command is guarded by assertion, that
+    # it will be performed, even if the connection was reset.
+    def connection
+      #puts "#{@pid} #{Process.pid}"
+      if @conn.nil? or @pid != Process.pid
+        reconnect
+      end
+      if block_given?
+        begin
+          yield @conn
+        rescue Errno::ECONNRESET
+          reconnect
+          yield @conn
+        end
+      else
+        @conn 
+      end
+    end
+
+    protected :connection, :reconnect
+
+    def clear_cache
+      @mts_cache = {}
+    end
+
+    # Closes connection with the server
+    def close
+      connection{|c| c.puts("(api-quit)")}
+      @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
+
+    # Send the raw message.
+    def send_message(msg)
+      @last_message = msg
+      puts "Send: #{msg}" if @debug
+      connection{|c| c.puts(msg)}
+    end
+
+    # Receive answer from server.
+    def receive_answer(options={})
+      answer = connection{|c| c.waitfor(/./)}
+      puts "Recv: #{answer}" if @debug
+      if answer.nil?
+        raise "Unknwon error occured. " +
+          "Check the submitted query in detail!"
+      end
+      while not answer =~ /\n/ do
+        next_answer = connection{|c| c.waitfor(/./)}
+        puts "Recv: #{next_answer}" if @debug
+        if answer.nil?
+          answer = next_answer
+        else
+          answer += next_answer
+        end
+      end
+      # XXX ignore some potential asynchronous answers
+      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
+          last_message = @last_message
+          while current_result.size == 100 do
+            send_message("(subseq #{last_message} #{result.size} " +
+                         "#{result.size + 100})")
+            current_result = receive_answer(options)
+            result.concat(current_result)
+          end
+          result
+        end
+      else
+        unless $2.nil?
+          puts $2.sub(/^"/,"").sub(/"$/,"") + "\n" +
+            @last_message
+        else
+          puts "unknown error!"
+        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?
+    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)
+         if mts
+           mts.select{|mt| mt.is_a? Symbol}.
+             reject{|mt| IRRELEVANT_MTS.include?(mt)} 
+         else
+           []
+         end)
+    end
+
+    def with_reconnect
+    end
+  end
+end

data/lib/cycr/collection.rb

@@ -0,0 +1,76 @@
+module Cyc
+  class Collection
+    attr_reader :symbol
+
+    def initialize(symbol, cyc)
+      @symbol = symbol
+      @cyc = cyc
+      @printed = false
+    end
+
+    def printed?
+      @printed
+    end
+
+    def parents
+      unless @parents
+        parents = @cyc.min_genls(symbol)
+        @parents = if parents
+          parents.map{|p| Collection.new(p,@cyc)}
+        else
+          []
+        end
+      end
+      @parents
+    end
+
+    def children
+      unless @children
+        children = @cyc.max_specs(symbol)
+        if children
+          @children = children.map{|p| Collection.new(p,@cyc)}
+        else
+          @children = []
+        end
+      end
+      @children
+    end
+
+    def comment
+      @cyc.comment(@symbol)
+    end
+
+    def lexemes()
+      default_str = [@cyc.symbol_str(symbol)]
+      aux_strs =  @cyc.symbol_strs(symbol) || []
+      (default_str + aux_strs).uniq.compact.join(", ")
+    end
+
+    def to_s
+      @symbol.to_s
+    end
+
+    def ==(other)
+      return false unless other.is_a? Collection
+      self.symbol == other.symbol
+    end
+
+    def =~(other)
+      return false unless other.is_a? Collection
+      self.parents - other.parents == [] &&
+        other.parents - self.parents == []
+    end
+
+    def ancestor?(node)
+      return true if node == :Thing
+      ancestors = @parents.dup
+      while !ancestors.empty?
+        ancestor = ancestors.shift
+        return true if ancestor == node
+        ancestors += ancestor.parents
+        ancestors.uniq!
+      end
+      false
+    end
+  end # Node
+end

data/lib/cycr/constants.rb

@@ -0,0 +1,8 @@
+module Cyc
+  # These Microteories contain non-ontological assertions.
+  IRRELEVANT_MTS = [:WordNetMappingMt, :EnglishMt, :UniversalVocabularyMt, 
+    :BaseKB, :CycHistoricalPossibilityTheoryMt, :SENSUSMappingMt, 
+    :GeneralLexiconMt, :BookkeepingMt,  :CycNounLearnerMt, :HPKBVocabMt,
+    :SKSIMt, :TopicMt, :SNOMEDMappingMt, :MeSHMappingMt, :CycNounLearnerMt,
+    :TheMotleyFoolUKCorpusMt, :AnalystDatabaseMt, :CyclistsMt ]
+end