rdf 3.0.12 → 3.1.3

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

@@ -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

data/lib/rdf/mixin/queryable.rb

@@ -19,7 +19,7 @@ module RDF
     #
     # @example Querying for statements having a given predicate
     #     queryable.query([nil, RDF::Vocab::DOAP.developer, nil])
-    #     queryable.query(predicate: RDF::Vocab::DOAP.developer) do |statement|
+    #     queryable.query({predicate: RDF::Vocab::DOAP.developer}) do |statement|
     #       puts statement.inspect
     #     end
     #
@@ -50,7 +50,7 @@ module RDF
           solutions = RDF::Query::Solutions.new
           block = lambda {|solution| solutions << solution} unless block_given?
           before_query(pattern) if respond_to?(:before_query)
-          query_execute(pattern, options, &block)
+          query_execute(pattern, **options, &block)
           after_query(pattern) if respond_to?(:after_query)
           # Returns the solutions, not an enumerator
           solutions
@@ -85,7 +85,7 @@ module RDF
 
             # Otherwise, we delegate to `#query_pattern`:
             else # pattern.variable?
-              query_pattern(pattern, options, &block)
+              query_pattern(pattern, **options, &block)
           end
           after_query(pattern) if respond_to?(:after_query)
           enum
@@ -116,7 +116,7 @@ module RDF
       # query execution by breaking down the query into its constituent
       # triple patterns and invoking `RDF::Query::Pattern#execute` on each
       # pattern.
-      query.execute(self, options, &block)
+      query.execute(self, **options, &block)
     end
     protected :query_execute
 
@@ -128,6 +128,14 @@ module RDF
     # method in order to provide for storage-specific optimized triple
     # pattern matching.
     #
+    # ## RDFStar (RDF*)
+    #
+    # Statements may have embedded statements as either a subject or object, recursively.
+    #
+    # Patterns may also have embedded patterns as either a subject or object, recursively.
+    #
+    # When matching, match an embedded pattern against embedded statements, recursively. (see {RDF::Query::Pattern#eql?})
+    #
     # @param  [RDF::Query::Pattern] pattern
     #   the query pattern to match
     # @param  [Hash{Symbol => Object}] options ({})

data/lib/rdf/mixin/writable.rb

@@ -7,6 +7,7 @@ module RDF
   # @see RDF::Repository
   module Writable
     extend RDF::Util::Aliasing::LateBound
+    include RDF::Util::Coercions
 
     ##
     # Returns `true` if `self` is writable.
@@ -53,31 +54,20 @@ module RDF
     # @overload insert(*statements)
     #   @param  [Array<RDF::Statement>] statements
     #   @return [self]
+    #   @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     #
     # @overload insert(statements)
     #   @param  [Enumerable<RDF::Statement>] statements
     #   @return [self]
+    #   @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     def insert(*statements)
-      statements.map! do |value|
-        case
-          when value.respond_to?(:each_statement)
-            insert_statements(value)
-            nil
-          when (statement = Statement.from(value))
-            statement
-          else
-            raise ArgumentError.new("not a valid statement: #{value.inspect}")
-        end
-      end
-      statements.compact!
-      insert_statements(statements) unless statements.empty?
+      coerce_statements(statements) { |value| insert_statements value }
 
       return self
     end
     alias_method :insert!, :insert
 
   protected
-
     ##
     # Inserts statements from the given RDF reader into the underlying
     # storage or output stream.
@@ -132,10 +122,14 @@ module RDF
     #
     # @param  [RDF::Enumerable] statements
     # @return [void]
+    # @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     # @since  0.1.6
     def insert_statements(statements)
       each = statements.respond_to?(:each_statement) ? :each_statement : :each
       statements.__send__(each) do |statement|
+        if statement.embedded? && respond_to?(:supports?) && !supports?(:rdfstar)
+          raise ArgumentError, "Wriable does not support embedded statements"
+        end
         insert_statement(statement)
       end
     end
@@ -150,6 +144,7 @@ module RDF
     #
     # @param  [RDF::Statement] statement
     # @return [void]
+    # @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     # @abstract
     def insert_statement(statement)
       raise NotImplementedError.new("#{self.class}#insert_statement")

data/lib/rdf/model/dataset.rb

@@ -104,7 +104,7 @@ module RDF
     # @private
     # @see RDF::Enumerable#supports?
     def supports?(feature)
-      return true if feature == :graph_name
+      return true if [:graph_name, :rdfstar].include?(feature)
       super
     end
 

data/lib/rdf/model/graph.rb

@@ -211,7 +211,7 @@ module RDF
     # @return [Integer]
     # @see    RDF::Enumerable#count
     def count
-      @data.query(graph_name: graph_name || false).count
+      @data.query({graph_name: graph_name || false}).count
     end
 
     ##
@@ -237,7 +237,7 @@ module RDF
     # @see    RDF::Enumerable#each_statement
     def each(&block)
       if @data.respond_to?(:query)
-        @data.query(graph_name: graph_name || false, &block)
+        @data.query({graph_name: graph_name || false}, &block)
       elsif @data.respond_to?(:each)
         @data.each(&block)
       else
@@ -283,6 +283,9 @@ module RDF
     # @private
     # @see RDF::Mutable#insert
     def insert_statement(statement)
+      if statement.embedded? && !@data.supports?(:rdfstar)
+        raise ArgumentError, "Graph does not support embedded statements"
+      end
       statement = statement.dup
       statement.graph_name = graph_name
       @data.insert(statement)

data/lib/rdf/model/list.rb

@@ -59,7 +59,7 @@ module RDF
     def initialize(subject: nil, graph: nil, values: nil, &block)
       @subject = subject || RDF.nil
       @graph   = graph   || RDF::Graph.new
-      is_empty = @graph.query(subject: subject, predicate: RDF.first).empty?
+      is_empty = @graph.query({subject: subject, predicate: RDF.first}).empty?
 
       if subject && is_empty
         # An empty list with explicit subject and value initializers
@@ -115,7 +115,7 @@ module RDF
         list_nodes << li
         rest = nil
         firsts = rests = 0
-        @graph.query(subject: li) do |st|
+        @graph.query({subject: li}) do |st|
           return false unless st.subject.node?
           case st.predicate
           when RDF.first
@@ -136,7 +136,7 @@ module RDF
 
       # All elements other than the head must be referenced exactly once
       return list_nodes.all? do |li|
-        refs = @graph.query(object: li).count
+        refs = @graph.query({object: li}).count
         case refs
         when 0 then li == subject
         when 1 then true
@@ -479,7 +479,7 @@ module RDF
     # @return [Boolean]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-empty-3F
     def empty?
-      graph.query(subject: subject, predicate: RDF.first).empty?
+      graph.query({subject: subject, predicate: RDF.first}).empty?
     end
 
     ##
@@ -822,7 +822,7 @@ module RDF
       return enum_statement unless block_given?
 
       each_subject do |subject|
-        graph.query(subject: subject, &block)
+        graph.query({subject: subject}, &block)
       end
     end
     alias_method :to_rdf, :each_statement

data/lib/rdf/model/literal.rb

@@ -49,7 +49,7 @@ module RDF
   #   RDF::Literal.new(123).datatype                 #=> XSD.integer
   #   RDF::Literal.new(9223372036854775807).datatype #=> XSD.integer
   #   RDF::Literal.new(3.1415).datatype              #=> XSD.double
-  #   RDF::Literal.new(Time.now).datatype            #=> XSD.time
+  #   RDF::Literal.new(Time.now).datatype            #=> XSD.dateTime
   #   RDF::Literal.new(Date.new(2010)).datatype      #=> XSD.date
   #   RDF::Literal.new(DateTime.new(2010)).datatype  #=> XSD.dateTime
   #
@@ -119,8 +119,8 @@ module RDF
           when ::Float      then RDF::Literal::Double
           when ::BigDecimal then RDF::Literal::Decimal
           when ::DateTime   then RDF::Literal::DateTime
+          when ::Time       then RDF::Literal::DateTime
           when ::Date       then RDF::Literal::Date
-          when ::Time       then RDF::Literal::Time # FIXME: Ruby's Time class can represent datetimes as well
           when ::Symbol     then RDF::Literal::Token
           else self
         end
@@ -360,7 +360,7 @@ module RDF
     # @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 language? && language.to_s !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
       return false if datatype? && datatype.invalid?
       grammar = self.class.const_get(:GRAMMAR) rescue nil
       grammar.nil? || value.match?(grammar)

data/lib/rdf/model/statement.rb

@@ -26,7 +26,7 @@ module RDF
   #   RDF::Statement(s, p, "o")
   #
   class Statement
-    include RDF::Value
+    include RDF::Resource
 
     ##
     # @private
@@ -112,7 +112,7 @@ module RDF
       elsif @subject.nil?
         nil
       else
-        raise ArgumentError, "expected subject to be nil or a term, was #{@subject.inspect}"
+        raise ArgumentError, "expected subject to be nil or a resource, was #{@subject.inspect}"
       end
       @predicate = Node.intern(@predicate) if @predicate.is_a?(Symbol)
       @object    = if @object.is_a?(Value)
@@ -124,6 +124,15 @@ module RDF
       else
         Literal.new(@object)
       end
+      @graph_name = if @graph_name.is_a?(Value)
+        @graph_name.to_term
+      elsif @graph_name.is_a?(Symbol)
+        Node.intern(@graph_name)
+      elsif !@graph_name
+        @graph_name
+      else
+        raise ArgumentError, "expected graph_name to be nil or a resource, was #{@graph_name.inspect}"
+      end
     end
 
     ##
@@ -140,10 +149,18 @@ module RDF
     #
     # @return [Boolean]
     def variable?
-      !(has_subject?    && subject.resource? &&
-        has_predicate?  && predicate.resource? &&
-        has_object?     && (object.resource? || object.literal?) &&
-        (has_graph?     ? graph_name.resource? : true))
+      !(has_subject?    && subject.constant? &&
+        has_predicate?  && predicate.constant? &&
+        has_object?     && object.constant? &&
+        (has_graph?     ? graph_name.constant? : true))
+    end
+
+    ##
+    # Returns `true` if any element of the statement is, itself, a statement.
+    #
+    # @return [Boolean]
+    def embedded?
+      subject && subject.statement? || object && object.statement?
     end
 
     ##
@@ -386,7 +403,13 @@ module RDF
     # @return [String]
     def to_s
       (graph_name ? to_quad : to_triple).map do |term|
-        term.respond_to?(:to_base) ? term.to_base : term.inspect
+        if term.is_a?(Statement)
+          "<<#{term.to_s[0..-3]}>>"
+        elsif term.respond_to?(:to_base)
+          term.to_base
+        else
+          term.inspect
+        end
       end.join(" ") + " ."
     end