treat 0.2.5 → 1.0.0

data/lib/treat/feature.rb

@@ -1,58 +0,0 @@
-module Treat
-  # This class represents a probabilistic feature;
-  # it is currently not used, because its
-  # behaviour is non-deterministic. Perhaps at 
-  # some point this will be of value for specific
-  # algorithms and so I'm keeping it here.
-  class Feature
-    # Undefine all methods, except those that 
-    # create any problems (e.g. with serializing).
-    instance_methods.each do |meth|
-      undef_method(meth) if meth !~ 
-      /^(__|object_id|class|instance_variables|instance_variable_get)/
-    end
-    # Allows to read the probability hash,
-    # the possible values of the feature,
-    # and the best value (with highest P).
-    attr_reader :p_hash, :values, :best
-    # Initialize the feature with a hash 
-    # of features => probabilities.
-    def initialize(p_hash)
-      @p_hash = p_hash
-      normalize
-      max = @p_hash.values.max
-      @best = @p_hash.select { |i,j| j == max }.keys.sample
-      @values = @p_hash.keys
-      type = @values[0].class
-      if type == ::Symbol || type == ::NilClass
-        @object = @best
-      else
-        @object = type.new(@best)
-      end
-    end
-    # Normalize the probabilities, so that
-    # the sum of all probabilities is 1,
-    # except if the sum of all probabilities
-    # is already below one (in which case we
-    # assume that the feature is intentionally
-    # incomplete).
-    def normalize
-      sum = @p_hash.inject(0.0) { |r, e| r + e[1] }
-      return if sum <= 1.0
-      p = {}
-      @p_hash.each { |k,v| p[k] =  v.to_f/sum.to_f }
-      @p_hash = p
-    end
-    # Find the probability of value x.
-    def probability(x)
-      @p_hash[x] ? @p_hash[x] : 0
-    end
-    # Alias for probability: p(x).
-    alias :p :probability
-    # Catch all other methods than the ones
-    # explicitly defined. 
-    def method_missing(sym, *args, &block)
-      @object.send(sym, *args, &block)
-    end
-  end
-end

data/lib/treat/features.rb

@@ -1,7 +0,0 @@
-module Treat
-  module Features
-    Time = Struct.new(:start, :end, :recurrence, :recurrence_interval)
-    Roles = Struct.new(:subject, :verb, :object, :patient, :agent)
-    Date = Struct.new(:year, :month, :day)
-  end
-end

data/lib/treat/formatters/visualizers/short_value.rb

@@ -1,29 +0,0 @@
-module Treat
-  module Formatters
-    module Visualizers
-      class ShortValue
-        # Default options for the visualizer.
-        DefaultOptions = { :max_words => 6, :max_length => 30 }
-        # Returns the text value of an entity, shortend
-        # with [..] if the value is longer than :max_words
-        # or longer than :max_length.
-        #
-        # Options:
-        # - (Integer) :max_words => the maximum number
-        # of words in an entity before it is shortened.
-        # - (Integer) :max_length => the maximum number
-        # of characters in an entity before it is shortened.s
-        def self.visualize(entity, options = {})
-          options = DefaultOptions.merge(options)
-          words = entity.to_s.split(' ')
-          if words.size < options[:max_words] || 
-            entity.to_s.length < options[:max_length]
-            entity.to_s
-          else
-            words[0..2].join(' ') + ' [...] ' + words[-3..-1].join(' ')
-          end
-        end
-      end
-    end
-  end
-end

data/lib/treat/formatters/visualizers/txt.rb

@@ -1,45 +0,0 @@
-module Treat
-  module Formatters
-    module Visualizers
-      # Creates a plain text visualization of an entity.
-      class Txt
-        # The default options for the visualizer.
-        DefaultOptions = { :sep => ' ' }
-        # Obtain a plain text visualization of the entity,
-        # with no additional information.
-        # 
-        # Options:
-        # (String) :sep => the separator to use between words.
-        def self.visualize(entity, options = {})
-          options[:first] = true unless options[:first] == false
-          first = options[:first]
-          options = DefaultOptions.merge(options)
-          return entity.value.dup if !entity.has_children?
-          value = ''
-          options[:first] = false
-          entity.each do |child|
-            value += "\n\n" if child.is_a?(Treat::Entities::Section)
-            if child.is_a?(Treat::Entities::Token) || child.value != ''
-              # Remove the trailing space for tokens that
-              # 'stick' to the previous one, such
-              # as punctuation symbols and clitics.
-              if child.is_a?(Treat::Entities::Punctuation) ||
-                 child.is_a?(Treat::Entities::Clitic)
-                  value.strip!
-              end
-              value += child.value + options[:sep]
-            else
-              value += visualize(child, options)
-            end
-            if child.is_a?(Treat::Entities::Title) ||
-               child.is_a?(Treat::Entities::Paragraph)
-              value += "\n\n"
-            end
-          end
-          value = value.strip if first
-          value
-        end
-      end
-    end
-  end
-end

data/lib/treat/group.rb

@@ -1,106 +0,0 @@
-module Treat
-  module Group
-    # Modify the extended class.
-    def self.extended(group)
-      group.module_eval do
-        class << self
-          attr_accessor :type, :default, :targets
-          attr_accessor :presets, :preprocessors, :postprocessors
-        end
-        self.presets = {}
-        self.preprocessors = {}
-        self.postprocessors = {}
-        # Return the method corresponding to the group.
-        # This method resolves the name of the method
-        # that a group should provide based on the name
-        # of the group. Basically, if the group ends in
-        # -ers, the verb corresponding to the group is
-        # returned (tokenizers -> tokenize, inflectors ->
-        # inflect). Otherwise, the name of the method
-        # is the same as that of the group (encoding ->
-        # encoding, tag -> tag).
-        @method = nil
-        def self.method
-          return @method if @method
-          m = ucc(cl(self))
-          if m[-3..-1] == 'ers'
-            if ['k', 't', 'm', 'd', 'g', 'n', 'x', 'h'].include? m[-4]
-              n = m[0..-4]
-              n = n[0..-2] if n[-1] == n[-2]
-            else
-              n = m[0..-3]
-            end
-          elsif m[-3..-1] == 'ors'
-            n = m[0..-4] + 'e'
-          else
-            n = m
-          end
-          @method = n.intern
-        end
-      end
-      group.list
-    end
-    # Create a new algorithm within the group. Once
-    # the algorithm is added, it will be automatically
-    # installed on all the targets of the group.
-    def add(class_name, &block)
-      klass = self.const_set(cc(class_name).intern, Class.new)
-      method = self.method
-      @@list[ucc(cl(self))] << class_name
-      klass.send(:define_singleton_method, method) do |entity, options={}|
-        block.call(entity, options)
-      end
-    end
-    # Boolean - does the group have the supplied class
-    # included in its targets?
-    def has_target?(target, strict = false)
-      is_target = false
-      self.targets.each do |entity_type|
-        entity_type = Entities.const_get(cc(entity_type))
-        if target < entity_type || entity_type == target
-          is_target = true; break
-        end
-      end
-      is_target
-    end
-    # Cache the list of adaptors to improve performance.
-    @@list = {}
-    # Populates once the list of the adaptors in the group
-    # by crawling the filesystem.
-    def list
-      mod = ucc(cl(self))
-      if @@list[mod].nil?
-        @@list[mod] = []
-        dirs = Dir.glob("#{Treat.lib}/treat/*/#{mod}/*.rb")
-        dirs.each do |file|
-          @@list[mod] <<
-          file.split('/')[-1][0..-4].intern
-        end
-      end
-      @@list[mod]
-    end
-    # Get constants in this module, excluding those
-    # defined by parent modules.
-    def const_get(const)
-      super(const, false)
-    end
-    # Lazy load the classes in the group.
-    def const_missing(const)
-      bits = self.ancestors[0].to_s.split('::')
-      bits.collect! { |bit| ucc(bit) }
-      file = bits.join('/') + "/#{ucc(const)}"
-      if not File.readable?("#{Treat.lib}/#{file}.rb")
-        raise Treat::Exception,
-        "File '#{file}.rb' corresponding to requested worker "+
-        "#{self}::#{const} does not exist."
-      else
-        require file
-        if not const_defined?(const)
-          raise Treat::Exception,
-          "File #{file} does not define #{self}::#{const}."
-        end
-        const_get(const)
-      end
-    end
-  end
-end

data/lib/treat/helpers/linguistics_loader.rb

@@ -1,18 +0,0 @@
-module Treat
-  module Helpers
-    class LinguisticsLoader
-      silence_warnings { require 'linguistics' }
-      def self.load(language)
-        begin
-          l = language.to_s.upcase
-          klass = nil
-          silence_warnings { klass = ::Linguistics.const_get(l) }
-          klass
-        rescue RuntimeError
-          raise "Ruby Linguistics does not have a module " +
-          " installed for the #{language} language."
-        end
-      end
-    end
-  end
-end

data/lib/treat/inflectors/cardinal_words/linguistics.rb

@@ -1,42 +0,0 @@
-module Treat
-  module Inflectors
-    module CardinalWords
-      # This class is a wrapper for the functions included
-      # in the 'linguistics' gem that allow to describe a
-      # number in words in cardinal form.
-      #
-      # Project website: http://deveiate.org/projects/Linguistics/
-      class Linguistics
-        require 'treat/helpers/linguistics_loader'
-        # Return the description of a cardinal number in words.
-        # 
-        # Options:
-        #
-        # - :group => Controls how many numbers at a time are 
-        # grouped together. Valid values are 0 (normal grouping), 
-        # 1 (single-digit grouping, e.g., “one, two, three, four”), 
-        # 2 (double-digit grouping, e.g., “twelve, thirty-four”, or 
-        # 3 (triple-digit grouping, e.g., “one twenty-three, four”).
-        # - :comma => Set the character/s used to separate word groups. 
-        # Defaults to ", ".
-        # - :and => Set the word and/or characters used where ' and ' 
-        # (the default) is normally used. Setting :and to ' ', for 
-        # example, will cause 2556 to be returned as “two-thousand, 
-        # five hundred fifty-six” instead of “two-thousand, five 
-        # hundred and fifty-six”.
-        # - :zero => Set the word used to represent the numeral 0 in 
-        # the result. 'zero' is the default.
-        # - :decimal => Set the translation of any decimal points in 
-        # the number; the default is 'point'.
-        # - :asArray If set to a true value, the number will be returned 
-        # as an array of word groups instead of a String.
-        # 
-        # More specific options when using :type => :ordinal:
-        def self.cardinal_words(entity, options = {})
-          klass = Treat::Helpers::LinguisticsLoader.load(entity.language)
-          klass.numwords(entity.to_s, options)
-        end
-      end
-    end
-  end
-end

data/lib/treat/inflectors/conjugations/linguistics.rb

@@ -1,36 +0,0 @@
-module Treat
-  module Inflectors
-    module Conjugations
-      # This class is a wrapper for the functions included
-      # in the 'linguistics' gem that allow to conjugate verbs.
-      #
-      # Project website: http://deveiate.org/projects/Linguistics/
-      class Linguistics
-        require 'treat/helpers/linguistics_loader'
-        # Conjugate a verb using ruby linguistics with the specified
-        # mode, tense, count and person.
-        #
-        # Options:
-        #
-        # - (Symbol) :mode => :infinitive, :indicative, :subjunctive, :participle
-        # - (Symbol) :tense => :past, :present, :future
-        # - (Symbol) :count => :singular, :plural
-        # - (Symbol) :person => :first, :second, :third
-        def self.conjugations(entity, parameters)
-          klass = Treat::Helpers::LinguisticsLoader.load(entity.language)
-          if parameters[:mode] == :infinitive
-            silence_warnings { klass.infinitive(entity.to_s) }
-          elsif parameters[:mode] == :participle && parameters[:tense] == :present
-            silence_warnings { klass.present_participle(entity.to_s) }
-          elsif parameters[:count] == :plural && parameters.size == 1
-            silence_warnings { klass.plural_verb(entity.to_s) }
-          else
-            raise Treat::Exception,
-            'This combination of modes, tenses, persons ' +
-            'and/or counts is not presently supported.'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/treat/inflectors/declensions/english.rb

@@ -1,319 +0,0 @@
-module Treat
-  module Inflectors
-    module Declensions
-      # This class is a wrapper for the Inflect module,
-      # copied from the unmaintained 'english' ruby gem,
-      # created by Thomas Sawyer.
-      # 
-      # Released under the MIT License.
-      #
-      #  http://english.rubyforge.org
-      class English
-        # Retrieve the declensions (singular, plural)
-        # of an english word using a class lifted from
-        # the 'english' ruby gem.
-        def self.declensions(entity, options)
-          unless options[:count]
-            raise Treat::Exception, 
-            "Must supply option count (:singular or :plural)."
-          end
-          string = entity.to_s
-          if entity.category == :verb
-            raise Treat::Exception,
-            "Cannot retrieve the declensions of a verb. " +
-            "Use #singular_verb and #plural_verb instead."
-          elsif options[:count] == :plural
-            Inflect.plural(string)
-          elsif options[:count] == :singular
-            Inflect.singular(string)
-          else
-            {:singular => Inflect.singular(string),
-             :plural => Inflect.plural(string)}
-          end
-        end
-
-        module Inflect
-
-          @singular_of = {}
-          @plural_of = {}
-
-          @singular_rules = []
-          @plural_rules = []
-
-          # This class provides the DSL for creating inflections, you can add additional rules.
-          # Examples:
-          #
-          #   word "ox", "oxen"
-          #   word "octopus", "octopi"
-          #   word "man", "men"
-          #
-          #   rule "lf", "lves"
-          #
-          #   word "equipment"
-          #
-          # Rules are evaluated by size, so rules you add to override specific cases should be longer than the rule
-          # it overrides. For instance, if you want "pta" to pluralize to "ptas", even though a general purpose rule
-          # for "ta" => "tum" already exists, simply add a new rule for "pta" => "ptas", and it will automatically win
-          # since it is longer than the old rule.
-          #
-          # Also, single-word exceptions win over general words ("ox" pluralizes to "oxen", because it's a single word
-          # exception, even though "fox" pluralizes to "foxes")
-          class << self
-            # Define a general two-way exception.
-            #
-            # This also defines a general rule, so foo_child will correctly become
-            # foo_children.
-            #
-            # Whole words also work if they are capitalized (Goose => Geese).
-            def word(singular, plural=nil)
-              plural = singular unless plural
-              singular_word(singular, plural)
-              plural_word(singular, plural)
-              rule(singular, plural)
-            end
-
-            # Define a singularization exception.
-            def singular_word(singular, plural)
-              @singular_of[plural] = singular
-              @singular_of[plural.capitalize] = singular.capitalize
-            end
-
-            # Define a pluralization exception.
-            def plural_word(singular, plural)
-              @plural_of[singular] = plural
-              @plural_of[singular.capitalize] = plural.capitalize
-            end
-
-            # Define a general rule.
-            def rule(singular, plural)
-              singular_rule(singular, plural)
-              plural_rule(singular, plural)
-            end
-
-            # Define a singularization rule.
-            def singular_rule(singular, plural)
-              @singular_rules << [singular, plural]
-            end
-
-            # Define a plurualization rule.
-            def plural_rule(singular, plural)
-              @plural_rules << [singular, plural]
-            end
-
-            # Read prepared singularization rules.
-            def singularization_rules
-              if defined?(@singularization_regex) && @singularization_regex
-                return [@singularization_regex, @singularization_hash]
-              end
-              # No sorting needed: Regexen match on longest string
-              @singularization_regex = Regexp.new("(" + @singular_rules.map {|s,p| p}.join("|") + ")$", "i")
-              @singularization_hash  = Hash[*@singular_rules.flatten].invert
-              [@singularization_regex, @singularization_hash]
-            end
-
-            # Read prepared singularization rules.
-            #def singularization_rules
-            #  return @singularization_rules if @singularization_rules
-            #  sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
-            #  @singularization_rules = sorted.collect do |s, p|
-            #    [ /#{p}$/, "#{s}" ]
-            #  end
-            #end
-
-            # Read prepared pluralization rules.
-            def pluralization_rules
-              if defined?(@pluralization_regex) && @pluralization_regex
-                return [@pluralization_regex, @pluralization_hash]
-              end
-              @pluralization_regex = Regexp.new("(" + @plural_rules.map {|s,p| s}.join("|") + ")$", "i")
-              @pluralization_hash = Hash[*@plural_rules.flatten]
-              [@pluralization_regex, @pluralization_hash]
-            end
-
-            # Read prepared pluralization rules.
-            #def pluralization_rules
-            #  return @pluralization_rules if @pluralization_rules
-            #  sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
-            #  @pluralization_rules = sorted.collect do |s, p|
-            #    [ /#{s}$/, "#{p}" ]
-            #  end
-            #end
-
-            #
-            def singular_of ; @singular_of ; end
-
-            #
-            def plural_of   ; @plural_of   ; end
-
-            # Convert an English word from plurel to singular.
-            #
-            #   "boys".singular      #=> boy
-            #   "tomatoes".singular  #=> tomato
-            #
-            def singular(word)
-              return "" if word == ""
-              if result = singular_of[word]
-                return result.dup
-              end
-              result = word.dup
-
-              regex, hash = singularization_rules
-              result.sub!(regex) {|m| hash[m]}
-              singular_of[word] = result
-              return result
-              #singularization_rules.each do |(match, replacement)|
-              #  break if result.gsub!(match, replacement)
-              #end
-              #return result
-            end
-
-            # Alias for #singular (a Railism).
-            #
-            alias_method(:singularize, :singular)
-
-            # Convert an English word from singular to plurel.
-            #
-            #   "boy".plural     #=> boys
-            #   "tomato".plural  #=> tomatoes
-            #
-            def plural(word)
-              return "" if word == ""
-              if result = plural_of[word]
-                return result.dup
-              end
-              #return self.dup if /s$/ =~ self # ???
-              result = word.dup
-
-              regex, hash = pluralization_rules
-              result.sub!(regex) {|m| hash[m]}
-              plural_of[word] = result
-              return result
-              #pluralization_rules.each do |(match, replacement)|
-              #  break if result.gsub!(match, replacement)
-              #end
-              #return result
-            end
-
-            # Alias for #plural (a Railism).
-            alias_method(:pluralize, :plural)
-
-            # Clear all rules.
-            def clear(type = :all)
-              if type == :singular || type == :all
-                @singular_of = {}
-                @singular_rules = []
-                @singularization_rules, @singularization_regex = nil, nil
-              end
-              if type == :plural || type == :all
-                @singular_of = {}
-                @singular_rules = []
-                @singularization_rules, @singularization_regex = nil, nil
-              end
-            end
-          end
-
-          # One argument means singular and plural are the same.
-
-          word 'equipment'
-          word 'information'
-          word 'money'
-          word 'species'
-          word 'series'
-          word 'fish'
-          word 'sheep'
-          word 'moose'
-          word 'hovercraft'
-          word 'news'
-          word 'rice'
-          word 'plurals'
-
-          # Two arguments defines a singular and plural exception.
-
-          word 'Swiss'     , 'Swiss'
-          word 'alias'     , 'aliases'
-          word 'analysis'  , 'analyses'
-          #word 'axis'      , 'axes'
-          word 'basis'     , 'bases'
-          word 'buffalo'   , 'buffaloes'
-          word 'child'     , 'children'
-          #word 'cow'       , 'kine'
-          word 'crisis'    , 'crises'
-          word 'criterion' , 'criteria'
-          word 'datum'     , 'data'
-          word 'goose'     , 'geese'
-          word 'hive'      , 'hives'
-          word 'index'     , 'indices'
-          word 'life'      , 'lives'
-          word 'louse'     , 'lice'
-          word 'man'       , 'men'
-          word 'matrix'    , 'matrices'
-          word 'medium'    , 'media'
-          word 'mouse'     , 'mice'
-          word 'movie'     , 'movies'
-          word 'octopus'   , 'octopi'
-          word 'ox'        , 'oxen'
-          word 'person'    , 'people'
-          word 'potato'    , 'potatoes'
-          word 'quiz'      , 'quizzes'
-          word 'shoe'      , 'shoes'
-          word 'status'    , 'statuses'
-          word 'testis'    , 'testes'
-          word 'thesis'    , 'theses'
-          word 'thief'     , 'thieves'
-          word 'tomato'    , 'tomatoes'
-          word 'torpedo'   , 'torpedoes'
-          word 'vertex'    , 'vertices'
-          word 'virus'     , 'viri'
-          word 'wife'      , 'wives'
-
-          # One-way singularization exception (convert plural to singular).
-
-          singular_word 'cactus', 'cacti'
-
-          # One-way pluralizaton exception (convert singular to plural).
-
-          plural_word 'axis', 'axes'
-
-          # General rules.
-
-          rule 'rf'     , 'rves'
-          rule 'ero'    , 'eroes'
-          rule 'ch'     , 'ches'
-          rule 'sh'     , 'shes'
-          rule 'ss'     , 'sses'
-          #rule 'ess'  , 'esses'
-          rule 'ta'     , 'tum'
-          rule 'ia'     , 'ium'
-          rule 'ra'     , 'rum'
-          rule 'ay'     , 'ays'
-          rule 'ey'     , 'eys'
-          rule 'oy'     , 'oys'
-          rule 'uy'     , 'uys'
-          rule 'y'      , 'ies'
-          rule 'x'      , 'xes'
-          rule 'lf'     , 'lves'
-          rule 'ffe'    , 'ffes'
-          rule 'af'     , 'aves'
-          rule 'us'     , 'uses'
-          rule 'ouse'   , 'ouses'
-          rule 'osis'   , 'oses'
-          rule 'ox'     , 'oxes'
-          rule ''       , 's'
-
-          # One-way singular rules.
-
-          singular_rule 'of' , 'ofs' # proof
-          singular_rule 'o'  , 'oes' # hero, heroes
-          #singular_rule 'f'  , 'ves'
-
-          # One-way plural rules.
-
-          plural_rule 's'   , 'ses'
-          plural_rule 'ive' , 'ives' # don't want to snag wife
-          plural_rule 'fe'  , 'ves'  # don't want to snag perspectives
-          
-        end
-      end
-    end
-  end
-end