cycr 0.0.3

data/lib/cycr/sexpr.flex

@@ -0,0 +1,74 @@
+package pl.apohllo.lexicon.pwn.server;
+
+import java.io.StringReader;
+%% 
+
+%class Lexer
+%unicode
+%line
+%public
+%type Symbol
+
+%{
+  StringBuffer string = new StringBuffer();
+
+  public Lexer(String input){
+    this.zzReader = new StringReader(input);
+  }
+
+  private Symbol symbol(int type) {
+    return new Symbol(type, yyline, yycolumn);
+  }
+  private Symbol symbol(int type, String value) {
+    return new Symbol(type, yyline, yycolumn, value);
+  }
+%}
+
+LineTerminator = \r|\n|\r\n
+InputCharacter = [^\r\n\"\(\):& ]
+WhiteSpace     = {LineTerminator} | [ \t\f]
+
+Symbol = : {InputCharacter}+
+
+Atom = {InputCharacter}+
+
+OpenPar = "("
+ClosePar = ")"
+
+%state STRING
+
+
+%%
+
+<YYINITIAL> {
+  /* keywords */
+  {OpenPar}			 { return symbol(Symbol.OPEN_PAR); }
+  {ClosePar}			 { return symbol(Symbol.CLOSE_PAR); }
+
+  /* identifiers */ 
+  {Symbol}			 { return symbol(Symbol.SYMBOL,yytext()); }
+  {Atom}			 { return symbol(Symbol.ATOM,yytext()); }
+
+
+  /* literals */
+  \"                             { string.setLength(0); yybegin(STRING); }
+
+  /* whitespace */
+  {WhiteSpace}                   { /* ignore */ }
+}
+
+<STRING> {
+  \"                             { yybegin(YYINITIAL); 
+                                   return symbol(Symbol.STRING_LITERAL, string.toString()); }
+  [^\n\r\"\\]+                   { string.append( yytext() ); }
+  \\t                            { string.append('\t'); }
+  \\n                            { string.append('\n'); }
+
+  \\r                            { string.append('\r'); }
+  \\\"                           { string.append('\"'); }
+  \\                             { string.append('\\'); }
+}
+
+/* error fallback */
+.|\n                             { throw new Error("Illegal character <"+ yytext()+">"); }
+

data/lib/cycr/sexpr.rex

@@ -0,0 +1,55 @@
+class Cyc::SExpressionLexer
+
+option
+  independent
+
+macro 
+  LINE_TERMINATOR       \r|\n|\r\n
+  INPUT_CHARACTER       [^\r\n\"\(\):& ]
+  WHITE_SPACE           [\ \t\f\r\n] | \r\n
+  SYMBOL                :[^<>\r\n\"\(\):&\ ]+
+  CYC_SYMBOL            \#\$[a-zA-Z0-9-]+
+  ATOM                  [^\r\n\"\(\):&\ ]+
+  OPEN_PAR              \(
+  CLOSE_PAR             \)
+  QUOTE                 \"
+  OPEN_AS_QUOTE         \#<AS:
+  OPEN_LIST_QUOTE       \#<
+  CLOSE_LIST_QUOTE      >
+  DOT                   \.
+
+
+rule
+                        # lists
+                        {OPEN_AS_QUOTE}   { [:open_as,text] }
+                        {OPEN_LIST_QUOTE}   { [:open_quote,text] }
+                        {CLOSE_LIST_QUOTE}  { [:close_quote,text] }
+                        {DOT}{DOT}{DOT}     { [:continuation] }
+                        # keywords 
+                        {OPEN_PAR}			  { [:open_par,text] }
+                        {CLOSE_PAR}			  { [:close_par,text] }
+                        NIL               { [:nil,text] }
+                        # identifiers 
+                        {SYMBOL}			    { [:symbol,text] }
+                        {CYC_SYMBOL}			{ [:cyc_symbol,text] }
+                        {ATOM}			      { [:atom,text] }
+                        # literals 
+                        {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] }
+  # error fallback 
+                        .|\n              { raise "Illegal character <#{text}>" }
+inner
+  def do_parse
+#    while !(token = next_token).nil?
+#      print " #{token[0]}:#{token[1]}" unless token[0] == :in_string
+#    end
+  end
+end

data/lib/cycr/sexpr.rex.rb

@@ -0,0 +1,136 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.2
+# from lexical definition file "sexpr.rex".
+#++
+
+module Cyc
+class SExpressionLexer
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader :lineno
+  attr_reader :filename
+
+  def scan_setup ; end
+
+  def action &block
+    yield
+  end
+
+  def scan_str( str )
+    scan_evaluate  str
+    do_parse
+  end
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_evaluate  f.read
+    end
+  end
+
+  def scan_file( filename )
+    load_file  filename
+    do_parse
+  end
+
+  def next_token
+    @rex_tokens.shift
+  end
+
+  def scan_evaluate( str )
+    scan_setup
+    @rex_tokens = []
+    @lineno  =  1
+    ss = StringScanner.new(str)
+    state = nil
+    until ss.eos?
+      text = ss.peek(1)
+      @lineno  +=  1  if text == "\n"
+      case state
+      when nil
+        case
+        when (text = ss.scan(/\#<AS:/))
+           @rex_tokens.push action { [:open_as,text] }
+
+        when (text = ss.scan(/\#</))
+           @rex_tokens.push action { [:open_quote,text] }
+
+        when (text = ss.scan(/>/))
+           @rex_tokens.push action { [:close_quote,text] }
+
+        when (text = ss.scan(/\.\.\./))
+           @rex_tokens.push action { [:continuation] }
+
+        when (text = ss.scan(/\(/))
+           @rex_tokens.push action { [:open_par,text] }
+
+        when (text = ss.scan(/\)/))
+           @rex_tokens.push action { [:close_par,text] }
+
+        when (text = ss.scan(/NIL/))
+           @rex_tokens.push action { [:nil,text] }
+
+        when (text = ss.scan(/:[^<>\r\n\"\(\):&\ ]+/))
+           @rex_tokens.push action { [:symbol,text] }
+
+        when (text = ss.scan(/\#\$[a-zA-Z0-9-]+/))
+           @rex_tokens.push action { [:cyc_symbol,text] }
+
+        when (text = ss.scan(/[^\r\n\"\(\):&\ ]+/))
+           @rex_tokens.push action { [:atom,text] }
+
+        when (text = ss.scan(/\"/))
+           @rex_tokens.push action { state = :STRING; @str = ""; [:in_string] }
+
+        when (text = ss.scan(/[\ \t\f\r\n]/))
+          ;
+
+        when (text = ss.scan(/.|\n/))
+           @rex_tokens.push action { raise "Illegal character <#{text}>" }
+
+        else
+          text = ss.string[ss.pos .. -1]
+          raise  ScanError, "can not match: '" + text + "'"
+        end  # if
+
+      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] }
+
+        when (text = ss.scan(/\n/))
+           @rex_tokens.push action { @str << '\n'; [:in_string] }
+
+        when (text = ss.scan(/\r/))
+           @rex_tokens.push action { @str << '\r'; [:in_string] }
+
+        when (text = ss.scan(/\\"/))
+           @rex_tokens.push action { @str << '\"'; [:in_string] }
+
+        when (text = ss.scan(/\\/))
+           @rex_tokens.push action { @str << '\\'; [:in_string] }
+
+        else
+          text = ss.string[ss.pos .. -1]
+          raise  ScanError, "can not match: '" + text + "'"
+        end  # if
+
+      else
+        raise  ScanError, "undefined state: '" + state.to_s + "'"
+      end  # case state
+    end  # until ss
+  end  # def scan_evaluate
+
+  def do_parse
+  end
+end # class
+end # module

data/lib/cycr/words_reader.lisp

@@ -0,0 +1,204 @@
+;(csetq *PATH* "/home/fox/src/nlp/wsd/cyc/~A")
+(csetq *PATH* "/mnt/cyc/export/~A")
+;(csetq *WORDS-PATH* (format nil *PATH* "m_100_en_hasla.txt"))
+(csetq *WORDS-PATH* (format nil *PATH* "all_english.txt"))
+(csetq *WORDS-FILE* "")
+(csetq *WORDS-OUTPUT* "")
+(csetq *WORDS-OUTPUT-PROP* "")
+(csetq *WORDS-MISSING* "")
+
+(define load-code () (load (format nil *PATH* "words_reader.lisp")))
+(define next-word () 
+  (clet (
+	 (word  (read *WORDS-FILE* nil))
+	)
+      (pif (null word) (ret '(("EOF" :eof))) ())
+      (clet (
+	     (denotations (denotation-mapper (format nil "~A" word)))
+	     (correct-denots ())
+	    )
+	(pif (consp denotations)
+	     ()
+	     (princ (format nil "~A~%" word) *WORDS-MISSING*)
+	)
+;	(csetq *PROP-WORD* word)
+	(cdolist (denot denotations) 
+		 (pif (denot-word-p denot word) (cpush denot correct-denots) nil)
+	)
+;	(csetq denotations (mremove-if #'prop-word-p denotations))
+	(ret (reverse correct-denots))
+      )
+  )
+)
+
+(define symbol-str (symbol)
+   (ret (cdr (caar 
+      (cyc-query `(#$prettyString-Canonical ,symbol ?w) #$EnglishMt)
+   )))
+)
+
+; same as above but prettyString (without canonical) is used,
+; so it can return many results
+(define symbol-strs (symbol)
+  (clet ((result ()))
+	(cdolist (el (cyc-query `(#$prettyString ,symbol ?w) #$EnglishMt))
+		 (cpush (cdar el) result))
+	(ret result))
+)
+
+(define print-names (symbols output) 
+   (cdolist (el symbols) 
+	    (princ (format nil "~A" el) output)
+	    (princ (format nil "  ~S" 
+		      (strip-s (symbol-str el) "type of ")) 
+	      output)
+;	    (terpri output)
+   )
+)
+(define min-genls-flat (concept stop-words) 
+  ;(ret (remove-invalid (min-genls concept #$EverythingPSC) stop-words))
+  ;CycNounLearnerMt UniversalVocabularyMt
+  (ret (remove-invalid (min-genls concept #$CycNounLearnerMt) stop-words))
+)
+(define min-isa-flat (concept stop-words) 
+  ;(ret (remove-invalid (min-isa concept #$EverythingPSC) stop-words))
+  (ret (remove-invalid (min-isa concept #$CycNounLearnerMt) stop-words))
+)
+
+(define read-all () 
+  (clet ( 
+	  (stop-words (read-stop))
+	  (output nil)
+	 )
+    (cdo ((words (next-word) (next-word))) 
+       ((equal words '(("EOF" :eof))))
+       (cdolist (word words)
+         (pif (consp word)
+              (progn 
+		(pif (isa? (cdr word) #$Individual) 
+         (csetq output *WORDS-OUTPUT-PROP*)
+         (csetq output *WORDS-OUTPUT*))
+    (princ (format nil "~A[~A]" 
+                   (car word)
+                   (cdr word)
+                   ) 
+           output)
+		(print-names (min-genls-flat (cdr word) stop-words) output)
+		(princ " ISA" output)
+		(print-names (min-isa-flat (cdr word) stop-words) output)
+		(terpri output)
+	      ) 
+	      ()
+	  )
+       )
+    )
+  )
+)
+
+; my implementation of the mapcar function
+(defmacro mmapcar (fun elems) 
+  (clet ((var (gensym)))
+        (ret `(clet ((result nil)) 
+	      (cdolist (,var ,elems) 
+		       (cpush  (funcall ,fun ,var ) result) ) 
+	      (reverse result))
+	 )
+  )
+)
+
+; removes elements from list if the fun returns nil
+(define mremove-if (fun elems)
+  (remove-if #'null (mmapcar fun elems))
+)
+
+;T if denotation's word equals word
+(define denot-word-p (denot word) 
+  (fif (equal (car denot) word) denot nil))
+
+;T if the car of the cons is equal to word 
+(define prop-word-p (el word) 
+  (fif (equal (car (eval el)) word) (eval el) nil))
+
+
+(define open-words ()
+  (csetq *WORDS-FILE* (open-text *WORDS-PATH* :input))
+)
+
+(define open-missing ()
+  (csetq *WORDS-MISSING* (open-text (format nil *PATH* "missing.txt") :output))
+)
+
+(define close-words ()
+  (close *WORDS-FILE*))
+
+
+(define open-output (version) 
+  (csetq *WORDS-OUTPUT* 
+	 (open-text (format nil *PATH* (format nil "pohl_cyc_~A.txt" version)) :output))
+  (csetq *WORDS-OUTPUT-PROP* 
+	 (open-text (format nil *PATH* (format nil "pohl_cyc_prop_~A.txt" version)) :output))
+)
+
+;close output file
+(define close-output () 
+  (close *WORDS-OUTPUT*)
+  (close *WORDS-OUTPUT-PROP*)
+)
+
+;returns the stop-list 
+(define read-stop ()
+  (clet ((stop-file (open-text (format nil *PATH* "stop_list.txt") :input))
+	 (stop-words (read stop-file))
+	 )
+    (close stop-file)
+    (ret stop-words)
+  )
+)
+
+; removes sequence #removed from the beginning of the sequence #sequence 
+ (define strip-s (sequence removed) 
+   (ret(fif (eq 0 (search removed sequence))
+	    (subseq sequence (length removed))
+	    sequence))
+)
+
+;main transforming loop
+(define main-prog (version) 
+    (open-words)
+    (open-output version)
+    (open-missing)
+    (read-all)
+    (close-words)
+    (close-output) 
+    (close *WORDS-MISSING*)
+)
+
+(define  remove-invalid (elements invalid) 
+  (clet ( (result () ) )
+	(cdolist (el elements) 
+		 (pif (null (cor (member el invalid)
+				 (cand (nart-p el) 
+				       (intersection invalid (nart-hl-formula el)) ))) 
+		      (cpush el result) ()) 
+		 )
+	(ret result) 
+  )
+)
+
+(define term-mts (term) 
+  (clet ((result ())) 
+        (cdolist (e (gather-index-in-any-mt term)) 
+                 (csetq result (adjoin (assertion-mt e) result))) 
+        result) 
+)
+
+(define any-assertion? (term mt)
+  (with-mt mt (pif (gather-index term) T ())))
+
+(define nart-denotation-mapper (word) 
+  (clet ((result ())) 
+        (cdolist (el (denotation-mapper word))
+                 (pif (nart-p (cdr el)) 
+                      (cpush (nart-id (cdr el)) result) 
+                      (cpush (cdr el) result))) result
+        (ret result)))

data/lib/cycr.rb

@@ -0,0 +1 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'cycr/**.rb')).each { |f| require f }

data/spec/assertion.rb

@@ -0,0 +1,36 @@
+$:.unshift "lib"
+require 'cycr'
+
+describe Cyc::Assertion do
+  before(:all) do
+    @client = Cyc::Client.new()
+    #@client.debug = true
+  end
+
+  after(:all) do
+    @client.close
+  end
+
+  it "should parse results with assertions" do
+    @client.talk("(gather-predicate-extent-index \#$minimizeExtent \#$BaseKB)").should_not == nil
+  end
+
+  it "should return assertions as results if present in the result" do
+    @client.talk("(gather-predicate-extent-index \#$minimizeExtent \#$BaseKB)").
+      first.class.should == Cyc::Assertion
+  end
+
+  it "should have microtheory assigned" do
+    @client.talk("(gather-predicate-extent-index \#$minimizeExtent \#$BaseKB)").
+      first.microtheory.should_not == nil
+  end
+
+  it "should have formula assigned" do
+    @client.talk("(gather-predicate-extent-index \#$minimizeExtent \#$BaseKB)").
+      first.formula.should_not == nil
+  end
+
+  it "should return many results" do
+    @client.talk("(gather-predicate-extent-index \#$minimizeExtent)").size.should > 100
+  end
+end

data/spec/client.rb

@@ -0,0 +1,39 @@
+require 'lib/cycr'
+
+describe Cyc::Client do
+  before(:each) do  
+    @client = Cyc::Client.new()
+#    @client.debug = true
+  end
+
+  after(:each) do 
+    @client.close
+  end
+
+  it "should allow to talk to the server" do 
+    @client.talk("(constant-count)").should_not == nil
+  end
+
+  it "should allow to talk to server by calling non-existent methods" 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
+      @client.find_collection("Cat")
+    else
+      @client.find_collection("Dog")
+    end
+    if Process.pid == parent_pid
+      Process.waitall
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: cycr
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Aleksander Pohl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-19 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :runtime
+  version_requirements: *id001
+description: Ruby wrapper for (Open)Cyc server and ontology
+email: apohllo@o2.pl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- Rakefile
+- cycr.gemspec
+- lib/cycr.rb
+- lib/cycr/sexpr.rex
+- lib/cycr/parser.rb
+- lib/cycr/domains.lisp
+- lib/cycr/sexpr.flex
+- lib/cycr/nart.rb
+- lib/cycr/constants.rb
+- lib/cycr/collection.rb
+- lib/cycr/sexpr.rex.rb
+- lib/cycr/client.rb
+- lib/cycr/extensions.rb
+- lib/cycr/assertion.rb
+- lib/cycr/words_reader.lisp
+- README.txt
+- spec/client.rb
+- spec/assertion.rb
+has_rdoc: true
+homepage: http://www.opencyc.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby client for the (Open)Cyc server
+test_files: 
+- spec/client.rb
+- spec/assertion.rb