gorilla 0.0.1.beta

data/README.rdoc

@@ -0,0 +1,3 @@
+= Gorilla
+
+TODO

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake/testtask'
+require 'rdoctest/task'
+
+Rdoctest::Task.new do |t|
+  t.ruby_opts << '-rgorilla/all -rgorilla/core_ext'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :default => [:doctest, :test]

data/lib/gorilla.rb

@@ -0,0 +1,11 @@
+require 'gorilla/unit'
+
+module Gorilla
+  @units = {}
+
+  class << self
+    attr_reader :units
+  end
+end
+
+G = Gorilla

data/lib/gorilla/all.rb

@@ -0,0 +1,5 @@
+require 'gorilla'
+require 'gorilla/temperature'
+require 'gorilla/time'
+require 'gorilla/volume'
+require 'gorilla/weight'

data/lib/gorilla/core_ext.rb

@@ -0,0 +1,72 @@
+module Gorilla::CoreExt
+  def unit
+    Gorilla::Unit.new self
+  end
+  alias units unit
+
+  Gorilla.units.each_pair do |klass_name, configs|
+    configs.each_key do |unit|
+      klass = Gorilla.const_get klass_name[/\w+$/]
+
+      define_method unit do
+        klass.new self, unit
+      end
+      alias_method "#{unit}s", unit if klass.pluralize
+    end
+  end
+
+  if Gorilla.const_defined? :Temperature
+    alias Celsius celsius
+    alias C celsius
+    alias Fahrenheit fahrenheit
+    alias F fahrenheit
+  end
+
+  if Gorilla.const_defined? :Temperature
+    alias s second
+    alias sec second
+    alias ms millisecond
+    alias min minute
+    alias h hour
+    alias hr hour
+    alias d day
+  end
+
+  if Gorilla.const_defined? :Volume
+    alias litre liter
+    alias l liter
+    alias L liter
+    alias millilitre milliliter
+    alias ml milliliter
+    alias mL milliliter
+    alias centilitre centiliter
+    alias cl centiliter
+    alias cL centiliter
+    alias t teaspoon
+    alias tsp teaspoon
+    alias T tablespoon
+    alias tbs tablespoon
+    alias tbsp tablespoon
+    alias fl_oz fluid_ounce
+    alias oz_fl fluid_ounce
+    alias c cup
+    alias cu cup
+    alias pt pint
+    alias qt quart
+    alias gal gallon
+  end
+
+  if Gorilla.const_defined? :Weight
+    alias g gram
+    alias kg kilogram
+    alias mg milligram
+    alias lb pound
+    alias lbs pounds
+    alias oz ounce
+    alias ozs ounces
+  end
+end
+
+class Numeric
+  include Gorilla::CoreExt
+end

data/lib/gorilla/scanner.rb

@@ -0,0 +1,222 @@
+# encoding: utf-8
+require 'gorilla/scantron_ext'
+
+module Gorilla
+  # A {Scantron}[http://github.com/stephencelis/scantron] scanner class from
+  # which all Gorilla::Scanner classes inherit.
+  #
+  # Your own Gorilla::Scanners will inherit the data assigned their
+  # Gorilla::Unit definitions so that, for example, units defined as metric
+  # will have additional scanner rules created for each prefix.
+  #
+  # For more information, see Gorilla::Scanner.rule.
+  class Scanner < ::Scantron::Scanner
+    # Maps metric prefixes to regular expressions used for parsing.
+    METRIC_MAP = {
+      # :yotta => /Y/,
+      # :zetta => /Z/,
+      # :exa   => /E/,
+      # :peta  => /P/,
+      # :tera  => /T/,
+      # :giga  => /G/,
+      # :mega  => /M/,
+      :kilo  => /k(?:ilo)?/,
+      # :hecto => /H/,
+      # :deca  => /da/,
+      # :deci  => /d/,
+      :centi => /c(?:enti)?/,
+      :milli => /m(?:illi)?/
+      # :micro => /μ/,
+      # :nano  => /n/,
+      # :pico  => /p/,
+      # :femto => /f/,
+      # :atto  => /a/,
+      # :zepto => /z/,
+      # :yocto => /y/
+    }
+
+    before_match do |r|
+      # Adjust for amounts before units.
+      pre_match = r.scanner.pre_match
+      if result = AmountScanner.new(pre_match).perform.last
+        between = r.scanner.string[
+          result.scanner.pos, pre_match.length - result.scanner.pos
+        ]
+
+        if between =~ /\S/
+          result = nil
+        else
+          r.length = r.length + (r.offset - result.offset)
+          r.offset = result.offset
+        end
+
+        amount = result.value if result
+      end
+
+      # Adjust for generic amounts.
+      unless amount
+        if match = pre_match =~ /\ban? *$/i
+          r.length = r.length + (r.offset - match)
+          r.offset = match
+          amount = 1
+        elsif match = pre_match =~ /\b(?:a )couple *$/i
+          r.length = r.length + (r.offset - match)
+          r.offset = match
+          amount = 2
+        end
+      end
+
+      # Adjust for trailing amounts ("...and a half").
+      if match = r.scanner.post_match.match(/^ and(?: an?)? (.+)/)
+        if r.scantron.class.parse(match[1]).nil?
+          if result = NumberScanner.new(match[1]).perform.first
+            if result.offset == 0
+              r.length = r.length + result.length + match.offset(1).first
+              amount += result.value
+            end
+          end
+        end
+      # Adjust for trailing ranges ("...or two").
+      elsif match = r.scanner.post_match.match(/^ or (.+)/)
+        if r.scantron.class.parse(match[1]).nil?
+          if result = NumberScanner.new(match[1]).perform.first
+            if result.offset == 0
+              r.length = r.length + result.length + match.offset(1).first
+              amount = amount..result.value
+            end
+          end
+        end
+      # Adjust for periods.
+      elsif r.scanner.post_match =~ /^\./
+        r.length += 1
+      end
+
+      r[:amount] = amount
+      r
+    end
+
+    after_match do |r|
+      case amount = r[:amount]
+      when Range
+        unit_class = constantize r.rule.data[:class_name]
+        unit_class.new(amount.min, r.name)..unit_class.new(amount.max, r.name)
+      else
+        constantize(r.rule.data[:class_name]).new amount, r.name
+      end
+    end
+
+    class << self
+      # ==== Options
+      #
+      # [<tt>:class_name</tt>]  The Gorilla::Unit return class for the rule
+      #                         given. By default, it is inferred from the name
+      #                         of the scanner, so that a "BogosityScanner"
+      #                         would try instantiate matches as "Bogosity"
+      #                         units.
+      #
+      # [<tt>:metric</tt>]      Whether or not additional rules should be
+      #                         generated for metric prefixes. By default, it
+      #                         is inferred from the unit's original
+      #                         definition.
+      #
+      # ==== Example
+      #
+      # Here we define a metric unit and scanner rule:
+      #
+      #   class Beauty < Gorilla::Unit
+      #     base :Helen, :metric => true
+      #   end
+      #
+      # And here we define the scanner rule:
+      #
+      #   class BeautyScanner < Gorilla::Scanner
+      #     rule :Helen, /[Hh](?:elen)?s?/
+      #   end
+      #
+      #   BeautyScanner.scan '1 milliHelen is required to launch the ship.'
+      #   # => [(1 milliHelen)]
+      #
+      #   BeautyScanner.scan '2 kiloHelens'
+      #   # => [(2 kiloHelens)]
+      #
+      # The return class (Beauty) is inferred from the scanner's class name
+      # (less "Scanner"), and the metric setting is taken from the matching
+      # rule on that class, but both can be overridden or made explicit.
+      #
+      #   class BeautyScanner < Gorilla::Scanner
+      #     rule :Helen, /[Hh](?:elen)?s?/, :class_name => 'Beauty',
+      #                                     :metric     => true
+      #   end
+      def rule unit, regexp, data = {}, &block
+        if class_name = data.delete(:class_name)
+          klass = constantize class_name
+        elsif class_name = name.sub!(/Scanner$/, '')
+          klass = constantize class_name rescue nil
+        end
+
+        config = { :class_name => class_name || 'Unit' }
+        config.update klass.rules[unit] if klass && klass.rules[unit]
+        config.update data
+
+        super unit, /(?<=^|[\d ])#{regexp}(?=[\d ]|\b|$)/, config, &block
+
+        if config[:metric]
+          METRIC_MAP.each_pair do |pre, sub|
+            super :"#{pre}#{unit}", /(?<=^|[\d ])#{sub}#{regexp}(?= |\b|$)/,
+              config, &block
+          end
+        end
+      end
+
+      private
+
+      def constantize class_name
+        names = class_name.split '::'
+        names.shift if names.first && names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = if constant.const_defined?(name)
+            constant.const_get name
+          else
+            constant.const_missing name
+          end
+        end
+        constant
+      end
+    end
+
+    def scan
+      results = perform
+      array   = []
+      range   = false
+
+      results.each.with_index do |result, index|
+        if range
+          range = false
+          next
+        end
+
+        if !result.value.is_a?(Range) and next_result = results[index + 1]
+          substring = string[
+            result.scanner.pos, next_result.offset - result.scanner.pos
+          ]
+
+          case substring
+          when /^ *(and|or|to) *$/
+            if $1 == 'and' && result.pre_match !~ /between $/
+              array << (result.value + next_result.value)
+            else
+              array << (result.value..next_result.value)
+            end
+            range = true and next
+          end
+        end
+
+        array << result.value
+      end
+
+      array
+    end
+  end
+end

data/lib/gorilla/scanners.rb

@@ -0,0 +1,9 @@
+require 'scantron'
+require 'number_scanner'
+require 'range_scanner'
+require 'gorilla/scanner'
+require 'gorilla/scanners/temperature_scanner'
+require 'gorilla/scanners/time_scanner'
+require 'gorilla/scanners/volume_scanner'
+require 'gorilla/scanners/weight_scanner'
+require 'gorilla/scanners/omni_scanner'

data/lib/gorilla/scanners/omni_scanner.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+require 'gorilla/scanner'
+require 'gorilla/scanners/temperature_scanner'
+require 'gorilla/scanners/time_scanner'
+require 'gorilla/scanners/volume_scanner'
+require 'gorilla/scanners/weight_scanner'
+
+module Gorilla
+  # An all-purpose units scanner combining the rules of TemperatureScanner,
+  # TimeScanner, VolumeScanner, and WeightScanner.
+  #
+  #   Gorilla::OmniScanner.
+  #     scan "Add 1 cup flour (125g). Bake @ 350F for 25 min."
+  #   # => [(1 cup), (125 grams), (350° Fahrenheit), (25 minutes)]
+  class OmniScanner < Scanner
+    rules.update TemperatureScanner.rules
+    rules.update TimeScanner.rules
+    rules.update VolumeScanner.rules
+    rules.update WeightScanner.rules
+  end
+end

data/lib/gorilla/scanners/temperature_scanner.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+require 'gorilla/scanner'
+require 'gorilla/temperature'
+
+module Gorilla
+  class TemperatureScanner < Scanner
+    degrees = /°| ?deg(?:ree)?s? /
+    rule :celsius,    /#{degrees}?(?:C|[Cc]elsius)|℃/
+    rule :fahrenheit, /#{degrees}?(?:F|[Ff]ahrenheit)|℉/
+  end
+end

data/lib/gorilla/scanners/time_scanner.rb

@@ -0,0 +1,34 @@
+require 'gorilla/scanner'
+require 'gorilla/time'
+
+module Gorilla
+  class TimeScanner < Scanner
+    rule :second,     /[Ss](?:ec(?:ond)?s?)?|S(?:EC(?:OND)?S?)/
+    rule :minute,     /[Mm](?:in(?:ute)?s?)?|M(?:IN(?:UTE)?S?)/
+    rule :hour,       /[Hh](?:(?:ou)?rs?)?|H(?:(?:OU)?RS?)?/
+    rule :day,        /[Dd](?:ays?)?|D(?:AYS?)/
+    rule :week,       /[Ww](?:ee)?ks?|W(?:EE)?KS?/
+    rule :month,      /[Mm](?:o(?:n(?:th))?s?)|M(?:O(?:N(?:TH))?S?)/
+    rule :year,       /[Yy](?:ea)?rs?|Y(?:EA)?RS?/
+    rule :decade,     /[Dd]ecades?|DECADES?/
+    rule :century,    /[Cc]entur(?:y|ies)|CENTUR(?:Y|IES)/
+    rule :millennium, /[Mm]illeni(?:um|a)|MILLENI(?:UM|A)/
+
+    rule :iso8601, /\bP(\d+Y)?(\d+W)?(\d+D)?T?(\d+H)?(\d+M)?([\d.]+S)?\b/ do |r|
+      y = Time.new r.scanner[1].to_i, :year
+      w = Time.new r.scanner[2].to_i, :week
+      d = Time.new r.scanner[3].to_i, :day
+      h = Time.new r.scanner[4].to_i, :hour
+      m = Time.new r.scanner[5].to_i, :minute
+      s = Time.new r.scanner[6].to_f, :second
+      y + w + d + h + m + s
+    end
+
+    rule :delimited, /\d{1,2}(?::\d{2}){1,2}/ do |r|
+      h, m, s = r.to_s.split ':'
+      time  = Time.new(h, :hour) + Time.new(m, :minute)
+      time += Time.new(s, :second) if s
+      time
+    end
+  end
+end

data/lib/gorilla/scanners/volume_scanner.rb

@@ -0,0 +1,15 @@
+require 'gorilla/scanner'
+require 'gorilla/volume'
+
+module Gorilla
+  class VolumeScanner < Scanner
+    rule :liter,       /[Ll](?:i?t(?:er|re?)|t|r)?s?/
+    rule :teaspoon,    /(?:t|(?:[Tt](?:ea)?s(?:p(?:oo)?n?)?))s?/
+    rule :tablespoon,  /(?:T|(?:[Tt](?:bl?s?p?|a?b(?:le?)?(?:s(?:p(?:oo)?n?)))))s?/
+    rule :fluid_ounce, /(?:[Ff]l(?:uid|\.)? )?[Oo](?:unce|z)s?/
+    rule :cup,         /[Cc]u?p?s?/
+    rule :pint,        /[Pp](?:(?:i?n)?t)?s?/
+    rule :quart,       /[Qq](?:(?:ua)?r)?ts?/
+    rule :gallon,      /[Gg](?:a?l(?:(?:lo)?n)?)s?/
+  end
+end

data/lib/gorilla/scanners/weight_scanner.rb

@@ -0,0 +1,10 @@
+require 'gorilla/scanner'
+require 'gorilla/weight'
+
+module Gorilla
+  class WeightScanner < Scanner
+    rule :gram,  /[Gg](?:r(?:am)?|m)?s?/
+    rule :ounce, /[Oo](?:unce|z)s?/
+    rule :pound, /(?:[Pp](?:ou)?n?d|[Ll]b|#)s?/
+  end
+end

data/lib/gorilla/scantron_ext.rb

@@ -0,0 +1,83 @@
+require 'scantron'
+require 'amount_scanner'
+
+class NumberScanner
+  words = WORD_MAP.keys.map { |v| v.sub /y$/, 'y-?' } * '|'
+  rules[:human].regexp = \
+    %r{(?:\b(?:\d+ (?:an?d? )*)?(?:#{words}))(?: ?\b(?:#{words}|an?d?|\d+)\b ?)*}i
+
+  def self.human_to_number words
+    numbers = words.split(/\W+/).map { |w|
+      WORD_MAP[w.downcase] || parse(w) || w
+    }
+
+    case numbers.count { |n| n.is_a? Numeric }
+      when 0 then false
+      when 1 then numbers[0]
+    else
+      array = []
+      total = 0
+      limit = 1
+      words = []
+      reset = true
+
+      numbers.each.with_index do |n, i|
+        words << n and next if n.is_a? String
+
+        if n == 1 && limit == 1
+          reset = false
+          next
+        end
+
+        if n >= 1_000
+          total += n * limit
+          limit = 1
+          reset = true
+        else
+          if n < 1
+            if words.join(' ') =~ /\band\b/
+              if total > 0 && total % 1_000
+                if total % (factor = 10 ** (total.to_i.to_s.size - 1)) == 0
+                  limit = n * factor
+                else
+                  limit = n
+                end
+              else
+                limit += n
+              end
+            else
+              limit *= n
+            end
+          elsif words.join(' ') =~ /\band\b/ && numbers[i + 1].to_i < 1
+            total += limit
+            limit = n
+          elsif !reset && limit >= 1 &&
+            m1 = (n > (m2 = numbers[i + 1].to_i) ? n + m2 : n) and
+            m = [limit, m1].sort and
+            !m[1].to_s[-(m0 = m[0].to_i.to_s.size), m0].to_i.zero?
+
+            array << total + limit
+            total = 0
+            limit = n
+          elsif !reset && limit == 1 && n > numbers[i + 1].to_i &&
+            m = [limit, n + numbers[i + 1].to_i].sort and
+              !m[1].to_s[-(m[0].to_i.to_s.size), m[0].to_i.to_s.size].to_i.zero?
+
+            array << total + limit
+            total = 0
+            limit = n
+          else
+            n > limit ? limit *= n : limit += n
+          end
+
+          total += limit if numbers[i + 1].nil?
+          reset = false
+        end
+
+        words.clear
+      end
+
+      array.empty? ? total : array << total
+    end
+  end
+end