rwdeliza 0.03

data/lib/linkparser/dictionary.rb

@@ -0,0 +1,208 @@
+#!/usr/bin/ruby
+#
+#	dictionary.rb - this file contains the Dictionary class of the
+#	Ruby-LinkParser system.  This governs the parsing of the dictionary files
+#	into their respective data structures.
+#
+# == Synopsis
+#
+#   require "linkparser/dictionary"
+#   
+#   dict_opts = Hash::new('')
+#   dict_opts[dict] = "tiny.dict"
+#   dict_opts[affix] = "4.0.affix"
+#   dict_opts[datadir] = "/usr/local/share/linkparser"
+#   dict = LinkParser::Dictionary::new(dict_opts)
+#	puts dict['word'].to_connectors
+#
+# == Rcsid
+#
+# $Id: dictionary.rb,v 1.16 2003/08/28 04:49:34 stillflame Exp $
+#
+# == Authors
+#
+#	Martin Chase <stillflame@FaerieMUD.org>
+#
+#:include: COPYRIGHT
+#
+#---
+#
+# Please see the file COPYRIGHT for licensing details.
+#
+
+require "forwardable"
+require "rbconfig"
+#require "linkparser/log"
+require "linkparser/utils"
+require "linkparser/definition"
+
+class LinkParser
+    
+    class Dictionary
+
+		DefaultDataDir = Config::CONFIG['datadir']
+
+		# Lots of constants for the handling of the different dictionary files.
+		Dict = 1
+		Affix = 2
+		Post = 3
+		Constituent = 4
+		DefaultDict = "4.0.dict"
+		DefaultAffix = "4.0.affix"
+		DefaultPost = "4.0.knowledge"
+		DefaultConstituent = "4.0.constituent-knowledge"
+
+		class << self
+
+			# This parses a dictionary string/file for its words and their
+			# definitions, returning a hash keyed by word with values being
+			# LinkParser::Definition objects.
+			def read_dict( dict, datadir = DefaultDataDir )
+				wordHash = {} # Hash#[] is faster than BinarySearchTree#[]
+				macros = [] # Array#each is faster than Hash#each
+				
+				# read the dictionary file into an array of words:definition
+				# "statements", excluding comments.
+				statements = dict.gsub(/\n+|\s*%(?!\").*?\n/, " ").split(/\s*;(?!\")\s*/).compact
+				return nil if statements.empty?
+				statements.each {|statement|
+					words, definition = statement.split(/\s*:(?!\")\s*/)
+					macros.each {|macro|
+						definition.gsub!(macro[0], macro[1])
+					}
+					if(words =~ /<.*>/)
+						words.strip!
+						macros << [Regexp::new(words), definition]
+					elsif(!words or !definition)
+					$stderr.print "dict error #{statement}"
+					
+					#	raise ParseError, "Dictionary outta whack: '#{statement}'"
+					else
+						if words =~ /^\// #/
+							# then it's a filename, not a word, and the file will
+							# contain a list of words.
+			#				Log.info("Reading in words from %s." % datadir + words)
+        $stderr.print "Reading in words \n"				
+        words = File.open(datadir + words) {|f| f.read(f.stat.size)}
+						end
+						# so now we have a bunch of words and their shared
+						# definition.  put each word into the hash with a value of
+						# the definition data structure.
+						words.gsub!(/"([^ ]+?)"/, '\1') # punctuation marks are in double-quotes
+						words = words.split(/\s+/)
+						definition = Definition::new(definition)
+						words.each {|word|
+							wordHash[word] = definition unless word.empty?
+						}
+					end
+				}
+				return wordHash
+			end
+
+			# This takes a filename of a dictionary, and reads it into the
+			# word-keyed hash.
+			def open_read_dict( dicttype, dictname, datadir = DefaultDataDir )
+				if dictname and dictname.empty?
+					# do nothing
+					return nil
+				else
+					if dictname
+						f = File.open( File.join(datadir, dictname) )
+					else
+						default = case dicttype
+								  when Dict
+									  DefaultDict
+								  when Affix
+									  DefaultAffix
+								  when Post
+									  DefaultPost
+								  when Constituent
+									  DefaultConstituent
+								  end
+						f = File.open( File.join(datadir, default) )
+					end
+					return read_dict(f.read(f.stat.size), datadir)
+				end
+			end
+
+		end # class << self
+
+		extend Forwardable
+
+		# Initializes a new Dictionary object.  takes a hash as its argument.
+		# entries:
+		#	datadir - the directory where the dictionary files are located
+		#	dict - the main dictionary file
+		#	affix - the affix dictionary file
+		#	knowledge - the post-processing dictionary file
+		#	constituent-knowledge - the constituent knowledge dictionary file
+		#
+		# setting a value to an empty string prevents it from being used, which
+		# will work out fine for all but the datadir and the main dict.  a value
+		# set to nil will mean to use the default setting.
+		def initialize( dict_opts )
+			@datadir = dict_opts['datadir'] || DefaultDataDir
+			
+			@dict =			Dictionary::open_read_dict( Dict,
+											dict_opts['dict'], @datadir )
+			@affix =		Dictionary::open_read_dict( Affix,
+											dict_opts['affix'], @datadir )
+			@post =			Dictionary::open_read_dict( Post,
+											dict_opts['knowledge'], @datadir )
+			@constituent =	Dictionary::open_read_dict( Constituent,
+											dict_opts['constituent-knowledge'], @datadir )
+		end
+
+		# the directory that the dictionary files are located
+		attr_reader :datadir
+
+		# the main dictionary hash
+		attr_reader :dict
+
+		def_delegators :@dict, *(Hash.instance_methods(false))
+
+		# does affix processing on the words, which is just separating
+		# conjunctions and punctuation from the words they are next to.
+		def affix( words )
+			return words unless @affix
+			@affix.each {|punct,move|
+				words = words.inject([]) {|arr,ele|
+					if /RPUNC/.match(move.inspect) && /(.*)(#{Regexp.escape(punct)}.*)$/.match(ele)
+						arr << $1 << $2
+					elsif /LPUNC/.match(move.inspect) && /^(#{Regexp.escape(punct)})(.*)/.match(ele)
+						arr << $1 << $2
+					else
+						arr << ele
+					end
+				}
+			}
+			words
+		end
+
+		# the post-processing dictionary hash
+		attr_reader :post
+
+		# the constituent-knowledge dictionary hash
+		attr_reader :constituent
+		
+    end # class Dictionary
+end # module LinkParser
+
+if $0 == __FILE__
+    #	require 'profile'
+    
+    # p LinkParser::Dictionary::read_dict("/home/stillflame/src/system-4.1/link-4.1/data/tiny.dict")["dog"]
+    
+    s = <<-DICT
+    <macro>:(A- and {Bb+ or @C+});
+    <meow>:(Aa- & E+);
+	bar:(A- or A-) and A-;
+	foo:( ((A- and E-) and {Bb+ or (@C+ and De-)});% and (E+) );
+	word: %comment - miaow
+  	(<meow>) | (<macro> & [@Dd- or De-]);
+	meow:(A+ and {B- or C-});
+	boo:[[[()]]];
+	am:((Sp- or (RS- & Bp-) or ({Q-} & SIp+)) & (((O+ or B-) & {@MV+}) or P+ or AF-));
+	DICT
+	LinkParser::Dictionary::read_dict(s).each {|k,v| puts "#{k} = #{(v).to_connectors}"}
+end

data/lib/linkparser/linkage.rb

@@ -0,0 +1,185 @@
+#!/usr/bin/ruby
+#
+#	linkage.rb - this file contains the class declarations for the
+#	LinkParser::Linkage class.
+#
+# == Synopsis
+#
+#
+# == Rcsid
+#
+# $Id: linkage.rb,v 1.12 2003/08/10 21:56:40 stillflame Exp $
+#
+# == Authors
+#
+#	Martin Chase <stillflame@FaerieMUD.org>
+#
+#:include: COPYRIGHT
+#
+#---
+#
+# Please see the file COPYRIGHT for licensing details.
+#
+
+require "linkparser/word"
+require "linkparser/connection"
+#require "linkparser/log"
+
+class LinkParser
+
+	class Linkage
+
+		def initialize( words=[], connections=[] )
+			@connections = connections
+			@words = words
+		end
+
+		# the connections of this linkage
+		attr_reader :connections
+
+		# the words in this linkage
+		attr_reader :words
+
+		# Combine two linkages together.
+		def combine(other)
+			Linkage::new( @words.superimpose(other.words),
+						  @connections + other.connections )
+		end
+		alias :+ :combine
+
+		# add new connections to the list of connections
+		def add_connections(*connections)
+			@connections += connections
+			self
+		end
+		alias :addConnections :add_connections
+
+		### Inserts into this linkage the connection and words found in the
+		### supplied arguments.
+		def insert(connection, left, right, left_word, right_word)
+			@connections << connection
+			if @words[left]
+				@words[left].combine!(left_word)
+			else
+				@words[left] = left_word
+			end
+			if @words[right]
+				@words[right].combine!(right_word)
+			else
+				@words[right] = right_word
+			end
+			self
+		end
+
+		# returns whether or not the linkage is valid
+		def valid? 
+			(@connections.length + 1) >= @words.length
+		end
+
+		# returns whether the linkage is connected
+		def connected? 
+			@words.length == @words.compact.length
+		end
+
+		# Hash on the only important part - the connections.
+		def hash 
+			@connections.sort.hash
+		end
+
+		# Equality based only on the "important" parts.
+		def eql?(o)
+			@connections.sort.eql?(o.connections.sort)
+		end
+
+		# string display
+		def inspect
+			result = @words.collect {|word| word.to_s}.join(" ") +
+				" --- " + @connections.join(" ")
+			#:TODO: ?
+		end
+
+		# pretty string display
+		def to_s
+			rows = [] # the diagram
+			rows.unshift(@words.join(' ').split('')) # insert the words
+			pos = 0
+			starts = @words.map {|word| # the starting position of each word
+				start = pos
+				pos += word.to_s.length + 1
+				start
+			}
+			offsets = @words.map {|word| word.to_s.length / 2}
+			centers = (starts.zip(offsets)).map {|c| c[0]+c[1]} # where to attach connections to each word
+			pos = 0
+			spaces = [] # where there are spaces between words
+			@words.each {|word|
+				spaces << ((pos - 1)..(pos - 1)) if pos.nonzero?
+				pos += word.to_s.length + 1
+			}
+			rows.unshift(Array.new(rows[0].length, " "))
+			centers.each {|i| rows[0][i] = "|"}
+			conns = @connections.dup
+			until conns.empty?
+				row = Array.new(rows[0].length, " ")
+				these = []
+				conns.delete_if {|conn| conn.length == (rows.length - 1) and these << conn}
+				#:TODO: loops infinitely - need to use counter instead of rows.length
+				#next if these.empty?
+				these.each {|conn|
+					first = centers[conn.lword.position]
+					last = centers[conn.rword.position]
+					span = (first..last)
+					dist = span.to_a.length
+					disp = "+" + conn.to_s + "+" # minimum display string
+					if disp.length > dist
+						#:TODO: *ack*
+						# i will need to expand the spaces inbetween the words,
+						# as well as between the connection arcs, and then
+						# update the centers and spaces array.  this could be
+						# done one space at a time, cycling through the possible
+						# word gaps.
+						space_affect = (spaces.index(spaces.find {|r| first <= r.first}))..(spaces.length - 1)
+						cent_affect = (centers.index(centers.find {|i| first <= i}))..(centers.length - 1)
+						until dist >= disp.length
+							#:?:
+							dist += 1
+# 							centers.map! {|i|
+# 								cent_affect.member?(centers.index(i)) ? i + 1 : i
+# 							}
+# 							first = centers[conn.lword.position]
+# 							last = centers[conn.rword.position]
+# 							span = (first..last)
+# 							dist = span.to_a.length
+						end
+					elsif disp.length < dist
+						side = true
+						until disp.length >= dist
+							if side
+								disp[0] = "+-"
+							else
+								disp[-1] = "-+"
+							end
+							side = ! side
+						end
+					end
+					first.upto(last) do |i|
+						row[i] = disp.slice!(0).chr
+					end
+				}
+				centers.each_with_index {|i,w|
+					row[i] = "|" if row[i] == " " and
+						conns.find {|conn| [conn.rword, conn.lword].include?(@words[w])}
+				}
+				rows.unshift(row)
+			end
+			return (rows.map {|row| row.join('')}).join("\n")
+		end
+
+		# string conversion
+		def to_str 
+			@words.join(' ')
+		end
+
+	end # class Linkage
+
+end # class LinkParser

data/lib/linkparser/log.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby
+#
+# log - Sets up the logger by which the linkparser system can log itself.
+#
+# == Synopsis
+#
+#
+#
+# == Description
+#
+#
+# == Author
+#
+#	Martin Chase <stillflame@FaerieMUD.org>
+#
+# == Copyright
+#
+# Copyright (c) 2002, 2003 The FaerieMUD Consortium. All rights reserved.
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the terms of the Perl Artistic License. (See
+# http://language.perl.com/misc/Artistic.html)
+
+require "log4r"
+
+class LinkParser
+	
+	include Log4r
+
+	Log = Logger::new( "LinkParser" )
+	Outputter.stderr.formatter =
+		PatternFormatter::new( :pattern => '\e[1;32m[%l] %C:\e[0m %.1024m' )
+	Log.outputters = Outputter.stderr
+	if $DEBUG
+		Log.level = Log4r::ALL
+	else
+		Log.level = Log4r::INFO
+	end
+end

data/lib/linkparser/sentence.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/ruby
+#
+#	sentence.rb - this file contains the class definition for the
+#	LinkParser::Sentence class.
+#
+
+require "forwardable"
+
+class LinkParser
+
+	class Sentence
+		
+		extend Forwardable
+
+		# initializes a new Sentence object
+		def initialize 
+			@definitions = []
+			@linkages = []
+			@names = []
+		end
+
+		# the definitions in this sentence
+		attr_accessor :definitions
+
+		# the linkages of this sentence
+		attr_accessor :linkages
+
+		# the words in this sentence
+		attr_accessor :names
+
+		def_delegators :@definitions, *(Array.instance_methods(false))
+
+		def to_str 
+			@names.join(" ")
+		end
+
+		def sentence? 
+			! @linkages.empty?
+		end
+
+		def verb 
+			return nil if @linkages.empty?
+			@linkages.find {|linkage|
+				vrb = linkage.connections.find {|conn|
+					conn.name.match(/^S/)
+				}
+				return vrb.rword if vrb
+				vrb = linkage.connections.find {|conn|
+					conn.name.match(/^O/)
+				}
+				return vrb.lword if vrb
+			}
+			return nil
+		end
+
+		def subject 
+			return nil if @linkages.empty?
+			@linkages.find {|linkage|
+				subj = linkage.connections.find {|conn|
+					conn.name.match(/^S/)
+				}
+				return subj.lword if subj
+			}
+			return nil
+		end
+
+		def object 
+			return nil if @linkages.empty?
+			@linkages.find {|linkage|
+				obj = linkage.connections.find {|conn|
+					conn.name.match(/^O/)
+				}
+				return obj.rword if obj
+			}
+			return nil
+		end
+
+	end # class Sentence
+end # class LinkParser