Finish 3.0.3

Author: gkellogg

.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
 bundler_args: --without debug
 script: "bundle exec rspec spec"
-before_install: "gem update --system"
+before_install:
+  - "gem update --system"
+  - "gem install bundler"
 env:
   - CI=true
 rvm:

VERSION

@@ -1 +1 @@
-3.0.2
+3.0.3

lib/rdf/cli.rb

@@ -92,6 +92,10 @@ class Option
       # @return [String]
       attr_reader :description
 
+      # Default value for this option
+      # @return [Object]
+      attr_reader :default
+
       # Potential values (for select or radio) or Ruby datatype
       # @return  [Class, Array<String>]
       attr_reader :datatype
@@ -110,6 +114,7 @@ class Option
       # @param [Symbol] symbol
       # @param [Array<String>] on
       # @param [String] datatype
+      # @param [Object] default
       # @param [String] control
       # @param [String] description
       # @param [[:optional, :disabled, :removed, :required]] use
@@ -118,10 +123,10 @@ class Option
       # @yieldparam [OptionParser] options (nil) optional OptionParser
       # @yieldreturn [Object] a possibly modified input value
       def initialize(symbol: nil, on: nil, datatype: nil, control: nil,
-                     description: nil, use: :optional, **options, &block)
+                     description: nil, use: :optional, default: nil, **options, &block)
         raise ArgumentError, "symbol is a required argument" unless symbol
         raise ArgumentError, "on is a required argument" unless on
-        @symbol, @on, @datatype, @control, @description, @use, @callback = symbol.to_sym, Array(on), datatype, control, description, use, block
+        @symbol, @on, @datatype, @control, @description, @use, @default, @callback = symbol.to_sym, Array(on), datatype, control, description, use, default, block
       end
 
       def call(arg, options = {})
@@ -142,6 +147,7 @@ def to_hash
         {
           symbol:       symbol,
           datatype:     (datatype.is_a?(Class) ? datatype.name : datatype),
+          default:      default,
           control:      control,
           description:  description,
           use:          use

lib/rdf/model/literal.rb

@@ -170,8 +170,7 @@ def initialize(value, language: nil, datatype: nil, lexical: nil, validate: fals
       @language = language.to_s.downcase.to_sym if language
       @datatype = RDF::URI(datatype).freeze if datatype
       @datatype ||= self.class.const_get(:DATATYPE) if self.class.const_defined?(:DATATYPE)
-      @datatype ||= @language ? RDF.langString : RDF::XSD.string
-      raise ArgumentError, "datatype of rdf:langString requires a language" if !@language && @datatype == RDF::langString
+      @datatype ||= @language ? RDF.langString : RDF::URI("http://www.w3.org/2001/XMLSchema#string")
     end
 
     ##
@@ -226,8 +225,8 @@ def compatible?(other)
       # * The arguments are plain literals with identical language tags
       # * The first argument is a plain literal with language tag and the second argument is a simple literal or literal typed as xsd:string
       has_language? ?
-        (language == other.language || other.datatype == RDF::XSD.string) :
-        other.datatype == RDF::XSD.string
+        (language == other.language || other.datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")) :
+        other.datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
     end
 
     ##
@@ -317,7 +316,7 @@ def ==(other)
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-plain-literal
     def plain?
-      [RDF.langString, RDF::XSD.string].include?(datatype)
+      [RDF.langString, RDF::URI("http://www.w3.org/2001/XMLSchema#string")].include?(datatype)
     end
 
     ##
@@ -327,7 +326,7 @@ def plain?
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/sparql11-query/#simple_literal
     def simple?
-      datatype == RDF::XSD.string
+      datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
     end
 
     ##
@@ -361,6 +360,8 @@ def has_datatype?
     # @return [Boolean] `true` or `false`
     # @since  0.2.1
     def valid?
+      return false if language? && language.to_s !~ /^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/
+      return false if datatype? && datatype.invalid?
       grammar = self.class.const_get(:GRAMMAR) rescue nil
       grammar.nil? || !!(value =~ grammar)
     end
@@ -487,15 +488,15 @@ def inspect
     def method_missing(name, *args)
       case name
       when :to_str
-        return to_s if @datatype == RDF.langString || @datatype == RDF::XSD.string
+        return to_s if @datatype == RDF.langString || @datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
       end
       super
     end
 
     def respond_to_missing?(name, include_private = false)
       case name
       when :to_str
-        return true if @datatype == RDF.langString || @datatype == RDF::XSD.string
+        return true if @datatype == RDF.langString || @datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
       end
       super
     end

lib/rdf/model/literal/boolean.rb

@@ -5,7 +5,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/xmlschema11-2/#boolean
   # @since 0.2.1
   class Boolean < Literal
-    DATATYPE = RDF::XSD.boolean
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#boolean")
     GRAMMAR  = /^(true|false|1|0)$/.freeze
     TRUES    = %w(true  1).freeze
     FALSES   = %w(false 0).freeze

lib/rdf/model/literal/date.rb

@@ -5,7 +5,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/xmlschema11-2/#date
   # @since 0.2.1
   class Date < Literal
-    DATATYPE = RDF::XSD.date
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#date")
     GRAMMAR  = %r(\A(-?\d{4}-\d{2}-\d{2})((?:[\+\-]\d{2}:\d{2})|UTC|GMT|Z)?\Z).freeze
     FORMAT   = '%Y-%m-%d'.freeze
 

lib/rdf/model/literal/datetime.rb

@@ -5,7 +5,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/xmlschema11-2/#dateTime#boolean
   # @since 0.2.1
   class DateTime < Literal
-    DATATYPE = RDF::XSD.dateTime
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#dateTime")
     GRAMMAR  = %r(\A(-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?)((?:[\+\-]\d{2}:\d{2})|UTC|GMT|Z)?\Z).freeze
     FORMAT   = '%Y-%m-%dT%H:%M:%S%:z'.freeze
 
@@ -57,14 +57,14 @@ def tz
     # @return [RDF::Literal]
     def timezone
       if tz == 'Z'
-        RDF::Literal("PT0S", datatype: RDF::XSD.dayTimeDuration)
+        RDF::Literal("PT0S", datatype: RDF::URI("http://www.w3.org/2001/XMLSchema#dayTimeDuration"))
       elsif md = tz.to_s.match(/^([+-])?(\d+):(\d+)?$/)
         plus_minus, hour, min = md[1,3]
         plus_minus = nil unless plus_minus == "-"
         hour = hour.to_i
         min = min.to_i
         res = "#{plus_minus}PT#{hour}H#{"#{min}M" if min > 0}"
-        RDF::Literal(res, datatype: RDF::XSD.dayTimeDuration)
+        RDF::Literal(res, datatype: RDF::URI("http://www.w3.org/2001/XMLSchema#dayTimeDuration"))
       end
     end
 

lib/rdf/model/literal/decimal.rb

@@ -11,7 +11,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/xmlschema11-2/#decimal
   # @since 0.2.1
   class Decimal < Numeric
-    DATATYPE = RDF::XSD.decimal
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#decimal")
     GRAMMAR  = /^[\+\-]?\d+(\.\d*)?$/.freeze
 
     ##

lib/rdf/model/literal/double.rb

@@ -11,7 +11,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/xmlschema11-2/#double
   # @since 0.2.1
   class Double < Numeric
-    DATATYPE = RDF::XSD.double
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#double")
     GRAMMAR  = /^(?:NaN|\-?INF|[+\-]?(?:\d+(:?\.\d*)?|\.\d+)(?:[eE][\+\-]?\d+)?)$/.freeze
 
     ##

lib/rdf/model/literal/integer.rb

@@ -12,7 +12,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#integer
   # @since 0.2.1
   class Integer < Decimal
-    DATATYPE = RDF::XSD.integer
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#integer")
     GRAMMAR  = /^[\+\-]?\d+$/.freeze
 
     ##

lib/rdf/model/literal/time.rb

@@ -10,7 +10,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/xmlschema11-2/#time
   # @since 0.2.1
   class Time < Literal
-    DATATYPE = RDF::XSD.time
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#time")
     GRAMMAR  = %r(\A(\d{2}:\d{2}:\d{2}(?:\.\d+)?)((?:[\+\-]\d{2}:\d{2})|UTC|GMT|Z)?\Z).freeze
     FORMAT   = '%H:%M:%S%:z'.freeze
 

lib/rdf/model/literal/token.rb

@@ -5,7 +5,7 @@ module RDF; class Literal
   # @see   http://www.w3.org/TR/xmlschema11-2/#token
   # @since 0.2.3
   class Token < Literal
-    DATATYPE = RDF::XSD.token
+    DATATYPE = RDF::URI("http://www.w3.org/2001/XMLSchema#token")
     GRAMMAR  = /\A[^\x0D\x0A\x09]+\z/i.freeze # FIXME
 
     ##

rdf.gemspec

@@ -18,11 +18,7 @@ Gem::Specification.new do |gem|
   gem.files              = %w(AUTHORS CREDITS README.md UNLICENSE VERSION bin/rdf etc/doap.nt) + Dir.glob('lib/**/*.rb')
   gem.bindir             = %q(bin)
   gem.executables        = %w(rdf)
-  gem.default_executable = gem.executables.first
   gem.require_paths      = %w(lib)
-  gem.extensions         = %w()
-  gem.test_files         = %w()
-  gem.has_rdoc           = false
 
   gem.required_ruby_version      = '>= 2.2.2'
   gem.requirements               = []

spec/model_literal_spec.rb

@@ -12,6 +12,10 @@ def self.literal(selector)
     when :plain       then ['Hello'.freeze]
     when :empty_lang  then [''.freeze, {language: :en}]
     when :plain_lang  then ['Hello'.freeze, {language: :en}]
+    # langString language: must not contain spaces
+    when :wrong_lang  then ['WrongLang'.freeze, {language: "en f"}]
+    # langString language: must be non-empty valid language
+    when :unset_lang  then ['NoLanguage'.freeze, {datatype: RDF::langString}]
     when :string      then ['String.freeze', {datatype: RDF::XSD.string}]
     when :false       then [false]
     when :true        then [true]
@@ -33,6 +37,7 @@ def self.literals(*selector)
       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_invalid_lang  then [:wrong_lang, :unset_lang].map {|s| literal(s)}
       when :all_plain         then literals(:all_simple, :all_plain_lang)
       else                         literals(:all_plain, :all_native)
       end
@@ -340,6 +345,43 @@ def self.literals(*selector)
     end
   end
 
+  describe "language-tagged string" do
+    literals(:all_plain_lang).each do |args|
+      it "validates #{args.inspect}" do
+        expect(RDF::Literal.new(*args)).to be_valid
+      end
+    end
+
+    literals(:all_invalid_lang).each do |args|
+      it "invalidates #{args.inspect}" do
+        expect(RDF::Literal.new(*args)).not_to be_valid
+      end
+    end
+
+    # test to make sure extra validation is not needed 
+    context "when language? && !@language" do
+      langString = RDF::Literal.new("hello", datatype: RDF::langString)
+      it "should be invalid" do
+        expect(langString.language?).to be true
+        expect(!langString.instance_variable_get("@language")).to be true
+        expect(langString).not_to be_valid
+      end
+    end
+  end
+
+  describe "datatyped literal" do
+    (literals(:all) - literals(:all_simple, :all_plain_lang) +
+     [["foo", datatype: RDF::URI("http://example/bar")]]).each do |args|
+      it "validates #{args.inspect}" do
+        expect(RDF::Literal.new(*args)).to be_valid
+      end
+    end
+
+    it "invalidates ['foo', datatype: 'bar']" do
+      expect(RDF::Literal.new("foo", datatype: "bar")).not_to be_valid
+    end
+  end
+
   describe RDF::Literal::Boolean do
     it_behaves_like 'RDF::Literal with datatype and grammar', "true", RDF::XSD.boolean
     it_behaves_like 'RDF::Literal equality', "true", true
@@ -1256,7 +1298,6 @@ def self.literals(*selector)
       {
         "language with xsd:string" => {value: "foo", language: "en", datatype: RDF::XSD.string},
         "language with xsd:date" => {value: "foo", language: "en", datatype: RDF::XSD.date},
-        "no language with rdf:langString" => {value: "foo", datatype: RDF::langString},
       }.each do |name, opts|
         it "raises error for #{name}" do
           expect {RDF::Literal.new(opts.delete(:value), opts)}.to raise_error(ArgumentError)