gorilla 0.0.1.beta

data/lib/gorilla/version.rb

@@ -0,0 +1,10 @@
+module Gorilla
+  module Version
+    MAJOR   = 0
+    MINOR   = 0
+    PATCH   = 1
+    BETA    = 'beta'
+
+    VERSION = [MAJOR, MINOR, PATCH, BETA].compact.join('.').freeze
+  end
+end

data/lib/gorilla/volume.rb

@@ -0,0 +1,13 @@
+module Gorilla
+  class Volume < Unit
+    base :liter, :metric => true
+
+    unit :teaspoon,    0.00492892159, :liter
+    unit :tablespoon,  3, :teaspoon
+    unit :fluid_ounce, 2, :tablespoon
+    unit :cup,         8, :fluid_ounce
+    unit :pint,        2, :cup
+    unit :quart,       2, :pint
+    unit :gallon,      4, :quart
+  end
+end

data/lib/gorilla/weight.rb

@@ -0,0 +1,8 @@
+module Gorilla
+  class Weight < Unit
+    base :gram, :metric => true
+
+    unit :ounce, 28.3495231, :gram
+    unit :pound, 16, :ounce
+  end
+end

data/test/gorilla/scanners/temperature_scanner_test.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'test_helper'
+
+class TemperatureScannerTest < Test::Unit::TestCase
+  def test_should_parse_celsius
+    regex = Gorilla::TemperatureScanner.rules[:celsius].regexp
+
+    [
+      '°C',
+      'deg C',
+      'degs C',
+      'degrees C',
+      'C',
+      'Celsius',
+      'celsius',
+      '℃'
+    ].each { |unit| assert_match regex, unit }
+
+    %w(
+      c
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_fahrenheit
+    regex = Gorilla::TemperatureScanner.rules[:fahrenheit].regexp
+
+    [
+      '°F',
+      'deg F',
+      'degs F',
+      'degrees F',
+      'F',
+      'Fahrenheit',
+      'fahrenheit',
+      '℉'
+    ].each { |unit| assert_match regex, unit }
+
+    %w(
+      f
+    ).each { |bad| assert_no_match regex, bad }
+  end
+end

data/test/gorilla/scanners/time_scanner_test.rb

@@ -0,0 +1,123 @@
+require 'test_helper'
+
+class TimeScannerTest < Test::Unit::TestCase
+  def test_should_parse_seconds
+    regex = Gorilla::TimeScanner.rules[:second].regexp
+    durations = %w(
+      s sec second seconds secs
+    )
+
+    durations.each do |duration|
+      assert_match regex, duration
+      assert_match regex, duration.capitalize
+      assert_match regex, duration.upcase
+    end
+
+    %w(
+      ss
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_minutes
+    regex = Gorilla::TimeScanner.rules[:minute].regexp
+    durations = %w(
+      m min mins minute minutes
+    )
+
+    durations.each do |duration|
+      assert_match regex, duration
+      assert_match regex, duration.capitalize
+      assert_match regex, duration.upcase
+    end
+
+    %w(
+      ms
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_hours
+    regex = Gorilla::TimeScanner.rules[:hour].regexp
+    durations = %w(
+      h hour hours hr hrs
+    )
+
+    durations.each do |duration|
+      assert_match regex, duration
+      assert_match regex, duration.capitalize
+      assert_match regex, duration.upcase
+    end
+
+    %w(
+      hs
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_days
+    regex = Gorilla::TimeScanner.rules[:day].regexp
+    durations = %w(
+      d day days
+    )
+
+    durations.each do |duration|
+      assert_match regex, duration
+      assert_match regex, duration.capitalize
+      assert_match regex, duration.upcase
+    end
+
+    %w(
+      ds
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_scan
+    {
+      ["1h30m",
+       "1hr, 30min",
+       "1 H 30 M"] => [1.hour, 30.minutes],
+      ["1:30",
+       "one hour and thirty minutes",
+       # "hour plus thirty",
+       "an hour and a half"] => [1.5.hours],
+      ["2h20m",
+       "2hr, 20min",
+       "2 H 20 M"] => [2.hours, 20.minutes],
+      [# "two hours and twenty",
+       "2:20"] => [2.hours + 20.minutes],
+      ["0 min", "zero min"] => [0.minutes],
+      "one hundred and eighty-two minutes, fifteen seconds" =>
+        [182.minutes, 15.seconds],
+      "40 to 45 min" => [40.minutes..45.minutes],
+      "between 18 and 22 hours" => [18.hours..22.hours],
+      "Bake at 325 for 45 min" => [45.minutes],
+      "Let dough rest 4.5 hours" => [4.5.hours],
+      "Nineteen hundred minutes" => [1_900.minutes],
+      "a half hour" => [0.5.hours],
+      "3 and a half hours" => [3.5.hours],
+      # "3 hours and 15" => [3.hours, 15.minutes],
+      "3 1/2 hours" => [3.5.hours],
+      "half day" => [0.5.days],
+      <<LONGER => [10.min, 8.min, 12.min, 22.min..25.min, 10.min]
+Turn the oven on to 400 degrees. Meanwhile, chop onions and fry till
+translucent, about 10 minutes. Add mushrooms and cook water out of them,
+another 8 minutes. Boil until reduced (12 minutes). Put in oven and bake for
+22 to 25 minutes till done. Let rest 10 minutes.
+LONGER
+    }.each do |inputs, parsed|
+      [*inputs].each do |input|
+        assert_equal parsed, Gorilla::TimeScanner.scan(input), input
+      end
+    end
+  end
+
+  def test_should_parse_iso8601
+    {
+      "P1Y2W3DT4H5M6.7S" =>
+        1.year + 2.weeks + 3.days + 4.hours + 5.minutes + 6.7.seconds,
+      "PT15M" => 15.minutes,
+      "PT1H30M" => 1.5.hours,
+      "P1DY3" => nil # Invalid.
+    }.each do |input, parsed|
+      assert_equal parsed, Gorilla::TimeScanner.parse(input), input
+    end
+  end
+end

data/test/gorilla/scanners/volume_scanner_test.rb

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+class VolumeScannerTest < Test::Unit::TestCase
+  def test_should_parse_cups
+    regex = Gorilla::VolumeScanner.rules[:cup].regexp
+    units = %w(
+      c cp cu cup
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+  end
+
+  def test_should_parse_gallons
+    regex = Gorilla::VolumeScanner.rules[:gallon].regexp
+    units = %w(
+      gal gallon galn gl gln
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      g glon
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_liters
+    regex = Gorilla::VolumeScanner.rules[:liter].regexp
+    units = %w(
+      l liter litr litre lr lt ltr
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      lier lire lit lite
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_fluid_ounces
+    regex = Gorilla::VolumeScanner.rules[:fluid_ounce].regexp
+    units = %w(
+      ounce oz
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      onc once one ounc
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_pints
+    regex = Gorilla::VolumeScanner.rules[:pint].regexp
+    units = %w(
+      p pint pnt pt
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      pi pin
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_quarts
+    regex = Gorilla::VolumeScanner.rules[:quart].regexp
+    units = %w(
+      qrt qt quart
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      qart qat qua quar qurt qut
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_tablespoons
+    regex = Gorilla::VolumeScanner.rules[:tablespoon].regexp
+    assert_match regex, "T"
+
+    units = %w(
+      tablesp tablespn tablespoon tablsp tb tbls tblsp tblspn tblspoon tbs tbsp
+      tbspn tbspoon
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      t table tables tsp tspn tspoon
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_teaspoons
+    regex = Gorilla::VolumeScanner.rules[:teaspoon].regexp
+    assert_match regex, "t"
+
+    units = %w(
+      teasp teaspoon teaspn tsp
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      T
+    ).each { |bad| assert_no_match regex, bad }
+  end
+end

data/test/gorilla/scanners/weight_scanner_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class WeightScannerTest < Test::Unit::TestCase
+  def test_should_parse_grams
+    regex = Gorilla::WeightScanner.rules[:gram].regexp
+    units = %w(
+      g gm gr gram
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      ga gra
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_ounces
+    regex = Gorilla::WeightScanner.rules[:ounce].regexp
+    units = %w(
+      ounce oz
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      onc once one ounc
+    ).each { |bad| assert_no_match regex, bad }
+  end
+
+  def test_should_parse_pounds
+    regex = Gorilla::WeightScanner.rules[:pound].regexp
+    units = %w(
+      lb pd pnd pound #
+    )
+
+    units.each do |unit|
+      assert_match regex, unit
+      assert_match regex, unit.capitalize
+      assert_match regex, unit.pluralize
+      assert_match regex, unit.capitalize.pluralize
+    end
+
+    %w(
+      p pn
+    ).each { |bad| assert_no_match regex, bad }
+  end
+end

data/test/gorilla/time_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class TimeTest < Test::Unit::TestCase
+  def test_should_format_iso8601
+    {
+      1.5.minutes => "PT1M30S",
+      45.minutes => "PT45M",
+      90.minutes => "PT1H30M",
+      1.5.days => "P1DT12H"
+    }.each_pair do |duration, iso8601|
+      assert_equal iso8601, duration.iso8601
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'gorilla/all'
+require 'gorilla/scanners'
+require 'gorilla/core_ext'
+
+class String
+  def pluralize
+    end_with?('s') ? to_s : "#{to_s}s"
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: gorilla
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 1
+  - beta
+  version: 0.0.1.beta
+platform: ruby
+authors: 
+- Stephen Celis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-15 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdoctest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: scantron
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: A unit conversion and parsing library.
+email: stephen@stephencelis.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/gorilla/all.rb
+- lib/gorilla/core_ext.rb
+- lib/gorilla/scanner.rb
+- lib/gorilla/scanners/omni_scanner.rb
+- lib/gorilla/scanners/temperature_scanner.rb
+- lib/gorilla/scanners/time_scanner.rb
+- lib/gorilla/scanners/volume_scanner.rb
+- lib/gorilla/scanners/weight_scanner.rb
+- lib/gorilla/scanners.rb
+- lib/gorilla/scantron_ext.rb
+- lib/gorilla/temperature.rb
+- lib/gorilla/time.rb
+- lib/gorilla/unit.rb
+- lib/gorilla/version.rb
+- lib/gorilla/volume.rb
+- lib/gorilla/weight.rb
+- lib/gorilla.rb
+- test/gorilla/scanners/temperature_scanner_test.rb
+- test/gorilla/scanners/time_scanner_test.rb
+- test/gorilla/scanners/volume_scanner_test.rb
+- test/gorilla/scanners/weight_scanner_test.rb
+- test/gorilla/time_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/stephencelis/gorilla
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Big, strong, intelligent unit conversions.
+test_files: 
+- test/gorilla/scanners/temperature_scanner_test.rb
+- test/gorilla/scanners/time_scanner_test.rb
+- test/gorilla/scanners/volume_scanner_test.rb
+- test/gorilla/scanners/weight_scanner_test.rb
+- test/gorilla/time_test.rb
+- test/test_helper.rb