rdf 3.0.11 → 3.1.2

data/lib/rdf.rb

@@ -6,6 +6,9 @@ require 'time'
 require 'rdf/version'
 require 'rdf/extensions'
 
+# When loading, issue deprecation warning on forthcoming unsupported versions of Ruby
+warn "[DEPRECATION] Ruby 2.4+ required in next version 3.1 of RDF.rb" if RUBY_VERSION < "2.4"
+
 module RDF
   # RDF mixins
   autoload :Countable,         'rdf/mixin/countable'
@@ -56,16 +59,18 @@ module RDF
   # RDF vocabularies
   autoload :Vocabulary,        'rdf/vocabulary'
   autoload :StrictVocabulary,  'rdf/vocabulary'
-  VOCABS = Dir.glob(File.expand_path("../rdf/vocab/*.rb", __FILE__)).map { |f| File.basename(f)[0...-(File.extname(f).size)].to_sym } rescue []
 
-  # Use const_missing instead of autoload to load most vocabularies so we can provide deprecation messages
-  def self.const_missing(constant)
-    if VOCABS.include?(constant.to_s.downcase.to_sym)
-      require "rdf/vocab/#{constant.to_s.downcase}"
-      const_get(constant)
-    else
-      super
-    end
+  VOCABS = {
+    owl: {uri: "http://www.w3.org/2002/07/owl#", class_name: "OWL"},
+    rdfs: {uri: "http://www.w3.org/2000/01/rdf-schema#", class_name: "RDFS"},
+    rdfv: {uri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", class_name: "RDFV"},
+    xsd: {uri: "http://www.w3.org/2001/XMLSchema#", class_name: "XSD"},
+  }
+
+  # Autoload vocabularies
+  VOCABS.each do |id, params|
+    v = (params[:class_name] ||= id.to_s.upcase).to_sym
+    autoload v, File.expand_path("../rdf/vocab/#{id}", __FILE__)
   end
 
   # Utilities
@@ -76,8 +81,8 @@ module RDF
   #
   # @param (see RDF::Resource#initialize)
   # @return [RDF::Resource]
-  def self.Resource(*args, &block)
-    Resource.new(*args, &block)
+  def self.Resource(*args)
+    Resource.new(*args)
   end
 
   ##
@@ -85,8 +90,8 @@ module RDF
   #
   # @param (see RDF::Node#initialize)
   # @return [RDF::Node]
-  def self.Node(*args, &block)
-    Node.new(*args, &block)
+  def self.Node(*args)
+    Node.new(*args)
   end
 
   ##
@@ -94,8 +99,15 @@ module RDF
   #
   # @param (see RDF::URI#initialize)
   # @return [RDF::URI]
-  def self.URI(uri, *args, &block)
-    uri.respond_to?(:to_uri) ? uri.to_uri : URI.new(uri, *args, &block)
+  def self.URI(*args)
+    if args.first.respond_to?(:to_uri)
+      args.first.to_uri
+    elsif args.first.is_a?(Hash)
+      URI.new(**args.first)
+    else
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      URI.new(*args, **opts)
+    end
   end
 
   ##
@@ -103,10 +115,10 @@ module RDF
   #
   # @param (see RDF::Literal#initialize)
   # @return [RDF::Literal]
-  def self.Literal(literal, *args, &block)
+  def self.Literal(literal, **options)
     case literal
       when RDF::Literal then literal
-      else Literal.new(literal, *args, &block)
+      else Literal.new(literal, **options)
     end
   end
 
@@ -116,7 +128,7 @@ module RDF
   # @param (see RDF::Graph#initialize)
   # @return [RDF::Graph]
   def self.Graph(**options, &block)
-    Graph.new(options, &block)
+    Graph.new(**options, &block)
   end
 
   ##
@@ -168,11 +180,11 @@ module RDF
   #   @option options [RDF::Resource]  :graph_name   (nil)
   #   @return [RDF::Statement]
   #
-  def self.Statement(*args)
-    if args.empty?
+  def self.Statement(*args, **options)
+    if args.empty? && options.empty?
       RDF[:Statement]
     else
-      Statement.new(*args)
+      Statement.new(*args, **options)
     end
   end
 
@@ -190,8 +202,8 @@ module RDF
   #
   # @param (see RDF::Vocabulary#initialize)
   # @return [Class]
-  def self.StrictVocabulary(prefix)
-    StrictVocabulary.create(prefix)
+  def self.StrictVocabulary(uri)
+    StrictVocabulary.create(uri)
   end
 
   ##

data/lib/rdf/changeset.rb

@@ -31,10 +31,11 @@ module RDF
   #
   # @since 2.0.0
   class Changeset
-    include RDF::Mutable
+    # include RDF::Mutable
+    include RDF::Util::Coercions
 
     ##
-    # Applies a changeset to the given mutable RDF::Enumerable .
+    # Applies a changeset to the given {RDF::Mutable} object.
     #
     # @param  [RDF::Mutable] mutable
     # @param  [Hash{Symbol => Object}] options
@@ -42,7 +43,7 @@ module RDF
     # @yieldparam [RDF::Changeset] changes
     # @return [void]
     def self.apply(mutable, **options, &block)
-      self.new(&block).apply(mutable, options)
+      self.new(&block).apply(mutable, **options)
     end
 
     ##
@@ -98,6 +99,24 @@ module RDF
       false
     end
 
+    ##
+    # Returns `false` as changesets are not {RDF::Writable}.
+    #
+    # @return [Boolean]
+    # @see    RDF::Writable#writable?
+    def writable?
+      false
+    end
+
+    ##
+    # Returns `false` as changesets are not {RDF::Mutable}.
+    #
+    # @return [Boolean]
+    # @see    RDF::Mutable#mutable?
+    def mutable?
+      false
+    end
+
     ##
     # Applies this changeset to the given mutable RDF::Enumerable.
     #
@@ -127,35 +146,77 @@ module RDF
 
     ##
     # Outputs a developer-friendly representation of this changeset to
-    # `stderr`.
+    # `$stderr`.
     #
     # @return [void]
     def inspect!
       $stderr.puts(self.inspect)
     end
 
-    protected
-
     ##
-    # Appends an RDF statement to the sequence to insert when applied.
+    # Returns the sum of both the `inserts` and `deletes` counts.
     #
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @see    RDF::Writable#insert_statement
-    def insert_statement(statement)
-      self.inserts << statement
+    # @return [Integer]
+    def count
+      inserts.count + deletes.count
     end
 
+    # Append statements to `inserts`. Statements _should_ be constant
+    # as variable statements will at best be ignored or at worst raise
+    # an error when applied.
+    #
+    # @param statements [Enumerable, RDF::Statement] Some statements
+    # @return [self]
+    def insert(*statements)
+      coerce_statements(statements) do |stmts|
+        append_statements :inserts, stmts
+      end
+
+      self
+    end
+    alias_method :insert!, :insert
+    alias_method :<<, :insert
+
+    # Append statements to `deletes`. Statements _may_ contain
+    # variables, although support will depend on the {RDF::Mutable}
+    # target.
+    #
+    # @param statements [Enumerable, RDF::Statement] Some statements
+    # @return [self]
+    def delete(*statements)
+      coerce_statements(statements) do |stmts|
+        append_statements :deletes, stmts
+      end
+
+      self
+    end
+    alias_method :delete!, :delete
+    alias_method :>>, :delete
+
+    private
+
     ##
-    # Appends an RDF statement to the sequence to delete when applied.
+    # Append statements to the appropriate target. This is a little
+    # shim to go in between the other shim and the target.
     #
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @see    RDF::Mutable#delete_statement
-    def delete_statement(statement)
-      self.deletes << statement
+    # @param target [Symbol] the method to send
+    # @param arg [Enumerable, RDF::Statement]
+    #
+    def append_statements(target, arg)
+      # coerce to an enumerator 
+      stmts = case
+              when arg.is_a?(RDF::Statement)
+                [arg]
+              when arg.respond_to?(:each_statement)
+                arg.each_statement
+              when arg.respond_to?(:each)
+                arg
+              else
+                raise ArgumentError, "Invalid statement: #{arg.class}"
+              end
+
+      stmts.each { |s| send(target) << s }
     end
 
-    undef_method :load, :update, :clear
   end # Changeset
 end # RDF

data/lib/rdf/cli.rb

@@ -175,7 +175,7 @@ module RDF
           unless repository.count > 0
             start = Time.new
             count = 0
-            self.parse(argv, opts) do |reader|
+            self.parse(argv, **opts) do |reader|
               reader.each_statement do |statement|
                 count += 1
               end
@@ -240,7 +240,7 @@ module RDF
           out = opts[:output]
           opts = opts.merge(prefixes: {})
           writer_opts = opts.merge(standard_prefixes: true)
-          writer_class.new(out, writer_opts) do |writer|
+          writer_class.new(out, **writer_opts) do |writer|
             writer << repository
           end
         end
@@ -262,7 +262,7 @@ module RDF
         description: "Validate parsed input",
         control: :none,
         parse: true,
-        help: "validate [options] [args...]\nvalidates parsed input (may also be used with --validate)",
+        help: "validate [options] [args...]\nvalidates resulting repository (may also be used with --validate to check for parse-time errors)",
         lambda: ->(argv, opts) do
           opts[:output].puts "Input is " + (repository.valid? ? "" : "in") + "valid"
         end,
@@ -501,7 +501,7 @@ module RDF
       if cmds.any? {|c| COMMANDS[c.to_sym][:parse]}
         start = Time.new
         count = 0
-        self.parse(args, options) do |reader|
+        self.parse(args, **options) do |reader|
           @repository << reader
         end
         secs = Time.new - start
@@ -575,7 +575,7 @@ module RDF
         RDF::Format.each do |format|
           format.cli_commands.each do |command, options|
             options = {lambda: options} unless options.is_a?(Hash)
-            add_command(command, options)
+            add_command(command, **options)
           end
         end
         @commands_loaded = true
@@ -637,13 +637,13 @@ module RDF
         r = RDF::Reader.for(format|| {sample: sample})
         raise ArgumentError, "Unknown format for evaluated input" unless r
         (@readers ||= []) << r
-        r.new(input, options) do |reader|
+        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|
+          RDF::Reader.open(file, **options) do |reader|
             (@readers ||= []) << reader.class.to_s
             yield(reader)
           end

data/lib/rdf/format.rb

@@ -122,7 +122,7 @@ module RDF
         sample = case sample
         when Proc then sample.call.to_s
         else sample.dup.to_s
-        end.force_encoding(Encoding::ASCII_8BIT)
+        end.dup.force_encoding(Encoding::ASCII_8BIT)
         # Given a sample, perform format detection across the appropriate formats, choosing the last that matches
         # Return last format that has a positive detection
         formats = formats.select {|f| f.detect(sample)}
@@ -145,10 +145,10 @@ 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
+    #   @param  [Hash{Symbol => Object}] options ({})
     #   @option options [String, #to_s]   :file_name      (nil)
     #   @option options [Symbol, #to_sym] :file_extension (nil)
     #   @option options [String, #to_s]   :content_type   (nil)
@@ -164,19 +164,26 @@ module RDF
     #   @yieldreturn [String] another way to provide a sample, allows lazy for retrieving the sample.
     #
     # @return [Class]
-    def self.for(*args, **options, &block)
+    def self.for(*arg, &block)
+      case arg.length
+      when 0 then arg = nil
+      when 1 then arg = arg.first
+      else
+        raise ArgumentError, "Format.for accepts zero or one argument, got #{arg.length}."
+      end
+
+      options =  arg.is_a?(Hash) ? arg : {}
       options = {sample: block}.merge(options) if block_given?
-      formats = case args.first
+      formats = case arg
       when String, RDF::URI
         # Find a format based on the file name
-        self.each(file_name: args.first, **options).to_a
+        self.each(file_name: arg, **options).to_a
       when Symbol
         # Try to find a match based on the full class name
         # We want this to work even if autoloading fails
-        fmt = args.first
-        classes = self.each(options).select {|f| f.symbols.include?(fmt)}
+        classes = self.each(**options).select {|f| f.symbols.include?(arg)}
         if classes.empty?
-          classes = case fmt
+          classes = case arg
           when :ntriples then [RDF::NTriples::Format]
           when :nquads   then [RDF::NQuads::Format]
           else                []
@@ -184,7 +191,7 @@ module RDF
         end
         classes
       else
-        self.each(options.merge(all_if_none: false)).to_a
+        self.each(**options.merge(all_if_none: false)).to_a
       end
 
       # Return the last detected format

data/lib/rdf/mixin/enumerable.rb

@@ -17,7 +17,7 @@ module RDF
   #   enumerable.has_quad?([subject, predicate, object, graph_name])
   #
   # @example Checking whether a specific value exists
-  #   enumerable.has_subject?(RDF::URI("http://rubygems.org/gems/rdf"))
+  #   enumerable.has_subject?(RDF::URI("https://rubygems.org/gems/rdf"))
   #   enumerable.has_predicate?(RDF::RDFS.label)
   #   enumerable.has_object?(RDF::Literal("A Ruby library for working with Resource Description Framework (RDF) data.", language: :en))
   #   enumerable.has_graph?(RDF::URI("http://ar.to/#self"))
@@ -71,6 +71,7 @@ module RDF
     #   * `:literal_equality' preserves [term-equality](https://www.w3.org/TR/rdf11-concepts/#dfn-literal-term-equality) for literals. Literals are equal only if their lexical values and datatypes are equal, character by character. Literals may be "inlined" to value-space for efficiency only if `:literal_equality` is `false`.
     #   * `:validity` allows a concrete Enumerable implementation to indicate that it does or does not support valididty checking. By default implementations are assumed to support validity checking.
     #   * `:skolemize` supports [Skolemization](https://www.w3.org/wiki/BnodeSkolemization) of an `Enumerable`. Implementations supporting this feature must implement a `#skolemize` method, taking a base URI used for minting URIs for BNodes as stable identifiers and a `#deskolemize` method, also taking a base URI used for turning URIs having that prefix back into the same BNodes which were originally skolemized.
+    #   * `:rdfstar` supports RDF* where statements may be subjects or objects of other statements.
     #
     # @param  [Symbol, #to_sym] feature
     # @return [Boolean]
@@ -220,7 +221,7 @@ module RDF
     def each_triple
       if block_given?
         each_statement do |statement|
-          yield *statement.to_triple
+          yield(*statement.to_triple)
         end
       end
       enum_triple
@@ -282,7 +283,7 @@ module RDF
     def each_quad
       if block_given?
         each_statement do |statement|
-          yield *statement.to_quad
+          yield(*statement.to_quad)
         end
       end
       enum_quad

data/lib/rdf/mixin/mutable.rb

@@ -9,6 +9,7 @@ module RDF
     extend  RDF::Util::Aliasing::LateBound
     include RDF::Readable
     include RDF::Writable
+    include RDF::Util::Coercions
 
     ##
     # Returns `true` if `self` is mutable.
@@ -37,10 +38,10 @@ module RDF
     # @option options [RDF::Resource] :graph_name
     #   Set set graph name of each loaded statement
     # @return [void]
-     def load(url, graph_name: nil, **options)
+    def load(url, graph_name: nil, **options)
       raise TypeError.new("#{self} is immutable") if immutable?
 
-      Reader.open(url, {base_uri: url}.merge(options)) do |reader|
+      Reader.open(url, base_uri: url, **options) do |reader|
         if graph_name
           statements = []
           reader.each_statement do |statement|
@@ -154,20 +155,9 @@ module RDF
     def delete(*statements)
       raise TypeError.new("#{self} is immutable") if immutable?
 
-      statements.map! do |value|
-        case
-          when value.respond_to?(:each_statement)
-            delete_statements(value)
-            nil
-          when (statement = Statement.from(value)).constant?
-            statement
-          else
-            delete_statements(query(value))
-            nil
-        end
+      coerce_statements(statements, query: true, constant: true) do |value|
+        delete_statements(value)
       end
-      statements.compact!
-      delete_statements(statements) unless statements.empty?
 
       return self
     end