rdf 2.1.1 → 2.2.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27bb98ac53c34487b7b019cec8348e4d1c1b0248
-  data.tar.gz: 02531a71cfeae374e921994416c23be579147b25
+  metadata.gz: 021b280777d430a6b79691be567737b25ca3dbb1
+  data.tar.gz: aaa41238c2b7fa38dcc80b760bb14dbed315c906
 SHA512:
-  metadata.gz: d50dc7d520c49ec465bbc83c6d0a0df1348a921e77b0c1df19ab6286a14598a5a11bf1ff5460a753f851411df6d2e743bbc092e3b93cef2ed7784e09b96db46e
-  data.tar.gz: 44d24ae43fc15dcfff3421c8a86e3a8cc6a4878f74b18077e30791d2284ccf99ce6a2556febce3dc94c0d1c5a220812da235e17f6c7ae27648195c1f630709e9
+  metadata.gz: 80781fd13019493a907988216a762d910568965b8aa352fc3a1674e752b0d30cf67ebfd428d7d3c9cec3212d44dd269e83e54783e3724ef20bb4bf5231677155
+  data.tar.gz: 915f78c9eb8d23b796bc6c7ba2f60b03c3fd09efc8544bff972bdb0c61de29913df3010f995218396459433299824f3737d96d879f8640e4db5cdb1e2a4ec183

data/VERSION

@@ -1 +1 @@
-2.1.1
+2.2.0-rc1

data/lib/rdf.rb

@@ -156,7 +156,7 @@ module RDF
   # @overload Statement()
   #   @return [RDF::URI] returns the IRI for `rdf:Statement`
   #
-  # @overload Statement(options = {})
+  # @overload Statement(**options)
   #   @param  [Hash{Symbol => Object}] options
   #   @option options [RDF::Resource]  :subject   (nil)
   #   @option options [RDF::URI]       :predicate (nil)
@@ -165,7 +165,7 @@ module RDF
   #     Note, a graph_name MUST be an IRI or BNode.
   #   @return [RDF::Statement]
   #
-  # @overload Statement(subject, predicate, object, options = {})
+  # @overload Statement(subject, predicate, object, **options)
   #   @param  [RDF::Resource]          subject
   #   @param  [RDF::URI]               predicate
   #   @param  [RDF::Term]              object

data/lib/rdf/changeset.rb

@@ -41,7 +41,7 @@ module RDF
     # @yield  [changes]
     # @yieldparam [RDF::Changeset] changes
     # @return [void]
-    def self.apply(mutable, options = {}, &block)
+    def self.apply(mutable, **options, &block)
       self.new(&block).apply(mutable, options)
     end
 
@@ -106,7 +106,7 @@ module RDF
     # @param  [RDF::Mutable] mutable
     # @param  [Hash{Symbol => Object}] options
     # @return [void]
-    def apply(mutable, options = {})
+    def apply(mutable, **options)
       mutable.apply_changeset(self)
     end
 

data/lib/rdf/cli.rb

@@ -338,23 +338,24 @@ module RDF
     # Execute one or more commands, parsing input as necessary
     #
     # @param  [Array<String>] args
+    # @param  [IO] output
+    # @param  [Hash{Symbol => Object}] options
     # @return [Boolean]
-    def self.exec(args, options = {})
-      out = options[:output] || $stdout
-      out.set_encoding(Encoding::UTF_8) if out.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
+    def self.exec(args, output: $stdout, option_parser: self.options, **options)
+      output.set_encoding(Encoding::UTF_8) if output.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
       cmds, args = args.partition {|e| commands.include?(e.to_s)}
 
       if cmds.empty?
-        usage(options.fetch(:option_parser, self.options))
+        usage(option_parser)
         abort "No command given"
       end
 
       if cmds.first == 'help'
         on_cmd = cmds[1]
         if on_cmd && COMMANDS.fetch(on_cmd.to_sym, {})[:help]
-          usage(options.fetch(:option_parser, self.options), banner: "Usage: #{self.basename.split('/').last} #{COMMANDS[on_cmd.to_sym][:help]}")
+          usage(option_parser, banner: "Usage: #{self.basename.split('/').last} #{COMMANDS[on_cmd.to_sym][:help]}")
         else
-          usage(options.fetch(:option_parser, self.options))
+          usage(option_parser)
         end
         return
       end
@@ -374,7 +375,7 @@ module RDF
 
       # Run each command in sequence
       cmds.each do |command|
-        COMMANDS[command.to_sym][:lambda].call(args, options)
+        COMMANDS[command.to_sym][:lambda].call(args, output: output, **options)
       end
     rescue ArgumentError => e
       abort e.message
@@ -409,7 +410,7 @@ module RDF
     # @yieldparam [Array<String>] argv
     # @yieldparam [Hash] opts
     # @yieldreturn [void]
-    def self.add_command(command, options = {}, &block)
+    def self.add_command(command, **options, &block)
       options[:lambda] = block if block_given?
       COMMANDS[command.to_sym] ||= options
     end
@@ -431,20 +432,25 @@ module RDF
     # yielding a reader
     #
     # @param  [Array<String>] files
+    # @param  [String] evaluate from command-line, rather than referenced file
+    # @param  [Symbol] format (:ntriples) Reader symbol for finding reader
+    # @param  [Encoding] encoding set on the input
+    # @param  [Hash{Symbol => Object}] options sent to reader
     # @yield  [reader]
     # @yieldparam [RDF::Reader]
     # @return [nil]
-    def self.parse(files, options = {}, &block)
+    def self.parse(files, evaluate: nil, format: :ntriples, encoding: Encoding::UTF_8, **options, &block)
       if files.empty?
         # If files are empty, either use options[:execute]
-        input = options[:evaluate] ? StringIO.new(options[:evaluate]) : $stdin
-        input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-        r = RDF::Reader.for(options[:format] || :ntriples)
+        input = evaluate ? StringIO.new(evaluate) : $stdin
+        input.set_encoding(encoding)
+        r = RDF::Reader.for(format)
         (@readers ||= []) << r
         r.new(input, options) do |reader|
           yield(reader)
         end
       else
+        options[:format] = format if format
         files.each do |file|
           RDF::Reader.open(file, options) do |reader|
             (@readers ||= []) << reader.class.to_s

data/lib/rdf/format.rb

@@ -70,7 +70,7 @@ module RDF
     #   @param  [String, RDF::URI] filename
     #   @return [Class]
     #
-    # @overload for(options = {})
+    # @overload for(**options)
     #   Finds an RDF serialization format class based on various options.
     #
     #   @param  [Hash{Symbol => Object}] options

data/lib/rdf/mixin/enumerable.rb

@@ -121,7 +121,7 @@ module RDF
     # @return [Array<RDF::Statement>]
     # @see    #each_statement
     # @see    #enum_statement
-    def statements(options = {})
+    def statements(**options)
       Array(enum_statement)
     end
 
@@ -184,7 +184,7 @@ module RDF
     # @return [Array<Array(RDF::Resource, RDF::URI, RDF::Term)>]
     # @see    #each_triple
     # @see    #enum_triple
-    def triples(options = {})
+    def triples(**options)
       enum_statement.map(&:to_triple) # TODO: optimize
     end
 
@@ -245,7 +245,7 @@ module RDF
     # @return [Array<Array(RDF::Resource, RDF::URI, RDF::Term, RDF::Resource)>]
     # @see    #each_quad
     # @see    #enum_quad
-    def quads(options = {})
+    def quads(**options)
       enum_statement.map(&:to_quad) # TODO: optimize
     end
 
@@ -711,7 +711,7 @@ module RDF
     # `{subject => {predicate => [*objects]}}`.
     #
     # @return [Hash]
-    def to_hash
+    def to_h
       result = {}
       each_statement do |statement|
         result[statement.subject] ||= {}
@@ -738,14 +738,24 @@ module RDF
     # @see    RDF::Writer.dump
     # @raise [RDF::WriterError] if no writer found
     # @since  0.2.0
-    def dump(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
+    def dump(*args, **options)
       writer = RDF::Writer.for(*args)
       raise RDF::WriterError, "No writer found using #{args.inspect}" unless writer
-      writer.dump(self, nil, options)
+      writer.dump(self, nil, **options)
     end
 
+  protected
+
     ##
+    # @overload #to_hash
+    #   Returns all RDF object terms indexed by their subject and predicate
+    #   terms.
+    #
+    #   The return value is a `Hash` instance that has the structure:
+    #   `{subject => {predicate => [*objects]}}`.
+    #
+    #   @return [Hash]
+    #   @deprecated Use {#to_h} instead.
     # @overload #to_writer
     #   Implements #to_writer for each available instance of {RDF::Writer},
     #   based on the writer symbol.
@@ -753,6 +763,11 @@ module RDF
     #   @return [String]
     #   @see {RDF::Writer.sym}
     def method_missing(meth, *args)
+      case meth
+      when :to_hash
+        warn "[DEPRECATION] Enumerable#to_hash is deprecated, use Enumerable#to_h instead. Called from #{Gem.location_of_caller.join(':')}"
+        return self.to_h
+      end
       writer = RDF::Writer.for(meth.to_s[3..-1].to_sym) if meth.to_s[0,3] == "to_"
       if writer
         writer.buffer(standard_prefixes: true) {|w| w << self}

data/lib/rdf/mixin/enumerator.rb

@@ -7,11 +7,29 @@ module RDF
       include Queryable
       include Enumerable
 
-      # Make sure returned arrays are also queryable
+      ##
+      # @return [Array]
+      # @note Make sure returned arrays are also queryable
       def to_a
         return super.to_a.extend(RDF::Queryable, RDF::Enumerable)
       end
-      alias_method :to_ary, :to_a
+
+      protected
+
+      ##
+      # @overload #to_ary
+      #   @see #to_a
+      #   @deprecated use {#to_a} instead
+      def method_missing(name, *args)
+        if name == :to_ary
+          warn "[DEPRECATION] #{self.class}#to_ary is deprecated, use " \
+               "#{self.class}#to_a instead. Called from " \
+               "#{Gem.location_of_caller.join(':')}"
+          to_a
+        else
+          super
+        end
+      end
     end
   end
 
@@ -28,11 +46,29 @@ module RDF
       include Queryable
       include Enumerable
 
-      # Make sure returned arrays are also queryable
+      ##
+      # @return [Array]
+      # @note Make sure returned arrays are also queryable
       def to_a
         return super.to_a.extend(RDF::Queryable, RDF::Enumerable)
       end
-      alias_method :to_ary, :to_a
+
+      protected
+
+      ##
+      # @overload #to_ary
+      #   @see #to_a
+      #   @deprecated use {#to_a} instead
+      def method_missing(name, *args)
+        if name == :to_ary
+          warn "[DEPRECATION] #{self.class}#to_ary is deprecated, use " \
+               "#{self.class}#to_a instead. Called from " \
+               "#{Gem.location_of_caller.join(':')}"
+          self.to_a
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/rdf/mixin/queryable.rb

@@ -41,7 +41,7 @@ module RDF
     #   Returns an enumerable of statements (may be an enumerator) or query solutions, if passed an {RDF::Query}
     # @see    RDF::Queryable#query_pattern
     # @note   Since 2.0, this may return an Enumerable or an Enumerator in addition to Solutions
-    def query(pattern, options = {}, &block)
+    def query(pattern, **options, &block)
       raise TypeError, "#{self} is not readable" if respond_to?(:readable?) && !readable?
 
       case pattern
@@ -111,7 +111,7 @@ module RDF
     # @see    RDF::Queryable#query
     # @see    RDF::Query#execute
     # @since  0.3.0
-    def query_execute(query, options = {}, &block)
+    def query_execute(query, **options, &block)
       # By default, we let RDF.rb's built-in `RDF::Query#execute` handle BGP
       # query execution by breaking down the query into its constituent
       # triple patterns and invoking `RDF::Query::Pattern#execute` on each
@@ -139,7 +139,7 @@ module RDF
     # @see    RDF::Queryable#query
     # @see    RDF::Query::Pattern#execute
     # @since  0.2.0
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, **options, &block)
       # By default, we let Ruby's built-in `Enumerable#grep` handle the
       # matching of statements by iterating over all statements and calling
       # `RDF::Query::Pattern#===` on each statement.

data/lib/rdf/model/dataset.rb

@@ -119,7 +119,7 @@ module RDF
     ##
     # Implements basic query pattern matching over the Dataset, with handling 
     # for a default graph.
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, **options, &block)
       return super unless pattern.graph_name == DEFAULT_GRAPH
 
       if block_given?

data/lib/rdf/model/graph.rb

@@ -87,12 +87,12 @@ module RDF
     end
 
     ##
-    # @param  [RDF::Resource]          graph_name
+    # @param  [RDF::Resource] graph_name
     #   The graph_name from the associated {RDF::Queryable} associated
     #   with this graph as provided with the `:data` option
     #   (only for {RDF::Queryable} instances supporting
     #   named graphs).
-    # @param [RDF::Queryable] :data (RDF::Repository.new)
+    # @param [RDF::Queryable] data (RDF::Repository.new)
     #   Storage behind this graph.
     #
     # @raise [ArgumentError] if a `data` does not support named graphs.
@@ -273,7 +273,7 @@ module RDF
     ##
     # @private
     # @see RDF::Queryable#query_pattern
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, **options, &block)
       pattern = pattern.dup
       pattern.graph_name = graph_name || false
       @data.query(pattern, &block)
@@ -294,7 +294,7 @@ module RDF
     def insert_statements(statements)
       enum = Enumerable::Enumerator.new do |yielder|
         
-        statements.send(method = statements.respond_to?(:each_statement) ? :each_statement : :each) do |s|
+        statements.send(statements.respond_to?(:each_statement) ? :each_statement : :each) do |s|
           s = s.dup
           s.graph_name = graph_name
           yielder << s

data/lib/rdf/model/literal.rb

@@ -104,13 +104,13 @@ module RDF
 
     ##
     # @private
-    def self.new(value, options = {})
-      raise ArgumentError, "datatype with language must be rdf:langString" if options[:language] && (options[:datatype] || RDF.langString).to_s != RDF.langString.to_s
+    def self.new(value, language: nil, datatype: nil, lexical: nil, validate: false, canonicalize: false, **options)
+      raise ArgumentError, "datatype with language must be rdf:langString" if language && (datatype || RDF.langString).to_s != RDF.langString.to_s
 
       klass = case
         when !self.equal?(RDF::Literal)
           self # subclasses can be directly constructed without type dispatch
-        when typed_literal = datatyped_class(options[:datatype].to_s)
+        when typed_literal = datatyped_class(datatype.to_s)
           typed_literal
         else case value
           when ::TrueClass  then RDF::Literal::Boolean
@@ -126,9 +126,9 @@ module RDF
         end
       end
       literal = klass.allocate
-      literal.send(:initialize, value, options)
-      literal.validate!     if options[:validate]
-      literal.canonicalize! if options[:canonicalize]
+      literal.send(:initialize, value, language: language, datatype: datatype, **options)
+      literal.validate!     if validate
+      literal.canonicalize! if canonicalize
       literal
     end
 
@@ -147,28 +147,28 @@ module RDF
     # depending on if there is language
     #
     # @param  [Object] value
-    # @option options [Symbol]  :language (nil)
+    # @param  [Symbol]  language (nil)
     #   Language is downcased to ensure proper matching
-    # @option options [String]  :lexical (nil)
+    # @param [String]  lexical (nil)
     #   Supplied lexical representation of this literal,
-    #   otherwise it comes from transforming `value` to a string form
-    #   See {#to_s}.
-    # @option options [URI]     :datatype (nil)
-    # @option options [Boolean] :validate (false)
-    # @option options [Boolean] :canonicalize (false)
+    #   otherwise it comes from transforming `value` to a string form..
+    # @param [URI]     datatype (nil)
+    # @param [Boolean] validate (false)
+    # @param [Boolean] canonicalize (false)
     # @raise [ArgumentError]
     #   if there is a language and datatype is no rdf:langString
     #   or datatype is rdf:langString and there is no language
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Datatypes
-    def initialize(value, options = {})
+    # @see #to_s
+    def initialize(value, language: nil, datatype: nil, lexical: nil, validate: false, canonicalize: false, **options)
       @object   = value.freeze
-      @string   = options[:lexical] if options[:lexical]
+      @string   = lexical if lexical
       @string   = value if !defined?(@string) && value.is_a?(String)
       @string   = @string.encode(Encoding::UTF_8).freeze if @string
       @object   = @string if @string && @object.is_a?(String)
-      @language = options[:language].to_s.downcase.to_sym if options[:language]
-      @datatype = RDF::URI(options[:datatype]).freeze if options[:datatype]
+      @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
@@ -233,7 +233,7 @@ module RDF
     ##
     # Returns a hash code for this literal.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def hash
       @hash ||= [to_s, datatype, language].hash
     end
@@ -242,7 +242,7 @@ module RDF
     ##
     # Returns a hash code for the value.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def value_hash
       @value_hash ||= value.hash
     end
@@ -441,7 +441,7 @@ module RDF
     #
     # @param  [String] string
     # @return [String]
-    # @see {RDF::Term#escape}
+    # @see RDF::Term#escape
     def escape(string)
       string.gsub('\\', '\\\\').
              gsub("\t", '\\t').
@@ -477,5 +477,27 @@ module RDF
     def inspect
       sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, RDF::NTriples.serialize(self))
     end
+
+    protected
+
+    ##
+    # @overload #to_str
+    #   This method is implemented when the datatype is `xsd:string` or `rdf:langString`
+    #   @return [String]
+    def method_missing(name, *args)
+      case name
+      when :to_str
+        return to_s if @datatype == RDF.langString || @datatype == RDF::XSD.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
+      end
+      super
+    end
   end # Literal
 end # RDF