rdf 3.2.3 → 3.2.6

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,15 +76,6 @@ 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 https://www.w3.org/TR/rdf-sparql-query/#prefNames
   class Vocabulary
     extend ::Enumerable
@@ -176,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,
@@ -204,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
@@ -286,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
@@ -389,7 +347,7 @@ module RDF
         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_ESCAPE_CHARS}/)
+        if suffix.match?(RDF::URI::PN_ESCAPES)
           suffix = suffix.gsub(RDF::URI::PN_ESCAPES) {|matched| matched[1..-1]}
         end
         if prefix == "rdf"
@@ -563,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
 
@@ -580,7 +534,6 @@ module RDF
           term_defs
         end
 
-        #require 'byebug'; byebug
         # Pass over embedded_defs with anonymous references, once
         embedded_defs.each do |term, attributes|
           attributes.each do |ak, avs|
@@ -963,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
@@ -971,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)
@@ -1110,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.
       #
@@ -1127,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>]
@@ -1144,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,
@@ -1161,9 +1146,7 @@ module RDF
               end
             end
           end
-
-          value
-        end
+        end.flatten
 
         prop_values.length <= 1 ? prop_values.first : prop_values
       end
@@ -1247,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: "")
@@ -1259,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"
+              "%(#{value.to_s.gsub('(', '\(').gsub(')', '\)')})"
             elsif value.node? && value.is_a?(RDF::Vocabulary::Term)
-              "#{value.to_ruby(indent: indent + "  ")}.freeze"
+              "#{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"
+                  "#{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}: " +
@@ -1340,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.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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 3.2.3
+  version: 3.2.6
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-16 00:00:00.000000000 Z
+date: 2022-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: link_header
@@ -81,6 +81,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -88,6 +91,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.1
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -209,7 +215,6 @@ files:
 - lib/rdf/mixin/countable.rb
 - lib/rdf/mixin/durable.rb
 - lib/rdf/mixin/enumerable.rb
-- lib/rdf/mixin/enumerator.rb
 - lib/rdf/mixin/indexable.rb
 - lib/rdf/mixin/mutable.rb
 - lib/rdf/mixin/queryable.rb
@@ -228,6 +233,7 @@ files:
 - lib/rdf/model/literal/double.rb
 - lib/rdf/model/literal/integer.rb
 - lib/rdf/model/literal/numeric.rb
+- lib/rdf/model/literal/temporal.rb
 - lib/rdf/model/literal/time.rb
 - lib/rdf/model/literal/token.rb
 - lib/rdf/model/node.rb
@@ -269,9 +275,9 @@ homepage: https://github.com/ruby-rdf/rdf
 licenses:
 - Unlicense
 metadata:
-  documentation_uri: https://rubydoc.info/github/ruby-rdf/rdf
+  documentation_uri: https://ruby-rdf.github.io/rdf
   bug_tracker_uri: https://github.com/ruby-rdf/rdf/issues
-  homepage_uri: https://ruby-rdf.github.io/rdf
+  homepage_uri: https://github.com/ruby-rdf/rdf
   mailing_list_uri: https://lists.w3.org/Archives/Public/public-rdf-ruby/
   source_code_uri: https://github.com/ruby-rdf/rdf
 post_install_message:

data/lib/rdf/mixin/enumerator.rb

@@ -1,40 +0,0 @@
-module RDF
-  ##
-  # Enumerators for different mixins. These are defined in a separate module, so that they are bound when used, allowing other mixins inheriting behavior to be included.
-  module Enumerable
-    # Extends Enumerator with {Queryable} and {Enumerable}, which is used by {Enumerable#each_statement} and {Queryable#enum_for}
-    class Enumerator < ::Enumerator
-      include Queryable
-      include Enumerable
-
-      ##
-      # @return [Array]
-      # @note Make sure returned arrays are also queryable
-      def to_a
-        return super.to_a.extend(RDF::Queryable, RDF::Enumerable)
-      end
-    end
-  end
-
-  module Countable
-    # Extends Enumerator with {Countable}, which is used by {Countable#enum_for}
-    class Enumerator < ::Enumerator
-      include Countable
-    end
-  end
-
-  module Queryable
-    # Extends Enumerator with {Queryable} and {Enumerable}, which is used by {Enumerable#each_statement} and {Queryable#enum_for}
-    class Enumerator < ::Enumerator
-      include Queryable
-      include Enumerable
-
-      ##
-      # @return [Array]
-      # @note Make sure returned arrays are also queryable
-      def to_a
-        return super.to_a.extend(RDF::Queryable, RDF::Enumerable)
-      end
-    end
-  end
-end