rdf 1.99.1 → 2.0.0.beta1

data/lib/rdf/vocab/rdfs.rb

@@ -1,45 +1,50 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 # This file generated automatically using vocab-fetch from http://www.w3.org/2000/01/rdf-schema#
 require 'rdf'
 module RDF
+  # @!parse
+  #   # Vocabulary for <http://www.w3.org/2000/01/rdf-schema#>
+  #   class RDFS < RDF::StrictVocabulary
+  #   end
   class RDFS < RDF::StrictVocabulary("http://www.w3.org/2000/01/rdf-schema#")
 
     # Class definitions
     term :Class,
       comment: %(The class of classes.).freeze,
       label: "Class".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       subClassOf: "rdfs:Resource".freeze,
       type: "rdfs:Class".freeze
     term :Container,
       comment: %(The class of RDF containers.).freeze,
       label: "Container".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       subClassOf: "rdfs:Resource".freeze,
       type: "rdfs:Class".freeze
     term :ContainerMembershipProperty,
       comment: %(The class of container membership properties, rdf:_1, rdf:_2, ...,
                     all of which are sub-properties of 'member'.).freeze,
       label: "ContainerMembershipProperty".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       subClassOf: "rdf:Property".freeze,
       type: "rdfs:Class".freeze
     term :Datatype,
       comment: %(The class of RDF datatypes.).freeze,
       label: "Datatype".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       subClassOf: "rdfs:Class".freeze,
       type: "rdfs:Class".freeze
     term :Literal,
       comment: %(The class of literal values, eg. textual strings and integers.).freeze,
       label: "Literal".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       subClassOf: "rdfs:Resource".freeze,
       type: "rdfs:Class".freeze
     term :Resource,
       comment: %(The class resource, everything.).freeze,
       label: "Resource".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdfs:Class".freeze
 
     # Property definitions
@@ -48,21 +53,21 @@ module RDF
       domain: "rdfs:Resource".freeze,
       label: "comment".freeze,
       range: "rdfs:Literal".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
     property :domain,
       comment: %(A domain of the subject property.).freeze,
       domain: "rdf:Property".freeze,
       label: "domain".freeze,
       range: "rdfs:Class".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
     property :isDefinedBy,
       comment: %(The defininition of the subject resource.).freeze,
       domain: "rdfs:Resource".freeze,
       label: "isDefinedBy".freeze,
       range: "rdfs:Resource".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       subPropertyOf: "rdfs:seeAlso".freeze,
       type: "rdf:Property".freeze
     property :label,
@@ -70,49 +75,49 @@ module RDF
       domain: "rdfs:Resource".freeze,
       label: "label".freeze,
       range: "rdfs:Literal".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
     property :member,
       comment: %(A member of the subject resource.).freeze,
       domain: "rdfs:Resource".freeze,
       label: "member".freeze,
       range: "rdfs:Resource".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
     property :range,
       comment: %(A range of the subject property.).freeze,
       domain: "rdf:Property".freeze,
       label: "range".freeze,
       range: "rdfs:Class".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
     property :seeAlso,
       comment: %(Further information about the subject resource.).freeze,
       domain: "rdfs:Resource".freeze,
       label: "seeAlso".freeze,
       range: "rdfs:Resource".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
     property :subClassOf,
       comment: %(The subject is a subclass of a class.).freeze,
       domain: "rdfs:Class".freeze,
       label: "subClassOf".freeze,
       range: "rdfs:Class".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
     property :subPropertyOf,
       comment: %(The subject is a subproperty of a property.).freeze,
       domain: "rdf:Property".freeze,
       label: "subPropertyOf".freeze,
       range: "rdf:Property".freeze,
-      "rdfs:isDefinedBy" => %(rdfs:).freeze,
+      :"rdfs:isDefinedBy" => %(rdfs:).freeze,
       type: "rdf:Property".freeze
 
     # Extra definitions
     term :"",
-      "dc11:title" => %(The RDF Schema vocabulary \(RDFS\)).freeze,
+      :"dc11:title" => %(The RDF Schema vocabulary \(RDFS\)).freeze,
       label: "".freeze,
-      "rdfs:seeAlso" => %(http://www.w3.org/2000/01/rdf-schema-more).freeze,
+      :"rdfs:seeAlso" => %(http://www.w3.org/2000/01/rdf-schema-more).freeze,
       type: "owl:Ontology".freeze
   end
 end

data/lib/rdf/vocab/xsd.rb

@@ -1,7 +1,12 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 # This file generated automatically using vocab-fetch from etc/xsd.ttl
 require 'rdf'
 module RDF
+  # @!parse
+  #   # Vocabulary for <http://www.w3.org/2001/XMLSchema#>
+  #   class XSD < RDF::Vocabulary
+  #   end
   class XSD < RDF::Vocabulary("http://www.w3.org/2001/XMLSchema#")
 
     # Datatype definitions

data/lib/rdf/vocabulary.rb

@@ -201,7 +201,7 @@ module RDF
       # @return [Array<RDF::Vocabulary>]
       def imports
         @imports ||= begin
-          Array(self[""].attributes["owl:imports"]).map {|pn|find(expand_pname(pn)) rescue nil}.compact
+          Array(self[""].attributes[:"owl:imports"]).map {|pn|find(expand_pname(pn)) rescue nil}.compact
         rescue KeyError
           []
         end
@@ -217,22 +217,6 @@ module RDF
         end
       end
 
-      ##
-      # @return [String] The label for the named property
-      # @deprecated Use {RDF::Vocabulary::Term#label} instead.
-      def label_for(name)
-        warn "[DEPRECATION] `Vocabulary.label_for is deprecated. Please use Vocabulary::Term#label instead. Called from #{Gem.location_of_caller.join(':')}"
-        self[name].label || ''
-      end
-
-      ##
-      # @return [String] The comment for the named property
-      # @deprecated Use {RDF::Vocabulary::Term#comment} instead.
-      def comment_for(name)
-        warn "[DEPRECATION] `Vocabulary.comment_for is deprecated. Please use Vocabulary::Term#comment instead. Called from #{Gem.location_of_caller.join(':')}"
-        self[name].comment || ''
-      end
-
       ##
       # Returns the base URI for this vocabulary class.
       #
@@ -256,6 +240,7 @@ module RDF
         end
       end
       alias_method :to_enum, :enum_for
+
       ##
       # Enumerate each statement constructed from the defined vocabulary terms
       #
@@ -280,42 +265,52 @@ module RDF
       ##
       # Load a vocabulary, optionally from a separate location.
       #
-      # @param [URI, #to_s] uri
-      # @param [Hash{Symbol => Object}] options
-      # @option options [String] class_name
+      # @param [URI, #to_s] url
+      # @param [String] class_name
       #   The class_name associated with the vocabulary, used for creating the class name of the vocabulary. This will create a new class named with a top-level constant based on `class_name`.
-      # @option options [URI, #to_s] :location
+      # @param [URI, #to_s] location
       #   Location from which to load the vocabulary, if not from `uri`.
-      # @option options [Array<Symbol>, Hash{Symbol => Hash}] :extra
+      # @param [Array<Symbol>, Hash{Symbol => Hash}] extra
       #   Extra terms to add to the vocabulary. In the first form, it is an array of symbols, for which terms are created. In the second, it is a Hash mapping symbols to property attributes, as described in {RDF::Vocabulary.property}.
+      # @param [String] patch
+      #   A patch to run on the graph after loading. Requires the `ld-patch` gem to be available.
       # @return [RDF::Vocabulary] the loaded vocabulary
-      def load(uri, options = {})
-        source = options.fetch(:location, uri)
-        class_name = options[:class_name]
+      def load(url, class_name: nil, location: nil, extra: nil, patch: nil)
+        source = location || url
         vocab = if class_name
-          Object.const_set(class_name, Class.new(self.create(uri)))
+          Object.const_set(class_name, Class.new(self.create(url)))
         else
-          Class.new(self.create(uri))
+          Class.new(self.create(url))
         end
 
-        graph = RDF::Graph.load(source)
+        graph = RDF::Repository.load(source)
+
+        if patch
+          begin
+            require 'ld/patch'
+            operator = LD::Patch.parse(patch)
+            graph.query(operator)
+          rescue LoadError
+            raise ArgumentError, "patching vocabulary requires the ld-patch gem"
+          end
+        end
         term_defs = {}
         graph.each do |statement|
-          next unless statement.subject.uri? && statement.subject.start_with?(uri)
-          name = statement.subject.to_s[uri.to_s.length..-1] 
+          next unless statement.subject.uri? && statement.subject.start_with?(url)
+          name = statement.subject.to_s[url.to_s.length..-1] 
           term = (term_defs[name.to_sym] ||= {})
           key = case statement.predicate
-          when RDF.type                   then :type
-          when RDF::RDFS.subClassOf       then :subClassOf
-          when RDF::RDFS.subPropertyOf    then :subPropertyOf
-          when RDF::RDFS.range            then :range
-          when RDF::RDFS.domain           then :domain
-          when RDF::RDFS.comment          then :comment
-          when RDF::RDFS.label            then :label
-          when RDF::SCHEMA.inverseOf      then :inverseOf
-          when RDF::SCHEMA.domainIncludes then :domainIncludes
-          when RDF::SCHEMA.rangeIncludes  then :rangeIncludes
-          else                            statement.predicate.pname
+          when RDF.type                                     then :type
+          when RDF::RDFS.subClassOf                         then :subClassOf
+          when RDF::RDFS.subPropertyOf                      then :subPropertyOf
+          when RDF::RDFS.range                              then :range
+          when RDF::RDFS.domain                             then :domain
+          when RDF::RDFS.comment                            then :comment
+          when RDF::RDFS.label                              then :label
+          when RDF::URI("http://schema.org/inverseOf")      then :inverseOf
+          when RDF::URI("http://schema.org/domainIncludes") then :domainIncludes
+          when RDF::URI("http://schema.org/rangeIncludes")  then :rangeIncludes
+          else                                              statement.predicate.pname
           end
 
           value = if statement.object.uri?
@@ -328,11 +323,11 @@ module RDF
         end
 
         # Create extra terms
-        term_defs = case options[:extra]
+        term_defs = case extra
         when Array
-          options[:extra].inject({}) {|memo, s| memo[s.to_sym] = {label: s.to_s}; memo}.merge(term_defs)
+          extra.inject({}) {|memo, s| memo[s.to_sym] = {label: s.to_s}; memo}.merge(term_defs)
         when Hash
-          options[:extra].merge(term_defs)
+          extra.merge(term_defs)
         else
           term_defs
         end
@@ -545,8 +540,7 @@ module RDF
       #   @option options [String, #to_s] :fragment The fragment component.
       #   @option options [Hash{Symbol,Resource => Term, #to_s}] :attributes
       #     Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF
-      def initialize(*args)
-        options = args.last.is_a?(Hash) ? args.last : {}
+      def initialize(*args, **options)
         @attributes = options.fetch(:attributes)
         super
       end
@@ -612,8 +606,6 @@ module RDF
       # @yieldparam [RDF::Statement]
       def each_statement
         attributes.reject {|p| p == :vocab}.each do |prop, values|
-          prop = RDF::Vocabulary.expand_pname(prop) unless prop.is_a?(Symbol)
-          next unless prop
           Array(values).each do |value|
             begin
               case prop
@@ -633,21 +625,23 @@ module RDF
                 prop = RDFS.range
                 value = RDF::Vocabulary.expand_pname(value)
               when :inverseOf
-                prop = RDF::SCHEMA.inverseOf
+                prop = RDF::URI("http://schema.org/inverseOf")
                 value = RDF::Vocabulary.expand_pname(value)
               when :domainIncludes
-                prop = RDF::SCHEMA.domainIncludes
+                prop = RDF::URI("http://schema.org/domainIncludes")
                 value = RDF::Vocabulary.expand_pname(value)
               when :rangeIncludes
-                prop = RDF::SCHEMA.rangeIncludes
+                prop = RDF::URI("http://schema.org/rangeIncludes")
                 value = RDF::Vocabulary.expand_pname(value)
               when :label
                 prop = RDFS.label
               when :comment
                 prop = RDFS.comment
               else
-                v = RDF::Vocabulary.expand_pname(value)
-                value = v.valid? ? v : RDF::Literal(value)
+                prop = RDF::Vocabulary.expand_pname(prop.to_s)
+                next unless prop
+                v = RDF::Vocabulary.expand_pname(value.to_s)
+                value = v.valid? ? v : RDF::Literal(value.to_s)
               end
               yield RDF::Statement(self, prop, value)
             rescue KeyError
@@ -683,13 +677,13 @@ module RDF
         @attributes.has_key?(method) || super
       end
 
-      # Accessor for `domainIncludes`
+      # Accessor for `schema:domainIncludes`
       # @return [RDF::URI]
       def domain_includes
         Array(@attributes[:domainIncludes]).map  {|v| RDF::Vocabulary.expand_pname(v)}
       end
 
-      # Accessor for `rangeIncludes`
+      # Accessor for `schema:rangeIncludes`
       # @return [RDF::URI]
       def range_includes
         Array(@attributes[:rangeIncludes]).map  {|v| RDF::Vocabulary.expand_pname(v)}
@@ -735,7 +729,7 @@ module RDF
       # @raise [KeyError] if property not defined in vocabulary
       def [](name)
         props.fetch(name.to_sym)
-      rescue KeyError => e
+      rescue KeyError
         raise KeyError, "#{name} not found in vocabulary #{self.__name__}"
       end
     end

data/lib/rdf/writer.rb

@@ -33,12 +33,24 @@ module RDF
   #     end
   #   end
   #
+  # @example Detecting invalid output
+  #   logger = Logger.new([])
+  #   RDF::Writer.for(:ntriples).buffer(logger: logger) do |writer|
+  #     statement = RDF::Statement.new(
+  #       RDF::URI("http://rubygems.org/gems/rdf"),
+  #       RDF::URI("http://purl.org/dc/terms/creator"),
+  #       nil)
+  #     writer << statement
+  #   end # => RDF::WriterError
+  #   logger.empty? => false
+  #
   # @abstract
   # @see RDF::Format
   # @see RDF::Reader
   class Writer
     extend  ::Enumerable
     extend  RDF::Util::Aliasing::LateBound
+    include RDF::Util::Logger
     include RDF::Writable
 
     ##
@@ -99,6 +111,40 @@ module RDF
       end
     end
 
+    ##
+    # Options suitable for automatic Writer provisioning.
+    # @return [Array<RDF::CLI::Option>]
+    def self.options
+      [
+        RDF::CLI::Option.new(
+          symbol: :canonicalize,
+          datatype: TrueClass,
+          on: ["--canonicalize"],
+          description: "Canonicalize input/output.") {true},
+        RDF::CLI::Option.new(
+          symbol: :encoding,
+          datatype: Encoding,
+          on: ["--encoding ENCODING"],
+          description: "The encoding of the input stream.") {|arg| Encoding.find arg},
+        RDF::CLI::Option.new(
+          symbol: :prefixes,
+          datatype: Hash,
+          multiple: true,
+          on: ["--prefixes PREFIX,PREFIX"],
+          description: "A comma-separated list of prefix:uri pairs.") do |arg|
+            arg.split(',').inject({}) do |memo, pfxuri|
+              pfx,uri = pfxuri.split(':', 2)
+              memo.merge(pfx.to_sym => RDF::URI(uri))
+            end
+        end,
+        RDF::CLI::Option.new(
+          symbol: :unique_bnodes,
+          datatype: TrueClass,
+          on: ["--unique-bnodes"],
+          description: "Use unique Node identifiers.") {true},
+      ]
+    end
+
     class << self
       alias_method :format_class, :format
     end
@@ -212,7 +258,7 @@ module RDF
     # @yieldreturn [void]
     def initialize(output = $stdout, options = {}, &block)
       @output, @options = output, options.dup
-      @nodes, @node_id  = {}, 0
+      @nodes, @node_id, @node_id_map  = {}, 0, {}
 
       if block_given?
         write_prologue
@@ -329,7 +375,7 @@ module RDF
     ##
     # Flushes the underlying output buffer.
     #
-    # @return [void] `self`
+    # @return [self]
     def flush
       @output.flush if @output.respond_to?(:flush)
       self
@@ -337,66 +383,82 @@ module RDF
     alias_method :flush!, :flush
 
     ##
-    # @return [void] `self`
+    # @return [self]
     # @abstract
     def write_prologue
       self
     end
 
     ##
-    # @return [void] `self`
+    # @return [self]
+    # @raise [RDF::WriterError] if errors logged during processing.
     # @abstract
     def write_epilogue
+      if log_statistics[:error]
+        raise RDF::WriterError, "Errors found during processing"
+      end
       self
     end
 
     ##
     # @param  [String] text
-    # @return [void] `self`
+    # @return [self]
     # @abstract
     def write_comment(text)
       self
     end
 
     ##
-    # @param  [RDF::Graph] graph
-    # @return [void] `self`
-    # @deprecated Use {RDF::Writable#insert_graph} instead .
-    def write_graph(graph)
-      warn "[DEPRECATION] `Writer#graph_write is deprecated. Please use RDF::Writable#insert instead. Called from #{Gem.location_of_caller.join(':')}"
-      graph.each_triple { |*triple| write_triple(*triple) }
-      self
-    end
-
-    ##
-    # @param  [Array<RDF::Statement>] statements
-    # @return [void] `self`
-    # @deprecated Use {RDF::Writable#insert} instead.
-    def write_statements(*statements)
-      warn "[DEPRECATION] `Writer#write_statements is deprecated. Please use RDF::Writable#insert instead. Called from #{Gem.location_of_caller.join(':')}"
-      statements.each { |statement| write_statement(statement) }
-      self
-    end
-
-    ##
+    # Add a statement to the writer. This will check to ensure that the statement is complete (no nil terms) and is valid, if the `:validation` option is set.
+    #
+    # Additionally, it will de-duplicate BNode terms sharing a common identifier.
+    #
     # @param  [RDF::Statement] statement
-    # @return [void] `self`
-    # @raise [RDF::WriterError] if validating and attempting to write an invalid {RDF::Statement} or if canonicalizing a statement which cannot be canonicalized.
+    # @return [self]
+    # @note logs error if attempting to write an invalid {RDF::Statement} or if canonicalizing a statement which cannot be canonicalized.
     def write_statement(statement)
       statement = statement.canonicalize! if canonicalize?
-      raise RDF::WriterError, "Statement #{statement.inspect} is incomplete" if statement.incomplete?
-      raise RDF::WriterError, "Statement #{statement.inspect} is invalid" if validate? && statement.invalid?
-      write_triple(*statement.to_triple)
+
+      # Make sure BNodes in statement use unique identifiers
+      if statement.node?
+        terms = statement.to_quad.map do |term|
+          if term.is_a?(RDF::Node)
+            term = term.original while term.original
+            @nodes[term] ||= begin
+              # Account for duplicated nodes
+              @node_id_map[term.to_s] ||= term
+              if !@node_id_map[term.to_s].equal?(term)
+                # Rename node
+                term.make_unique!
+                @node_id_map[term.to_s] = term
+              end
+            end
+          else
+            term
+          end
+        end
+        statement = RDF::Statement.from(statement.to_quad)
+      end
+
+      if statement.incomplete?
+        log_error "Statement #{statement.inspect} is incomplete"
+      elsif validate? && statement.invalid?
+        log_error "Statement #{statement.inspect} is invalid"
+      elsif respond_to?(:write_quad)
+        write_quad(*statement.to_quad)
+      else
+        write_triple(*statement.to_triple)
+      end
       self
     rescue ArgumentError => e
-      raise WriterError, e.message
+      log_error e.message
     end
     alias_method :insert_statement, :write_statement # support the RDF::Writable interface
 
     ##
     # @param  [Array<Array(RDF::Resource, RDF::URI, RDF::Term)>] triples
-    # @return [void] `self`
-    # @raise [RDF::WriterError] if validating and attempting to write an invalid {RDF::Term}.
+    # @return [self]
+    # @note logs error if attempting to write an invalid {RDF::Statement} or if canonicalizing a statement which cannot be canonicalized.
     def write_triples(*triples)
       triples.each { |triple| write_triple(*triple) }
       self
@@ -406,9 +468,9 @@ module RDF
     # @param  [RDF::Resource] subject
     # @param  [RDF::URI]      predicate
     # @param  [RDF::Term]     object
-    # @return [void] `self`
+    # @return [self]
     # @raise  [NotImplementedError] unless implemented in subclass
-    # @raise [RDF::WriterError] if validating and attempting to write an invalid {RDF::Term}.
+    # @note logs error if attempting to write an invalid {RDF::Statement} or if canonicalizing a statement which cannot be canonicalized.
     # @abstract
     def write_triple(subject, predicate, object)
       raise NotImplementedError.new("#{self.class}#write_triple") # override in subclasses
@@ -429,16 +491,6 @@ module RDF
       end
     end
 
-    ##
-    # @param  [RDF::Term] term
-    # @return [String]
-    # @since  0.3.0
-    # @deprecated Use {#format_term} instead
-    def format_value(term, options = {})
-      warn "[DEPRECATION] Writer#format_value is being replaced with Writer#format_term in RDF.rb 2.0. Called from #{Gem.location_of_caller.join(':')}"
-      format_term(term, options)
-    end
-
     ##
     # @param  [RDF::Node] value
     # @param  [Hash{Symbol => Object}] options = ({})
@@ -490,16 +542,16 @@ module RDF
     end
 
     ##
-    # @param  [RDF::Resource] uriref
+    # @param  [RDF::Resource] term
     # @return [String]
-    def uri_for(uriref)
+    def uri_for(term)
       case
-        when uriref.is_a?(RDF::Node)
-          @nodes[uriref]
-        when uriref.respond_to?(:to_uri)
-          uriref.to_uri.to_s
+        when term.is_a?(RDF::Node)
+          @nodes[term] ||= term.to_base
+        when term.respond_to?(:to_uri)
+          term.to_uri.to_s
         else
-          uriref.to_s
+          term.to_s
       end
     end