rwdeliza 0.03

data/lib/linkparser/connection.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/ruby
+#
+#	connection.rb - this file contains the class declarations for the
+#	LinkParser::Connection class.
+#
+# == Synopsis
+#
+#
+# == Rcsid
+#
+# $Id: connection.rb,v 1.3 2003/06/08 03:53:27 stillflame Exp $
+#
+# == Authors
+#
+#	Martin Chase <stillflame@FaerieMUD.org>
+#
+#:include: COPYRIGHT
+#
+#---
+#
+# Please see the file COPYRIGHT for licensing details.
+#
+
+class LinkParser
+	class Connection
+		include Comparable
+
+		def initialize( conn1, conn2, lword, rword )
+			raise( ParseError::new( "A connection cannot be formed between two words that do not match: %s and %s" %
+								   [ conn1, conn2 ]) ) unless
+				conn1.match(conn2)
+			@name, @subName = conn1.generalize(conn2)
+			@lword = lword
+			@rword = rword
+			@length = rword.position - lword.position
+		end
+
+		# the major name of the link
+		attr_reader :name
+
+		# the minor name of the link
+		attr_reader :subName
+
+		# the index of the word connected to this link on the left
+		attr_reader :lword
+
+		# the index of the word connected to this link on the right
+		attr_reader :rword
+
+		# the number of words spanned by this connection
+		attr_reader :length
+
+		# Hash on the important part - the name and subname.
+ 		def hash 
+ 			[@name, @subName].hash
+ 		end
+
+		# Provide a consistent basis for sorting connections within a linkage to
+		# allow two linkages to be compared.
+		def <=>(other)
+			pos = self.lword.position <=> other.lword.position
+			return pos if pos.nonzero?
+			len = self.length <=> other.length
+			return len if len.nonzero?
+			return self.to_s <=> other.to_s
+		end
+
+		# Equality based only on the name and subname.
+		def eql?(o)
+			@name == o.name &&
+				@subName == o.subName &&
+				@length == o.length
+		end
+
+		# Stringification delegated to the @general connector.
+		def to_s 
+			@name + @subName
+		end
+
+	end # class Connection
+end # class LinkParser

data/lib/linkparser/connector.rb

@@ -0,0 +1,201 @@
+#~/usr/bin/ruby
+#
+#	connector.rb - this file contains the Connector class.  This describes the
+#	behavior of an un-linked link, as they exist in the Definition of a word.
+#
+# == Synopsis
+#
+#
+# == Rcsid
+#
+# $Id: connector.rb,v 1.5 2003/05/18 19:26:06 stillflame Exp $
+#
+# == Authors
+#
+#	Martin Chase <stillflame@FaerieMUD.org>
+#
+#:include: COPYRIGHT
+#
+#---
+#
+# Please see the file COPYRIGHT for licensing details.
+#
+
+class LinkParser
+	class Connector
+		
+		LEFT = 'l'		# left side
+		RIGHT = 'r'		# right side
+		BOTH = '*'		# both sides
+		n = 1.0/0.0
+		ONCE = 1..1		# matches once
+		OPTIONAL = 0..1	# matches zero or one times
+		PLUS = 1..n		# matches one or more times
+		STAR = 0..n		# matches zero or more times
+		# The names 'star' and 'plus' are taken from regexen.
+		@@connectors = []
+
+		# Creates and returns a connector.  Creation only happens once for each
+		# unique set of arguments.
+		#	name - major name of the connector ('A','AA','P*',&c.)
+		#	subName - minor name of the connector ('s' or 'p*x' from 'MVs' or
+		#		'MVp*x', respectively)
+		#	side - which side the connector accepts from
+		#	multiplicity - the number of connections required to satisfy this
+		#		connector.
+ 		def Connector.new( name, subName='', side=BOTH, multiplicity=ONCE, cost=0 )
+ 			subName = '' unless subName
+			connector = super(name,subName,side,multiplicity,cost)
+			if(already = (@@connectors.find {|c| c.eql? connector}))
+				return already
+			else
+				@@connectors << connector
+				return connector
+			end
+ 		end
+
+		# Initializes a new Connector object.
+		def initialize( name, subName, side, multiplicity, cost )
+			@name = name
+			@subName = subName
+			@side = side
+			@multiplicity = multiplicity
+			@cost = cost
+		end
+
+		# The name of the connector.
+		attr_reader :name
+
+		# The sub name of the connector, if any.
+		attr_reader :subName
+
+		# The linking cost of the connector.
+		attr_reader :cost
+
+		# How many connections it takes to satisfy this connector.
+		attr_reader :multiplicity
+
+		# Whether or not the connector is optional.
+		def optional? 
+			@multiplicity === 0
+		end
+		alias :optional :optional?
+
+		# Whether or not the connector accepts multiple connections.
+		def multiple? 
+			@multiplicity === 2
+		end
+
+		# Which side the connector links to (LEFT, RIGHT or BOTH).
+		attr_reader :side
+
+		# Whether or not the connector links to the LEFT.
+		def left? 
+			@side == LEFT or @side == BOTH
+		end
+
+		# Whether or not the connector links to the RIGHT.
+		def right? 
+			@side == RIGHT or @side == BOTH
+		end
+
+		# Whether or not the connector links to both sides
+		def both? 
+			@side == BOTH
+		end
+
+		# Returns self
+		def dup 
+			self
+		end
+		alias :clone :dup
+
+		# Returns a simple stringy representation
+		def to_s 
+			result = @name + @subName
+			result = "@" + result if self.multiple?
+			result += (@side == LEFT ? "-" : "+") unless @side == BOTH
+			result += "(#{@cost})" if self.cost.nonzero?
+			result = "{" + result + "}" if self.optional?
+			return result
+		end
+		alias :inspect :to_s
+
+		# Checks to see if the two connectors can match.  rules for matching:
+		#	1: a '*' matches any character
+		#	2: a '^' matches only the '*' character
+		#	3: a 'a' matches either a 'a' or a '*' (for any character 'a-Z')
+		#	4: a Connector is considered to be followed by an infinite number of
+		#		'*'s
+		def match(other)
+			return false unless (@side != other.side ||
+								 @side == BOTH)		
+			i = 0
+			while( i <= @name.length && i <= other.name.length )
+				return( false ) unless ( @name[i] == '*'[0] || 
+										other.name[i] == '*'[0] ||
+										( (@name[i] == other.name[i]) &&
+										  (@name[i] != '^'[0]) ) ||
+										(@name[i].nil? || other.name[i].nil?) )
+				i += 1
+			end
+			
+			i = 0
+			while( i <= @subName.length && i <= other.subName.length )
+				return( false ) unless ( @subName[i] == '*'[0] || 
+										other.subName[i] == '*'[0] ||
+										( (@subName[i] == other.subName[i]) &&
+										  (@subName[i] != '^'[0]) ) ||
+										(@subName[i].nil? || other.subName[i].nil? ) )
+				i += 1
+			end
+			
+			return true
+		end
+
+		# Generalizes this connector with the given other connector in a
+		# position-based comparison according to the following rules:
+		#   Names are compared separately from subNames.
+		#	Matching characters: left the same.
+		#	'*' and any character: becomes a '*'.
+		#	'^' matches only the '*' character
+		#	Non-matching characters: turned into a '*'.
+		def generalize(other)
+			name = @name
+			subName = @subName
+			
+			i = 0
+			while( i < name.length && i < other.name.length )
+				name[i] = '*' if name[i] != other.name[i] or
+					name[i,1] == '*' or other.name[i,1] == '*'
+				i += 1
+			end
+			
+			if other.subName.empty?
+				subName = '*' * subName.length
+			elsif subName.empty?
+				subName = '*' * other.subName.length
+			else
+				i = 0
+				while( i < subName.length && i < other.subName.length )
+					subName[i] = '*' unless subName[i] == other.subName[i]
+					i += 1
+				end
+			end
+			
+			return [name,subName]
+		end
+
+		# Tests for equality by value.
+ 		def eql?(other)
+ 			@name == other.name and
+ 				@subName == other.subName and
+ 				@cost == other.cost and
+ 				@multiplicity == other.multiplicity and
+ 				@side == other.side
+ 		end
+		alias :equal? :eql?;
+		alias :== :eql?;
+
+	end # class Connector
+end # module LinkParser

data/lib/linkparser/definition.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/ruby
+#
+#	definition.rb - contains the Definition class, a class the encompasses the
+#	way a word is defined in link grammar: a set of sets of connectors with
+#	sidedness.
+#
+# == Synopsis
+#
+#
+# == Rcsid
+#
+# $Id: definition.rb,v 1.5 2003/05/15 01:51:32 stillflame Exp $
+#
+# == Authors
+#
+#	Martin Chase <stillflame@FaerieMUD.org>
+#
+#:include: COPYRIGHT
+#
+#---
+#
+# Please see the file COPYRIGHT for licensing details.
+#
+
+#require "linkparser/log"
+require "linkparser/utils"
+require "linkparser/connector"
+
+require "strscan"
+require "forwardable"
+
+class LinkParser
+
+	class Definition
+
+		# Constants for definition parsing.
+		Token		= /\s+|@?[A-Z*^]+[a-z^*]*[+-]|\(|\[|\{|\)|\]|\}|[Aa][Nn][Dd]|&|[Oo][Rr]|\|/
+		Connect		= /(@)?([A-Z*^]+[a-z^*]*)([+-])/
+		Conjunction	= /(and)|(&)|(or)|(\|)/i
+		Open		= /\(|\[|\{/
+		Close		= /\)|\]|\}/
+		Space		= /\s+/
+
+		# Takes a definition string and returns a Definition object populated
+		# with the set of sets of connectors that will satisfy that the provided
+		# string.
+		# args:
+		#	definition - the string to be parsed for meaning, or a
+		#		StringScanner on that string, possibly in mid-parse
+		def Definition.satisfy( definition )
+			Definition::new(Definition::re_satisfy(definition))
+		end
+
+		# The main body of satisfy, 
+		def Definition.re_satisfy(definition)
+			definition	= StringScanner.new( definition, false ) unless
+				definition.kind_of?(StringScanner)
+			results = []
+			side = nil
+			current = nil
+			multi = false
+			
+			while definition.rest?
+				case current = definition.scan(Token)
+				when Connect
+					# Connectors - puts the connector alone in a set, and
+					# puts that into the results.
+					connector_m = Connect.match( current )
+					side = connector_m[3] =~ /-/ ? Connector::LEFT : Connector::RIGHT
+					multi = connector_m[1] ? Connector::PLUS : Connector::ONCE
+					name_scan = StringScanner::new(connector_m[2])
+					# Slurp in all the characters up to the last capitol
+					# letter and up to one star or caret.
+					name = name_scan.scan(/.*[A-Z][*^]?/)
+					sub_name = name_scan.rest or ''
+#					Log.debug( "Found connector '%s'" % current )
+					results << [ Connector::new(name, sub_name, side, multi) ]
+				when Conjunction
+					# Conjunctions (and, or) - combine the results so far with the
+					# results of what would be the rest of the parse, as per the
+					# rules of the conjunction used.
+					conj_m = Conjunction.match( current )
+					raise ParseError, "conjunction with nothing preceeding it: '#{definition.string}'" if
+						results.empty?
+					if conj_m[1] or conj_m[2]
+						# and, & - the new results will be every combination of the
+						# previous results and the results of the rest of the parse.
+						rest = re_satisfy(definition)
+						raise ParseError, "conjunction with nothing following: '#{definition.string}'" if
+							rest.empty?
+						results.combine!(rest)
+					else
+						# or, | - the new results will be the union of the previous
+						# results and the results of the rest of the parse.
+						rest = re_satisfy(definition)
+						raise ParseError, "conjunction with nothing following: '#{definition.string}'" if
+							rest.empty?
+						results.add!(rest)
+					end
+					return results
+				when Open
+					# Open parens - treated the same as a single connector, but
+					# concerning the entire contents of the parens.
+					if current =~ /\[/
+						re_satisfy( definition ).each {|set| 
+							set.map! {|conn|
+								Connector.new(conn.name,conn.subName,conn.side,conn.multiplicity,conn.cost+1)
+							}
+							results << set
+						}
+					elsif current =~ /\{/
+						re_satisfy( definition ).each {|set|
+							set.map! {|conn|
+								if conn.multiplicity == Connector::ONCE
+									Connector.new(conn.name,conn.subName,conn.side,Connector::OPTIONAL,conn.cost)
+								elsif conn.multiplicity == Connector::PLUS
+									Connector.new(conn.name,conn.subName,conn.side,Connector::STAR,conn.cost)
+								else
+									conn
+								end
+							}
+							results << set
+						}
+					else
+						results.add!(re_satisfy( definition ))
+					end
+					raise ParseError, "improper parentheses usage: '#{definition.string}'" if
+						results.empty?
+				when Close
+					# Close parens - if this is found, the method returns, checking
+					# for the null-connector condition first.
+					return results.empty? ? [ [Connector::new("*")] ] : results
+				when Space
+					# Spaces - are ignored
+				when nil
+					# Nil - means the parse has encountered something not matching
+					# the Token regex.
+					raise ParseError, "Definition unparsable before end of definition: '#{definition.rest}'"
+				end
+			end
+			
+			return results
+		end
+
+		extend Forwardable
+
+		# The single argument may be either a String or an Array.  If the
+		# argument is a string, it is treated as a definition string, and won't
+		# be parsed until needed.  If it is an array, no reverse engineering
+		# will be done to create the corresponding definition string.
+		def initialize( an_arg )
+			if an_arg.kind_of? String
+				@raw = an_arg
+				@connector_sets = []
+			else
+				@raw = nil
+				@connector_sets = an_arg
+			end
+		end
+
+		# The raw string from which this definition is derived.
+		attr_reader :raw
+
+		# The sets of sets of connectors that is the algorithmicly useful version
+		# of this object.
+		def connector_sets 
+			if @connector_sets and @connector_sets.empty?
+				@connector_sets = Definition::re_satisfy(@raw)
+			else
+				@connector_sets
+			end
+		end
+		alias :connectorSets :connector_sets
+
+		# Delegate all calls of array-like methods to the connector sets.
+		def_delegators :connector_sets, *(Array.instance_methods(false) - %w{to_s inspect ==})
+
+		# The most sensible stringification of this definition.
+		def to_s 
+			@raw ? @raw : self.to_connectors
+		end
+
+		# Stringification of the connector sets.
+		def to_connectors 
+			self.connector_sets.inspect
+		end
+		alias :two_s :to_connectors
+
+		# Stringification with a 'sensible' opposite of the one for to_s.
+		def inspect 
+			(@connector_sets && @connector_sets.empty?) ? @raw : @connector_sets.inspect
+		end
+
+		# tests for equality
+		def ==(other)
+ 			return(false) unless
+ 				other.kind_of?(self.class)
+ 			return(@raw == other.raw) if
+ 				(@raw && other.raw) and (@raw == other.raw)
+			return self.connector_sets.set_of_sets_equal?(other.connector_sets)
+		end
+		alias :=== :==;
+		alias :eql? :==;
+
+		# Returns those connector_sets which include a connector which matches the
+		# provided connector.
+		def sets_matching(connector)
+			self.find_all {|set|
+				set.find {|c|
+					c.match(connector)
+				}
+			}
+		end
+
+		# Returns whether or not there exists a matching connector to a given connector.
+		def includes_match?(connector)
+			self.find {|set|
+				set.find {|c|
+					c.match(connector)
+				}
+			}
+		end
+
+	end # class Definition
+end # module LinkParser