Fix a bug where RDF::Literal::Integer.new("0123") was interpreted as an Octal value.

Author: gkellogg

lib/rdf/model/literal/integer.rb

@@ -23,9 +23,8 @@ def initialize(value, options = {})
       @string   = options[:lexical] if options.has_key?(:lexical)
       @string   ||= value if value.is_a?(String)
       @object   = case
-        when value.is_a?(::String)    then Integer(value) rescue nil
-        when value.is_a?(::Integer)   then value
         when value.respond_to?(:to_i) then value.to_i
+        when value.is_a?(::Integer)   then value
         else Integer(value.to_s) rescue nil
       end
     end

spec/model_literal_spec.rb

@@ -30,9 +30,9 @@ def self.literal(selector)
   def self.literals(*selector)
     selector.inject([]) do |ary, sel|
       ary += case sel
-      when :all_simple        then [:empty, :plain, :string].map {|sel| literal(sel)}
-      when :all_plain_lang    then [:empty_lang, :plain_lang].map {|sel| literal(sel)}
-      when :all_native        then [:false, :true, :int, :long, :double, :time, :date, :datetime].map {|sel| literal(sel)}
+      when :all_simple        then [:empty, :plain, :string].map {|s| literal(s)}
+      when :all_plain_lang    then [:empty_lang, :plain_lang].map {|s| literal(s)}
+      when :all_native        then [:false, :true, :int, :long, :double, :time, :date, :datetime].map {|s| literal(s)}
       when :all_plain         then literals(:all_simple, :all_plain_lang)
       else                         literals(:all_plain, :all_native)
       end
@@ -180,7 +180,7 @@ def self.literals(*selector)
       end
 
       it "returns true for value of #{args.inspect}" do
-        literal = RDF::Literal.new(*args)
+        #literal = RDF::Literal.new(*args)
         #expect(literal).to eq literal.value # FIXME: fails on xsd:date, xsd:time, and xsd:dateTime
       end
     end
@@ -351,6 +351,7 @@ def self.literals(*selector)
     it_behaves_like 'RDF::Literal lexical values', "1"
     it_behaves_like 'RDF::Literal canonicalization', RDF::XSD.integer, [
       %w(01 1),
+      %w(0123 123),
       %w(1  1),
       %w(-1 -1),
       %w(+1 1)
@@ -381,12 +382,15 @@ def self.literals(*selector)
     it_behaves_like 'RDF::Literal lexical values', "1.1"
     it_behaves_like 'RDF::Literal canonicalization', RDF::XSD.decimal, [
       %w(1                              1.0),
+      %w(01                             1.0),
+      %w(0123                           123.0),
       %w(-1                             -1.0),
       %w(1.                             1.0),
       %w(1.0                            1.0),
       %w(1.00                           1.0),
       %w(+001.00                        1.0),
       %w(123.456                        123.456),
+      %w(0123.456                       123.456),
       %w(1.000000000                    1.0),
       %w(2.345                          2.345),
       %w(2.3                            2.3),
@@ -439,6 +443,8 @@ def self.literals(*selector)
     it_behaves_like 'RDF::Literal lexical values', "1.0E0"
     it_behaves_like 'RDF::Literal canonicalization', RDF::XSD.double, [
       %w(1         1.0E0),
+      %w(01        1.0E0),
+      %w(0123      1.23E2),
       %w(-1        -1.0E0),
       %w(+01.000   1.0E0),
       #%w(1.        1.0E0),
@@ -502,7 +508,7 @@ def self.literals(*selector)
 
     it "recognizes -INF" do
       expect(-inf).to be_infinite
-      expect(RDF::Literal.new('-INF', datatype: RDF::Literal::Double::DATATYPE)).to eq -inf
+      expect(RDF::Literal.new('-INF', datatype: RDF::Literal::Double::DATATYPE)).to eq(-inf)
       expect {-inf.canonicalize}.not_to raise_error
     end
 
@@ -542,10 +548,10 @@ def self.literals(*selector)
 
     # Multiplication
     {
-      -1 => [RDF::Literal::Double.new("-INF"), RDF::Literal::Double.new("-INF")],
-      0  => [:nan, :nan],
-      1  => [RDF::Literal::Double.new("INF"), RDF::Literal::Double.new("INF")],
-    }.each do |n, (p, m)|
+      -1 => RDF::Literal::Double.new("-INF"),
+      0  => :nan,
+      1  => RDF::Literal::Double.new("INF"),
+    }.each do |n, p|
       it "returns #{p} for #{n} * INF" do
         if p == :nan
           expect(RDF::Literal::Double.new(n) * inf).to be_nan
@@ -581,7 +587,7 @@ def self.literals(*selector)
     it "adds infinities" do
       expect(inf + inf).to eq inf
       expect(inf + -inf).to be_nan
-      expect(-inf + -inf).to eq -inf
+      expect(-inf + -inf).to eq(-inf)
       expect(-inf + inf).to be_nan
     end