rdf 2.1.1 → 2.2.0.pre.rc1

data/lib/rdf/model/literal/boolean.rb

@@ -11,12 +11,11 @@ module RDF; class Literal
     FALSES   = %w(false 0).freeze
 
     ##
-    # @param  [Boolean] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Boolean] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when true.equal?(value)  then true
         when false.equal?(value) then false

data/lib/rdf/model/literal/date.rb

@@ -10,12 +10,11 @@ module RDF; class Literal
     FORMAT   = '%Y-%m-%d'.freeze
 
     ##
-    # @param  [Date] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Date, #to_date] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::Date)         then value
         when value.respond_to?(:to_date) then value.to_date

data/lib/rdf/model/literal/datetime.rb

@@ -12,10 +12,9 @@ module RDF; class Literal
     ##
     # @param  [DateTime] value
     # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::DateTime)         then value
         when value.respond_to?(:to_datetime) then value.to_datetime

data/lib/rdf/model/literal/decimal.rb

@@ -15,15 +15,19 @@ module RDF; class Literal
     GRAMMAR  = /^[\+\-]?\d+(\.\d*)?$/.freeze
 
     ##
-    # @param  [BigDecimal] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, BidDecimal, Numeric] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
-        when value.is_a?(BigDecimal) then value
-        else BigDecimal(value.to_s)
+        when value.is_a?(::BigDecimal) then value
+        when value.is_a?(::Float)      then BigDecimal(value.to_s)
+        when value.is_a?(::Numeric)    then BigDecimal(value)
+        else
+          value = value.to_s
+          value += "0" if value.end_with?(".")  # Normalization required in Ruby 2.4
+          BigDecimal(value) rescue nil
       end
     end
 

data/lib/rdf/model/literal/double.rb

@@ -15,12 +15,11 @@ module RDF; class Literal
     GRAMMAR  = /^(?:NaN|(?:[\+\-]?(?:INF|(?:\d+(\.\d*)?(e[\+\-]?\d+)?))))$/i.freeze
 
     ##
-    # @param  [Float, #to_f] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Float, #to_f] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::String) then case value
           when '+INF'  then 1/0.0

data/lib/rdf/model/literal/integer.rb

@@ -16,15 +16,14 @@ module RDF; class Literal
     GRAMMAR  = /^[\+\-]?\d+$/.freeze
 
     ##
-    # @param  [Integer, #to_i] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Integer, #to_i] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
+      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

data/lib/rdf/model/literal/time.rb

@@ -15,12 +15,11 @@ module RDF; class Literal
     FORMAT   = '%H:%M:%S%:z'.freeze
 
     ##
-    # @param  [Time] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, DateTime, #to_datetime] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::DateTime)         then value
         when value.respond_to?(:to_datetime) then value.to_datetime rescue ::DateTime.parse(value.to_s)

data/lib/rdf/model/literal/token.rb

@@ -9,13 +9,12 @@ module RDF; class Literal
     GRAMMAR  = /\A[^\x0D\x0A\x09]+\z/i.freeze # FIXME
 
     ##
-    # @param  [Symbol, #to_s]  value
-    # @option options [String] :lexical (nil)
-    def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
-      @object   = value.is_a?(Symbol) ? value : value.to_s
+    # @param  [String, Symbol, #to_sym]  value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil, **options)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
+      @object   = value.is_a?(Symbol) ? value : value.to_sym
     end
 
     ##

data/lib/rdf/model/node.rb

@@ -114,7 +114,7 @@ module RDF
     ##
     # Returns a hash code for this blank node.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def hash
       @id.hash
     end

data/lib/rdf/model/statement.rb

@@ -31,11 +31,11 @@ module RDF
     ##
     # @private
     # @since 0.2.2
-    def self.from(statement, options = {})
+    def self.from(statement, graph_name: nil, **options)
       case statement
         when Array, Query::Pattern
-          graph_name = statement[3] == false ? nil : statement[3]
-          self.new(statement[0], statement[1], statement[2], options.merge(graph_name: graph_name))
+          graph_name ||= statement[3] == false ? nil : statement[3]
+          self.new(statement[0], statement[1], statement[2], graph_name: graph_name, **options)
         when Statement then statement
         when Hash      then self.new(options.merge(statement))
         else raise ArgumentError, "expected RDF::Statement, Hash, or Array, but got #{statement.inspect}"
@@ -58,7 +58,7 @@ module RDF
     attr_accessor :object
 
     ##
-    # @overload initialize(options = {})
+    # @overload initialize(**options)
     #   @param  [Hash{Symbol => Object}] options
     #   @option options [RDF::Term]  :subject   (nil)
     #     A symbol is converted to an interned {Node}.
@@ -70,11 +70,11 @@ module RDF
     #   @option options [Boolean] :inferred used as a marker to record that this statement was inferred based on semantic relationships (T-Box).
     #   @return [RDF::Statement]
     #
-    # @overload initialize(subject, predicate, object, options = {})
+    # @overload initialize(subject, predicate, object, **options)
     #   @param  [RDF::Term]          subject
     #     A symbol is converted to an interned {Node}.
-    #   @param  [RDF::URI]               predicate
-    #   @param  [RDF::Resource]              object
+    #   @param  [RDF::URI]           predicate
+    #   @param  [RDF::Resource]      object
     #     if not a {Resource}, it is coerced to {Literal} or {Node} depending on if it is a symbol or something other than a {Term}.
     #   @param  [Hash{Symbol => Object}] options
     #   @option options [RDF::Term]  :graph_name   (nil)
@@ -244,7 +244,7 @@ module RDF
     end
 
     ##
-    # Generates a Fixnum hash value as a quad.
+    # Generates a Integer hash value as a quad.
     def hash
       @hash ||= to_quad.hash
     end
@@ -337,9 +337,14 @@ module RDF
     def to_triple
       [subject, predicate, object]
     end
+    alias_method :to_a, :to_triple
 
-    alias_method :to_a,   :to_triple
-    alias_method :to_ary, :to_triple
+    ##
+    # @deprecated use {#to_a} or {#to_triple} instead
+    # @see #to_triple
+    def to_ary
+      to_triple
+    end
 
     ##
     # Canonicalizes each unfrozen term in the statement
@@ -375,7 +380,7 @@ module RDF
     # @param  [Symbol] predicate_key
     # @param  [Symbol] object_key
     # @return [Hash{Symbol => RDF::Term}]
-    def to_hash(subject_key = :subject, predicate_key = :predicate, object_key = :object, graph_key = :graph_name)
+    def to_h(subject_key = :subject, predicate_key = :predicate, object_key = :object, graph_key = :graph_name)
       {subject_key => subject, predicate_key => predicate, object_key => object, graph_key => graph_name}
     end
 
@@ -392,17 +397,40 @@ module RDF
     ##
     # Returns a graph containing this statement in reified form.
     #
-    # @param  [Hash{Symbol => Object}] options
+    # @param [RDF::Term]  subject   (nil)
+    #   Subject of reification.
+    # @param [RDF::Term]  id   (nil)
+    #   Node identifier, when subject is anonymous
+    # @param [RDF::Term]  graph_name   (nil)
+    #   Note, in RDF 1.1, a graph name MUST be an {Resource}.
     # @return [RDF::Graph]
     # @see    http://www.w3.org/TR/rdf-primer/#reification
-    def reified(options = {})
-      RDF::Graph.new(graph_name: options[:graph_name]) do |graph|
-        subject = options[:subject] || RDF::Node.new(options[:id])
+    def reified(subject: nil, id: nil, graph_name: nil)
+      RDF::Graph.new(graph_name: graph_name) do |graph|
+        subject = subject || RDF::Node.new(id)
         graph << [subject, RDF.type,      RDF[:Statement]]
         graph << [subject, RDF.subject,   self.subject]
         graph << [subject, RDF.predicate, self.predicate]
         graph << [subject, RDF.object,    self.object]
       end
     end
+
+  protected
+    ##
+    # @overload #to_hash
+    # Returns the terms of this statement as a `Hash`.
+    #
+    # @param  (see #to_h)
+    # @return (see #to_h)
+    #   @deprecated Use {#to_h} instead.
+    def method_missing(meth, *args)
+      case meth
+      when :to_hash
+        warn "[DEPRECATION] Statement#to_hash is deprecated, use Statement#to_h instead. Called from #{Gem.location_of_caller.join(':')}"
+        self.to_h
+      else
+        super
+      end
+    end
   end
 end

data/lib/rdf/model/uri.rb

@@ -143,6 +143,7 @@ module RDF
     # @return [RDF::URI] an immutable, frozen URI object
     def self.intern(*args)
       str = args.first
+      args << {} unless args.last.is_a?(Hash)  # FIXME: needed until #to_hash is removed to avoid DEPRECATION warning.
       (cache[(str = str.to_s).to_sym] ||= self.new(*args)).freeze
     end
 
@@ -200,10 +201,10 @@ module RDF
     end
 
     ##
-    # @overload URI(uri, options = {})
+    # @overload URI(uri, **options)
     #   @param  [URI, String, #to_s]    uri
     #
-    # @overload URI(options = {})
+    # @overload URI(**options)
     #   @param  [Hash{Symbol => Object}] options
     #   @option [String, #to_s] :scheme The scheme component.
     #   @option [String, #to_s] :user The user component.
@@ -281,7 +282,7 @@ module RDF
     #
     # @return [Boolean] `true` or `false`
     # @see    http://en.wikipedia.org/wiki/URI_scheme
-    # @see    {NON_HIER_SCHEMES}
+    # @see    NON_HIER_SCHEMES
     # @since  1.0.10
     def hier?
       !NON_HIER_SCHEMES.include?(scheme)
@@ -807,7 +808,7 @@ module RDF
     ##
     # Returns a hash code for this URI.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def hash
       @hash ||= (value.hash * -1)
     end
@@ -819,7 +820,7 @@ module RDF
     def object
       @object ||= parse(@value)
     end
-    alias_method :to_hash, :object
+    alias_method :to_h, :object
 
     ##{
     # Parse a URI into it's components
@@ -1287,6 +1288,23 @@ module RDF
         ""
       end
     end
+
+  protected
+    ##
+    # @overload #to_hash
+    #   Returns object representation of this URI, broken into components
+    #
+    #   @return (see #object)
+    #   @deprecated Use {#to_h} instead.
+    def method_missing(meth, *args)
+      case meth
+      when :to_hash
+        warn "[DEPRECATION] URI#to_hash is deprecated, use URI#to_h instead. Called from #{Gem.location_of_caller.join(':')}"
+        self.to_h
+      else
+        super
+      end
+    end
   end
 
   # RDF::IRI is a synonym for RDF::URI

data/lib/rdf/nquads.rb

@@ -106,7 +106,7 @@ module RDF
       # @param  [Hash{Symbol => Object}] options = ({})
       # @return [String]
       # @since  0.4.0
-      def format_statement(statement, options = {})
+      def format_statement(statement, **options)
         format_quad(*statement.to_quad, options)
       end
 
@@ -119,7 +119,7 @@ module RDF
       # @param  [RDF::Term]     graph_name
       # @param  [Hash{Symbol => Object}] options = ({})
       # @return [String]
-      def format_quad(subject, predicate, object, graph_name, options = {})
+      def format_quad(subject, predicate, object, graph_name, **options)
         s = "%s %s %s " % [subject, predicate, object].map { |value| format_term(value, options) }
         s += format_term(graph_name, options) + " " if graph_name
         s + "."

data/lib/rdf/ntriples/reader.rb

@@ -91,8 +91,9 @@ module RDF::NTriples
     # @param  [String] input
     # @param [{Symbol => Object}] options
     #   From {RDF::Reader#initialize}
+    # @option options  [RDF::Util::Logger] :logger ([])
     # @return [RDF::Term]
-    def self.unserialize(input, options = {})
+    def self.unserialize(input, **options)
       case input
         when nil then nil
         else self.new(input, {logger: []}.merge(options)).read_value
@@ -102,27 +103,27 @@ module RDF::NTriples
     ##
     # (see unserialize)
     # @return [RDF::Resource]
-    def self.parse_subject(input, options = {})
+    def self.parse_subject(input, **options)
       parse_uri(input, options) || parse_node(input, options)
     end
 
     ##
     # (see unserialize)
     # @return [RDF::URI]
-    def self.parse_predicate(input, options = {})
+    def self.parse_predicate(input, *options)
       parse_uri(input, intern: true)
     end
 
     ##
     # (see unserialize)
-    def self.parse_object(input, options = {})
+    def self.parse_object(input, **options)
       parse_uri(input, options) || parse_node(input, options) || parse_literal(input, options)
     end
 
     ##
     # (see unserialize)
     # @return [RDF::Node]
-    def self.parse_node(input, options = {})
+    def self.parse_node(input, **options)
       if input =~ NODEID
         RDF::Node.new($1)
       end
@@ -130,18 +131,19 @@ module RDF::NTriples
 
     ##
     # (see unserialize)
+    # @param [Boolean] intern (false) Use Interned URI
     # @return [RDF::URI]
-    def self.parse_uri(input, options = {})
+    def self.parse_uri(input, intern: false, **options)
       if input =~ URIREF
         uri_str = unescape($1)
-        RDF::URI.send(options[:intern] ? :intern : :new, unescape($1))
+        RDF::URI.send(intern ? :intern : :new, unescape($1))
       end
     end
 
     ##
     # (see unserialize)
     # @return [RDF::Literal]
-    def self.parse_literal(input, options = {})
+    def self.parse_literal(input, **options)
       case input
         when LITERAL_WITH_LANGUAGE
           RDF::Literal.new(unescape($1), language: $4)
@@ -218,12 +220,13 @@ module RDF::NTriples
     end
 
     ##
+    # @param [Boolean] intern (false) Use Interned Node
     # @return [RDF::URI]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (uriref)
-    def read_uriref(options = {})
+    def read_uriref(intern: false, **options)
       if uri_str = match(URIREF)
         uri_str = self.class.unescape(uri_str)
-        uri = RDF::URI.send(intern? && options[:intern] ? :intern : :new, uri_str)
+        uri = RDF::URI.send(intern? && intern ? :intern : :new, uri_str)
         uri.validate!     if validate?
         uri.canonicalize! if canonicalize?
         uri