m9t 0.3.2 → 1.0.0

data/spec/direction_spec.rb

@@ -0,0 +1,195 @@
+require "m9t/direction"
+
+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_falsey
+      end
+    end
+
+    context "units" do
+      it "is degrees" do
+        expect(M9t::Direction.options[:units]).to eq(:degrees)
+      end
+    end
+  end
+
+  describe ".normalize" do
+    it "reduces number greater than 360" do
+      expect(M9t::Direction.normalize(725)).to eq(5)
+    end
+
+    it "reduces 360" do
+      expect(M9t::Direction.normalize(360)).to eq(0)
+    end
+
+    it "increases numbers less than zero" do
+      expect(M9t::Direction.normalize(-355)).to eq(5)
+    end
+
+    it "handles values with decimals" do
+      expect(M9t::Direction.normalize(360.5)).to eq(0.5)
+    end
+
+    it "handles large values" do
+      M9t::Direction.normalize(1000000000)
+    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

data/spec/distance_spec.rb

@@ -0,0 +1,127 @@
+require "m9t/distance"
+
+describe M9t::Distance do
+  context "class methods" do
+    it "has a measurement name" do
+      expect(M9t::Distance.measurement_name).to eq("distance")
+    end
+
+    context "default options" do
+      it "has options" do
+        expect(M9t::Distance.options).not_to be_nil
+      end
+
+      it "not abbreviated" do
+        expect(M9t::Distance.options[:abbreviated]).to be_falsey
+      end
+
+      it "units: meters" do
+        expect(M9t::Distance.options[:units]).to be(:meters)
+      end
+
+      it "precision: 5" do
+        expect(M9t::Distance.options[:precision]).to eq(5)
+      end
+    end
+
+    it "constructs from meters" do
+      expect(M9t::Distance.new(0.3).to_f).to eq(0.3)
+    end
+
+    context "units factories" do
+      [
+        [:meters, 0.3, 0.3],
+        [:kilometers, 0.3, 300.0],
+        [:miles, 26.21875, 42194.988]
+      ].each do |unit, input, result|
+        it "#{unit} constructs correctly" do
+          distance = M9t::Distance.send(unit, input)
+          expect(distance.to_f).to be_within(0.0001).of(result)
+        end
+      end
+    end
+
+    context "conversions" do
+      [
+        ["meters", "kilometers", 0.3, 0.0003],
+        ["miles", "kilometers", 26.21875, 42.194988]
+      ].each do |from, to, input, expected|
+        method = :"#{from}_to_#{to}"
+        specify method do
+          expect(M9t::Distance.send(method, input)).to eq(expected)
+        end
+      end
+    end
+  end
+
+  context ".conversions" do
+    specify "#to_meters" do
+      expect(M9t::Distance.new(0.3).to_meters).to eq(0.3)
+    end
+
+    specify "#to_kilometers" do
+      expect(M9t::Distance.new(0.3).to_kilometers).to eq(0.0003)
+    end
+
+    specify "#to_feet" do
+      expect(M9t::Distance.new(0.3).to_feet).to be_within(0.00001).of(0.98425)
+    end
+  end
+
+  context "#to_s" do
+    before do
+      I18n.locale = :en
+    end
+
+    it "handles singluar" do
+      distance = M9t::Distance.new(1)
+      expect(distance.to_s(precision: 0)).to eq("1 meter")
+    end
+
+    it "handles plural" do
+      distance = M9t::Distance.new(10)
+      expect(distance.to_s(precision: 0)).to eq("10 meters")
+    end
+
+    it "handles abbreviation" do
+      distance = M9t::Distance.new(0.3)
+      expect(distance.to_s(abbreviated: true)).to eq("0.30000m")
+    end
+
+    specify "units: kilometers" do
+      distance = M9t::Distance.new( 156003 )
+      expect(distance.to_s(precision: 1, units: :kilometers)).to eq("156.0 kilometers")
+    end
+
+    specify "units: miles, singular" do
+      marathon = M9t::Distance.miles(26.21875)
+      expect(marathon.to_s(units: :miles, precision: 0)).to eq("26 miles")
+    end
+
+    specify "units: miles, plural" do
+      ten_km = M9t::Distance.new(10000)
+      expect(ten_km.to_s(units: :miles, precision: 1)).to eq("6.2 miles")
+    end
+
+    context "i18n" do
+      before do
+        I18n.locale = :it
+      end
+
+      specify "precision: 0" do
+        distance = M9t::Distance.new(10)
+        expect(distance.to_s(precision: 0)).to eq("10 metri")
+      end
+
+      specify "units: miles" do
+        marathon = M9t::Distance.miles(26.21875)
+        expect(marathon.to_s(units: :miles, precision: 0)).to eq("26 miglia")
+      end
+
+      specify "units: miles, precision: 1" do
+        ten_km = M9t::Distance.new(10000)
+        expect(ten_km.to_s(units: :miles, precision: 1)).to eq("6,2 miglia")
+      end
+    end
+  end
+end

data/spec/i18n_spec.rb

@@ -0,0 +1,54 @@
+require "m9t/i18n"
+
+describe I18n do
+  before do
+    @old_locale = I18n.locale
+  end
+
+  after do
+    I18n.locale = @old_locale
+  end
+
+  context "languages" do
+    [
+      [:en, "mile"],
+      [:it, "miglio"],
+      [:de, "Meile"],
+    ].each do |locale, expected|
+      it "has #{locale}" do
+        I18n.locale = locale
+        expect(I18n.t("units.distance.miles.full.one")).to eq(expected)
+      end
+    end
+  end
+
+  context "decimal separator" do
+    [
+      [:en, "."],
+      [:it, ","],
+    ].each do |locale, separator|
+      it "has #{separator} for #{locale}" do
+        I18n.locale = locale
+        expect(I18n.t("numbers.decimal_separator")).to eq(separator)
+      end
+    end
+  end
+
+  context ".localize_float" do
+    [
+      [:en, "."],
+      [:it, ","],
+    ].each do |locale, separator|
+      it "uses the #{separator} separator in #{locale}" do
+        I18n.locale = locale
+        expected = "1#{separator}500000"
+        expect(I18n.localize_float(1.5)).to eq(expected)
+      end
+    end
+
+    it "accepts a format indicator" do
+      I18n.locale = :en
+      expect(I18n.localize_float(1.5, {format: "%0.1f"})).to eq("1.5")
+    end
+  end
+end

data/spec/pressure_spec.rb

@@ -0,0 +1,22 @@
+require "m9t/pressure"
+
+describe M9t::Pressure do
+  context "class methods" do
+    context ".new" do
+      it "returns the identity" do
+        expect(M9t::Pressure.new(1.0).value).to eq(1.0)
+      end
+    end
+
+    context "other units" do
+      [
+        [:hectopascals, 0.001],
+        [:inches_of_mercury, 0.03386],
+      ].each do |unit, expected|
+        it "handles #{unit}" do
+          expect(M9t::Pressure.send(unit, 1.0).value).to be_within(expected / 1000.0).of(expected)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require "codeclimate-test-reporter"
+require "rspec"
+
+CodeClimate::TestReporter.start
+
+if RUBY_PLATFORM != "java"
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+require "m9t"
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = "random"
+end

data/spec/speed_spec.rb

@@ -0,0 +1,102 @@
+require "m9t/speed"
+
+describe M9t::Speed do
+  context "conversion constants" do
+    it "has knots" do
+      expect(M9t::Speed::KNOTS).to be_within(0.0001).of(1.9438)
+    end
+  end
+
+  context "known units" do
+    it "gives an error for unknown units" do
+      speed = M9t::Speed.new(10)
+      expect {
+        speed.to_s(units: :foos)
+      }.to raise_error(M9t::UnitError)
+    end
+  end
+
+  context "class methods" do
+    context ".new" do
+      it "handles identity" do
+        expect(M9t::Speed.new(45).value).to eq(45)
+      end
+    end
+
+    context ".measurement_name" do
+      it "is 'speed'" do
+        expect(M9t::Speed.measurement_name).to eq("speed")
+      end
+    end
+
+    context "conversion factories" do
+      [
+        [:kilometers_per_hour, 0.2778],
+        [:miles_per_hour, 0.447],
+        [:knots, 0.5144],
+      ].each do |unit, expected|
+        specify unit do
+          expect(M9t::Speed.send(unit, 1.0).value).to be_within(0.0001).of(expected)
+        end
+      end
+    end
+
+    context "conversions" do
+      [
+        [:meters_per_second, :miles_per_hour, 45.0, 100.6621],
+      ].each do |from, to, input, expected|
+        method = :"#{from}_to_#{to}"
+        specify method do
+          expect(M9t::Speed.send(method, input)).to be_within(0.0001).of(expected)
+        end
+      end
+    end
+  end
+
+  context "conversions" do
+    subject { M9t::Speed.new(45) }
+
+    [
+      [:kilometers_per_hour, 162.0],
+      [:miles_per_hour, 100.6621],
+    ].each do |unit, expected|
+      method = :"to_#{unit}"
+      specify method do
+        expect(subject.send(method)).to be_within(expected / 1000.0).of(expected)
+      end
+    end
+  end
+
+  context "#to_s" do
+    subject { M9t::Speed.new(135.0) }
+
+    specify "full en" do
+      I18n.locale = :en
+      expect(subject.to_s).to eq("135.00000 meters per second")
+    end
+
+    specify "full it" do
+      I18n.locale = :it
+      expect(subject.to_s).to eq("135,00000 metri al second")
+    end
+
+    specify "precision" do
+      I18n.locale = :en
+      expect(subject.to_s(precision: 0)).to eq("135 meters per second")
+    end
+
+    specify "abbreviated" do
+      expect(subject.to_s(abbreviated: true, precision: 0)).to eq("135m/s")
+    end
+
+    specify "units: knots, en" do
+      I18n.locale = :en
+      expect(subject.to_s(units: :knots, precision: 0)).to eq("262 knots")
+    end
+
+    specify "units: knots, it" do
+      I18n.locale = :it
+      expect(subject.to_s(units: :knots, precision: 0)).to eq("262 nodi")
+    end
+  end
+end