measurb 0.0.1

data/spec/comparison_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Measurb::Dimension do
+  before :context do
+    clear_defined_inches
+    clear_defined_feet
+    remove_loaded_default_dimensions
+
+    Measurb.configure do |config|
+      config.enable_defaults :inches, :feet
+    end
+  end
+
+  it 'defines all the comparison methods' do
+    expect(Measurb::Dimension).to have_method(:<=>)
+    expect(Measurb::Dimension).to have_method(:<)
+    expect(Measurb::Dimension).to have_method(:>)
+    expect(Measurb::Dimension).to have_method(:<=)
+    expect(Measurb::Dimension).to have_method(:>=)
+  end
+
+  it 'handles inequality operations correctly with same class' do
+    expect(2.feet).to_not        be <  2.feet
+    expect(2.feet).to_not        be >  2.feet
+    expect(2.feet).to            be <= 2.feet
+    expect(2.feet).to            be >= 2.feet
+    expect(2.feet <=> 2.feet).to be(0)
+
+    expect(2.feet).to            be <  3.feet
+    expect(2.feet).to            be <= 3.feet
+    expect(2.feet).to_not        be >  3.feet
+    expect(2.feet).to_not        be >= 3.feet
+    expect(2.feet <=> 3.feet).to be(-1)
+
+    expect(3.feet).to_not        be <  2.feet
+    expect(3.feet).to_not        be <= 2.feet
+    expect(3.feet).to            be >  2.feet
+    expect(3.feet).to            be >= 2.feet
+    expect(3.feet <=> 2.feet).to be(1)
+  end
+
+  it 'handles inequality operations correctly with a different dimension class' do
+    expect(2.feet).to_not           be <  24.inches
+    expect(2.feet).to_not           be >  24.inches
+    expect(2.feet).to               be <= 24.inches
+    expect(2.feet).to               be >= 24.inches
+    expect(2.feet <=> 24.inches).to be(0)
+
+    expect(2.feet).to            be <  36.inches
+    expect(2.feet).to            be <= 36.inches
+    expect(2.feet).to_not        be >  36.inches
+    expect(2.feet).to_not        be >= 36.inches
+    expect(2.feet <=> 36.inches).to be(-1)
+
+    expect(3.feet).to_not        be <  24.inches
+    expect(3.feet).to_not        be <= 24.inches
+    expect(3.feet).to            be >  24.inches
+    expect(3.feet).to            be >= 24.inches
+    expect(3.feet <=> 24.inches).to be(1)
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'rspec/expectations'
+
+describe Measurb do
+  describe '.config' do
+    def get_config
+      Measurb.__send__(:config)
+    end
+
+    subject { get_config }
+
+    it { should be_a Measurb::Config }
+
+    describe '.enable_defaults' do
+      before :example do
+        clear_defined_inches
+        clear_defined_feet
+        clear_defined_yards
+        remove_loaded_default_dimensions
+      end
+
+      let :dims_dimensions do
+        Measurb.constants.reduce([]) do |array, constant_name|
+          constant = Measurb.const_get(constant_name)
+          array << constant if constant.is_a?(Class) && constant < Measurb::Dimension
+          array
+        end
+      end
+
+      context 'without arguments' do
+        subject { get_config.enable_defaults }
+
+        it "doesn't add any dimensions" do
+          subject
+          expect(dims_dimensions).to be_empty
+        end
+
+        it 'returns an empty array' do
+          expect(subject).to be_empty
+        end
+      end
+
+      context 'with one argument' do
+        subject { get_config.enable_defaults(:inches) }
+
+        it 'only adds the one dimension' do
+          subject
+          expect(dims_dimensions).to match_array [Measurb::Inches]
+        end
+
+        it 'returns the enabled dimension name in an array' do
+          expect(subject).to match_array [:inches]
+        end
+      end
+
+      context 'with more than one argument' do
+        subject { get_config.enable_defaults(:inches, :feet) }
+
+        it 'only adds the given dimensions' do
+          subject
+          expect(dims_dimensions).to match_array [Measurb::Inches, Measurb::Feet]
+        end
+
+        it 'returns the enabled dimension names in an array' do
+          expect(subject).to match_array [:inches, :feet]
+        end
+      end
+
+      context 'with fake default dimension name arguments' do
+        subject { get_config.enable_defaults(:inches, :miles, :feet, :leagues) }
+
+        it 'only adds the available default dimensions' do
+          subject
+          expect(dims_dimensions).to match_array [Measurb::Inches, Measurb::Feet]
+        end
+
+        it 'returns only the enabled available dimension names in an array' do
+          expect(subject).to match_array [:inches, :feet]
+        end
+
+        it 'outputs a warning for each unavailable default dimension name' do
+          expectation = "'miles' is not a default dimension\n" <<
+                        "'leagues' is not a default dimension\n"
+
+          expect { subject }.to output(expectation).to_stderr
+        end
+      end
+    end
+  end
+end

data/spec/conversions_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Measurb do
+  describe '.define' do
+    shared_context 'defines own conversion' do |with_abbrev = false|
+      it 'defines own conversion' do
+        expect(Measurb::Inches).to have_method(:to_inches)
+      end
+
+      it 'returns itself' do
+        n = 42.inches
+        expect(n.to_inches).to be(n)
+      end
+    end
+
+    context 'without define block' do
+      before :example do
+        clear_defined_inches
+        Measurb.define(:inches)
+      end
+
+      include_context 'defines own conversion'
+
+      it "doesn't have other conversions" do
+        expect(Measurb::Inches).to_not have_method(:to_feet)
+      end
+    end
+
+    context 'with define block' do
+      before :example do
+        clear_defined_inches
+        clear_defined_feet
+
+        Measurb.define(:inches) { feet value / 12.0 }
+        Measurb.define(:feet)
+      end
+
+      include_context 'defines own conversion'
+
+      it 'adds the `to_feet` conversion' do
+        expect(Measurb::Inches).to have_method(:to_feet)
+      end
+
+      it 'returns an instance of `Measurb::Feet` with the correct value' do
+        n = 24.inches
+
+        expect(n.to_feet).to be_a(Measurb::Feet)
+        expect(n.to_feet).to eq(2.feet)
+      end
+    end
+  end
+end

data/spec/define_dimension_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Measurb do
+  describe '.define' do
+    before :example do
+      clear_defined_inches
+    end
+
+    shared_context 'adding the Numeric method' do |method, options = {}|
+      it 'adds the Numeric method' do
+        int   = 42
+        float = 3.14
+
+        expect { int.__send__(method) }.to   raise_error(NoMethodError)
+        expect { float.__send__(method) }.to raise_error(NoMethodError)
+
+        Measurb.define(:inches, options)
+
+        expect(int.__send__(method)).to   eq(Measurb::Inches.new(int))
+        expect(float.__send__(method)).to eq(Measurb::Inches.new(float))
+      end
+    end
+
+    it 'creates the class' do
+      expect { Measurb::Inches }.to raise_error(NameError)
+      Measurb.define(:inches)
+      expect(Measurb::Inches).to be < Measurb::Dimension
+    end
+
+    it 'adds the helper method' do
+      expect(Measurb).to_not respond_to(:inches)
+      Measurb.define(:inches)
+      expect(Measurb).to respond_to(:inches)
+    end
+
+    it 'returns the dimension class' do
+      expect(Measurb.define(:inches)).to be(Measurb::Inches)
+    end
+
+    it 'raises an error if the class is already defined' do
+      Measurb.define(:inches)
+
+      expect {
+        Measurb.define(:inches)
+      }.to raise_error(Measurb::DuplicateDimensionError, 'Already defined dimension class `Inches`')
+    end
+
+    include_context 'adding the Numeric method', :inches
+
+    context 'with `abbrev` option' do
+      include_context 'adding the Numeric method', :in, abbrev: 'in'
+    end
+  end
+end

data/spec/dimension_builder_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Measurb::DimensionBuilder do
+  describe '.get_dimension_class_name' do
+    def m(name)
+      Measurb::DimensionBuilder.get_dimension_class_name(name)
+    end
+
+    it 'generates the expected class name from a symbol' do
+      expect(m(:feet)).to           eq('Feet')
+      expect(m(:nautical_miles)).to eq('NauticalMiles')
+    end
+
+    it 'generates the expected class name from a string' do
+      expect(m('feet')).to           eq('Feet')
+      expect(m('nautical_miles')).to eq('NauticalMiles')
+    end
+  end
+end

data/spec/dimension_precision_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Measurb::Dimension do
+  describe '.new' do
+    before :context do
+      clear_defined_inches
+      clear_defined_feet
+      clear_defined_yards
+      remove_loaded_default_dimensions
+
+      Measurb.configure do |config|
+        config.enable_defaults :inches, :feet
+      end
+    end
+
+    let(:default_precision)  { Measurb::DEFAULT_PRECISION }
+    let(:supplied_precision) { 2 }
+
+    let(:int)             { Measurb::Inches.new(42) }
+    let(:int_precision)   { Measurb::Inches.new(42, supplied_precision) }
+    let(:float)           { Measurb::Inches.new(Math::PI) }
+    let(:float_precision) { Measurb::Inches.new(Math::PI, supplied_precision) }
+
+    context 'without precision supplied' do
+      it 'uses the default precision' do
+        expect(int).to   have_precision(default_precision)
+        expect(float).to have_precision(default_precision)
+      end
+
+      it 'keeps the same precision when converted' do
+        expect(int.to_feet).to   have_precision(int.precision)
+        expect(float.to_feet).to have_precision(float.precision)
+      end
+
+      it 'sets the value based on the precision' do
+        expect(int).to       have_value(42.0)
+        expect(int).to       have_value(42)
+        expect(float).to     have_value(3.142)
+        expect(float).to_not have_value(Math::PI)
+      end
+
+      it 'rounds floats correctly' do
+        float1 = Measurb::Inches.new(1.2346)
+        float2 = Measurb::Inches.new(1.2344)
+        float3 = Measurb::Inches.new(1.2345)
+
+        expect(float1).to have_value(1.235)
+        expect(float2).to have_value(1.234)
+        expect(float3).to have_value(1.235)
+      end
+    end
+
+    context 'with precision supplied' do
+      it 'uses the supplied precision' do
+        expect(int_precision).to   have_precision(supplied_precision)
+        expect(float_precision).to have_precision(supplied_precision)
+      end
+
+      it 'keeps the same precision when converted' do
+        expect(int_precision.to_feet).to   have_precision(int_precision.precision)
+        expect(float_precision.to_feet).to have_precision(float_precision.precision)
+      end
+
+      it 'sets the value based on the precision' do
+        expect(int_precision).to       have_value(42.0)
+        expect(int_precision).to       have_value(42)
+        expect(float_precision).to     have_value(3.14)
+        expect(float_precision).to_not have_value(3.1)
+        expect(float_precision).to_not have_value(Math::PI)
+      end
+
+      it 'rounds floats correctly' do
+        float1 = Measurb::Inches.new(1.237, supplied_precision)
+        float2 = Measurb::Inches.new(1.232, supplied_precision)
+        float3 = Measurb::Inches.new(1.235, supplied_precision)
+
+        expect(float1).to have_value(1.24)
+        expect(float2).to have_value(1.23)
+        expect(float3).to have_value(1.24)
+      end
+    end
+  end
+end

data/spec/equality_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Measurb::Dimension do
+  before :context do
+    clear_defined_inches
+    clear_defined_feet
+    remove_loaded_default_dimensions
+
+    Measurb.configure do |config|
+      config.enable_defaults :inches, :feet
+    end
+  end
+
+  describe '#==' do
+    it 'handles equality with itself correctly' do
+      n = 42.inches
+      expect(n).to eq(n)
+      expect(n).to be(n)
+    end
+
+    it 'handles equality with same dimension class correctly' do
+      x, y = 42.inches, 42.inches
+
+      expect(x).to     eq(y)
+      expect(x).to_not be(y)
+      expect(x).to_not eq(24.inches)
+    end
+
+    it 'handles equality with another dimension class correctly' do
+      expect(24.inches).to    eq(2.feet)
+      expect(2.inches).to_not eq(24.feet)
+    end
+  end
+
+  describe '#!=' do
+    it 'handles inequality with itself correctly' do
+      n = 42.inches
+      expect(n != n).to be(false)
+      expect(n).to      be(n)
+    end
+
+    it 'handles inequality with same dimension class correctly' do
+      x = 42.inches
+      expect(x != 42.inches).to be(false)
+      expect(x != 24.inches).to be(true)
+    end
+
+    it 'handles inequality with another dimension class correctly' do
+      expect(24.inches != 2.feet).to  be(false)
+      expect(2.inches  != 24.feet).to be(true)
+    end
+  end
+
+  describe '#eql?' do
+    it 'recognizes equality with itself' do
+      n = 42.inches
+      expect(n).to eql(n)
+      expect(n).to be(n)
+    end
+
+    it 'recognizes equality only with dimensions of the same class and value' do
+      n = 24.inches
+
+      expect(n).to     eql(24.inches)
+      expect(n).to_not eql(2.feet)
+      expect(n).to_not eql(3.feet)
+      expect(n).to_not eql(36.inches)
+    end
+  end
+end

data/spec/helpers/clear_dimensions.rb

@@ -0,0 +1,26 @@
+def remove_loaded_default_dimensions
+  $".delete_if do |file|
+    file =~ %r{measurb/lib/measurb/defaults}
+  end
+end
+
+def clear_defined_dimension(name, abbrev)
+  class_name = name.to_s.capitalize
+
+  Measurb.singleton_class.__send__(:remove_method, name) if Measurb.singleton_class.method_defined?(name)
+  Measurb.__send__(:remove_const, class_name)            if Measurb.const_defined?(class_name)
+  Numeric.__send__(:remove_method, name)                 if Numeric.method_defined?(name)
+  Numeric.__send__(:remove_method, abbrev)               if Numeric.method_defined?(abbrev)
+end
+
+def clear_defined_inches
+  clear_defined_dimension(:inches, :in)
+end
+
+def clear_defined_feet
+  clear_defined_dimension(:feet, :ft)
+end
+
+def clear_defined_yards
+  clear_defined_dimension(:yards, :yd)
+end

data/spec/helpers/matchers.rb

@@ -0,0 +1,17 @@
+RSpec::Matchers.define :have_method do |expected|
+  match do |actual|
+    actual.method_defined?(expected)
+  end
+end
+
+RSpec::Matchers.define :have_value do |expected|
+  match do |actual|
+    actual.value == expected
+  end
+end
+
+RSpec::Matchers.define :have_precision do |expected|
+  match do |actual|
+    actual.precision == expected
+  end
+end

data/spec/numeric_ext_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Numeric do
+  describe '#inches' do
+    before :context do
+      clear_defined_inches
+      Measurb.define(:inches)
+    end
+
+    shared_context 'returning expected' do |n|
+      it 'returns the dimension class instance' do
+        expect(n.inches).to be_a(Measurb::Inches)
+        expect(n.inches).to eq(Measurb::Inches.new(n))
+      end
+    end
+
+    shared_context 'having correct precision' do |n|
+      it 'sets default precision without an argument' do
+        expect(n.inches).to have_precision(Measurb::DEFAULT_PRECISION)
+      end
+
+      it 'sets the supplied precision' do
+        expect(n.inches(2)).to have_precision(2)
+      end
+    end
+
+    context 'with integer value' do
+      n = 42
+
+      include_context 'returning expected', n
+      include_context 'having correct precision', n
+    end
+
+    context 'with float value' do
+      n = Math::PI
+
+      include_context 'returning expected', n
+      include_context 'having correct precision', n
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'measurb'
+require 'helpers/matchers'
+require 'helpers/clear_dimensions'
+
+RSpec.configure do |config|
+  # Silence output
+  original_stderr = $stderr
+  original_stdout = $stdout
+  dummy_io = StringIO.new
+
+  config.before :context do
+    $stderr = dummy_io
+    $stdout = dummy_io
+  end
+
+  config.after :context do
+    $stderr = original_stderr
+    $stdout = original_stdout
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+end