root/trunk/lib/fm/linguistics.rb

#!/usr/bin/ruby

require 'linguistics'

require 'fm'
require 'fm/logger'

# 
# A mixin which adds natural language methods to including classes.
# 
# == Subversion ID
# 
# $Id$
# 
# == Authors
# 
# * Michael Granger <ged@FaerieMUD.org>
# 
# :include: LICENSE
#
#---
#
# Please see the file LICENSE for licensing details.
#
module FaerieMUD::Linguistics

        # SVN Revision
        SVNRev = %q$Rev$

        # SVN Id
        SVNId = %q$Id$

        # Load the English-language modules
        Linguistics::use( :en, :installProxy => true )


        ### Anything that mixes this module gets the Linguistics default languages.
        def self::included( mod )
                FaerieMUD::Logger.debug "Installing linguistic functions in %s" % [mod.name]
                mod.extend( ::Linguistics )
        end


        ###############
        module_function
        ###############

        ### Return a simple noun for the given +object+. If the object responds to
        ### the #noun method, the return value from that will be used -- otherwise
        ### the result will be derived from the name of the object's class.
        def make_noun( object )
                noun = nil
                if object.respond_to?( :noun )
                        noun = object.noun
                else
                        noun = guess_object_noun( object )
                end

                FaerieMUD::Logger.debug "Making a noun out of %p: %p" % [ object, noun ]
                return noun
        end


        ### Return a noun phrase describing the specified +objects+.
        def make_noun_phrase( *objects )
                objects.flatten.conjunction {|obj| make_noun(obj) }
        end


        ### Guess and return an appropriate noun for the given +object+ based on the
        ### name of its class.
        def guess_object_noun( object )
                object.class.name.
                        sub( /.*::/, '' ).
                        en.camel_case_to_english
        end


        ### This is a really simplistic version of what should really happen. 
        ### Ideally, verbs will be able to respond with the appropriate word form of
        ### themselves. However, the NLG engine should be able to pervert the canonical
        ### form to achieve tainted or ecstatic views, etc.

        ### Conjugate the given +verb+ (a FaerieMUD::Verb object) and return it.
        def conjugate_verb( verb, subject=nil )
                if /(\w+)Verb/.match( verb.class.name )
                        $1.downcase
                else
                        verb.class.name.downcase
                end
        end


        ### Linguistic sentence class -- instances of this class are used to
        ### encapsulate single-sentence chunks of linguistic content in the
        ### natural-language system.
        class Sentence
                include FaerieMUD::Linguistics

                ### Create the sentence. Can be constructed either with an explicit
                ### subject, verb, and optional direct object, or with a
                ### FaerieMUD::Event that will provide these parts.
                def initialize( *args )
                        if args.length == 1
                                init_from_event( args.first )
                        else
                                init_from_parts( *args )
                        end
                end


                # The subject of the sentence (a FaerieMUD::GameObject object)
                attr_reader :subject

                # The FaerieMUD;;Verb instance associated with the sentence
                attr_reader :verb

                # The FaerieMUD::GameObject which is the recipient of the action in the
                # sentence, if any.
                attr_reader :direct_object


                ### Return the sentence as a String
                def to_s
                        parts = [
                                make_noun_phrase( @subject ),
                                @verb.inflect_for( @subject )
                        ]

                        parts << make_noun_phrase( @direct_object ) if @direct_object

                        return parts.join( " " ) + "."
                end


                #########
                protected
                #########

                ### Set the members of the sentence from the parts of the given +event+
                ### (a FaerieMUD::Event object).
                def init_from_event( event )
                        init_from_parts( event.instigator, event.verb, event.target )
                end

                ### Set the members of the sentence from the given +subject+, +verb+,
                ### and +direct_object+.
                def init_from_parts( subject, verb, direct_object=nil )
                        @subject = subject
                        @verb = verb
                        @direct_object = direct_object
                end


        end

end # module FaerieMUD::Linguistics


__END__