measured 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c85f59c2c66ee777904c96802d3c647887dd1fb
-  data.tar.gz: 59e9b89428cab80194f786aa714cb9bb4396473c
+  metadata.gz: 764bee6ab868a789054d59899c4537f87683066f
+  data.tar.gz: c15508d99d6154c9b1d2cef708d45d914d7f7071
 SHA512:
-  metadata.gz: afaf1dc4ad37532af6235a2b4737801096c7cfb0984f8c38c3038659db3558febc09b5770325b0cb246ed916fca852e21503bac853d0bbdd7de7aea4c579fde3
-  data.tar.gz: ad503908ae66eebe29f56830a414c072b75753fe4698b36402d73c58e2a8b53b333f249a27a325af0510a2610f36f8294036c769f1aa1cd1aabb8de7335916b2
+  metadata.gz: abfd4a35d558578bbef37100de6c2f2f16d6e8557bc05f892c549a93c5adce7d61c5102bb7bad73c00fa3acf0a245e7cddefb26a86228d09fb0dd2dc66b0a4a6
+  data.tar.gz: 736f30253c7df7f6fd63ccf7d6c1db550ee09420bc0709473287aa8494ca6307b536bb3aa7fee74ff5cea1bdf6cb4ab84d4d1ef35cd0c14c75601d2f7c698564

data/README.md

@@ -185,12 +185,23 @@ class Measured::Thing < Measured::Measurable
 
   conversion.add :different_unit
     aliases: [:du],
-    value: [Rational(2/3), "another_unit"]  # Conversion rate can be Rational, otherwise it is coerced to BigDecimal
+    value: [Rational(2,3), "another_unit"]  # Conversion rate can be Rational, otherwise it is coerced to BigDecimal
+end
+```
+
+By default all names and aliases and case insensitive. If you would like to create a new unit with names and aliases that are case sensitive, you should subclass `Measured::CaseSensitiveMeasurable` instead. Other than case sensitivity, both classes are identical to each other.
+
+```ruby
+class Measured::Thing < Measured::CaseSensitiveMeasurable
+  conversion.set_base :base_unit,
+    aliases: [:bu]
 end
 ```
 
 The base unit takes no value. Values for conversion units can be defined as a string with two tokens `"number unit"` or as an array with two elements. The numbers must be `Rational` or `BigDecimal`, else they will be coerced to `BigDecimal`. Conversion paths don't have to be direct as a conversion table will be built for all possible conversions using tree traversal.
 
+The `case_sensitive` flag, which is false by default, gets taken into account any time you attempt to reference a unit by name or alias.
+
 You can also open up the existing classes and add a new conversion:
 
 ```ruby

data/lib/measured/base.rb

@@ -29,3 +29,4 @@ require "measured/unit"
 require "measured/conversion"
 require "measured/conversion_table"
 require "measured/measurable"
+require "measured/case_sensitive_measurable"

data/lib/measured/case_sensitive_measurable.rb

@@ -0,0 +1,7 @@
+class Measured::CaseSensitiveMeasurable < Measured::Measurable
+  class << self
+    def conversion
+      @conversion ||= Measured::Conversion.new(case_sensitive: true)
+    end
+  end
+end

data/lib/measured/conversion.rb

@@ -1,11 +1,12 @@
 class Measured::Conversion
   ARBITRARY_CONVERSION_PRECISION = 20
-  def initialize
+  def initialize(case_sensitive: false)
     @base_unit = nil
     @units = []
+    @case_sensitive = case_sensitive
   end
 
-  attr_reader :base_unit, :units
+  attr_reader :base_unit, :units, :case_sensitive
 
   def set_base(unit_name, aliases: [])
     add_new_unit(unit_name, aliases: aliases, base: true)
@@ -24,11 +25,13 @@ class Measured::Conversion
   end
 
   def unit_or_alias?(name)
-    unit_names_with_aliases.include?(name.to_s)
+    @units.each{|unit| return true if unit.names_include?(name, case_sensitive: @case_sensitive)}
+    false
   end
 
   def unit?(name)
-    unit_names.include?(name.to_s)
+    @units.each{|unit| return true if unit.name_eql?(name, case_sensitive: @case_sensitive)}
+    false
   end
 
   def to_unit_name(name)
@@ -79,7 +82,7 @@ class Measured::Conversion
 
   def unit_for(name)
     @units.each do |unit|
-      return unit if unit.names.include?(name.to_s)
+      return unit if unit.names_include?(name, case_sensitive: @case_sensitive)
     end
 
     raise Measured::UnitError, "Cannot find unit for #{ name }."

data/lib/measured/unit.rb

@@ -10,6 +10,22 @@ class Measured::Unit
 
   attr_reader :name, :names, :conversion_amount, :conversion_unit
 
+  def name_eql?(name_to_compare, case_sensitive: false)
+    return false unless name_to_compare.present?
+    name_to_compare = name_to_compare.to_s
+    case_sensitive ? @name.eql?(name_to_compare) : case_insensitive(@name).include?(name_to_compare.downcase)
+  end
+
+  def names_include?(name_to_compare, case_sensitive: false)
+    return false unless name_to_compare.present?
+    name_to_compare = name_to_compare.to_s
+    case_sensitive ? @names.include?(name_to_compare) : case_insensitive(@names).include?(name_to_compare.downcase)
+  end
+
+  def add_alias(aliases)
+    @names = (@names << aliases).flatten.sort unless aliases.nil? || aliases.empty?
+  end
+
   def to_s
     if conversion_string
       "#{ @name } (#{ conversion_string })"
@@ -40,6 +56,10 @@ class Measured::Unit
 
   private
 
+  def case_insensitive(comparison)
+    [comparison].flatten.map(&:downcase)
+  end
+
   def conversion_string
     "#{ conversion_amount } #{ conversion_unit }" if @conversion_amount || @conversion_unit
   end

data/lib/measured/version.rb

@@ -1,3 +1,3 @@
 module Measured
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/test/case_sensitive_measurable_test.rb

@@ -0,0 +1,227 @@
+require "test_helper"
+
+class Measured::CaseSensitiveMeasurableTest < ActiveSupport::TestCase
+
+  setup do
+    @magic = CaseSensitiveMagic.new(10, :magic_missile)
+  end
+
+  test "#initialize requires two params, the amount and the unit" do
+    assert_nothing_raised do
+      CaseSensitiveMagic.new(1, "fireball")
+    end
+
+    assert_raises ArgumentError do
+      CaseSensitiveMagic.new(1)
+    end
+  end
+
+  test "#initialize converts unit to string from symbol" do
+    magic = CaseSensitiveMagic.new(1, :arcane)
+    assert_equal "arcane", magic.unit
+  end
+
+  test "#initialize raises if it is an unknown unit" do
+    assert_raises Measured::UnitError do
+      CaseSensitiveMagic.new(1, "slash")
+    end
+  end
+
+  test "#initialize converts numbers and strings into BigDecimal" do
+    assert_equal BigDecimal(1), CaseSensitiveMagic.new(1, :arcane).value
+    assert_equal BigDecimal("2.3"), CaseSensitiveMagic.new("2.3", :arcane).value
+    assert_equal BigDecimal("5"), CaseSensitiveMagic.new("5", :arcane).value
+  end
+
+  test "#initialize converts floats to strings and then to BigDecimal so it does not raise" do
+    assert_equal BigDecimal("1.2345"), CaseSensitiveMagic.new(1.2345, :fire).value
+  end
+
+  test "#initialize converts numbers and strings BigDecimal and does not round large numbers" do
+    assert_equal BigDecimal(9.1234572342342, 14), CaseSensitiveMagic.new(9.1234572342342, :fire).value
+    assert_equal BigDecimal("9.1234572342342"), CaseSensitiveMagic.new(9.1234572342342, :fire).value
+  end
+
+  test "#initialize converts to the base unit name" do
+    assert_equal "fireball", CaseSensitiveMagic.new(1, :fire).unit
+  end
+
+  test "#initialize raises an expected error when initializing with nil value" do
+    exception = assert_raises(Measured::UnitError) do
+      CaseSensitiveMagic.new(nil, :fire)
+    end
+    assert_equal "Unit value cannot be nil", exception.message
+  end
+
+  test "#initialize raises an expected error when initializing with nil unit" do
+    exception = assert_raises(Measured::UnitError) do
+      CaseSensitiveMagic.new(1, nil)
+    end
+    assert_equal "Unit cannot be blank", exception.message
+  end
+
+  test "#initialize raises an expected error when initializing with empty string value" do
+    exception = assert_raises(Measured::UnitError) do
+      CaseSensitiveMagic.new("", :fire)
+    end
+    assert_equal "Unit value cannot be blank", exception.message
+  end
+
+  test "#initialize raises an expected error when initializing with empty string unit" do
+    exception = assert_raises(Measured::UnitError) do
+      CaseSensitiveMagic.new(1, "")
+    end
+    assert_equal "Unit cannot be blank", exception.message
+  end
+
+  test "#unit allows you to read the unit string" do
+    assert_equal "magic_missile", @magic.unit
+  end
+
+  test "#value allows you to read the numeric value" do
+    assert_equal BigDecimal(10), @magic.value
+  end
+
+  test ".conversion is set and cached" do
+    conversion = CaseSensitiveMagic.conversion
+
+    assert_instance_of Measured::Conversion, conversion
+    assert_equal conversion, CaseSensitiveMagic.conversion
+  end
+
+  test ".conversion is set to case sensitive" do
+    conversion = CaseSensitiveMagic.conversion
+
+    assert_instance_of Measured::Conversion, conversion
+    assert_equal conversion, CaseSensitiveMagic.conversion
+    assert_equal true, conversion.case_sensitive
+  end
+
+  test ".units returns just the base units" do
+    assert_equal ["arcane", "fireball", "ice", "magic_missile", "ultima"], CaseSensitiveMagic.units
+  end
+
+  test ".units_with_aliases returns all units" do
+    assert_equal ["arcane", "fire", "fireball", "fireballs", "ice", "magic_missile", "magic_missiles", "ultima"], CaseSensitiveMagic.units_with_aliases
+  end
+
+  test ".valid_unit? looks at the list of units and aliases" do
+    assert CaseSensitiveMagic.valid_unit?("fire")
+    assert CaseSensitiveMagic.valid_unit?("fireball")
+    assert CaseSensitiveMagic.valid_unit?(:ice)
+    refute CaseSensitiveMagic.valid_unit?("junk")
+  end
+
+  test ".name looks at the class name" do
+    module Example
+      class VeryComplexThing < Measured::Measurable ; end
+    end
+
+    assert_equal "case sensitive magic", CaseSensitiveMagic.name
+    assert_equal "measurable", Measured::Measurable.name
+    assert_equal "very complex thing", Example::VeryComplexThing.name
+  end
+
+  test "#convert_to raises on an invalid unit" do
+    assert_raises Measured::UnitError do
+      @magic.convert_to(:punch)
+    end
+  end
+
+  test "#convert_to returns a new object of the same type in the new unit" do
+    converted = @magic.convert_to(:arcane)
+
+    assert_equal converted, @magic
+    refute_equal converted.object_id, @magic.object_id
+    assert_equal BigDecimal(10), @magic.value
+    assert_equal "magic_missile", @magic.unit
+    assert_equal BigDecimal(1), converted.value
+    assert_equal "arcane", converted.unit
+  end
+
+  test "#convert_to from and to the same unit returns the same object" do
+    converted = @magic.convert_to(@magic.unit)
+    assert_equal converted.object_id, @magic.object_id
+  end
+
+  test "#convert_to! replaces the existing object with a new version in the new unit" do
+    converted = @magic.convert_to!(:arcane)
+
+    assert_equal converted, @magic
+    assert_equal BigDecimal(1), @magic.value
+    assert_equal "arcane", @magic.unit
+    assert_equal BigDecimal(1), converted.value
+    assert_equal "arcane", converted.unit
+  end
+
+  test "#to_s outputs the number and the unit" do
+    assert_equal "10 fireball", CaseSensitiveMagic.new(10, :fire).to_s
+    assert_equal "1.234 magic_missile", CaseSensitiveMagic.new("1.234", :magic_missile).to_s
+  end
+
+  test "#inspect shows the number and the unit" do
+    assert_equal "#<CaseSensitiveMagic: 10.0 fireball>", CaseSensitiveMagic.new(10, :fire).inspect
+    assert_equal "#<CaseSensitiveMagic: 1.234 magic_missile>", CaseSensitiveMagic.new(1.234, :magic_missile).inspect
+  end
+
+  test "#<=> compares regardless of the unit" do
+    assert_equal -1, @magic <=> CaseSensitiveMagic.new(10, :fire)
+    assert_equal 1, @magic <=> CaseSensitiveMagic.new(9, :magic_missile)
+    assert_equal 0, @magic <=> CaseSensitiveMagic.new(10, :magic_missile)
+    assert_equal -1, @magic <=> CaseSensitiveMagic.new(11, :magic_missile)
+  end
+
+  test "#<=> compares against zero" do
+    assert_equal 1, @magic <=> 0
+    assert_equal 1, @magic <=> BigDecimal.new(0)
+    assert_equal 1, @magic <=> 0.00
+    assert_equal -1, CaseSensitiveMagic.new(-1, :magic_missile) <=> 0
+  end
+
+  test "#== should be the same if the classes, unit, and amount match" do
+    assert @magic == @magic
+    assert CaseSensitiveMagic.new(10, :magic_missile) == CaseSensitiveMagic.new("10", "magic_missile")
+    assert CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10, :magic_missile)
+    refute CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10.1, :magic_missile)
+  end
+
+  test "#== should be the same if the classes and amount match but the unit does not so they convert" do
+    assert CaseSensitiveMagic.new(2, :magic_missile) == CaseSensitiveMagic.new("1", "ice")
+  end
+
+  test "#== compares against zero" do
+    assert CaseSensitiveMagic.new(0, :fire) == 0
+    assert CaseSensitiveMagic.new(0, :magic_missile) == 0
+    assert CaseSensitiveMagic.new(0, :fire) == BigDecimal.new(0)
+    assert CaseSensitiveMagic.new(0, :fire) == 0.00
+    refute @magic == 0
+    refute @magic == BigDecimal.new(0)
+  end
+
+  test "#> and #< should compare measurements" do
+    assert CaseSensitiveMagic.new(10, :magic_missile) < CaseSensitiveMagic.new(20, :magic_missile)
+    refute CaseSensitiveMagic.new(10, :magic_missile) > CaseSensitiveMagic.new(20, :magic_missile)
+  end
+
+  test "#> and #< should compare measurements of different units" do
+    assert CaseSensitiveMagic.new(10, :magic_missile) < CaseSensitiveMagic.new(100, :ice)
+    refute CaseSensitiveMagic.new(10, :magic_missile) > CaseSensitiveMagic.new(100, :ice)
+  end
+
+  test "#> and #< should compare against zero" do
+    assert @magic > 0
+    assert @magic > BigDecimal.new(0)
+    assert @magic > 0.00
+    assert CaseSensitiveMagic.new(-1, :arcane) < 0
+    refute @magic < 0
+    refute CaseSensitiveMagic.new(-1, :arcane) > 0
+  end
+
+  test "#eql? should be the same if the classes and amount match, and unit is converted" do
+    assert @magic == @magic
+    assert CaseSensitiveMagic.new(10, :magic_missile) == CaseSensitiveMagic.new("10", "magic_missile")
+    assert CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10, :magic_missile)
+    refute CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10.1, :magic_missile)
+  end
+
+end

data/test/conversion_test.rb

@@ -66,20 +66,57 @@ class Measured::ConversionTest < ActiveSupport::TestCase
 
     assert @conversion.unit?(:inch)
     assert @conversion.unit?("m")
+    assert @conversion.unit?("M")
     refute @conversion.unit?("in")
     refute @conversion.unit?(:yard)
   end
 
+  test "#unit? takes into account case_sensitive flag" do
+    conversion = Measured::Conversion.new(case_sensitive: true)
+    conversion.set_base :m
+    conversion.add :inch, aliases: [:in], value: "0.0254 meter"
+
+    assert conversion.unit?(:inch)
+    assert conversion.unit?("m")
+    refute conversion.unit?("M")
+    refute conversion.unit?("in")
+  end
+
+  test "#unit? with blank and nil arguments" do
+    refute @conversion.unit?("")
+    refute @conversion.unit?(nil)
+  end
+
   test "#unit_or_alias? checks if the unit is part of the units but not aliases" do
     @conversion.set_base :m
     @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
 
     assert @conversion.unit_or_alias?(:inch)
     assert @conversion.unit_or_alias?("m")
+    assert @conversion.unit_or_alias?(:IN)
     assert @conversion.unit_or_alias?("in")
     refute @conversion.unit_or_alias?(:yard)
   end
 
+  test "#unit_or_alias? takes into account case_sensitive flag" do
+    conversion = Measured::Conversion.new(case_sensitive: true)
+    conversion.set_base :m
+    conversion.add :inch, aliases: [:in], value: "0.0254 meter"
+
+    assert conversion.unit_or_alias?(:inch)
+    assert conversion.unit_or_alias?("m")
+    refute conversion.unit_or_alias?(:M)
+    refute conversion.unit_or_alias?("IN")
+  end
+
+  test "#unit_or_alias? with blank and nil arguments" do
+    @conversion.set_base :m
+    @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
+
+    refute @conversion.unit_or_alias?("")
+    refute @conversion.unit_or_alias?(nil)
+  end
+
   test "#to_unit_name converts a unit name to its base unit" do
     assert_equal "fireball", Magic.conversion.to_unit_name("fire")
   end

data/test/support/fake_system.rb

@@ -18,6 +18,26 @@ class Magic < Measured::Measurable
 
 end
 
+class CaseSensitiveMagic < Measured::CaseSensitiveMeasurable
+
+  conversion.set_base :magic_missile,
+    aliases: [:magic_missiles]
+
+  conversion.add :fireball,
+    aliases: [:fire, :fireballs],
+    value: "2/3 magic_missile"
+
+  conversion.add :ice,
+    value: "2 magic_missile"
+
+  conversion.add :arcane,
+    value: "10 magic_missile"
+
+  conversion.add :ultima,
+    value: "10 arcane"
+
+end
+
 class OtherFakeSystem < Measured::Measurable
 
   conversion.set_base :other_fake_base

data/test/unit_test.rb

@@ -13,6 +13,70 @@ class Measured::UnitTest < ActiveSupport::TestCase
     assert_equal ["cake", "pie", "sweets"], Measured::Unit.new(:pie, aliases: ["cake", :sweets]).names
   end
 
+  test "#name_eql?" do
+    assert @unit.name_eql?("pIe")
+    refute @unit.name_eql?("pastry")
+  end
+
+  test "#name_eql? with case_sensitive true" do
+    assert @unit.name_eql?("pie", case_sensitive: true)
+    refute @unit.name_eql?("Pie", case_sensitive: true)
+  end
+
+  test "#name_eql? with empty string" do
+    assert @unit.name_eql?("pie")
+    refute @unit.name_eql?("")
+  end
+
+  test "#names_include?" do
+    unit = Measured::Unit.new(:pie, aliases:["cake", "tart"])
+    assert unit.names_include?("pie")
+    assert unit.names_include?("caKe")
+    assert unit.names_include?("taRt")
+    refute unit.names_include?("pastry")
+  end
+
+  test "#names_include? with case_sensitive true" do
+    unit = Measured::Unit.new(:pie, aliases:["cake", "tart"])
+    assert unit.names_include?("pie", case_sensitive: true)
+    assert unit.names_include?("cake", case_sensitive: true)
+    refute unit.names_include?("TART", case_sensitive: true)
+  end
+
+  test "#names_include? with empty string" do
+    unit = Measured::Unit.new(:pie, aliases: ["cake", "tart"])
+    assert unit.names_include?("cake")
+    refute unit.names_include?("")
+  end
+
+  test "#add_alias with string" do
+    unit = Measured::Unit.new(:pie, aliases: ["cake"], value: "10 cake")
+    assert_equal ["cake", "pie"], unit.names
+    unit.add_alias("pastry")
+    assert_equal ["cake", "pastry", "pie"], unit.names
+  end
+
+  test "#add_alias with array" do
+    unit = Measured::Unit.new(:pie, aliases: ["cake"], value: "10 cake")
+    assert_equal ["cake", "pie"], unit.names
+    unit.add_alias(["pastry", "tart", "turnover"])
+    assert_equal ["cake", "pastry", "pie", "tart", "turnover"], unit.names
+  end
+
+  test "#add_alias with nil" do
+    unit = Measured::Unit.new(:pie, aliases: ["cake"], value: "10 cake")
+    assert_equal ["cake", "pie"], unit.names
+    unit.add_alias(nil)
+    assert_equal ["cake", "pie"], unit.names
+  end
+
+  test "#add_alias with empty string" do
+    unit = Measured::Unit.new(:pie, aliases: ["cake"], value: "10 cake")
+    assert_equal ["cake", "pie"], unit.names
+    unit.add_alias("")
+    assert_equal ["cake", "pie"], unit.names
+  end
+
   test "#initialize parses out the unit and the number part" do
     assert_equal BigDecimal(10), @unit.conversion_amount
     assert_equal "cake", @unit.conversion_unit

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: measured
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Kevin McPhillips
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-12 00:00:00.000000000 Z
+date: 2015-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -97,6 +97,7 @@ files:
 - lib/measured.rb
 - lib/measured/arithmetic.rb
 - lib/measured/base.rb
+- lib/measured/case_sensitive_measurable.rb
 - lib/measured/conversion.rb
 - lib/measured/conversion_table.rb
 - lib/measured/measurable.rb
@@ -108,6 +109,7 @@ files:
 - repodb.yml
 - shipit.rubygems.yml
 - test/arithmetic_test.rb
+- test/case_sensitive_measurable_test.rb
 - test/conversion_table_test.rb
 - test/conversion_test.rb
 - test/measurable_test.rb
@@ -137,12 +139,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: Encapsulate measurements with their units in Ruby
 test_files:
 - test/arithmetic_test.rb
+- test/case_sensitive_measurable_test.rb
 - test/conversion_table_test.rb
 - test/conversion_test.rb
 - test/measurable_test.rb