phys-units 0.9.7 → 0.9.8

data/spec/unit_spec.rb

@@ -4,226 +4,226 @@ require "helper"
 describe "Create Units" do
 
   describe U[1] do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should == 1}
-    its(:conversion_factor) {should == 1}
-    its(:name) {should be_nil}
-    its(:expr) {should be_nil}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == ""}
-    it {should be_dimensionless}
-    it {should be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to eq 1}
+    its(:conversion_factor) {is_expected.to eq 1}
+    its(:name) {is_expected.to be_nil}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq ""}
+    it {is_expected.to be_dimensionless}
+    it {is_expected.to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U[2] do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should == 2}
-    its(:conversion_factor) {should == 2}
-    its(:name) {should be_nil}
-    its(:expr) {should be_nil}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "2"}
-    it {should be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to eq 2}
+    its(:conversion_factor) {is_expected.to eq 2}
+    its(:name) {is_expected.to be_nil}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "2"}
+    it {is_expected.to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U['pi'] do
-    it {should be_an_kind_of Phys::Unit}
-    its(:factor) {should == 1}
-    its(:conversion_factor) {should == Math::PI}
-    its(:name) {should == 'pi'}
-    its(:expr) {should == '!dimensionless'}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'pi'=>1}}
-    its(:dimension_value) {should == Math::PI}
-    its(:string_form) {should == "pi"}
-    it {should be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_kind_of Phys::Unit}
+    its(:factor) {is_expected.to eq 1}
+    its(:conversion_factor) {is_expected.to eq Math::PI}
+    its(:name) {is_expected.to eq 'pi'}
+    its(:expr) {is_expected.to eq '!dimensionless'}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'pi'=>1})}
+    its(:dimension_value) {is_expected.to eq Math::PI}
+    its(:string_form) {is_expected.to eq "pi"}
+    it {is_expected.to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U['m'] do
-    it {should be_an_kind_of Phys::Unit}
-    its(:factor) {should == 1}
-    its(:conversion_factor) {should == 1}
-    its(:name) {should == 'm'}
-    its(:expr) {should == '!'}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'m'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "m"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_kind_of Phys::Unit}
+    its(:factor) {is_expected.to eq 1}
+    its(:conversion_factor) {is_expected.to eq 1}
+    its(:name) {is_expected.to eq 'm'}
+    its(:expr) {is_expected.to eq '!'}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'m'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "m"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U[:m] do
-    it {should == U["m"]}
+    it {is_expected.to eq U["m"]}
   end
 
   describe U['miles'] do
-    it {should be_an_kind_of Phys::Unit}
-    its(:factor) {should == 1609.344}
-    its(:factor) {should be_an_instance_of Rational}
-    its(:conversion_factor) {should == 1609.344}
-    its(:name) {should == 'mile'}
-    its(:expr) {should == "5280 ft"}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'m'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "1609.344 m"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_kind_of Phys::Unit}
+    its(:factor) {is_expected.to eq 1609.344}
+    its(:factor) {is_expected.to be_an_instance_of Rational}
+    its(:conversion_factor) {is_expected.to eq 1609.344}
+    its(:name) {is_expected.to eq 'mile'}
+    its(:expr) {is_expected.to eq "5280 ft"}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'m'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "1609.344 m"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe 1.609344*U['km'] do
-    it {should be_an_kind_of Phys::Unit}
-    it {should == Phys::Unit[:miles]}
-    its(:factor) {should == 1609.344}
-    its(:conversion_factor) {should == 1609.344}
-    its(:name) {should be_nil}
-    its(:expr) {should be_nil}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'m'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "1609.344 m"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_kind_of Phys::Unit}
+    it {is_expected.to eq Phys::Unit[:miles]}
+    its(:factor) {is_expected.to eq 1609.344}
+    its(:conversion_factor) {is_expected.to eq 1609.344}
+    its(:name) {is_expected.to be_nil}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'m'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "1609.344 m"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U['g'] do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should == Rational(1,1000)}
-    its(:conversion_factor) {should == Rational(1,1000)}
-    its(:name) {should == 'g'}
-    #its(:expr) {should == 'gram'}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'kg'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "0.001 kg"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to eq Rational(1,1000)}
+    its(:conversion_factor) {is_expected.to eq Rational(1,1000)}
+    its(:name) {is_expected.to eq 'g'}
+    #its(:expr) {is_expected.to eq 'gram'}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'kg'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "0.001 kg"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
 
   describe U['h'] do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should be_within(1e-16*1e-33).of 6.626069574766962e-34}
-    its(:conversion_factor) {should be_within(1e-16*1e-33).of 6.626069574766962e-34}
-    its(:name) {should == 'h'}
-    its(:expr) {should == "4.135667516e-15 eV s"}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'kg'=>1,'m'=>2,'s'=>-1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "6.626069574766962e-34 s^-1 kg m^2"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to be_within(1e-16*1e-33).of 6.626069574766962e-34}
+    its(:conversion_factor) {is_expected.to be_within(1e-16*1e-33).of 6.626069574766962e-34}
+    its(:name) {is_expected.to eq 'h'}
+    its(:expr) {is_expected.to eq "4.135667516e-15 eV s"}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'kg'=>1,'m'=>2,'s'=>-1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "6.626069574766962e-34 s^-1 kg m^2"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U['e'] do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should be_within(1e-15*1e-18).of 1.602176565e-19}
-    its(:conversion_factor) {should be_within(1e-15*1e-18).of 1.602176565e-19}
-    its(:name) {should == 'e'}
-    its(:expr) {should == "1.602176565e-19 C"}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'A'=>1,'s'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "1.602176565e-19 A s"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to be_within(1e-15*1e-18).of 1.602176565e-19}
+    its(:conversion_factor) {is_expected.to be_within(1e-15*1e-18).of 1.602176565e-19}
+    its(:name) {is_expected.to eq 'e'}
+    its(:expr) {is_expected.to eq "1.602176565e-19 C"}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'A'=>1,'s'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "1.602176565e-19 A s"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U.parse('123.5 s') do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should == 123.5}
-    its(:conversion_factor) {should == 123.5}
-    its(:name) {should be_nil}
-    its(:expr) {should be_nil}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'s'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "123.5 s"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to eq 123.5}
+    its(:conversion_factor) {is_expected.to eq 123.5}
+    its(:name) {is_expected.to be_nil}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'s'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "123.5 s"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U['m']/U['s'] do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should == 1}
-    its(:conversion_factor) {should == 1}
-    its(:name) {should be_nil}
-    its(:expr) {should be_nil}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'m'=>1, 's'=>-1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "m s^-1"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
-    it {should === Q[1,'miles/hr']}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to eq 1}
+    its(:conversion_factor) {is_expected.to eq 1}
+    its(:name) {is_expected.to be_nil}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'m'=>1, 's'=>-1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "m s^-1"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
+    it {is_expected.to be_comformable_with Q[1,'miles/hr']}
   end
 
   describe U.parse('(m/s)**2') do
-    it {should be_an_instance_of Phys::Unit}
-    its(:factor) {should == 1}
-    its(:conversion_factor) {should == 1}
-    its(:name) {should be_nil}
-    its(:expr) {should be_nil}
-    its(:offset) {should be_nil}
-    its(:dimension) {should == {'m'=>2, 's'=>-2}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "m^2 s^-2"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should be_operable}
+    it {is_expected.to be_an_instance_of Phys::Unit}
+    its(:factor) {is_expected.to eq 1}
+    its(:conversion_factor) {is_expected.to eq 1}
+    its(:name) {is_expected.to be_nil}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to be_nil}
+    its(:dimension) {is_expected.to eq({'m'=>2, 's'=>-2})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "m^2 s^-2"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.to be_operable}
   end
 
   describe U.parse("3.6 km/hour") do
-    its(:string_form) {should == "m s^-1"}
+    its(:string_form) {is_expected.to eq "m s^-1"}
   end
 
   describe U['tempC'] do
-    it {should be_an_instance_of Phys::OffsetUnit}
-    its(:factor) {should == 1}
-    its(:conversion_factor) {should == 1}
-    its(:name) {should == 'tempC'}
-    its(:expr) {should be_nil}
-    its(:offset) {should == 273.15}
-    its(:dimension) {should == {'K'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "K"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should_not be_operable}
+    it {is_expected.to be_an_instance_of Phys::OffsetUnit}
+    its(:factor) {is_expected.to eq 1}
+    its(:conversion_factor) {is_expected.to eq 1}
+    its(:name) {is_expected.to eq 'tempC'}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to eq 273.15}
+    its(:dimension) {is_expected.to eq({'K'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "K"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.not_to be_operable}
   end
 
   describe U['tempF'] do
-    it {should be_an_instance_of Phys::OffsetUnit}
-    its(:factor) {should == Rational(5,9)}
-    its(:factor) {should be_an_instance_of Rational}
-    its(:conversion_factor) {should == Rational(5,9)}
-    its(:name) {should == 'tempF'}
-    its(:expr) {should be_nil}
-    its(:offset) {should == Rational(45967,180)}
-    its(:dimension) {should == {'K'=>1}}
-    its(:dimension_value) {should == 1}
-    its(:string_form) {should == "(1/1.8) K"}
-    it {should_not be_dimensionless}
-    it {should_not be_scalar}
-    it {should_not be_operable}
+    it {is_expected.to be_an_instance_of Phys::OffsetUnit}
+    its(:factor) {is_expected.to eq Rational(5,9)}
+    its(:factor) {is_expected.to be_an_instance_of Rational}
+    its(:conversion_factor) {is_expected.to eq Rational(5,9)}
+    its(:name) {is_expected.to eq 'tempF'}
+    its(:expr) {is_expected.to be_nil}
+    its(:offset) {is_expected.to eq Rational(45967,180)}
+    its(:dimension) {is_expected.to eq({'K'=>1})}
+    its(:dimension_value) {is_expected.to eq 1}
+    its(:string_form) {is_expected.to eq "(1/1.8) K"}
+    it {is_expected.not_to be_dimensionless}
+    it {is_expected.not_to be_scalar}
+    it {is_expected.not_to be_operable}
   end
 
   describe "temperature unit" do

data/spec/utils_spec.rb

@@ -6,11 +6,11 @@ Utils = Phys::Unit::Utils
 describe "UnitUtils test" do
 
   describe Utils.num_inspect(Rational(1609344,1000)) do
-    it {should == "1609.344"}
+    it {is_expected.to eq "1609.344"}
   end
 
   describe Utils.num_inspect(Rational(1000,1609344)) do
-    it {should == "(1/1609.344)"}
+    it {is_expected.to eq "(1/1609.344)"}
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phys-units
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors:
 - Masahiro TANAKA
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-27 00:00:00.000000000 Z
+date: 2015-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Library for Unit conversion of Physical Quantities using GNU Units data.
@@ -111,3 +111,4 @@ test_files:
 - spec/quantity_spec.rb
 - spec/unit_spec.rb
 - spec/utils_spec.rb
+has_rdoc: