rdf 3.1.15 → 3.2.4

data/lib/rdf/vocabulary.rb

@@ -5,7 +5,14 @@ module RDF
   # A {Vocabulary} can also serve as a Domain Specific Language (DSL) for generating an RDF Graph definition for the vocabulary (see {RDF::Vocabulary#to_enum}).
   #
   # ### Defining a vocabulary using the DSL
-  # Vocabularies can be defined based on {RDF::Vocabulary} or {RDF::StrictVocabulary} using a simple Domain Specific Language (DSL). Terms of the vocabulary are specified using either `property` or `term` (alias), with the attributes of the term listed in a hash. See {property} for description of the hash.
+  # Vocabularies can be defined based on {RDF::Vocabulary} or {RDF::StrictVocabulary} using a simple Domain Specific Language (DSL).
+  #
+  # * Ontology information for the vocabulary itself can be specified using the {ontology} method.
+  # * Terms of the vocabulary are specified using either `property` or `term` (alias), with the attributes of the term listed in a hash. See {property} for description of the hash. Term attributes become properties of the associated {RDF::Vocabulary::Term} (see {RDF::Vocabulary::Term#attributes}).
+  #
+  # Note that, by default, the prefix associated with the vocabulary for forming and interpreting PNames is created from the class name of the vocabulary. See {\_\_prefix\_\_=} for overriding this at runtime.
+  #
+  # The simplest way to generate a DSL representation of a vocabulary is using {RDF::Vocabulary::Writer} given an {RDF::Graph} representation of the vocabulary.
   #
   # ### Vocabularies:
   #
@@ -31,6 +38,31 @@ module RDF
   #   foaf.knows    #=> RDF::URI("http://xmlns.com/foaf/0.1/knows")
   #   foaf[:name]   #=> RDF::URI("http://xmlns.com/foaf/0.1/name")
   #   foaf['mbox']  #=> RDF::URI("http://xmlns.com/foaf/0.1/mbox")
+  #
+  # @example Defining a simple vocabulary
+  #   EX = Class.new(RDF::StrictVocabulay("http://example/ns#")) do
+  #     # Ontology definition
+  #     ontology :"http://example/ns#",
+  #       label: "The RDF Example Vocablary",
+  #       type: "http://www.w3.org/2002/07/owl#Ontology"
+  #
+  #     # Class definitions
+  #     term :Class,
+  #       label: "My Class",
+  #       comment: "Good to use as an example",
+  #       type: "rdfs:Class",
+  #       subClassOf: "http://example/SuperClass",
+  #       "ex:prop": "Some annotation property not having a shortcut"
+  #
+  #     # Property definitions
+  #     property :prop,
+  #       comment: "A description of the property",
+  #       label: "property",
+  #       domain: "http://example/ns#Class",
+  #       range: "rdfs:Literal",
+  #       isDefinedBy: %(ex:),
+  #       type: "rdf:Property"
+  #   end
   # 
   # @example Method calls are converted to the typical RDF camelcase convention
   #   foaf = RDF::Vocabulary.new("http://xmlns.com/foaf/0.1/")
@@ -44,17 +76,7 @@ module RDF
   #   graph = RDF::Graph.new << RDF::RDFS.to_enum
   #   graph.dump(:ntriples)
   #
-  # @example Defining a simple vocabulary
-  #   class EX < RDF::StrictVocabulay("http://example/ns#")
-  #     term :Class,
-  #       label: "My Class",
-  #       comment: "Good to use as an example",
-  #       "rdf:type" => "rdfs:Class",
-  #       "rdfs:subClassOf" => "http://example/SuperClass"
-  #   end
-  #
-  # @see http://www.w3.org/TR/curie/
-  # @see http://en.wikipedia.org/wiki/QName
+  # @see https://www.w3.org/TR/rdf-sparql-query/#prefNames
   class Vocabulary
     extend ::Enumerable
 
@@ -70,7 +92,7 @@ module RDF
       # @return [Enumerator]
       def each(&block)
         if self.equal?(Vocabulary)
-          if @vocabs
+          if instance_variable_defined?(:@vocabs) && @vocabs
             @vocabs.select(&:name).each(&block)
           else
             # This is needed since all vocabulary classes are defined using
@@ -177,16 +199,28 @@ module RDF
       #   @return [RDF::Vocabulary::Term]
       #
       # @overload property(name, options)
-      #   Defines a new property or class in the vocabulary.
+      #   Defines a new property or class in the vocabulary as a {RDF::Vocabulary::Term}.
       #
       #   @example A simple term definition
       #       property :domain,
-      #         comment: %(A domain of the subject property.).freeze,
-      #         domain: "rdf:Property".freeze,
-      #         label: "domain".freeze,
-      #         range: "rdfs:Class".freeze,
-      #         isDefinedBy: %(rdfs:).freeze,
-      #         type: "rdf:Property".freeze
+      #         comment: %(A domain of the subject property.),
+      #         domain: "rdf:Property",
+      #         label: "domain",
+      #         range: "rdfs:Class",
+      #         isDefinedBy: %(rdfs:),
+      #         type: "rdf:Property"
+      #
+      #   @example A term definition with tagged values
+      #       property :actor,
+      #       comment: {en: "Subproperty of as:attributedTo that identifies the primary actor"},
+      #       domain: "https://www.w3.org/ns/activitystreams#Activity",
+      #       label: {en: "actor"},
+      #       range: term(
+      #           type: "http://www.w3.org/2002/07/owl#Class",
+      #           unionOf: list("https://www.w3.org/ns/activitystreams#Object", "https://www.w3.org/ns/activitystreams#Link")
+      #         ),
+      #       subPropertyOf: "https://www.w3.org/ns/activitystreams#attributedTo",
+      #       type: "http://www.w3.org/2002/07/owl#ObjectProperty"
       #
       #   @example A SKOS term with anonymous values
       #         term: :af,
@@ -205,76 +239,8 @@ module RDF
       #           "foaf:name": "Aland Islands"
       #
       #   @param [String, #to_s] name
-      #   @param [Hash{Symbol=>String,Array<String,Term>}] options
-      #     Any other values are expected to expands to a {URI} using built-in vocabulary prefixes. The value is a `String`, `Array<String>` or `Array<Term>` which is interpreted according to the `range` of the associated property.
-      #   @option options [String, Array<String,Term>] :type
-      #     Shortcut for `rdf:type`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String>] :comment
-      #     Shortcut for `rdfs:comment`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :domain
-      #     Shortcut for `rdfs:domain`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :isDefinedBy
-      #     Shortcut for `rdfs:isDefinedBy`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String>] :label
-      #     Shortcut for `rdfs:label`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :range
-      #     Shortcut for `rdfs:range`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :subClassOf
-      #     Shortcut for `rdfs:subClassOf`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :subPropertyOf
-      #     Shortcut for `rdfs:subPropertyOf`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :allValuesFrom
-      #     Shortcut for `owl:allValuesFrom`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :cardinality
-      #     Shortcut for `owl:cardinality`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :equivalentClass
-      #     Shortcut for `owl:equivalentClass`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :equivalentProperty
-      #     Shortcut for `owl:equivalentProperty`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :intersectionOf
-      #     Shortcut for `owl:intersectionOf`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :inverseOf
-      #     Shortcut for `owl:inverseOf`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :maxCardinality
-      #     Shortcut for `owl:maxCardinality`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :minCardinality
-      #     Shortcut for `owl:minCardinality`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :onProperty
-      #     Shortcut for `owl:onProperty`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :someValuesFrom
-      #     Shortcut for `owl:someValuesFrom`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :unionOf
-      #     Shortcut for `owl:unionOf`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :domainIncludes
-      #     Shortcut for `schema:domainIncludes`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :rangeIncludes
-      #     Shortcut for `schema:rangeIncludes`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String>] :altLabel
-      #     Shortcut for `skos:altLabel`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :broader
-      #     Shortcut for `skos:broader`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String>] :definition
-      #     Shortcut for `skos:definition`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String>] :editorialNote
-      #     Shortcut for `skos:editorialNote`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :exactMatch
-      #     Shortcut for `skos:exactMatch`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :hasTopConcept
-      #     Shortcut for `skos:hasTopConcept`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :inScheme
-      #     Shortcut for `skos:inScheme`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :member
-      #     Shortcut for `skos:member`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String,Term>] :narrower
-      #     Shortcut for `skos:narrower`, values are interpreted as a {Term}.
-      #   @option options [String, Array<String>] :notation
-      #     Shortcut for `skos:notation`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String>] :note
-      #     Shortcut for `skos:note`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String>] :prefLabel
-      #     Shortcut for `skos:prefLabel`, values are interpreted as a {Literal}.
-      #   @option options [String, Array<String,Term>] :related
-      #     Shortcut for `skos:related`, values are interpreted as a {Term}.
+      #   @param [Hash{Symbol=>String,Array<String>}] options
+      #     Any other values are expected to expands to a {URI} using built-in vocabulary prefixes. The value is a `String`, 'Hash{Symbol=>String,Array<String>}' or `Array<String,Hash{Symbol=>Array<String>}>` which is interpreted according to the `range` of the associated property and by heuristically determining the value datatype. See `attributes` argument to {Term#initialize}.
       #   @return [RDF::Vocabulary::Term]
       def property(*args)
         case args.length
@@ -287,15 +253,6 @@ module RDF
             uri_str = [to_s, name.to_s].join('')
             URI.cache.delete(uri_str.to_sym)  # Clear any previous entry
 
-            # Transform attribute keys that are PNames with a warning
-            # FIXME: add back later
-            #if !@is_deprecated && options.is_a?(Hash) &&
-            #   options.keys.map(&:to_s).any? {|k| k.include?(':') && !k.match?(/^https?:/)}
-            #
-            #  @is_deprecated = true
-            #  warn "[DEPRECATION] Vocabulary #{to_uri} includes pname attribute keys, regenerate"
-            #end
-
             # Term attributes passed in a block for lazy evaluation. This helps to avoid load-time circular dependencies
             prop = Term.intern(uri_str, vocab: self, attributes: options || {})
             props[name.to_sym] = prop
@@ -356,7 +313,7 @@ module RDF
       def ontology(*args)
         case args.length
         when 0
-          @ontology
+          @ontology if instance_variable_defined?(:@ontology)
         else
           uri, options = args
           URI.cache.delete(uri.to_s.to_sym)  # Clear any previous entry
@@ -379,15 +336,20 @@ module RDF
       alias_method :__properties__, :properties
 
       ##
-      # Attempt to expand a Compact IRI/PName/QName using loaded vocabularies
+      # Attempt to expand a Compact IRI/PName using loaded vocabularies
       #
       # @param [String, #to_s] pname
+      # The local-part of the PName will will have [reserved character escapes](https://www.w3.org/TR/turtle/#reserved) unescaped.
       # @return [Term]
-      # @raise [KeyError] if pname suffix not found in identified vocabulary
+      # @raise [KeyError] if pname suffix not found in identified vocabulary.
       # @raise [ArgumentError] if resulting URI is not valid
       def expand_pname(pname)
         return pname unless pname.is_a?(String) || pname.is_a?(Symbol)
         prefix, suffix = pname.to_s.split(":", 2)
+        # Unescape escaped PN_ESCAPE_CHARS
+        if suffix.match?(RDF::URI::PN_ESCAPES)
+          suffix = suffix.gsub(RDF::URI::PN_ESCAPES) {|matched| matched[1..-1]}
+        end
         if prefix == "rdf"
           RDF[suffix]
         elsif vocab_detail = RDF::Vocabulary.vocab_map[prefix.to_sym]
@@ -417,9 +379,10 @@ module RDF
       end
 
       ##
-      # Return the Vocabulary term associated with a  URI
+      # Return the Vocabulary term associated with a URI
       #
-      # @param [RDF::URI] uri
+      # @param [RDF::URI, String] uri
+      #   If `uri` has is a pname in a locded vocabulary, the suffix portion of the PName will have escape characters unescaped before resolving against the vocabulary.
       # @return [Vocabulary::Term]
       def find_term(uri)
         uri = RDF::URI(uri)
@@ -428,7 +391,8 @@ module RDF
           if vocab.ontology == uri
             vocab.ontology
           else
-            vocab[uri.to_s[vocab.to_uri.to_s.length..-1].to_s]
+            suffix = uri.to_s[vocab.to_uri.to_s.length..-1].to_s
+            vocab[suffix]
           end
         end
       end
@@ -507,7 +471,7 @@ module RDF
         end
 
         # Also include the ontology, if it's not also a property
-        @ontology.each_statement(&block) if @ontology && @ontology != self
+        @ontology.each_statement(&block) if self.ontology && self.ontology != self
       end
 
       ##
@@ -557,10 +521,6 @@ module RDF
             statement.predicate.to_s.to_sym
           end
 
-          # Skip literals other than plain or english
-          # This is because the ruby representation does not preserve language
-          next if statement.object.literal? && (statement.object.language || :en).to_s !~ /^en-?/
-
           (term[key] ||= []) << statement.object
         end
 
@@ -642,12 +602,31 @@ module RDF
       alias_method :__name__, :name
 
       ##
-      # Returns a suggested CURIE/PName prefix for this vocabulary class.
+      # Returns a suggested vocabulary prefix for this vocabulary class.
       #
       # @return [Symbol]
       # @since  0.3.0
       def __prefix__
-        __name__.split('::').last.downcase.to_sym
+        instance_variable_defined?(:@__prefix__) ?
+          @__prefix__ :
+          __name__.split('::').last.downcase.to_sym
+      end
+
+      ##
+      # Sets the vocabulary prefix to use for this vocabulary..
+      #
+      # @example Overriding a standard vocabulary prefix.
+      #   RDF::Vocab::DC.__prefix__ = :dcterms
+      #   RDF::Vocab::DC.title.pname #=> 'dcterms:title'
+      #
+      # @param [Symbol] prefix
+      # @return [Symbol]
+      # @since  3.2.3
+      def __prefix__=(prefix)
+        params = RDF::Vocabulary.vocab_map[__prefix__]
+        @__prefix__ = prefix.to_sym
+        RDF::Vocabulary.register(@__prefix__, self, **params)
+        @__prefix__
       end
 
     protected
@@ -937,6 +916,10 @@ module RDF
       #
       # Symbols which are accessors may also be looked up by their associated URI.
       #
+      # Values may be Strings, Hash (Map), or Terms, or an Array including a combination of these. A Hash (Map) is used to create a datatype/language map to one or more string values which represent either datatyped literals, or language-tagged literals as interpreted by {#attribute_value}.
+      #
+      # In general, this accessor is used internally. The {#properties} method interprets these values as {RDF::Value}.
+      #
       # @note lookup by PName is DEPRECATED and will be removed in a future version.
       #
       # @example looking up term label
@@ -945,23 +928,23 @@ module RDF
       #   RDF::RDFS.Literal.attributes[RDF::RDFS.label] #=> "Literal"
       #   RDF::RDFS.Literal.attributes["http://www.w3.org/2000/01/rdf-schema#label"] #=> "Literal"
       #   RDF::RDFS.Literal.attributes[:"http://www.w3.org/2000/01/rdf-schema#label"] #=> "Literal"
-      # @return [Hash{Symbol,Resource => Term, #to_s}]
+      # @return [Hash{Symbol => String, Term, Hash{Symbol => String}, Array<String, Term, Hash{Symbol => String}>}]
+      # @see #properties
       attr_reader :attributes
 
       ##
-      # @overload new(uri, attributes:, **options)
+      # @overload new(uri, attributes:, vocab:, **options)
       #   @param  [URI, String, #to_s]    uri
       #   @param [Vocabulary] vocab Vocabulary of this term.
-      #   @param [Hash{Symbol => Symbol,Array<String,Term>}] attributes ({})
+      #   @param [Hash{Symbol => String,Term,Hash{Symbol=>String,Array<String>},Array<String>}] attributes ({})
       #     Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF. See {#attributes} and {#properties} for other ways to access.
       #   @param  [Hash{Symbol => Object}] options
       #     Options from {URI#initialize}
       #
-      # @overload new(attributes:, **options)
-      #   @param  [Hash{Symbol => Object}] options
+      # @overload new(attributes:, vocab:, **options)
       #   @param [Vocabulary] vocab Vocabulary of this term.
-      #   @param [Hash{Symbol => Symbol,Array<String,Term>}] attributes ({})
-      #     Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF. See {#attributes} and {#properties} for other ways to access.
+      #   @param [Hash{Symbol => String,Term,Hash{Symbol=>String,Array<String>},Array<String>}] attributes ({})
+      #     Attributes of this vocabulary term, used for finding `label`,  `comment` and other term properties, and to serialize the term back to RDF. See {#attributes} and {#properties} for other ways to access.
       #   @param  [Hash{Symbol => Object}] options
       #     Options from {URI#initialize}
       def self.new(*args, vocab: nil, attributes: {}, **options)
@@ -1084,7 +1067,7 @@ module RDF
 
       ##
       # Enumerate attributes with values transformed into {RDF::Value} instances
-      # Uses an empty hash with a default_proc which looks up values in attributes.
+      # Uses an empty hash with a default_proc which looks up values in attributes. The prevents specific attributes from being evaluated until acessed.
       #
       # Properties are indexed by symbol. Symbols directly interpreted by a term are the accessors defined for the {RDF::Vocabulary::Term} class, also in {Term::ATTR_URIs}. Other keys are interpreted as absolute URIs or PNames for properties defined on this term.
       #
@@ -1101,12 +1084,27 @@ module RDF
       #   RDF::RDFS.Literal.properties[:"http://www.w3.org/2000/01/rdf-schema#label"] #=> RDF::Literal("Literal")
       #
       # @return [Hash{Symbol => Array<RDF::Value>}]
+      # @see #attribute_value
       def properties
         Hash.new {|hash, key| attribute_value(key)}
       end
 
       ##
-      # Values of an attributes as {RDF::Value}
+      # Values of an attributes as {RDF::Value}.
+      #
+      # Attribute values are returned as either an {RDF::Value} or {Array<RDf::Value} if there is more than one value.
+      #
+      # Attribute values which are not already a {RDF::Value} (including strings and symbols) are converted by a heuristic loookup as follows:
+      #
+      # * An {RDF::URI} if it can be turned into a valid IRI using {RDF::Vocabulary.expand_pname}. This includes IRIs already in non-relative form.
+      # * A {Hash{Symbol=>String,Array<String>}} is interpreted as a datatype/language map. If the key contains a ':', it is treated as a PName or IRI datatype applied to the values. Otherwise, it is treated as a language-tag applied to the values.
+      # * {RDF::Literal::Date} if valid,
+      # * {RDF::Literal::DateTime} if valid, 
+      # * {RDF::Literal::Integer} if valid, 
+      # * {RDF::Literal::Decimal} if valid, 
+      # * {RDF::Literal::Double} if valid, 
+      # * {RDF::Literal::Boolean} if valid
+      # * Otherwise, {RDF::Literal} where type may be inferred by the class of the value.
       #
       # @param [Symbol] prop
       # @return [RDF::Value, Array<RDF::Value>]
@@ -1118,9 +1116,22 @@ module RDF
           v = value.is_a?(Symbol) ? value.to_s : value
           value = (RDF::Vocabulary.expand_pname(v) rescue nil) if v.is_a?(String) && v.include?(':')
           value = value.to_uri if value.respond_to?(:to_uri)
-          unless value.is_a?(RDF::Value) && value.valid?
+          value = if value.is_a?(RDF::Value) && value.valid?
+            value
+          elsif value.is_a?(Hash)
+            # type/language map
+            value.inject([]) do |memo, (k,v)|
+              vv = [v] unless v.is_a?(Array)
+              memo << if k.to_s.include?(':')
+                dt = RDF::Vocabulary.expand_pname(v) rescue nil
+                vv.map {|val| RDF::Literal(val, datatype: dt)}
+              else
+                vv.map {|val| RDF::Literal(val, language: k)}
+              end
+            end.flatten.compact.select(&:valid?)
+          else
             # Use as most appropriate literal
-            value = [
+            [
               RDF::Literal::Date,
               RDF::Literal::DateTime,
               RDF::Literal::Integer,
@@ -1135,9 +1146,7 @@ module RDF
               end
             end
           end
-
-          value
-        end
+        end.flatten
 
         prop_values.length <= 1 ? prop_values.first : prop_values
       end
@@ -1221,7 +1230,9 @@ module RDF
         rangeIncludes
       end
 
-      # Serialize back to a Ruby source initializer
+      ##
+      # Serialize back to a Ruby source initializer. This is used primarily by {RDF::Vocabulary::Writer}.
+      #
       # @param [String] indent
       # @return [String]
       def to_ruby(indent: "")
@@ -1233,24 +1244,24 @@ module RDF
           values = [values].compact unless values.is_a?(Array)
           values = values.map do |value|
             if value.is_a?(Literal) && %w(: comment definition notation note editorialNote).include?(k.to_s)
-              "%(#{value.to_s.gsub('(', '\(').gsub(')', '\)')}).freeze"
-            # elsif value.is_a?(RDF::Vocabulary::Term)
-            #  value.to_ruby(indent: indent + "  ")
+              "%(#{value.to_s.gsub('(', '\(').gsub(')', '\)')})"
+            elsif value.node? && value.is_a?(RDF::Vocabulary::Term)
+              "#{value.to_ruby(indent: indent + "  ")}"
             elsif value.is_a?(RDF::Term)
-              "#{value.to_s.inspect}.freeze"
+              "#{value.to_s.inspect}"
             elsif value.is_a?(RDF::List)
               list_elements = value.map do |u|
                 if u.uri?
-                  "#{u.to_s.inspect}.freeze"
-                # elsif u.respond_to?(:to_ruby)
-                #  u.to_ruby(indent: indent + "  ")
+                  "#{u.to_s.inspect}"
+                elsif u.node? && u.respond_to?(:to_ruby)
+                  u.to_ruby(indent: indent + "  ")
                 else
-                  "#{u.to_s.inspect}.freeze"
+                  "#{u.to_s.inspect}"
                 end
               end
               "list(#{list_elements.join(', ')})"
             else
-              "#{value.inspect}.freeze"
+              "#{value.inspect}"
             end
           end
           "#{k.to_s.include?(':') ? k.to_s.inspect : k}: " +
@@ -1314,7 +1325,7 @@ module RDF
       def [](name)
         props.fetch(name.to_sym)
       rescue KeyError
-        raise KeyError, "#{name} not found in vocabulary #{self.__name__}"
+        raise KeyError, "#{name.inspect} not found in vocabulary #{self.__name__}"
       end
     end
   end # StrictVocabulary

data/lib/rdf/writer.rb

@@ -516,7 +516,7 @@ module RDF
         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_embTriple(term, **options)
+        when RDF::Statement then format_quotedTriple(term, **options)
         else nil
       end
     end
@@ -574,7 +574,7 @@ module RDF
     # @return [String]
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
-    def format_embTriple(value, **options)
+    def format_quotedTriple(value, **options)
       raise NotImplementedError.new("#{self.class}#format_statement") # override in subclasses
     end
 

data/lib/rdf.rb

@@ -7,9 +7,6 @@ require "ostruct"
 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'