linguistics 1.0.9 → 2.0.0

data/lib/linguistics/en/stemmer.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require 'linguistics' unless defined?( Linguistics )
+require 'linguistics/en' unless defined?( Linguistics::EN )
+
+# Ruby-Stemmer support for the English-language Linguistics module. It
+# requires the Ruby-Stemmer gem to be installed; if it is not
+# installed, calling the functions defined by this file will raise
+# NotImplementedErrors.
+#
+#   # Test to be sure the Stemmer gem loaded okay.
+#   Linguistics::EN.has_stemmer?
+#   # => true
+#
+module Linguistics::EN::Stemmer
+
+	# Module instance variables -- copied over to the EN module when registered
+	@has_stemmer   = false
+	@stemmer_error = nil
+	@stemmer       = nil
+
+	# Load Ruby-Stemmer if possible, saving the error that occurs if anything goes wrong.
+	begin
+		require 'lingua/stemmer'
+		@has_stemmer = true
+	rescue LoadError => err
+		@stemmer_error = err
+	end
+
+
+	# Container for methods intended to extend the EN module as singleton methods.
+	module SingletonMethods
+
+		### Returns +true+ if Ruby-Stemmer was loaded okay
+		def has_stemmer? ; @has_stemmer; end
+
+		### If #has_stemmer? returns +false+, this can be called to fetch the
+		### exception which was raised when Ruby-Stemmer was loaded.
+		def stemmer_error ; @stemmer_error; end
+
+	end # module SingletonMethods
+	extend SingletonMethods
+
+
+	# Register this module to the list of modules to include
+	Linguistics::EN.register_extension( self )
+
+	#################################################################
+	###	M O D U L E   M E T H O D S
+	#################################################################
+
+	### The instance of the Lingua::Stemmer used for all Linguistics Stemmer
+	### functions.
+	def self::stemmer
+		raise self.stemmer_error unless self.has_stemmer?
+		@stemmer ||= Lingua::Stemmer.new
+	end
+
+
+	#################################################################
+	###	S T E M M E R   I N T E R F A C E
+	#################################################################
+
+	######
+	public
+	######
+
+
+	### Return the stem of the receiving word.
+	def stem
+		return Linguistics::EN::Stemmer.stemmer.stem( self.obj.to_s )
+	end
+
+end # module Linguistics::EN::Stemmer
+

data/lib/linguistics/en/titlecase.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/ruby
+
+require 'linguistics/en' unless defined?( Linguistics::EN )
+
+# Methods for capitalizing a sentence as a title, nouns as proper
+# nouns, and for turning a sentence into its equivalent CamelCaseSentence
+# and vice-versa. It's part of the English-language Linguistics module.
+module Linguistics::EN::TitleCase
+
+	# Register this module to the list of modules to include
+	Linguistics::EN.register_extension( self )
+
+
+	# Exceptions: Indefinite articles
+	ARTICLES = %w[a and the]
+
+	# Exceptions: Prepositions shorter than five letters
+	SHORT_PREPOSITIONS = ["amid", "at", "but", "by", "down", "for", "from", "in",
+		"into", "like", "near", "of", "off", "on", "onto", "out", "over",
+		"past", "save", "with", "till", "to", "unto", "up", "upon", "with"]
+
+	# Exceptions: Coordinating conjunctions
+	COORD_CONJUNCTIONS = %w[and but as]
+
+	# Titlecase exceptions: "In titles, capitalize the first word, the
+	# last word, and all words in between except articles (a, an, and
+	# the), prepositions under five letters (in, of, to), and coordinating
+	# conjunctions (and, but). These rules apply to titles of long, short,
+	# and partial works as well as your own papers" (Anson, Schwegler,
+	# and Muth. The Longman Writer's Companion 240).
+	TITLE_CASE_EXCEPTIONS = ARTICLES | SHORT_PREPOSITIONS | COORD_CONJUNCTIONS
+
+	# The words which don't get capitalized in a compound proper noun
+	PROPER_NOUN_EXCEPTIONS = %w{and the of}
+
+
+
+	### Turns a camel-case +string+ ("camelCaseToEnglish") to plain English
+	### ("camel case to english"). Each word is decapitalized.
+	def un_camel_case
+		self.to_s.
+			gsub( /([A-Z])([A-Z])/ ) { "#$1 #$2" }.
+			gsub( /([a-z])([A-Z])/ ) { "#$1 #$2" }.downcase
+	end
+
+
+	### Turns an English language +string+ into a CamelCase word.
+	def to_camel_case
+		self.to_s.gsub( /\s+([a-z])/i ) { $1.upcase }
+	end
+
+
+	### Returns the inflected object as a title-cased String.
+	###
+	### Some examples:
+	###
+	###   "a portrait of the artist as a young man".en.titlecase
+	###   # => "A Portrait of the Artist as a Young Man"
+	###
+	###   "a seven-sided romance".en.titlecase
+	###   # => "A Seven-Sided Romance"
+	###
+	###   "the curious incident of the dog in the night-time".en.titlecase
+	###   # => "The Curious Incident of the Dog in the Night-Time"
+	###
+	###   "the rats of n.i.m.h.".en.titlecase
+	###   # => "The Rats of N.I.M.H."
+	def titlecase
+
+		# Split on word-boundaries
+		words = self.to_s.split( /\b/ )
+
+		# Always capitalize the first and last words
+		words.first.capitalize!
+		words.last.capitalize!
+
+		# Now scan the rest of the tokens, skipping non-words and capitalization
+		# exceptions.
+		words.each_with_index do |word, i|
+
+			# Non-words
+			next unless /^\w+$/.match( word )
+
+			# Skip exception-words
+			next if TITLE_CASE_EXCEPTIONS.include?( word )
+
+			# Skip second parts of contractions
+			next if words[i - 1] == "'" && /\w/.match( words[i - 2] )
+
+			# Have to do it this way instead of capitalize! because that method
+			# also downcases all other letters.
+			word.gsub!( /^(\w)(.*)/ ) { $1.upcase + $2 }
+		end
+
+		return words.join
+	end
+
+
+	### Returns the proper noun form of the inflected object by capitalizing most of the
+	### words.
+	###
+	### Some examples:
+	###
+	###   "bosnia and herzegovina".en.proper_noun
+	###   # => "Bosnia and Herzegovina"
+	###   "macedonia, the former yugoslav republic of".en.proper_noun
+	###   # => "Macedonia, the Former Yugoslav Republic of"
+	###   "virgin islands, u.s.".en.proper_noun
+	###   # => "Virgin Islands, U.S."
+	def proper_noun
+		return self.to_s.split(/([ .]+)/).collect do |word|
+			next word unless
+				/^[a-z]/.match( word ) &&
+				! (PROPER_NOUN_EXCEPTIONS.include?( word ))
+			word.capitalize
+		end.join
+	end
+
+
+end # module Linguistics::EN::TitleCase
+

data/lib/linguistics/en/wordnet.rb

@@ -1,61 +1,58 @@
 #!/usr/bin/ruby
 
-require 'linguistics/en'
+require 'linguistics/en' unless defined?( Linguistics::EN )
 
-# This file contains functions for finding relations for English words. It
-# requires the Ruby-WordNet module to be installed; if it is not installed,
-# calling the functions defined by this file will raise NotImplemented
-# exceptions if called. Requiring this file adds functions and constants to the
-# Linguistics::EN module.
-#
-# == Synopsis
+# WordNet support for the English-language Linguistics module. It
+# requires the Ruby-WordNet module to be installed; if it is not
+# installed, calling the functions defined by this file will raise
+# NotImplementedErrors.
 #
 #   # Test to be sure the WordNet module loaded okay.
 #   Linguistics::EN.has_wordnet?
 #   # => true
-#  
+#
 #   # Fetch the default synset for the word "balance"
-#   "balance".synset
+#   "balance".en.synset
 #   # => #<WordNet::Synset:0x40376844 balance (noun): "a state of equilibrium"
 #    (derivations: 3, antonyms: 1, hypernyms: 1, hyponyms: 3)>
-#  
+#
 #   # Fetch the synset for the first verb sense of "balance"
 #   "balance".en.synset( :verb )
 #   # => #<WordNet::Synset:0x4033f448 balance, equilibrate, equilibrize, equilibrise
 #   (verb): "bring into balance or equilibrium; "She has to balance work and her
 #   domestic duties"; "balance the two weights"" (derivations: 7, antonyms: 1,
 #   verbGroups: 2, hypernyms: 1, hyponyms: 5)>
-#  
+#
 #   # Fetch the second noun sense
 #   "balance".en.synset( 2, :noun )
 #   # => #<WordNet::Synset:0x404ebb24 balance (noun): "a scale for weighing; depends
 #   on pull of gravity" (hypernyms: 1, hyponyms: 5)>
-#  
+#
 #   # Fetch the second noun sense's hypernyms (more-general words, like a superclass)
 #   "balance".en.synset( 2, :noun ).hypernyms
 #   # => [#<WordNet::Synset:0x404e5620 scale, weighing machine (noun): "a measuring
 #   instrument for weighing; shows amount of mass" (derivations: 2, hypernyms: 1,
 #   hyponyms: 2)>]
-#  
+#
 #   # A simpler way of doing the same thing:
 #   "balance".en.hypernyms( 2, :noun )
 #   # => [#<WordNet::Synset:0x404e5620 scale, weighing machine (noun): "a measuring
 #   instrument for weighing; shows amount of mass" (derivations: 2, hypernyms: 1,
 #   hyponyms: 2)>]
-#  
+#
 #   # Fetch the first hypernym's hypernyms
 #   "balance".en.synset( 2, :noun ).hypernyms.first.hypernyms
 #   # => [#<WordNet::Synset:0x404c60b8 measuring instrument, measuring system,
 #   measuring device (noun): "instrument that shows the extent or amount or quantity
 #   or degree of something" (hypernyms: 1, hyponyms: 83)>]
-#  
+#
 #   # Find the synset to which both the second noun sense of "balance" and the
 #   # default sense of "shovel" belong.
 #   ("balance".en.synset( 2, :noun ) | "shovel".en.synset)
 #   # => #<WordNet::Synset:0x40473da4 instrumentality, instrumentation (noun): "an
 #   artifact (or system of artifacts) that is instrumental in accomplishing some
 #   end" (derivations: 1, hypernyms: 1, hyponyms: 13)>
-#  
+#
 #   # Fetch just the words for the other kinds of "instruments"
 #   "instrument".en.hyponyms.collect {|synset| synset.words}.flatten
 #   # => ["analyzer", "analyser", "cautery", "cauterant", "drafting instrument",
@@ -65,25 +62,13 @@ require 'linguistics/en'
 #   instrument", "sonograph", "surveying instrument", "surveyor's instrument",
 #   "tracer", "weapon", "arm", "weapon system", "whip"]
 # 
-# 
-# == Authors
-# 
-# * Michael Granger <ged@FaerieMUD.org>
-# 
-# :include: LICENSE
-# 
-# == Version
-#
-#  $Id: wordnet.rb,v 2640c845eb5c 2009/11/17 16:59:25 ged $
-# 
-module Linguistics::EN
+module Linguistics::EN::WordNet
 
-	@has_wordnet	= false
-	@wn_error		= nil
-	@wn_lexicon		= nil
+	@has_wordnet  = false
+	@wn_error     = nil
+	@lexicon      = nil
 
-	# Load WordNet and open the lexicon if possible, saving the error that
-	# occurs if anything goes wrong.
+	# Load WordNet if possible, saving the error that occurs if anything goes wrong.
 	begin
 		require 'wordnet'
 		@has_wordnet = true
@@ -92,44 +77,48 @@ module Linguistics::EN
 	end
 
 
-	#################################################################
-	###	M O D U L E   M E T H O D S
-	#################################################################
-	class << self
+	# Container for methods intended to extend the EN module as singleton methods.
+	module SingletonMethods
 
 		### Returns +true+ if WordNet was loaded okay
 		def has_wordnet? ; @has_wordnet; end
 
-		### If #haveWordnet? returns +false+, this can be called to fetch the
+		### If #has_wordnet? returns +false+, this can be called to fetch the
 		### exception which was raised when WordNet was loaded.
-		def wn_error ; @wn_error; end
-
-		### The instance of the WordNet::Lexicon used for all Linguistics WordNet
-		### functions.
-		def wn_lexicon
-			if @wn_error
-				raise NotImplementedError,
-					"WordNet functions are not loaded: %s" %
-					@wn_error.message
-			end
-
-			@wn_lexicon ||= WordNet::Lexicon::new
-		end
+		def wordnet_error ; @wn_error; end
+
+	end # module SingletonMethods
+	extend SingletonMethods
 
-		### Make a function that calls the method +meth+ on the synset of an input
-		### word.
-		def def_synset_function( meth )
-			(class << self; self; end).instance_eval do
-				define_method( meth ) {|*args|
-					word, pos, sense = *args
-					raise ArgumentError,
-						"wrong number of arguments (0 for 1)" unless word
-					sense ||= 1
-
-					syn = synset( word.to_s, pos, sense )
-					return syn.nil? ? nil : syn.send( meth )
-				}
-			end
+
+	# Register this module to the list of modules to include
+	Linguistics::EN.register_extension( self )
+
+
+	#################################################################
+	###	M O D U L E   M E T H O D S
+	#################################################################
+
+	### The instance of the WordNet::Lexicon used for all Linguistics WordNet
+	### functions.
+	def self::lexicon
+		raise self.wordnet_error unless self.has_wordnet?
+		@lexicon ||= WordNet::Lexicon::new
+	end
+
+
+	### Set the WordNet::Lexicon used by the linguistic functions.
+	def self::lexicon=( newlex )
+		@lexicon = newlex
+	end
+
+
+	### Make a function that calls the method +meth+ on the synset of an input
+	### word.
+	def self::def_synset_function( name )
+		define_method( name ) do |*criteria|
+			syn = self.synset( *criteria ) or return nil
+			return syn.send( name )
 		end
 	end
 
@@ -139,50 +128,27 @@ module Linguistics::EN
 	###	W O R D N E T   I N T E R F A C E
 	#################################################################
 
-	###############
-	module_function
-	###############
+	######
+	public
+	######
 
 	### Look up the synset associated with the given word or collocation in the
 	### WordNet lexicon and return a WordNet::Synset object.
-	def synset( word, pos=nil, sense=1 )
-		lex = Linguistics::EN::wn_lexicon
-		if pos.is_a?( Fixnum )
-			sense = pos
-			pos = nil
-		end
-		postries = pos ? [pos] : [:noun, :verb, :adjective, :adverb, :other]
-		syn = nil
-
-		postries.each do |pos|
-			break if syn = lex.lookup_synsets( word.to_s, pos, sense )
-		end
-
-		return syn
+	def synset( *args )
+		return Linguistics::EN::WordNet.lexicon[ self.to_s, *args ]
 	end
 
 
 	### Look up all the synsets associated with the given word or collocation in
 	### the WordNet lexicon and return an Array of WordNet::Synset objects. If
 	### +pos+ is +nil+, return synsets for all parts of speech.
-	def synsets( word, pos=nil )
-		lex = Linguistics::EN::wn_lexicon
-		postries = pos ? [pos] : [:noun, :verb, :adjective, :adverb, :other]
-		syns = []
-
-		postries.each {|pos|
-			syns << lex.lookup_synsets( word.to_s, pos )
-		}
-
-		return syns.flatten.compact
+	def synsets( *args )
+		return Linguistics::EN::WordNet.lexicon.lookup_synsets( self.to_s, *args )
 	end
 
 
 	# Returns definitions and/or example sentences as a String.
-	def_synset_function :gloss
-
-	# Returns definitions and/or example sentences as an Array.
-	def_synset_function :glosses
+	def_synset_function :definition
 
 	# Return nouns or verbs that have the same hypernym as the receiver.
 	def_synset_function :coordinates

data/lib/linguistics/inflector.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/ruby
+# coding: utf-8
+
+require 'loggability'
+require 'linguistics' unless defined?( Linguistics )
+
+# A facade object that acts as the extension point for linguistic modules
+# for a single language. A single instance of an inflector is generated
+# for an object that has been extended with a Linguistics language
+# the first time the language is used.
+class Linguistics::Inflector
+	extend Loggability
+
+
+	# Loggability API -- log to the linguistics logger
+	log_to :linguistics
+
+
+	### Create a new inflector for +obj+.
+	def initialize( language_code, obj )
+		raise TypeError, "can't inflect for another inflector!" if
+			obj.is_a?( Linguistics::Inflector )
+		@language_code = language_code
+		@obj = obj
+		super()
+	end
+
+
+	######
+	public
+	######
+
+	# The object the inflector is delegating for
+	attr_reader :obj
+
+	# The inflector's language code
+	attr_reader :language_code
+
+
+	### Return the english-language name of the language the inflector is delegating
+	### for.
+	def language
+		::Linguistics::ISO639::LANGUAGE_CODES[ self.language_code.to_sym ][:eng_name]
+	end
+
+
+	### Returns +true+ if either the inflector or the object it's wrapping respond to
+	### the specified +message+.
+	def respond_to_missing?( message, include_priv=false )
+		return self.obj.respond_to?( message, include_priv )
+	end
+
+
+	### Return the target object as a String.
+	def to_s
+		return self.obj.to_s
+	end
+
+
+	### Return the target object as an Integer
+	def to_i
+		return self.obj.to_i
+	end
+
+
+	### Output a programmer-readable representation of the object suitable for debugging.
+	def inspect
+		return "#<(%s-language inflector) for <%s:0x%0x> >" % [
+			self.language,
+			@obj.class,
+			@obj.object_id / 2
+		]
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Delegate missing methods to the target object.
+	def method_missing( sym, *args, &block )
+		return super unless self.obj.respond_to?( sym )
+		meth = self.obj.method( sym )
+		self.singleton_class.send( :define_method, sym, &meth )
+		return self.method( sym ).call( *args, &block )
+	end
+
+end # class Linguistics::Inflector
+