aixm 0.3.7 → 0.3.8

data/spec/lib/aixm/version_spec.rb

@@ -2,6 +2,6 @@ require_relative '../../spec_helper'
 
 describe AIXM do
   it "must be defined" do
-    AIXM::VERSION.wont_be_nil
+    _(AIXM::VERSION).wont_be_nil
   end
 end

data/spec/lib/aixm/w_spec.rb

@@ -7,97 +7,97 @@ describe AIXM::W do
 
   describe :wgt= do
     it "fails on invalid values" do
-      [:foobar, -1].wont_be_written_to subject, :wgt
+      _([:foobar, -1]).wont_be_written_to subject, :wgt
     end
 
     it "converts Numeric to Float" do
-      subject.tap { |s| s.wgt = 5 }.wgt.must_equal 5.0
+      _(subject.tap { |s| s.wgt = 5 }.wgt).must_equal 5.0
     end
   end
 
   describe :unit= do
     it "fails on invalid values" do
-      [:foobar, 123].wont_be_written_to subject, :unit
+      _([:foobar, 123]).wont_be_written_to subject, :unit
     end
 
     it "symbolizes and downcases values" do
-      subject.tap { |s| s.unit = "KG" }.unit.must_equal :kg
+      _(subject.tap { |s| s.unit = "KG" }.unit).must_equal :kg
     end
   end
 
   describe :to_kg do
     it "leaves kilograms untouched" do
       subject = AIXM.w(2, :kg)
-      subject.to_kg.must_be_same_as subject
+      _(subject.to_kg).must_be_same_as subject
     end
 
     it "converts metric tonnes to kilograms" do
-      AIXM.w(0.5, :t).to_kg.must_equal AIXM.w(500, :kg)
+      _(AIXM.w(0.5, :t).to_kg).must_equal AIXM.w(500, :kg)
     end
 
     it "converts pound to kilograms" do
-      AIXM.w(200, :lb).to_kg.must_equal AIXM.w(90.718474, :kg)
+      _(AIXM.w(200, :lb).to_kg).must_equal AIXM.w(90.718474, :kg)
     end
 
     it "converts US tons to kilograms" do
-      AIXM.w(0.5, :ton).to_kg.must_equal AIXM.w(453.59237, :kg)
+      _(AIXM.w(0.5, :ton).to_kg).must_equal AIXM.w(453.59237, :kg)
     end
   end
 
   describe :to_t do
     it "leaves metric tonnes untouched" do
       subject = AIXM.w(2, :t)
-      subject.to_t.must_be_same_as subject
+      _(subject.to_t).must_be_same_as subject
     end
 
     it "converts kilograms to metric tonnes" do
-      AIXM.w(10_000, :kg).to_t.must_equal AIXM.w(10, :t)
+      _(AIXM.w(10_000, :kg).to_t).must_equal AIXM.w(10, :t)
     end
 
     it "converts pound to metric tonnes" do
-      AIXM.w(1000, :lb).to_t.must_equal AIXM.w(0.45359237, :t)
+      _(AIXM.w(1000, :lb).to_t).must_equal AIXM.w(0.45359237, :t)
     end
 
     it "converts US tons to metric tonnes" do
-      AIXM.w(1, :ton).to_t.must_equal AIXM.w(0.90718474, :t)
+      _(AIXM.w(1, :ton).to_t).must_equal AIXM.w(0.90718474, :t)
     end
   end
 
   describe :to_lb do
     it "leaves pound untouched" do
       subject = AIXM.w(2, :lb)
-      subject.to_lb.must_be_same_as subject
+      _(subject.to_lb).must_be_same_as subject
     end
 
     it "converts kilograms to pound" do
-      AIXM.w(50, :kg).to_lb.must_equal AIXM.w(110.2311311, :lb)
+      _(AIXM.w(50, :kg).to_lb).must_equal AIXM.w(110.2311311, :lb)
     end
 
     it "converts metric tonnes to pound" do
-      AIXM.w(0.5, :t).to_lb.must_equal AIXM.w(1102.311311, :lb)
+      _(AIXM.w(0.5, :t).to_lb).must_equal AIXM.w(1102.311311, :lb)
     end
 
     it "converts US tons to pound" do
-      AIXM.w(0.5, :ton).to_lb.must_equal AIXM.w(1000.00000007, :lb)
+      _(AIXM.w(0.5, :ton).to_lb).must_equal AIXM.w(1000.00000007, :lb)
     end
   end
 
   describe :to_ton do
     it "leaves US tons untouched" do
       subject = AIXM.w(2, :ton)
-      subject.to_ton.must_be_same_as subject
+      _(subject.to_ton).must_be_same_as subject
     end
 
     it "converts kilograms to US tons" do
-      AIXM.w(1000, :kg).to_ton.must_equal AIXM.w(1.10231131, :ton)
+      _(AIXM.w(1000, :kg).to_ton).must_equal AIXM.w(1.10231131, :ton)
     end
 
     it "converts metrical tons to US tons" do
-      AIXM.w(0.5, :t).to_ton.must_equal AIXM.w(0.55115566, :ton)
+      _(AIXM.w(0.5, :t).to_ton).must_equal AIXM.w(0.55115566, :ton)
     end
 
     it "converts pound to US tons" do
-      AIXM.w(3000, :lb).to_ton.must_equal AIXM.w(1.5, :ton)
+      _(AIXM.w(3000, :lb).to_ton).must_equal AIXM.w(1.5, :ton)
     end
   end
 
@@ -105,46 +105,46 @@ describe AIXM::W do
     it "recognizes objects with identical unit and weight as equal" do
       a = AIXM.w(123, :kg)
       b = AIXM.w(123.0, 'KG')
-      a.must_equal b
+      _(a).must_equal b
     end
 
     it "recognizes objects with different units and converted weight as equal" do
       a = AIXM.w(123, :kg)
       b = AIXM.w(271.16858251, 'LB')
-      a.must_equal b
+      _(a).must_equal b
     end
 
     it "recognizes objects with different units and identical weight as unequal" do
       a = AIXM.w(123, :kg)
       b = AIXM.w(123, :lb)
-      a.wont_equal b
+      _(a).wont_equal b
     end
 
     it "recognizes objects of different class as unequal" do
       a = AIXM.w(123, :kg)
       b = :oggy
-      a.wont_equal b
+      _(a).wont_equal b
     end
   end
 
   describe :hash do
     it "returns an integer" do
-      subject.hash.must_be_instance_of Integer
+      _(subject.hash).must_be_instance_of Integer
     end
 
     it "allows for the use of instances as hash keys" do
       dupe = subject.dup
-      { subject => true }[dupe].must_equal true
+      _({ subject => true }[dupe]).must_equal true
     end
   end
 
   describe :zero? do
     it "returns true for zero weight" do
-      subject.tap { |s| s.wgt = 0 }.must_be :zero?
+      _(subject.tap { |s| s.wgt = 0 }).must_be :zero?
     end
 
     it "returns false for non-zero weight" do
-      subject.tap { |s| s.wgt = 1 }.wont_be :zero?
+      _(subject.tap { |s| s.wgt = 1 }).wont_be :zero?
     end
   end
 end

data/spec/lib/aixm/xy_spec.rb

@@ -7,16 +7,16 @@ describe AIXM::XY do
 
   describe :lat= do
     it "fails on invalid values" do
-      [91, "foobar"].wont_be_written_to subject, :lat
+      _([91, "foobar"]).wont_be_written_to subject, :lat
     end
 
     it "parses valid DD values" do
-      subject.tap { |s| s.lat = 11.2233 }.lat.must_equal 11.2233
+      _(subject.tap { |s| s.lat = 11.2233 }.lat).must_equal 11.2233
     end
 
     it "parses valid DMS values"  do
-      subject.tap { |s| s.lat = %q(11°22'33"N) }.lat.must_equal(11.37583333)
-      subject.tap { |s| s.lat = %q(11°22'33"S) }.lat.must_equal(-11.37583333)
+      _(subject.tap { |s| s.lat = %q(11°22'33"N) }.lat).must_equal(11.37583333)
+      _(subject.tap { |s| s.lat = %q(11°22'33"S) }.lat).must_equal(-11.37583333)
     end
   end
 
@@ -27,15 +27,15 @@ describe AIXM::XY do
       end
 
       it "must format DD (default) correctly" do
-        subject.lat.must_equal 1.1234
+        _(subject.lat).must_equal 1.1234
       end
 
       it "must format AIXM correctly" do
-        subject.lat(:aixm).must_equal %q(010724.24N)
+        _(subject.lat(:aixm)).must_equal %q(010724.24N)
       end
 
       it "must format OFM correctly" do
-        subject.lat(:ofmx).must_equal '01.12340000N'
+        _(subject.lat(:ofmx)).must_equal '01.12340000N'
       end
     end
 
@@ -45,31 +45,31 @@ describe AIXM::XY do
       end
 
       it "must format DD (default) correctly" do
-        subject.lat.must_equal(-1.1234)
+        _(subject.lat).must_equal(-1.1234)
       end
 
       it "must format AIXM correctly" do
-        subject.lat(:aixm).must_equal %q(010724.24S)
+        _(subject.lat(:aixm)).must_equal %q(010724.24S)
       end
 
       it "must format OFM correctly" do
-        subject.lat(:ofmx).must_equal '01.12340000S'
+        _(subject.lat(:ofmx)).must_equal '01.12340000S'
       end
     end
   end
 
   describe :long= do
     it "fails on invalid values" do
-      [181, "foobar"].wont_be_written_to subject, :lat
+      _([181, "foobar"]).wont_be_written_to subject, :lat
     end
 
     it "parses valid DD values" do
-      subject.tap { |s| s.long = 22.3344 }.long.must_equal 22.3344
+      _(subject.tap { |s| s.long = 22.3344 }.long).must_equal 22.3344
     end
 
     it "parses valid DMS values"  do
-      subject.tap { |s| s.long = %q(22°33'44"E) }.long.must_equal(22.56222222)
-      subject.tap { |s| s.long = %q(22°33'44"W) }.long.must_equal(-22.56222222)
+      _(subject.tap { |s| s.long = %q(22°33'44"E) }.long).must_equal(22.56222222)
+      _(subject.tap { |s| s.long = %q(22°33'44"W) }.long).must_equal(-22.56222222)
     end
   end
 
@@ -80,15 +80,15 @@ describe AIXM::XY do
       end
 
       it "must format DD (default) correctly" do
-        subject.long.must_equal 1.1234
+        _(subject.long).must_equal 1.1234
       end
 
       it "must format AIXM correctly" do
-        subject.long(:aixm).must_equal %q(0010724.24E)
+        _(subject.long(:aixm)).must_equal %q(0010724.24E)
       end
 
       it "must format OFM correctly" do
-        subject.long(:ofmx).must_equal '001.12340000E'
+        _(subject.long(:ofmx)).must_equal '001.12340000E'
       end
     end
 
@@ -98,27 +98,27 @@ describe AIXM::XY do
       end
 
       it "must format DD (default) correctly" do
-        subject.long.must_equal(-1.1234)
+        _(subject.long).must_equal(-1.1234)
       end
 
       it "must format AIXM correctly" do
-        subject.long(:aixm).must_equal %q(0010724.24W)
+        _(subject.long(:aixm)).must_equal %q(0010724.24W)
       end
 
       it "must format OFM correctly" do
-        subject.long(:ofmx).must_equal '001.12340000W'
+        _(subject.long(:ofmx)).must_equal '001.12340000W'
       end
     end
   end
 
   describe :seconds? do
     it "must detect coordinates with zero DMS seconds" do
-      AIXM.xy(lat: %q(44°33'00"N), long: %q(004°03'00"E)).wont_be :seconds?
-      AIXM.xy(lat: %q(44°33'00.01"N), long: %q(004°03'00"E)).must_be :seconds?
-      AIXM.xy(lat: %q(44°33'00"N), long: %q(004°03'00.01"E)).must_be :seconds?
-      AIXM.xy(lat: %q(47°29'10"N), long: %q(000°33'15"W)).must_be :seconds?
-      AIXM.xy(lat: %q(44°36'50"N), long: %q(004°23'50"E)).must_be :seconds?
-      AIXM.xy(lat: %q(44°48'00"N), long: %q(000°34'27"W)).must_be :seconds?
+      _(AIXM.xy(lat: %q(44°33'00"N), long: %q(004°03'00"E))).wont_be :seconds?
+      _(AIXM.xy(lat: %q(44°33'00.01"N), long: %q(004°03'00"E))).must_be :seconds?
+      _(AIXM.xy(lat: %q(44°33'00"N), long: %q(004°03'00.01"E))).must_be :seconds?
+      _(AIXM.xy(lat: %q(47°29'10"N), long: %q(000°33'15"W))).must_be :seconds?
+      _(AIXM.xy(lat: %q(44°36'50"N), long: %q(004°23'50"E))).must_be :seconds?
+      _(AIXM.xy(lat: %q(44°48'00"N), long: %q(000°34'27"W))).must_be :seconds?
     end
   end
 
@@ -128,7 +128,7 @@ describe AIXM::XY do
     end
 
     it "must return a point object with these coordinates" do
-      subject.to_point.xy.must_equal AIXM.point(xy: subject).xy
+      _(subject.to_point.xy).must_equal AIXM.point(xy: subject).xy
     end
   end
 
@@ -138,12 +138,12 @@ describe AIXM::XY do
     end
 
     it "calculates the distance between the same point as zero" do
-      subject.distance(subject).must_equal AIXM.d(0, :m)
+      _(subject.distance(subject)).must_equal AIXM.d(0, :m)
     end
 
     it "calculates the distance between two points correctly" do
       other = AIXM.xy(lat: %q(43°59'25.31"N), long: %q(004°45'23.24"E))
-      subject.distance(other).must_equal AIXM.d(1351, :m)
+      _(subject.distance(other)).must_equal AIXM.d(1351, :m)
     end
   end
 
@@ -151,30 +151,30 @@ describe AIXM::XY do
     it "recognizes objects with identical latitude and longitude as equal" do
       a = AIXM.xy(lat: "112233N", long: "0223344E")
       b = AIXM.xy(lat: 11.37583333, long: 22.56222222)
-      a.must_equal b
+      _(a).must_equal b
     end
 
     it "recognizes objects with different latitude or longitude as unequal" do
       a = AIXM.xy(lat: "112233.44N", long: "0223344.55E")
       b = AIXM.xy(lat: 11, long: 22)
-      a.wont_equal b
+      _(a).wont_equal b
     end
 
     it "recognizes objects of different class as unequal" do
       a = AIXM.xy(lat: "112233.44N", long: "0223344.55E")
       b = :oggy
-      a.wont_equal b
+      _(a).wont_equal b
     end
   end
 
   describe :hash do
     it "returns an integer" do
-      subject.hash.must_be_instance_of Integer
+      _(subject.hash).must_be_instance_of Integer
     end
 
     it "allows for the use of instances as hash keys" do
       dupe = subject.dup
-      { subject => true }[dupe].must_equal true
+      _({ subject => true }[dupe]).must_equal true
     end
   end
 end

data/spec/lib/aixm/z_spec.rb

@@ -7,47 +7,47 @@ describe AIXM::Z do
 
   describe :alt= do
     it "fails on invalid values" do
-      [:foobar].wont_be_written_to subject, :alt
+      _([:foobar]).wont_be_written_to subject, :alt
     end
 
     it "converts Numeric to Integer" do
-      subject.tap { |s| s.alt = 5.5 }.alt.must_equal 5
+      _(subject.tap { |s| s.alt = 5.5 }.alt).must_equal 5
     end
   end
 
   describe :code= do
     it "fails on invalid values" do
-      [nil, :foobar].wont_be_written_to subject, :code
+      _([nil, :foobar]).wont_be_written_to subject, :code
     end
 
     it "symbolizes and downcases values" do
-      subject.tap { |s| s.code = "QFE" }.code.must_equal :qfe
+      _(subject.tap { |s| s.code = "QFE" }.code).must_equal :qfe
     end
   end
 
   describe :qfe? do
     it "recognizes same Q code" do
-      AIXM.z(111, :qfe).must_be :qfe?
+      _(AIXM.z(111, :qfe)).must_be :qfe?
     end
 
     it "doesn't recognize different Q code" do
-      AIXM.z(111, :qnh).wont_be :qfe?
+      _(AIXM.z(111, :qnh)).wont_be :qfe?
     end
   end
 
   describe :ground? do
     it "must detect ground" do
-      AIXM.z(0, :qfe).must_be :ground?
-      AIXM.z(111, :qfe).wont_be :ground?
-      AIXM.z(0, :qnh).wont_be :ground?
+      _(AIXM.z(0, :qfe)).must_be :ground?
+      _(AIXM.z(111, :qfe)).wont_be :ground?
+      _(AIXM.z(0, :qnh)).wont_be :ground?
     end
   end
 
   describe :unit do
     it "must return the correct unit" do
-      AIXM.z(0, :qfe).unit.must_equal :ft
-      AIXM.z(0, :qnh).unit.must_equal :ft
-      AIXM.z(0, :qne).unit.must_equal :fl
+      _(AIXM.z(0, :qfe).unit).must_equal :ft
+      _(AIXM.z(0, :qnh).unit).must_equal :ft
+      _(AIXM.z(0, :qne).unit).must_equal :fl
     end
   end
 
@@ -55,40 +55,40 @@ describe AIXM::Z do
     it "recognizes objects with identical altitude and Q code as equal" do
       a = AIXM.z(111, :qnh)
       b = AIXM.z(111, :qnh)
-      a.must_equal b
+      _(a).must_equal b
     end
 
     it "recognizes objects with different altitude or Q code as unequal" do
       a = AIXM.z(111, :qnh)
       b = AIXM.z(222, :qnh)
-      a.wont_equal b
+      _(a).wont_equal b
     end
 
     it "recognizes objects of different class as unequal" do
       a = AIXM.z(111, :qnh)
       b = :oggy
-      a.wont_equal b
+      _(a).wont_equal b
     end
   end
 
   describe :hash do
     it "returns an integer" do
-      subject.hash.must_be_instance_of Integer
+      _(subject.hash).must_be_instance_of Integer
     end
 
     it "allows for the use of instances as hash keys" do
       dupe = subject.dup
-      { subject => true }[dupe].must_equal true
+      _({ subject => true }[dupe]).must_equal true
     end
   end
 
   describe :zero? do
     it "returns true for zero height, elevation or altitude" do
-      subject.tap { |s| s.alt = 0 }.must_be :zero?
+      _(subject.tap { |s| s.alt = 0 }).must_be :zero?
     end
 
     it "returns false for non-zero height, elevation or altitude" do
-      subject.tap { |s| s.alt = 1 }.wont_be :zero?
+      _(subject.tap { |s| s.alt = 1 }).wont_be :zero?
     end
   end
 end