m9t 0.3.2 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e9e5be154c21f5d10e86c7c6f906f5bdd2287c56797965f8430c12fbcee09b2
+  data.tar.gz: c23bd6fe57b417fc46680c9c91dfe7517ea0833e1ec76f6cd959df5466a02028
+SHA512:
+  metadata.gz: 12f3a7e3428384abfa69f90c2d7210dff7ba94494ae82e14b0be892159de160722ad60fd16502e68b699e228a1206af122246ff3c2062c24e14d942d0e90831f
+  data.tar.gz: 0b2fd9ec442f4dcaf8d992a3d301404d91c4ce6da76972affe6c40deb152f034cc6cc76a752ad921a7328748d3e4b05a40ee50edfe7675e687856fc5dcac58f1

data/.gitignore

@@ -0,0 +1,6 @@
+/bin/
+/coverage/
+/Gemfile.lock
+/pkg/
+/vendor/bundle/
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,13 @@
+sudo: false
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.2.0
+  - 2.3.0
+  - 2.4.0
+  - jruby-19mode
+branches:
+  only:
+    - master
+script: "bundle exec rake spec"

data/Gemfile

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

data/README.md

@@ -1,5 +1,8 @@
-m9t [![Build Status](https://secure.travis-ci.org/joeyates/m9t.png)][Continuous Integration]
-===
+[![Build Status](https://secure.travis-ci.org/joeyates/m9t.png)][Continuous Integration]
+[![Source Analysis](https://codeclimate.com/github/joeyates/m9t/badges/gpa.svg)](https://codeclimate.com/github/joeyates/m9t)
+[![Test Coverage](https://codeclimate.com/github/joeyates/m9t/badges/coverage.svg)](https://codeclimate.com/github/joeyates/m9t/coverage)
+
+# m9t
 
 *Measurements and coversions library for Ruby*
 
@@ -42,45 +45,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
-
-Testing
-=======
-
-Coverage
---------
-
-ruby 1.8.x:
-
-    $ rake rcov
-
-ruby 1.9.x:
-
-    $ COVERAGE=1 rake test
+```ruby
+M9t::Distance.miles_to_meters(26.21875) -> 42194.988
+```
 
 Alternatives
 ============
@@ -91,6 +90,12 @@ Alternatives
   - Monkey patches a lot of core classes:
     - Adds methods to e.g. Object.
 
+Contributors
+============
+
+* [Joe Yates](https://github.com/joeyates)
+* [Florian Egermann and Mathias Wollin](https://github.com/math)
+
 License
 =======
 

data/Rakefile

@@ -1,32 +1,10 @@
-require 'bundler'
-require 'rake/testtask'
+#!/usr/bin/env rake
 
-$:.unshift( File.dirname(__FILE__) + '/lib' )
-require 'm9t'
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-task :default => :test
+task default: :spec
 
-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/'
-  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.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2010 Joe Yates
+# Copyright (c) 2010-2021 Joe Yates
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -22,26 +22,10 @@
 #++
 
 # encoding: utf-8
-require 'i18n'
 
-locales_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'locales'))
-I18n.load_path += Dir.glob("#{ locales_path }/*.yml")
-I18n.reload!
+module M9t; end
 
-libs = %w( base direction distance i18n pressure speed temperature version )
-libs.each do | library |
-  require "m9t/#{ library }"
+libs = %w(i18n base direction distance pressure speed temperature version)
+libs.each do |library|
+  require "m9t/#{library}"
 end
-
-module M9t
-
-  # Base class for all M9t exceptions
-  class M9tError < StandardError
-  end
-
-  # Raised when a M9t class receives an unrecogized ':units' value
-  class UnitError < M9tError
-  end
-
-end
-

data/lib/m9t/base.rb

@@ -1,45 +1,65 @@
-# encoding: utf-8
-require 'i18n'
+require "m9t/errors"
+require "m9t/i18n"
 
 module M9t
-
   module Base
-
     def self.generate_conversions(klass)
-      klass.instance_eval do |klass|
+      klass.instance_eval do
         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
-          return send(name, args[0]) if define_constructor(name)
-          raise "Method '#{ name }' unknown" # TODO use standard exception
+          super
+        end
+
+        def respond_to?(name, _include_all = false)
+          from, to = extract_from_and_to(name)
+          return true if from && legal_conversion?(from, to)
+          legal_constructor?(name)
         end
 
         private
 
+        def extract_from_and_to(name)
+          name.to_s.scan(/^(\w+)_to_(\w+)$/)[0]
+        end
+
+        def legal_conversion?(from, to)
+          self::CONVERSIONS.include?(from.to_sym) &&
+            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|
+            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 ] )
+            define_method(name.to_sym) do |*args|
+              new(args[0].to_f / self::CONVERSIONS[name])
             end
           end
         end
@@ -55,20 +75,21 @@ module M9t
           end
         end
 
-        # Returns the classes current options - see the specific class for defaults
+        # Returns the class's current options - see the specific class for
+        # defaults
         def options
           @options
         end
 
-        # Reloads the class' default options
+        # Reloads the class"s default options
         def reset_options!
-          @options = self::DEFAULT_OPTIONS.clone # 'self::' is necessary with ruby 1.8
+          @options = self::DEFAULT_OPTIONS.clone
         end
 
         # The name used for i18n translations
-        #  M9t::Distance => 'distance'
+        #  M9t::Distance => "distance"
         def measurement_name
-          name.split('::')[-1].downcase
+          name.split("::")[-1].downcase
         end
 
         def default_unit
@@ -86,51 +107,73 @@ module M9t
     end
 
     attr_reader :value, :options
-    alias :to_f :value
+    alias_method :to_f, :value
 
-    def initialize( value )
+    def initialize(value)
       @value = value.to_f
     end
 
     # 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 && 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 && legal_conversion?(to)
+      super
     end
 
     # Returns the string representation of the measurement,
     # taking into account locale, desired units and abbreviation.
-    def to_s( options = {} )
-      options = self.class.options.merge( options )
-      units_error( options[ :units ] ) if not self.class::CONVERSIONS.has_key?( options[ :units ] )
-      value_in_units = self.send("to_#{ options[:units] }")
-      localized_value = I18n.localize_float(value_in_units, {:format => "%0.#{ options[:precision] }f"})
+    def to_s(options = {})
+      options = self.class.options.merge(options)
+      unless self.class::CONVERSIONS.include?(options[:units])
+        units_error(options[:units])
+      end
+      value_in_units = send("to_#{options[:units]}")
+      localized_value = I18n.localize_float(
+        value_in_units, format: "%0.#{options[:precision]}f"
+      )
 
-      key = 'units.' + self.class.measurement_name + '.' + options[:units].to_s
-      options[:abbreviated] ? key += '.abbreviated' : key += '.full'
-      unit = I18n.t(key, {:count => value_in_units})
+      key = i18n_key(options)
+      unit = I18n.t(key, count: value_in_units)
 
-      "#{ localized_value }%s#{ unit }" % (options[:abbreviated] ? '' : ' ')
+      "#{localized_value}%s#{unit}" % (options[:abbreviated] ? "" : " ")
     end
 
     private
 
+    def i18n_key(options = {})
+      key = "units.#{self.class.measurement_name}.#{options[:units]}"
+      key += options[:abbreviated] ? ".abbreviated" : ".full"
+      key
+    end
+
     def units_error(units)
-      raise M9t::UnitError.new("Unknown units '#{ units }'. Known: #{ self.class::CONVERSIONS.keys.collect{|unit| unit.to_s}.join(', ') }")
+      known = self.class::CONVERSIONS.keys.collect(&:to_s).join(", ")
+      fail M9t::UnitError, %Q(Unknown units "#{units}". Known: #{known})
+    end
+
+    def extract_to(name)
+      name.to_s[/^to_(\w+)$/, 1]
+    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
-          self.class.convert(self.class.default_unit, to.to_sym, self.to_f)
+        define_method("to_#{to}") do
+          self.class.convert(self.class.default_unit, to.to_sym, to_f)
         end
       end
-      true
     end
-
   end
-
 end

data/lib/m9t/direction.rb

@@ -1,14 +1,12 @@
-# encoding: utf-8
-require 'i18n'
+require "m9t/base"
 
 module M9t
-
   # Represents a geographical direction
   class Direction
-    DEFAULT_OPTIONS = {:units => :degrees, :abbreviated => false, :decimals => 5}
-    CONVERSIONS          = {
-      :degrees  => 1.0,
-      :compass  => nil,
+    DEFAULT_OPTIONS = {units: :degrees, abbreviated: false, decimals: 5}
+    CONVERSIONS = {
+      degrees:  1.0,
+      compass:  nil,
     }
 
     # Conversions
@@ -18,39 +16,35 @@ module M9t
     include M9t::Base
 
     class << self
-
       # Given a value in degrees, returns the nearest (localized) compass direction
-      #  M9t::Directions.to_compass(42) => 'NE'
+      #  M9t::Directions.to_compass(42) => "NE"
       def degrees_to_compass(degrees)
         sector = (normalize(degrees) / COMPASS_SECTOR_DEGREES).round
-        I18n.t(self.measurement_name + '.sectors')[sector]
+        I18n.t(self.measurement_name + ".sectors")[sector]
       end
 
       def compass_to_degrees(compass_direction)
         compass(compass_direction).to_f
       end
 
-      # Accepts a localized compass direction (e.g. 'N') and returns the equivalent M9t::Direction
-      #  M9t::Direction.compass('NE') => #<M9t::Direction:0xb76cc750 @value=45.0, @options={:units=>:degrees, :decimals=>5, :abbreviated=>false}>
+      # Accepts a localized compass direction (e.g. "N") and returns the equivalent M9t::Direction
+      #  M9t::Direction.compass("NE") => #<M9t::Direction:0x000000014a438618 @value=45.0>
       def compass(compass_direction)
-        sector = I18n.t(self.measurement_name + '.sectors').find_index(compass_direction)
-        raise "Compass direction '#{ compass_direction }' not recognised" if sector.nil?
+        sector = I18n.t(self.measurement_name + ".sectors").find_index(compass_direction)
+        raise "Compass direction '#{compass_direction}' not recognised" if sector.nil?
         new(sector.to_f * COMPASS_SECTOR_DEGREES)
       end
 
       # Reduce directions in degrees to the range [0, 360)
       #  M9t::Direction.normalize(1000) => 280.0
       def normalize(degrees)
-        case
-        when degrees < 0
-          normalize(degrees + CIRCLE)
-        when degrees >= CIRCLE
-          normalize(degrees - CIRCLE)
+        remainder = degrees.remainder(CIRCLE)
+        if remainder < 0
+          remainder + CIRCLE
         else
-          degrees
+          remainder
         end
       end
-
     end
 
     # Handles the special case where compass directions are the desired output.
@@ -65,7 +59,5 @@ module M9t
     def to_compass
       self.class.degrees_to_compass(@value)
     end
-
   end
-
 end