rdf 3.1.1 → 3.1.6

data/lib/rdf/vocabulary.rb

@@ -58,6 +58,9 @@ module RDF
   class Vocabulary
     extend ::Enumerable
 
+    autoload :Format, 'rdf/vocab/writer'
+    autoload :Writer, 'rdf/vocab/writer'
+
     class << self
       ##
       # Enumerates known RDF vocabulary classes.
@@ -67,16 +70,103 @@ module RDF
       # @return [Enumerator]
       def each(&block)
         if self.equal?(Vocabulary)
-          # This is needed since all vocabulary classes are defined using
-          # Ruby's autoloading facility, meaning that `@@subclasses` will be
-          # empty until each subclass has been touched or require'd.
-          RDF::VOCABS.each { |v| require "rdf/vocab/#{v}" unless v == :rdf }
-          @@subclasses.select(&:name).each(&block)
+          if @vocabs
+            @vocabs.select(&:name).each(&block)
+          else
+            # This is needed since all vocabulary classes are defined using
+            # Ruby's autoloading facility, meaning that `@@subclasses` will be
+            # empty until each subclass has been touched or require'd.
+            RDF::VOCABS.each { |v, p| RDF.const_get(p[:class_name].to_sym) unless v == :rdf }
+            @@subclasses.select(&:name).each(&block)
+          end
         else
           __properties__.each(&block)
         end
       end
 
+      ##
+      # A hash of all vocabularies by prefix showing relevant URI and
+      # associated vocabulary Class Name
+      #
+      # @return [Hash{Symbol => Hash{Symbol => String}}]
+      def vocab_map
+        # Create an initial duplicate of RDF::VOCABS. We want to
+        # ensure the hash itself is modifiable but the values are
+        # frozen.
+        @vocab_map ||= RDF::VOCABS.transform_values(&:freeze)
+      end
+
+      ##
+      # Return the vocabulary based on it's class_name symbol
+      #
+      # @param [Symbol] sym
+      # @return [RDF::Vocabulary]
+      def from_sym(sym)
+        RDF.const_get(sym.to_sym)
+      end
+
+      ##
+      # Register a vocabulary for internal prefix lookups. Parameters
+      # of interest include `:uri`, `:class_name`, `:source`, and `:skip`.
+      #
+      # @param prefix [Symbol] the prefix to use
+      # @param vocab  [String, Class] either the URI or the vocab class
+      # @param params [Hash{Symbol => String}] Relevant parameters
+      # @return [Hash] The parameter hash, but frozen
+      def register(prefix, vocab, **params)
+        # check the input
+        raise ArgumentError, "#{prefix} must be symbol-able" unless
+          [String, Symbol].any? { |c| prefix.is_a? c }
+
+        # note an explicit uri: param overrides
+        case vocab
+        when String then params[:uri] ||= vocab
+        when Class
+          raise ArgumentError, 'vocab must be an RDF::(Strict)Vocabulary' unless
+            vocab.ancestors.include? RDF::Vocabulary
+          params[:class] = vocab
+          params[:uri] ||= vocab.to_uri.to_s
+        end
+
+        # fill in the class name
+        params[:class_name] ||= prefix.to_s.upcase
+
+        # now freeze and assign
+        vocab_map[prefix.to_s.to_sym] = params.freeze
+      end
+
+      ##
+      # Limits iteration over vocabularies to just those selected
+      #
+      # @example limit to set of vocabularies by symbol
+      #     RDF::Vocabulary.limit_vocabs(:rdf, :rdfs
+      #     RDF::Vocabulary.find_term('http://www.w3.org/2000/01/rdf-schema#Resource').pname
+      #     # => 'rdfs:Resource'
+      #
+      # @example limit to set of vocabularies by class name
+      #     RDF::Vocabulary.limit_vocabs(RDF::RDFV, RDF::RDFS)
+      #     RDF::Vocabulary.find_term('http://www.w3.org/2000/01/rdf-schema#Resource').pname
+      #     # => 'rdfs:Resource'
+      #
+      # @param [Array<symbol, RDF::Vocabulary>] vocabs
+      #   A list of vocabularies (symbols or classes) which may
+      #   be returned by {Vocabulary.each}. Also limits
+      #   vocabularies that will be inspeced for other methods.
+      #   Set to nil, or an empty array to reset.
+      # @return [Array<RDF::Vocabulary>]
+      def limit_vocabs(*vocabs)
+        @vocabs = if Array(vocabs).empty?
+          nil
+        else
+          vocabs.map do |vocab|
+            vocab = :rdfv if vocab == :rdf
+            vocab.is_a?(Symbol) && RDF::VOCABS.key?(vocab) ?
+              RDF.const_get(RDF::VOCABS[vocab][:class_name].to_sym) :
+              vocab
+          end.compact
+        end
+      end
+
       ##
       # Is this a strict vocabulary, or a liberal vocabulary allowing arbitrary properties?
       def strict?; false; end
@@ -291,7 +381,9 @@ module RDF
         prefix, suffix = pname.to_s.split(":", 2)
         if prefix == "rdf"
           RDF[suffix]
-        elsif vocab = RDF::Vocabulary.each.detect {|v| v.__name__ && v.__prefix__ == prefix.to_sym}
+        elsif vocab_detail = RDF::Vocabulary.vocab_map[prefix.to_sym]
+          vocab = vocab_detail[:class] ||
+            RDF::Vocabulary.from_sym(vocab_detail[:class_name])
           suffix.to_s.empty? ? vocab.to_uri : vocab[suffix]
         else
           (RDF::Vocabulary.find_term(pname) rescue nil) || RDF::URI(pname, validate: true)
@@ -817,11 +909,10 @@ module RDF
       # @return [RDF::Vocabulary]
       attr_reader :vocab
 
-      #   Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF.
-      #   @return [Hash{Symbol,Resource => Term, #to_s}]
+      # Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF.
+      # @return [Hash{Symbol,Resource => Term, #to_s}]
       attr_reader :attributes
 
-
       ##
       # @overload new(uri, attributes:, **options)
       #   @param  [URI, String, #to_s]    uri
@@ -882,7 +973,10 @@ module RDF
       #
       # @return [RDF::URI]
       def dup
-        self.class.new((@value || @object).dup, attributes: attributes).extend(Term)
+        term = super.extend(Term)
+        term.instance_variable_set(:@vocab, vocab)
+        term.instance_variable_set(:@attributes, attributes)
+        term
       end
 
       ##
@@ -943,7 +1037,7 @@ module RDF
       ##
       # Values of an attributes as {RDF::Value}
       #
-      # @property [Symbol] prop
+      # @param [Symbol] prop
       # @return [RDF::Value, Array<RDF::Value>]
       def attribute_value(prop)
         values = attributes[prop]

data/lib/rdf/writer.rb

@@ -511,11 +511,12 @@ module RDF
     # @since  0.3.0
     def format_term(term, **options)
       case term
-        when String       then format_literal(RDF::Literal(term, **options), **options)
-        when RDF::List    then format_list(term, **options)
-        when RDF::Literal then format_literal(term, **options)
-        when RDF::URI     then format_uri(term, **options)
-        when RDF::Node    then format_node(term, **options)
+        when String         then format_literal(RDF::Literal(term, **options), **options)
+        when RDF::List      then format_list(term, **options)
+        when RDF::Literal   then format_literal(term, **options)
+        when RDF::URI       then format_uri(term, **options)
+        when RDF::Node      then format_node(term, **options)
+        when RDF::Statement then format_rdfstar(term, **options)
         else nil
       end
     end
@@ -562,6 +563,21 @@ module RDF
       format_term(value.subject, **options)
     end
 
+    ##
+    # Formats a referenced triple.
+    #
+    # @example
+    #     <<<s> <p> <o>>> <p> <o> .
+    #
+    # @param  [RDF::Statement] value
+    # @param  [Hash{Symbol => Object}] options = ({})
+    # @return [String]
+    # @raise  [NotImplementedError] unless implemented in subclass
+    # @abstract
+    def format_rdfstar(value, **options)
+      raise NotImplementedError.new("#{self.class}#format_statement") # override in subclasses
+    end
+
   protected
 
     ##

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.6
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-08 00:00:00.000000000 Z
+date: 2020-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: link_header
@@ -279,7 +279,7 @@ files:
 - lib/rdf/vocab/xsd.rb
 - lib/rdf/vocabulary.rb
 - lib/rdf/writer.rb
-homepage: https://ruby-rdf.github.com/
+homepage: https://github.com/ruby-rdf/rdf
 licenses:
 - Unlicense
 metadata:
@@ -303,7 +303,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.1
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: A Ruby library for working with Resource Description Framework (RDF) data.