m9t 0.3.3 → 0.3.4

data/Gemfile

@@ -1,3 +1,4 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec :name => 'm9t'
+

data/README.md

@@ -42,31 +42,41 @@ Interface
 
 new: accepts the S.I. unit as a parameter:
 
-    height = M9t::Distance.new(1.75)
+```ruby
+height = M9t::Distance.new(1.75)
+```
 
 to_f: returns the decimal value(s):
 
-    height.to_f -> 1.75
+```ruby
+height.to_f -> 1.75
+```
 
 other units:
 there are class methods named after each known unit,
 which take values in that unit
 (actually, they are defined as needed):
 
-    marathon = M9t::Distance.miles(26.21875)
-    marathon.to_f -> 42194.988
+```ruby
+marathon = M9t::Distance.miles(26.21875)
+marathon.to_f -> 42194.988
+```
 
 to_s: returns a localized string with units:
 
-    I18n.locale = :it
-    puts M9t::Distance.new(3).to_s -> '3 metri'
+```ruby
+I18n.locale = :it
+puts M9t::Distance.new(3).to_s -> '3 metri'
+```
 
 Class methods for conversion
 ============================
 
 Methods are available for conversion between any pair of units:
 
-    M9t::Distance.miles_to_meters(26.21875) -> 42194.988
+```ruby
+M9t::Distance.miles_to_meters(26.21875) -> 42194.988
+```
 
 Testing
 =======
@@ -74,13 +84,17 @@ Testing
 Coverage
 --------
 
-ruby 1.8.x:
+ruby 1.8.x (not jruby):
 
-    $ rake rcov
+```shell
+$ rake rcov
+```
 
 ruby 1.9.x:
 
-    $ COVERAGE=1 rake test
+```shell
+$ COVERAGE=1 rake test
+```
 
 Alternatives
 ============
@@ -104,3 +118,4 @@ Dual license:
 
 - MIT License: see MIT-LICENSE.txt,
 - GPL version 3: see GPL-LICENSE.txt
+

data/Rakefile

@@ -1,32 +1,19 @@
-require 'bundler'
-require 'rake/testtask'
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rcov/rcovtask' if RUBY_VERSION < '1.9'
+require 'rspec/core/rake_task'
 
-$:.unshift( File.dirname(__FILE__) + '/lib' )
-require 'm9t'
+task :default => :spec
 
-task :default => :test
-
-Rake::TestTask.new do |t|
-  t.libs       << 'test'
-  t.test_files = FileList['test/*_test.rb']
-  t.verbose    = true
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
 end
 
 if RUBY_VERSION < '1.9'
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.test_files = FileList['test/*_test.rb']
-    t.rcov_opts  << '--exclude /gems/'
+  RSpec::Core::RakeTask.new('spec:rcov') do |t|
+    t.pattern   = 'spec/**/*_spec.rb'
+    t.rcov      = true
+    t.rcov_opts = ['--exclude', 'spec/,/gems/']
   end
 end
 
-desc "Build the gem"
-task :build do
-  `gem build m9t.gemspec`
-end
-
-desc "Publish a new version of the gem"
-task :release => :build do
-  `gem push m9t-#{M9t::VERSION::STRING}.gem`
-end
-

data/lib/m9t/base.rb

@@ -2,41 +2,67 @@
 require 'i18n'
 
 module M9t
-
   module Base
-
     def self.generate_conversions(klass)
       klass.instance_eval do |klass|
         def convert(from, to, value)
           value / self::CONVERSIONS[from] * self::CONVERSIONS[to]
         end
 
+        # Define class conversion methods as required
         def method_missing(name, *args, &block)
-          # Define class conversion methods as required
-          if name.to_s =~ /^(\w+)_to_(\w+)$/
-            return send(name, args[0]) if define_conversion($1, $2)
+          from, to = extract_from_and_to(name)
+          if from
+            if legal_conversion?(from, to)
+              define_conversion(from, to)
+              return send(name, args[0])
+            end
+          end
+          if legal_constructor?(name)
+            define_constructor(name)
+            return send(name, args[0])
+          end
+          super
+        end
+
+        def respond_to?(name, include_all = false)
+          from, to = extract_from_and_to(name)
+          if from
+            return true if legal_conversion?(from, to)
           end
-          return send(name, args[0]) if define_constructor(name)
-          raise "Method '#{ name }' unknown" # TODO use standard exception
+          return legal_constructor?(name)
+          super
         end
 
         private
 
+        def extract_from_and_to(name)
+          if name.to_s =~ /^(\w+)_to_(\w+)$/
+            [$1, $2]
+          else
+            nil
+          end
+        end
+
+        def legal_conversion?(from, to)
+          self::CONVERSIONS.include?(from.to_sym) and self::CONVERSIONS.include?(to.to_sym)
+        end
+
         def define_conversion(from, to)
-          return false if not self::CONVERSIONS[from.to_sym]
-          return false if not self::CONVERSIONS[to.to_sym]
           self.class.instance_exec do
             define_method("#{ from }_to_#{ to }") do |value|
               convert(from.to_sym, to.to_sym, value)
             end
           end
-          true
+        end
+
+        def legal_constructor?(name)
+          self::CONVERSIONS.include?(name.to_sym)
         end
 
         # Define klass.unit(value) which converts the parameter
         # from the unit and returns an instance
         def define_constructor(name)
-          return false if not self::CONVERSIONS[name.to_sym]
           self.class.instance_exec do
             define_method( name.to_sym ) do | *args |
               new( args[ 0 ].to_f / self::CONVERSIONS[ name ] )
@@ -94,10 +120,18 @@ module M9t
 
     # define conversion instance methods as required
     def method_missing(name, *args, &block)
-      if name.to_s =~ /^to_(\w+)$/
-        return send(name) if define_conversion($1)
+      to = extract_to(name)
+      if to and legal_conversion?(to)
+        define_conversion(to)
+        return send(name)
       end
-      raise "Method '#{ name }' unknown" # TODO use standard exception
+      super
+    end
+
+    def respond_to?(name, include_all = false)
+      to = extract_to(name)
+      return true if to and legal_conversion?(to)
+      super
     end
 
     # Returns the string representation of the measurement,
@@ -121,16 +155,25 @@ module M9t
       raise M9t::UnitError.new("Unknown units '#{ units }'. Known: #{ self.class::CONVERSIONS.keys.collect{|unit| unit.to_s}.join(', ') }")
     end
 
+    def extract_to(name)
+      if name.to_s =~ /^to_(\w+)$/
+        $1
+      else
+        nil
+      end
+    end
+
+    def legal_conversion?(to)
+      self.class::CONVERSIONS.include?(to.to_sym)
+    end
+
     def define_conversion(to)
-      return false if not self.class::CONVERSIONS[to.to_sym]
       self.class.instance_exec do
-        define_method("to_#{ to }") do
+        define_method("to_#{to}") do
           self.class.convert(self.class.default_unit, to.to_sym, self.to_f)
         end
       end
-      true
     end
-
   end
-
 end
+

data/lib/m9t/version.rb

@@ -3,7 +3,7 @@ module M9t
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 3
+    TINY  = 4
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/locales/en.yml

@@ -22,6 +22,7 @@ en:
           zero: miles
           one: mile
           other: miles
+        abbreviated: mi
       feet:
         full:
           one: foot
@@ -35,6 +36,12 @@ en:
           other: degrees
         abbreviated: °
     speed:
+      miles_per_hour:
+        full:
+          zero: miles per hour
+          one: mile per hour
+          other: miles per hour
+        abbreviated: mph
       meters_per_second:
         full:
           zero: meters per second
@@ -52,6 +59,12 @@ en:
           one: knot
           other: knots
     temperature:
+      fahrenheit:
+        full:
+          zero: degrees
+          one: degree
+          other: degrees
+        abbreviated: °F
       degrees:
         full:
           zero: degrees

data/m9t.gemspec

@@ -23,6 +23,13 @@ gemspec = Gem::Specification.new do |s|
   s.add_dependency 'rake'
   s.add_dependency 'i18n', '>= 0.3.5'
 
-  s.add_development_dependency 'rcov'      if RUBY_VERSION < '1.9'
-  s.add_development_dependency 'simplecov' if RUBY_VERSION > '1.9'
+  s.add_development_dependency 'rspec'
+  if RUBY_VERSION < '1.9'
+    if RUBY_PLATFORM != 'java'
+      s.add_development_dependency 'rcov'
+    end
+  else
+    s.add_development_dependency 'simplecov'
+  end
 end
+

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'rspec'
+require 'rspec/autorun'
+
+if RUBY_VERSION > '1.9'
+  require 'simplecov'
+  if ENV['COVERAGE']
+    SimpleCov.start do
+      add_filter '/spec/'
+    end
+  end
+end
+
+require 'm9t'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end
+

data/spec/unit/base_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require 'spec_helper'
+
+class SomeMeasurement
+  DEFAULT_OPTIONS = {
+    :units       => :foos,
+    :abbreviated => false,
+    :decimals    => 1
+  }
+  CONVERSIONS = {
+    :foos =>      1.0,
+    :bars => 1 / 42.0
+  }
+
+  include M9t::Base
+end
+
+class SomeDerivedMeasurement < SomeMeasurement; end
+
+describe M9t::Base do
+  describe '.method_missing' do
+    it 'handles conversion between known units' do
+      expect(SomeMeasurement.foos_to_bars(3.0)).to be_a(Float)
+    end
+
+    it 'fails for unknown units' do
+      expect {
+        SomeMeasurement.bazs_to_bars(3.0)
+      }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#method_missing' do
+    subject { SomeMeasurement.new(3.0) }
+
+    it 'handles conversion to known units' do
+      expect(subject.to_bars).to be_a(Float)
+    end
+
+    it 'fails for unknown units' do
+      expect {
+        subject.to_bazs(3.0)
+      }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe 'derived class' do
+    it 'inherits options' do
+      expect(SomeDerivedMeasurement.options).to eq(SomeMeasurement.options)
+    end
+  end
+end
+

data/spec/unit/direction_spec.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe M9t::Direction do
+  before do
+    I18n.locale = :en
+  end
+
+  describe '.measurement_name' do
+    it "is 'direction'" do
+      expect(M9t::Direction.measurement_name).to eq('direction')
+    end
+  end
+
+  describe '.options' do
+    it 'is set' do
+      expect(M9t::Direction.options).not_to be_nil
+    end
+
+    context 'abbreviated' do
+      it 'is false' do
+        expect(M9t::Direction.options[:abbreviated]).to be_false
+      end
+    end
+
+    context 'units' do
+      it 'is degrees' do
+        expect(M9t::Direction.options[:units]).to eq(:degrees)
+      end
+    end
+  end
+
+  describe '.normalize' do
+    it 'handles values > 360' do
+      expect(M9t::Direction.normalize(725)).to eq(5)
+    end
+
+    it 'handles values < 0' do
+      expect(M9t::Direction.normalize(-355)).to eq(5)
+    end
+  end
+
+  context 'conversion class methods' do
+    describe '.degrees_to_degrees' do
+      it 'returns the identity' do
+        expect(M9t::Direction.degrees_to_degrees(45)).to eq(45)
+      end
+    end
+
+    describe '.degrees_to_compass' do
+      before do
+        I18n.locale = :en
+      end
+
+      context 'exact' do
+        [
+          'N', 'NNE', 'NE', 'ENE',
+          'E', 'ESE', 'SE', 'SSE',
+          'S', 'SSW', 'SW', 'WSW',
+          'W', 'WNW', 'NW', 'NNW'
+        ].each.with_index do |result, i|
+          it "recognizes #{result}" do
+            expect(M9t::Direction.degrees_to_compass(i * 22.5)).to eq(result)
+          end
+        end
+      end
+
+      context 'rounding' do
+        specify 'up' do
+          expect(M9t::Direction.degrees_to_compass(42)).to eq('NE')
+        end
+
+        specify 'down' do
+          expect(M9t::Direction.degrees_to_compass(93)).to eq('E')
+        end
+      end
+
+      context 'i18n' do
+        before do
+          I18n.locale = :it
+        end
+
+        it 'translates' do
+          expect(M9t::Direction.degrees_to_compass(270)).to eq('O')
+        end
+      end
+    end
+
+    describe 'compass_to_degrees' do
+      it 'converts correctly' do
+        expect(M9t::Direction.compass_to_degrees('WSW')).to eq(247.5)
+      end
+    end
+  end
+
+  describe '.new' do
+    context 'strings' do
+      it 'works' do
+        expect(M9t::Direction.new('35').value).to eq(35)
+      end
+
+      it 'handles leading zeroes' do
+        expect(M9t::Direction.new('010').value).to eq(10)
+      end
+    end
+  end
+
+  describe '.compass' do
+    it 'converts cardinals' do
+      expect(M9t::Direction.compass('N').value).to eq(0)
+    end
+
+    it 'handles 16ths' do
+      expect(M9t::Direction.compass('WSW').value).to eq(247.5)
+    end
+  end
+
+  describe '#value' do
+    let(:degrees) { M9t::Direction.new(45) }
+
+    it 'returns the supplied value' do
+      expect(degrees.value).to eq(45)
+    end
+  end
+
+  describe '#to_s' do
+    context 'not abbreviated' do
+      context 'singular' do
+        subject { M9t::Direction.new(1) }
+
+        it 'returns the full unit name' do
+          expect(subject.to_s).to eq('1 degree')
+        end
+
+        it 'translates' do
+          I18n.locale = :it
+          expect(subject.to_s).to eq('1 grado')
+        end
+      end
+
+      context 'plural' do
+        subject { M9t::Direction.new(135) }
+
+        it 'returns the full unit name' do
+          expect(subject.to_s).to eq('135 degrees')
+        end
+
+        it 'translates' do
+          I18n.locale = :it
+          expect(subject.to_s).to eq('135 gradi')
+        end
+      end
+    end
+
+    context 'abbreviated' do
+      subject { M9t::Direction.new(135) }
+
+      it 'uses the symbol' do
+        expect(subject.to_s(:abbreviated => true)).to eq('135°')
+      end
+    end
+
+    context 'compass units' do
+      subject { M9t::Direction.new(225) }
+
+      it 'works' do
+        expect(subject.to_s(:units => :compass)).to eq('SW')
+      end
+
+      it 'translates' do
+        I18n.locale = :it
+        expect(subject.to_s(:units => :compass)).to eq('SO')
+      end
+    end
+  end
+
+  describe '#to_compass' do
+    subject { M9t::Direction.new(0) }
+
+    it 'is correct' do
+      expect(subject.to_compass).to eq('N')
+    end
+  end
+end
+