rdf 3.0.13 → 3.1.4

data/lib/rdf/vocab/xsd.rb

@@ -5,9 +5,210 @@ require 'rdf'
 module RDF
   # @!parse
   #   # Vocabulary for <http://www.w3.org/2001/XMLSchema#>
+  #   #
   #   class XSD < RDF::Vocabulary
+  #     #      `ENTITIES` represents the `ENTITIES` attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value     space· of `ENTITIES` is the set of finite, non-zero-length sequences of     ·{ENTITY}· values that have been declared as unparsed entities in a document     type definition. The ·lexical space· of `ENTITIES` is the set of     space-separated lists of tokens, of which each token is in the ·lexical     space· of {ENTITY}. The ·item type· of `ENTITIES` is {ENTITY}. `ENTITIES` is     derived from ·{anySimpleType}· in two steps: an anonymous list type is     defined, whose ·item type· is {ENTITY}; this is the ·base type· of `ENTITIES`,     which restricts its value space to lists with at least one item.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :ENTITIES
+  #
+  #     #       `ENTITY` represents the `ENTITY` attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value space·      of `ENTITY` is the set of all strings that ·match· the `NCName` production in      [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/) and have been declared as an unparsed entity in a      document type definition. The ·lexical space· of `ENTITY` is the set of all      strings that ·match· the `NCName` production in [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/). The      ·base type· of `ENTITY` is {NCName}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :ENTITY
+  #
+  #     #       `ID` represents the ID attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value space· of `ID` is      the set of all strings that ·match· the `NCName` production in [Namespaces      in XML]. The ·lexical space· of `ID` is the set of all strings that ·match·      the `NCName` production in [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/). The ·base type· of `ID` is      {NCName}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :ID
+  #
+  #     #      `IDREF` represents the `IDRE`F attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value space· of     `IDREF` is the set of all strings that ·match· the `NCName` production in     [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/). The ·lexical space· of `IDREF` is the set of strings     that ·match· the `NCName` production in [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/). The ·base type·     of `IDREF` is {NCName}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :IDREF
+  #
+  #     #      `IDREFS` represents the `IDREFS` attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value space·     of `IDREFS` is the set of finite, non-zero-length sequences of `IDREFs`. The     ·lexical space· of `IDREFS` is the set of space-separated lists of tokens, of     which each token is in the ·lexical space· of `IDREF.` The ·item type· of     `IDREFS` is {IDREF}. `IDREFS` is derived from ·{anySimpleType}· in two steps: an     anonymous list type is defined, whose ·item type· is {IDREF}; this is the     ·base type· of `IDREFS`, which restricts its value space to lists with at     least one item.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :IDREFS
+  #
+  #     #       `NCName` represents XML "non-colonized" `Names`. The ·value space· of `NCName`      is the set of all strings which ·match· the `NCName` production of      [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/). The ·lexical space· of `NCName` is the set of all      strings which ·match· the `NCName` production of [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/). The      ·base type· of `NCName` is {Name}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :NCName
+  #
+  #     #       `NMTOKEN` represents the `NMTOKEN` attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value      space· of `NMTOKEN` is the set of tokens that ·match· the `Nmtoken` production      in [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·lexical space· of `NMTOKEN` is the set of strings that      ·match· the `Nmtoken` production in [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·base type· of `NMTOKEN` is      {token}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :NMTOKEN
+  #
+  #     #      `NMTOKENS` represents the `NMTOKENS` attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value     space· of `NMTOKENS` is the set of finite, non-zero-length sequences of     ·`NMTOKEN`·s. The ·lexical space· of `NMTOKENS` is the set of space-separated     lists of tokens, of which each token is in the ·lexical space· of `NMTOKEN`.     The ·item type· of `NMTOKENS` is `NMTOKEN`. `NMTOKEN`S is derived from     ·{anySimpleType}· in two steps: an anonymous list type is defined, whose     ·item type· is `NMTOKEN`; this is the ·base type· of `NMTOKENS`, which     restricts its value space to lists with at least one item.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :NMTOKENS
+  #
+  #     #      `NOTATION` represents the `NOTATION` attribute type from [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·value     space· of `NOTATION` is the set of `QName`s of notations declared in the     current schema. The ·lexical space· of `NOTATION` is the set of all names of     notations declared in the current schema (in the form of `QNames`).   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :NOTATION
+  #
+  #     #      `Name` represents XML Names. The ·value space· of `Name` is the set of all     strings which ·match· the `Name` production of [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814)(http://www.w3.org/TR/2000/WD-xml-2e-20000814). The ·lexical space· of     `Name` is the set of all strings which ·match· the `Name` production of [XML](http://www.w3.org/TR/2000/WD-xml-2e-20000814).     The ·base type· of `Name` is {token}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :Name
+  #
+  #     #      `QName` represents XML qualified names. The ·value space· of `QName` is the set     of tuples `{namespace name, local part}`, where namespace name is an anyURI     and local part is an NCName. The ·lexical space· of `QName` is the set of     strings that ·match· the `QName` production of [Namespaces in XML](http://www.w3.org/TR/1999/REC-xml-names-19990114/).   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :QName
+  #
+  #     #      `anyAtomicType` is a special ·restriction· of {anySimpleType}. The ·value· and     ·lexical spaces· of `anyAtomicType` are the unions of the ·value· and     ·lexical spaces· of all the ·primitive· datatypes, and `anyAtomicType` is     their ·base type·.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :anyAtomicType
+  #
+  #     #      The definition of `anySimpleType` is a special ·restriction· of {anyType}. The     ·lexical space· of `anySimpleType` is the set of all sequences of Unicode     characters, and its ·value space· includes all ·atomic values· and all     finite-length lists of zero or more ·atomic values·.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :anySimpleType
+  #
+  #     #      The root of the [XML Schema 1.1] datatype heirarchy.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :anyType
+  #
+  #     #      `anyURI` represents an Internationalized Resource Identifier Reference     (`IRI`). An `anyURI` value can be absolute or relative, and may have an     optional fragment identifier (i.e., it may be an `IRI Reference`). This     type should be used when the value fulfills the role of an `IRI`, as     defined in [RFC 2045](https://www.ietf.org/rfc/rfc3987.txt) or its successor(s) in the IETF Standards Track.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :anyURI
+  #
+  #     #      `base64Binary` represents arbitrary `Base64`-encoded binary data. For     `base64Binary` data the entire binary stream is encoded using the `Base64`     Encoding defined in [RFC 3548](https://www.ietf.org/rfc/rfc3548.txt), which is derived from the encoding     described in [RFC 2045](https://www.ietf.org/rfc/rfc2045.txt).   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :base64Binary
+  #
+  #     #      `boolean` represents the values of two-valued logic.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :boolean
+  #
+  #     #     ` byte` is ·derived· from short by setting the value of ·`maxInclusive`· to be     `127` and ·`minInclusive`· to be `-128`. The ·base type· of `byte` is {short}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :byte
+  #
+  #     #      `date` represents top-open intervals of exactly one day in length on the     timelines of {dateTime}, beginning on the beginning moment of each day, up to     but not including the beginning moment of the next day). For non-timezoned     values, the top-open intervals disjointly cover the non-timezoned timeline,     one per day. For timezoned values, the intervals begin at every minute and     therefore overlap.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :date
+  #
+  #     #      `dateTime` represents instants of time, optionally marked with a particular     time zone offset. Values representing the same instant but having different     time zone offsets are equal but not identical.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :dateTime
+  #
+  #     #      The `dateTimeStamp` datatype is ·derived· from {dateTime} by giving the value     required to its explicitTimezone facet. The result is that all values of     `dateTimeStamp` are required to have explicit time zone offsets and the     datatype is totally ordered.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :dateTimeStamp
+  #
+  #     #       `dayTimeDuration` is a datatype ·derived· from {duration} by restricting its      ·lexical representations· to instances of `dayTimeDurationLexicalRep`. The      ·value space· of `dayTimeDuration` is therefore that of {duration} restricted      to those whose ·months· property is 0. This results in a {duration} datatype      which is totally ordered.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :dayTimeDuration
+  #
+  #     #      `decimal` represents a subset of the real numbers, which can be represented     by decimal numerals. The ·value space· of `decimal` is the set of numbers     that can be obtained by dividing an integer by a non-negative power of ten,     i.e., expressible as `i / 10n` where `i` and `n` are integers and `n ≥ 0`.     Precision is not reflected in this value space; the number `2.0` is not     distinct from the number `2.00`. The order relation on `decimal` is the order     relation on real numbers, restricted to this subset.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :decimal
+  #
+  #     #      The `double` datatype is patterned after the IEEE double-precision 64-bit     floating point datatype [IEEE 754-2008](https://ieeexplore.ieee.org/document/4610935). Each floating point datatype has a     value space that is a subset of the rational numbers. Floating point     numbers are often used to approximate arbitrary real numbers.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :double
+  #
+  #     #      `duration` is a datatype that represents durations of time. The concept of     duration being captured is drawn from those of [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html), specifically     durations without fixed endpoints. For example, "15 days" (whose most     common lexical representation in duration is "'P15D'") is a `duration` value;     "15 days beginning 12 July 1995" and "15 days ending 12 July 1995" are not     `duration` values. `duration` can provide addition and subtraction operations     between duration values and between `duration`/{dateTime} value pairs, and can     be the result of subtracting dateTime values. However, only addition to     {dateTime} is required for XML Schema processing and is defined in the     function ·`dateTimePlusDuration`·.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :duration
+  #
+  #     #      The `float` datatype is patterned after the IEEE single-precision 32-bit     floating point datatype [IEEE 754-2008](https://ieeexplore.ieee.org/document/4610935). Its value space is a subset of the     rational numbers. Floating point numbers are often used to approximate     arbitrary real numbers.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :float
+  #
+  #     #      `gDay` represents whole days within an arbitrary month—days that recur at the     same point in each (Gregorian) month. This datatype is used to represent a     specific day of the month. To indicate, for example, that an employee gets     a paycheck on the 15th of each month. (Obviously, days beyond 28 cannot     occur in all months; they are nonetheless permitted, up to 31.)   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :gDay
+  #
+  #     #      `gMonth` represents whole (Gregorian) months within an arbitrary year—months     that recur at the same point in each year. It might be used, for example,     to say what month annual Thanksgiving celebrations fall in different     countries (--11 in the United States, --10 in Canada, and possibly other     months in other countries).   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :gMonth
+  #
+  #     #      `gMonthDay` represents whole calendar days that recur at the same point in     each calendar year, or that occur in some arbitrary calendar year.     (Obviously, days beyond 28 cannot occur in all Februaries; 29 is     nonetheless permitted.)   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :gMonthDay
+  #
+  #     #      `gYear` represents Gregorian calendar years.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :gYear
+  #
+  #     #      `gYearMonth` represents specific whole Gregorian months in specific Gregorian years.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :gYearMonth
+  #
+  #     #      `hexBinary` represents arbitrary hex-encoded binary data.    
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :hexBinary
+  #
+  #     #        `int` is ·derived· from long by setting the value of ·`maxInclusive`· to be       ``2147483647`` and ·`minInclusive`· to be ``-2147483648``. The ·base type· of `int`       is {long}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :int
+  #
+  #     #       `integer` is ·derived· from {decimal} by fixing the value of ·`fractionDigits`·      to be `0` and disallowing the trailing decimal point. This results in the      standard mathematical concept of the integer numbers. The ·value space· of      `integer` is the infinite set `{...,-2,-1,0,1,2,...}`. The ·base type· of      `integer` is {decimal}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :integer
+  #
+  #     #      `language` represents formal natural language identifiers, as defined by [BCP 47](https://tools.ietf.org/html/bcp47) (currently represented by [RFC 2045](https://www.ietf.org/rfc/rfc4646.txt) and [RFC 2045](https://www.ietf.org/rfc/rfc4647.txt)) or its     successor(s). The ·value space· and ·lexical space· of `language` are the set     of all strings that conform to the pattern `[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*`   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :language
+  #
+  #     #       `long` is ·derived· from {integer} by setting the value of ·`maxInclusive`· to      be `9223372036854775807` and ·`minInclusive`· to be `-9223372036854775808`. The      ·base type· of `long` is {integer}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :long
+  #
+  #     #       `negativeInteger` is ·derived· from {nonPositiveInteger} by setting the value      of ·`maxInclusive`· to be `-1`. This results in the standard mathematical      concept of the negative integers. The ·value space· of `negativeInteger` is      the infinite set `{...,-2,-1}`. The ·base type· of `negativeInteger` is      {nonPositiveInteger}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :negativeInteger
+  #
+  #     #       `nonNegativeInteger` is ·derived· from {integer} by setting the value of      ·`minInclusive`· to be `0`. This results in the standard mathematical concept      of the non-negative integers. The ·value space· of `nonNegativeInteger` is      the infinite set `{0,1,2,...}`. The ·base type· of `nonNegativeInteger` is      {integer}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :nonNegativeInteger
+  #
+  #     #      `nonPositiveInteger` is ·derived· from {integer} by setting the value of     ·`maxInclusive`· to be `0`. This results in the standard mathematical concept     of the non-positive integers. The ·value space· of `nonPositiveInteger` is     the infinite set `{...,-2,-1,0}`. The ·base type· of `nonPositiveInteger` is     {integer}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :nonPositiveInteger
+  #
+  #     #      `normalizedString` represents white space normalized strings. The ·value     space· of `normalizedString` is the set of strings that do not contain the     carriage return `(#xD)`, line feed `(#xA) no`r tab `(#x9)` characters. The     ·lexical space· of `normalizedString` is the set of strings that do not     contain the carriage return `(#xD)`, line feed `(#xA)` nor tab `(#x9)`     characters. The ·base type· of `normalizedString` is {string}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :normalizedString
+  #
+  #     #       `positiveInteger` is ·derived· from `nonNegativeInteger` by setting the value      of ·`minInclusive`· to be `1`. This results in the standard mathematical      concept of the positive integer numbers. The ·value space· of      `positiveInteger` is the infinite set `{1,2,...}`. The ·base type· of      `positiveInteger` is {nonNegativeInteger}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :positiveInteger
+  #
+  #     #      `short` is ·derived· from `int` by setting the value of ·`maxInclusive`· to be     `32767` and ·minInclusive· to be `-32768`. The ·base type· of `short` is {int}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :short
+  #
+  #     #      The `string` datatype represents character strings in XML.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :string
+  #
+  #     #      `time` represents instants of time that recur at the same point in each     calendar day, or that occur in some arbitrary calendar day.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :time
+  #
+  #     #       `token` represents tokenized strings. The ·value space· of `token` is the set      of strings that do not contain the carriage return `(#xD)`, line feed `(#xA)`      nor tab `(#x9)` characters, that have no leading or trailing spaces `(#x20)`      and that have no internal sequences of two or more spaces. The ·lexical      space· of `token` is the set of strings that do not contain the carriage      return `(#xD)`, line feed `(#xA)` nor tab `(#x9)` characters, that have no      leading or trailing spaces `(#x20)` and that have no internal sequences of      two or more spaces. The ·base type· of `token` is {normalizedString}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :token
+  #
+  #     #        `unsignedByte` is ·derived· from {unsignedShort} by setting the value of       ·`maxInclusive`· to be `255`. The ·base type· of `unsignedByte` is       {unsignedShort}.     
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :unsignedByte
+  #
+  #     #      `unsignedInt` is ·derived· from {unsignedLong} by setting the value of     ·`maxInclusive`· to be `4294967295`. The ·base type· of `unsignedInt` is     {unsignedLong}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :unsignedInt
+  #
+  #     #       `unsignedLong` is ·derived· from {nonNegativeInteger} by setting the value of      ·`maxInclusive`· to be `18446744073709551615`. The ·base type· of `unsignedLong`      is {nonNegativeInteger}.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :unsignedLong
+  #
+  #     #         `unsignedShort` is ·derived· from {unsignedInt} by setting the value of        ·`maxInclusive`· to be `65535`. The ·base type· of `unsignedShort` is        {unsignedInt}.     
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :unsignedShort
+  #
+  #     #       `yearMonthDuration` is a datatype ·derived· from {duration} by restricting its      ·lexical representations· to instances of `yearMonthDurationLexicalRep`. The      ·value space· of `yearMonthDuration` is therefore that of {duration}      restricted to those whose ·seconds· property is 0. This results in a      duration datatype which is totally ordered.   
+  #     # @return [RDF::Vocabulary::Term]
+  #     attr_reader :yearMonthDuration
+  #
   #   end
-  class XSD < RDF::Vocabulary("http://www.w3.org/2001/XMLSchema#")
+  XSD = Class.new(RDF::Vocabulary("http://www.w3.org/2001/XMLSchema#")) do
 
     # Datatype definitions
     term :ENTITIES,
@@ -190,7 +391,7 @@ module RDF
       comment: %(
     boolean represents the values of two-valued logic.
   ).freeze,
-      label: "base64Binary".freeze,
+      label: "boolean".freeze,
       subClassOf: "xsd:anyAtomicType".freeze,
       type: "rdfs:Datatype".freeze
     term :byte,

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
@@ -873,8 +964,8 @@ module RDF
       #
       # @param (see #initialize)
       # @return [RDF::URI] an immutable, frozen URI object
-      def self.intern(str, *args)
-        (URI.cache[(str = str.to_s).to_sym] ||= self.new(str, *args)).freeze
+      def self.intern(str, *args, **options)
+        (URI.cache[(str = str.to_s).to_sym] ||= self.new(str, *args, **options)).freeze
       end
 
       ##
@@ -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]
@@ -1001,7 +1095,7 @@ module RDF
               when :domainIncludes, :rangeIncludes
                 RDF::Vocabulary.find_term("http://schema.org/#{p}")
               when :broader, :definition, :exactMatch, :hasTopConcept, :inScheme,
-                   :member, :narrower, :related, :altLabel, :definition, :editorialNote,
+                   :member, :narrower, :related, :altLabel, :editorialNote,
                    :notation, :note, :prefLabel
                 RDF::Vocabulary.find_term("http://www.w3.org/2004/02/skos/core##{p}")
               else

data/lib/rdf/writer.rb

@@ -79,7 +79,7 @@ module RDF
     #   @param  [String] filename
     #   @return [Class]
     #
-    # @overload for(**options)
+    # @overload for(options = {})
     #   Finds an RDF writer class based on various options.
     #
     #   @param  [Hash{Symbol => Object}] options
@@ -89,9 +89,15 @@ module RDF
     #   @return [Class]
     #
     # @return [Class]
-    def self.for(options = {})
-      options = options.merge(has_writer: true) if options.is_a?(Hash)
-      if format = self.format || Format.for(options)
+    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
+      arg = arg.merge(has_writer: true) if arg.is_a?(Hash)
+      if format = self.format || Format.for(arg)
         format.writer
       end
     end
@@ -505,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
@@ -553,7 +560,22 @@ module RDF
     # @abstract
     # @since  0.2.3
     def format_list(value, **options)
-      format_term(value.subject, options)
+      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