rdf 1.1.3 → 1.1.4

data/lib/rdf/model/statement.rb

@@ -6,19 +6,25 @@ module RDF
   #   s = RDF::URI.new("http://rubygems.org/gems/rdf")
   #   p = RDF::DC.creator
   #   o = RDF::URI.new("http://ar.to/#self")
-  #   RDF::Statement.new(s, p, o)
+  #   RDF::Statement(s, p, o)
   #
   # @example Creating an RDF statement with a context
   #   uri = RDF::URI("http://example/")
-  #   RDF::Statement.new(s, p, o, :context => uri)
+  #   RDF::Statement(s, p, o, :context => uri)
   #
   # @example Creating an RDF statement from a `Hash`
-  #   RDF::Statement.new({
+  #   RDF::Statement({
   #     :subject   => RDF::URI.new("http://rubygems.org/gems/rdf"),
   #     :predicate => RDF::DC.creator,
   #     :object    => RDF::URI.new("http://ar.to/#self"),
   #   })
   #
+  # @example Creating an RDF statement with interned nodes
+  #   RDF::Statement(:s, p, :o)
+  #
+  # @example Creating an RDF statement with a string
+  #   RDF::Statement(s, p, "o")
+  #
   class Statement
     include RDF::Value
 
@@ -54,21 +60,23 @@ module RDF
     ##
     # @overload initialize(options = {})
     #   @param  [Hash{Symbol => Object}] options
-    #   @option options [RDF::Resource]  :subject   (nil)
+    #   @option options [RDF::Term]  :subject   (nil)
+    #     A symbol is converted to an interned {Node}.
     #   @option options [RDF::URI]       :predicate (nil)
-    #   @option options [RDF::Term]      :object    (nil)
-    #     if not an `RDF::Term`, it is coerced to `RDF::Literal`.
-    #   @option options [RDF::Resource]  :context   (nil)
-    #     Note, in RDF 1.1, a context MUST be an IRI.
+    #   @option options [RDF::Resource]      :object    (nil)
+    #     if not a {Resource}, it is coerced to {Literal} or {Node} depending on if it is a symbol or something other than a {Term}.
+    #   @option options [RDF::Term]  :context   (nil)
+    #     Note, in RDF 1.1, a context MUST be an {Resource}.
     #   @return [RDF::Statement]
     #
     # @overload initialize(subject, predicate, object, options = {})
-    #   @param  [RDF::Resource]          subject
+    #   @param  [RDF::Term]          subject
+    #     A symbol is converted to an interned {Node}.
     #   @param  [RDF::URI]               predicate
-    #   @param  [RDF::Term]              object
-    #     if not an `RDF::Term`, it is coerced to `RDF::Literal`.
+    #   @param  [RDF::Resource]              object
+    #     if not a {Resource}, it is coerced to {Literal} or {Node} depending on if it is a symbol or something other than a {Term}.
     #   @param  [Hash{Symbol => Object}] options
-    #   @option options [RDF::Resource]  :context   (nil)
+    #   @option options [RDF::Term]  :context   (nil)
     #   @return [RDF::Statement]
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
       case subject

data/lib/rdf/model/uri.rb

@@ -140,8 +140,9 @@ module RDF
     #
     # @param (see #initialize)
     # @return [RDF::URI] an immutable, frozen URI object
-    def self.intern(str)
-      (cache[str = str.to_s] ||= self.new(str)).freeze
+    def self.intern(*args)
+      str = args.first
+      (cache[str = str.to_s] ||= self.new(*args)).freeze
     end
 
     ##
@@ -632,6 +633,14 @@ module RDF
       return nil # no QName found
     end
 
+    ##
+    # Returns a string version of the QName or the full IRI
+    #
+    # @return [String] or `nil`
+    def pname
+      (q = self.qname) ? q.join(":") : to_s
+    end
+
     ##
     # Returns a duplicate copy of `self`.
     #

data/lib/rdf/nquads.rb

@@ -114,17 +114,18 @@ module RDF
       # @param  [RDF::Term]     object
       # @return [void]
       def write_quad(subject, predicate, object, context)
-        puts format_quad(subject, predicate, object, context)
+        puts format_quad(subject, predicate, object, context, @options)
       end
 
       ##
       # Returns the N-Quads representation of a statement.
       #
       # @param  [RDF::Statement] statement
+      # @param  [Hash{Symbol => Object}] options = ({})
       # @return [String]
       # @since  0.4.0
-      def format_statement(statement)
-        format_quad(*statement.to_quad)
+      def format_statement(statement, options = {})
+        format_quad(*statement.to_quad, options)
       end
 
       ##
@@ -134,10 +135,11 @@ module RDF
       # @param  [RDF::URI]      predicate
       # @param  [RDF::Term]     object
       # @param  [RDF::Term]     context
+      # @param  [Hash{Symbol => Object}] options = ({})
       # @return [String]
-      def format_quad(subject, predicate, object, context)
-        s = "%s %s %s " % [subject, predicate, object].map { |value| format_term(value) }
-        s += format_term(context) + " " if context
+      def format_quad(subject, predicate, object, context, options = {})
+        s = "%s %s %s " % [subject, predicate, object].map { |value| format_term(value, options) }
+        s += format_term(context, options) + " " if context
         s + "."
       end
     end # Writer

data/lib/rdf/ntriples/writer.rb

@@ -179,7 +179,7 @@ module RDF::NTriples
     #
     # @param  [IO, File] output
     #   the output stream
-    # @param  [Hash{Symbol => Object}] options
+    # @param  [Hash{Symbol => Object}] options = ({})
     #   any additional options. See {RDF::Writer#initialize}
     # @option options [Boolean]  :validate (true)
     #   whether to validate terms when serializing
@@ -208,16 +208,17 @@ module RDF::NTriples
     # @param  [RDF::Term]     object
     # @return [void]
     def write_triple(subject, predicate, object)
-      puts format_triple(subject, predicate, object)
+      puts format_triple(subject, predicate, object, @options)
     end
 
     ##
     # Returns the N-Triples representation of a statement.
     #
     # @param  [RDF::Statement] statement
+    # @param  [Hash{Symbol => Object}] options = ({})
     # @return [String]
-    def format_statement(statement)
-      format_triple(*statement.to_triple)
+    def format_statement(statement, options = {})
+      format_triple(*statement.to_triple, options)
     end
 
     ##
@@ -226,26 +227,29 @@ module RDF::NTriples
     # @param  [RDF::Resource] subject
     # @param  [RDF::URI]      predicate
     # @param  [RDF::Term]     object
+    # @param  [Hash{Symbol => Object}] options = ({})
     # @return [String]
-    def format_triple(subject, predicate, object)
-      "%s %s %s ." % [subject, predicate, object].map { |value| format_term(value) }
+    def format_triple(subject, predicate, object, options = {})
+      "%s %s %s ." % [subject, predicate, object].map { |value| format_term(value, options) }
     end
 
     ##
     # Returns the N-Triples representation of a blank node.
     #
     # @param  [RDF::Node] node
-    # @param  [Hash{Symbol => Object}] options
+    # @param  [Hash{Symbol => Object}] options = ({})
+    # @option options [Boolean] :unique_bnodes (false)
+    #   Serialize node using unique identifier, rather than any used to create the node.
     # @return [String]
     def format_node(node, options = {})
-      node.to_base
+      options[:unique_bnodes] ? node.to_unique_base : node.to_base
     end
 
     ##
     # Returns the N-Triples representation of a URI reference.
     #
     # @param  [RDF::URI] uri
-    # @param  [Hash{Symbol => Object}] options
+    # @param  [Hash{Symbol => Object}] options = ({})
     # @return [String]
     def format_uri(uri, options = {})
       uri.to_base
@@ -255,7 +259,7 @@ module RDF::NTriples
     # Returns the N-Triples representation of a literal.
     #
     # @param  [RDF::Literal, String, #to_s] literal
-    # @param  [Hash{Symbol => Object}] options
+    # @param  [Hash{Symbol => Object}] options = ({})
     # @return [String]
     def format_literal(literal, options = {})
       case literal

data/lib/rdf/query/pattern.rb

@@ -18,21 +18,23 @@ module RDF; class Query
     ##
     # @overload initialize(options = {})
     #   @param  [Hash{Symbol => Object}]     options
-    #   @option options [Variable, Resource, nil] :subject   (nil)
-    #   @option options [Variable, URI, nil]      :predicate (nil)
-    #   @option options [Variable, Term, nil]     :object    (nil)
-    #   @option options [Variable, Resource, nil, false] :context   (nil)
+    #   @option options [Variable, Resource, Symbol, nil] :subject   (nil)
+    #   @option options [Variable, URI, Symbol, nil]      :predicate (nil)
+    #   @option options [Variable, Term, Symbol, nil]     :object    (nil)
+    #   @option options [Variable, Resource, Symbol, nil, false] :context   (nil)
     #     A context of nil matches any context, a context of false, matches only the default context.
     #   @option options [Boolean]            :optional  (false)
     #
     # @overload initialize(subject, predicate, object, options = {})
-    #   @param  [Variable, Resource, nil]         subject
-    #   @param  [Variable, URI, nil]              predicate
-    #   @param  [Variable, Termm, nil]            object
+    #   @param  [Variable, Resource, Symbol, nil]         subject
+    #   @param  [Variable, URI, Symbol, nil]              predicate
+    #   @param  [Variable, Termm, Symbol, nil]            object
     #   @param  [Hash{Symbol => Object}]          options
-    #   @option options [Variable, Resource, nil, false] :context   (nil)
+    #   @option options [Variable, Resource, Symbol, nil, false] :context   (nil)
     #     A context of nil matches any context, a context of false, matches only the default context.
     #   @option options [Boolean]                 :optional  (false)
+    #
+    # @note {Statement} treats symbols as interned {Node} instances, in a {Pattern}, they are treated as {Variable}.
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
       super
     end

data/lib/rdf/reader.rb

@@ -115,9 +115,18 @@ module RDF
     ##
     # Parses input from the given file name or URL.
     #
+    # @note A reader returned via this method may not be readable depending on the processing model of the specific reader, as the file is only open during the scope of `open`. The reader is intended to be accessed through a block.
+    #
+    # @example Parsing RDF statements from a file
+    #   RDF::Reader.open("etc/doap.nt") do |reader|
+    #     reader.each_statement do |statement|
+    #       puts statement.inspect
+    #     end
+    #   end
+    #
     # @param  [String, #to_s] filename
     # @param  [Hash{Symbol => Object}] options
-    #   any additional options (see {RDF::Reader#initialize} and {RDF::Format.for})
+    #   any additional options (see {RDF::Util::File.open_file}, {RDF::Reader#initialize} and {RDF::Format.for})
     # @option options [Symbol] :format (:ntriples)
     # @yield  [reader]
     # @yieldparam  [RDF::Reader] reader
@@ -138,7 +147,7 @@ module RDF
         if reader
           reader.new(file, options, &block)
         else
-          raise FormatError, "unknown RDF format: #{format_options.inspect}"
+          raise FormatError, "unknown RDF format: #{format_options.inspect}\nThis may be resolved with a require of the 'linkeddata' gem."
         end
       end
     end

data/lib/rdf/repository.rb

@@ -71,7 +71,7 @@ module RDF
     #
     # @param  [String, Array<String>] filenames
     # @param  [Hash{Symbol => Object}] options
-    #   Options from {RDF::Reader#initialize}, {RDF::Format.for} and {RDF::Repository#initialize}
+    #   Options from {RDF::Repository#initialize} and {RDF::Mutable#load}
     # @yield  [repository]
     # @yieldparam [Repository]
     # @return [void]

data/lib/rdf/vocab.rb

@@ -2,6 +2,11 @@ module RDF
   ##
   # A {Vocabulary} represents an RDFS or OWL vocabulary.
   #
+  # A {Vocabulary} can also serve as a Domain Specific Language (DSL) for generating an RDF Graph definition for the vocabulary (see {RDF::Vocabulary#to_graph}).
+  #
+  # ### 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:
   #
   # The following vocabularies are pre-defined for your convenience:
@@ -16,7 +21,7 @@ module RDF
   # * {RDF::FOAF}   - Friend of a Friend (FOAF)
   # * {RDF::GEO}    - WGS84 Geo Positioning (GEO)
   # * {RDF::GR}     - Good Relations
-  # * {RDF::HTTP}   - Hypertext Transfer Protocol (HTTP)
+  # * {RDF::HT}   - Hypertext Transfer Protocol (HTTP)
   # * {RDF::ICAL}   - iCal
   # * {RDF::MA}     - W3C Meda Annotations
   # * {RDF::OG}     - FaceBook OpenGraph
@@ -55,6 +60,19 @@ module RDF
   #   foaf[:name]   #=> RDF::URI("http://xmlns.com/foaf/0.1/name")
   #   foaf['mbox']  #=> RDF::URI("http://xmlns.com/foaf/0.1/mbox")
   #
+  # @example Generating RDF from a vocabulary definition
+  #   graph = RDF::RDFS.to_graph
+  #   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
   class Vocabulary
@@ -73,56 +91,125 @@ module RDF
           # 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.each(&block)
+          @@subclasses.select(&:name).each(&block)
         else
-          # TODO: should enumerate vocabulary-specific defined properties.
+          __properties__.each(&block)
         end
       end
 
+      ##
+      # Is this a strict vocabulary, or a liberal vocabulary allowing arbitrary properties?
+      def strict?; false; end
+
       ##
       # @overload property
       #   Returns `property` in the current vocabulary
-      #   @return [RDF::URI]
+      #   @return [RDF::Vocabulary::Term]
       #
       # @overload property(name, options)
       #   Defines a new property or class in the vocabulary.
-      #   Optional labels and comments are stripped of unnecessary whitespace.
       #
       #   @param [String, #to_s] name
       #   @param [Hash{Symbol => Object}] options
-      #   @option options [String, #to_s] :label
-      #   @option options [String, #to_s] :comment
+      #     Any other values are expected to be String which expands to a {URI} using built-in vocabulary prefixes. The value is a `String` or `Array<String>` which is interpreted according to the `range` of the associated property.
+      #   @option options [String, Array<String>] :label
+      #     Shortcut for `rdfs:label`, values are String interpreted as a {Literal}.
+      #   @option options [String, Array<String>] :comment
+      #     Shortcut for `rdfs:comment`, values are String interpreted as a {Literal}.
+      #   @option options [String, Array<String>] :subClassOf
+      #     Shortcut for `rdfs:subClassOf`, values are String interpreted as a {URI}.
+      #   @option options [String, Array<String>] :subPropertyOf
+      #     Shortcut for `rdfs:subPropertyOf`, values are String interpreted as a {URI}.
+      #   @option options [String, Array<String>] :domain
+      #     Shortcut for `rdfs:domain`, values are String interpreted as a {URI}.
+      #   @option options [String, Array<String>] :range
+      #     Shortcut for `rdfs:range`, values are String interpreted as a {URI}.
+      #   @option options [String, Array<String>] :type
+      #     Shortcut for `rdf:type`, values are String interpreted as a {URI}.
+      #   @return [RDF::Vocabulary::Term]
       def property(*args)
         case args.length
         when 0
-          RDF::URI.intern("#{self}property")
+          Term.intern("#{self}property", attributes: {label: "property", vocab: self})
         else
           name, options = args
-          options ||= {}
-          prop = RDF::URI.intern([to_s, name.to_s].join(''))
-          @@labels[prop] = options[:label].to_s.strip.gsub(/\s+/m, ' ') if options[:label]
-          @@comments[prop] = options[:comment].to_s.strip.gsub(/\s+/m, ' ') if options[:comment]
+          options = {:label => name.to_s, vocab: self}.merge(options || {})
+          prop = Term.intern([to_s, name.to_s].join(''), attributes: options)
+          props[prop] = options
           (class << self; self; end).send(:define_method, name) { prop } unless name.to_s == "property"
+          prop
+        end
+      end
+
+      # Alternate use for vocabulary terms, functionally equivalent to {#property}.
+      alias_method :term, :property
+      alias_method :__property__, :property
+
+      ##
+      #  @return [Array<RDF::URI>] a list of properties in the current vocabulary
+      def properties
+        props.keys
+      end
+      alias_method :__properties__, :properties
+
+      ##
+      # Attempt to expand a Compact IRI/PName/QName using loaded vocabularies
+      #
+      # @param [String, #to_s] pname
+      # @return [RDF::URI]
+      def expand_pname(pname)
+        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}
+          suffix.to_s.empty? ? vocab.to_uri : vocab[suffix]
+        else
+          RDF::Vocabulary.find_term(pname) || RDF::URI(pname)
         end
       end
 
+      ##
+      # Return the Vocabulary associated with a URI
+      #
+      # @param [RDF::URI] uri
+      # @return [Vocabulary]
+      def find(uri)
+        RDF::Vocabulary.detect {|v| RDF::URI(uri).start_with?(v.to_uri)}
+      end
+
+      ##
+      # Return the Vocabulary term associated with a  URI
+      #
+      # @param [RDF::URI] uri
+      # @return [Vocabulary::Term]
+      def find_term(uri)
+        uri = RDF::URI(uri)
+        return uri if uri.is_a?(Vocabulary::Term)
+        vocab = RDF::Vocabulary.detect {|v| uri.start_with?(v.to_uri)}
+        term = vocab[uri.to_s[vocab.to_uri.to_s.length..-1]] if vocab
+      end
+
       ##
       # Returns the URI for the term `property` in this vocabulary.
       #
       # @param  [#to_s] property
       # @return [RDF::URI]
       def [](property)
-        RDF::URI.intern([to_s, property.to_s].join(''))
+        if self.respond_to?(property.to_sym)
+          self.send(property.to_sym)
+        else
+          Term.intern([to_s, property.to_s].join(''), attributes: {vocab: self})
+        end
       end
 
       # @return [String] The label for the named property
       def label_for(name)
-        @@labels[self[name]]
+        props.fetch(self[name], {}).fetch(:label, "")
       end
 
       # @return [String] The comment for the named property
       def comment_for(name)
-        @@comments[self[name]]
+        props.fetch(self[name], {}).fetch(:comment, "")
       end
 
       ##
@@ -133,6 +220,65 @@ module RDF
         RDF::URI.intern(to_s)
       end
 
+      # For IRI compatibility
+      alias_method :to_iri, :to_uri
+
+      ##
+      # Return an enumerator over {RDF::Statement} defined for this vocabulary.
+      # @return [RDF::Enumerable::Enumerator]
+      # @see    Object#enum_for
+      def enum_for(method = :each_statement, *args)
+        # Ensure that enumerators are, themselves, queryable
+        this = self
+        Enumerable::Enumerator.new do |yielder|
+          this.send(method, *args) {|*y| yielder << (y.length > 1 ? y : y.first)}
+        end
+      end
+      alias_method :to_enum, :enum_for
+
+      ##
+      # Enumerate each statement constructed from the defined vocabulary terms
+      #
+      # If a property value is known to be a {URI}, or expands to a {URI}, the `object` is a URI, otherwise, it will be a {Literal}.
+      #
+      # @yield statement
+      # @yieldparam [RDF::Statement]
+      def each_statement(&block)
+        props.each do |subject, attributes|
+          attributes.each do |prop, values|
+            prop = RDF::Vocabulary.expand_pname(prop) unless prop.is_a?(Symbol)
+            next unless prop
+            Array(values).each do |value|
+              case prop
+              when :type
+                prop = RDF.type
+                value = expand_pname(value)
+              when :subClassOf
+                prop = RDFS.subClassOf
+                value = expand_pname(value)
+              when :subPropertyOf
+                prop = RDFS.subPropertyOf
+                value = expand_pname(value)
+              when :domain
+                prop = RDFS.domain
+                value = expand_pname(value)
+              when :range
+                prop = RDFS.range
+                value = expand_pname(value)
+              when :label
+                prop = RDFS.label
+              when :comment
+                prop = RDFS.comment
+              else
+                value = RDF::Vocabulary.expand_pname(value)
+              end
+
+              block.call RDF::Statement(subject, prop, value)
+            end
+          end
+        end
+      end
+
       ##
       # Returns a string representation of this vocabulary class.
       #
@@ -141,6 +287,71 @@ module RDF
         @@uris.has_key?(self) ? @@uris[self].to_s : super
       end
 
+      ##
+      # Load a vocabulary, optionally from a separate location.
+      #
+      # @param [URI, #to_s] uri
+      # @param [Hash{Symbol => Object}] options
+      # @option options [String] class_name
+      #   The class_name associated with the vocabulary, used for creating the class name of the vocabulary. This will create a new class named with a top-level constant based on `class_name`.
+      # @option options [URI, #to_s] :location
+      #   Location from which to load the vocabulary, if not from `uri`.
+      # @option options [Array<Symbol>, Hash{Symbol => Hash}] :extra
+      #   Extra terms to add to the vocabulary. In the first form, it is an array of symbols, for which terms are created. In the second, it is a Hash mapping symbols to property attributes, as described in {#property}.
+      # @return [RDF::Vocabulary] the loaded vocabulary
+      def load(uri, options = {})
+        source = options.fetch(:location, uri)
+        class_name = options[:class_name]
+        vocab = if class_name
+          Object.const_set(class_name, Class.new(self.create(uri)))
+        else
+          Class.new(self.create(uri))
+        end
+
+        graph = RDF::Graph.load(source)
+        term_defs = {}
+        graph.each do |statement|
+          next unless statement.subject.uri? && statement.subject.start_with?(uri)
+          name = statement.subject.to_s[uri.to_s.length..-1] 
+          term = (term_defs[name.to_sym] ||= {})
+          key = case statement.predicate
+          when RDF.type                then :type
+          when RDF::RDFS.subClassOf    then :subClassOf
+          when RDF::RDFS.subPropertyOf then :subPropertyOf
+          when RDF::RDFS.range         then :range
+          when RDF::RDFS.domain        then :domain
+          when RDF::RDFS.comment       then :comment
+          when RDF::RDFS.label         then :label
+          else                         statement.predicate.pname
+          end
+
+          value = if statement.object.uri?
+            statement.object.pname
+          elsif statement.object.literal? && (statement.object.language || :en) == :en
+            statement.object.to_s
+          end
+
+          (term[key] ||= []) << value if value
+        end
+
+        # Create extra terms
+        term_defs = case options[:extra]
+        when Array
+          options[:extra].inject({}) {|memo, s| memo[s.to_sym] = {label: s.to_s}; memo}.merge(term_defs)
+        when Hash
+          options[:extra].merge(term_defs)
+        else
+          term_defs
+        end
+
+        # Create each term
+        term_defs.each do |term, attributes|
+          vocab.term term, attributes
+        end
+
+        vocab
+      end
+
       ##
       # Returns a developer-friendly representation of this vocabulary class.
       #
@@ -156,15 +367,39 @@ module RDF
       # Preserve the class name so that it can be obtained even for
       # vocabularies that define a `name` property:
       alias_method :__name__, :name
-    end
 
-    ##
-    # Returns a suggested CURIE/QName prefix for this vocabulary class.
-    #
-    # @return [Symbol]
-    # @since  0.3.0
-    def self.__prefix__
-      self.__name__.split('::').last.downcase.to_sym
+      ##
+      # Returns a suggested CURIE/PName prefix for this vocabulary class.
+      #
+      # @return [Symbol]
+      # @since  0.3.0
+      def __prefix__
+        __name__.split('::').last.downcase.to_sym
+      end
+
+    protected
+      def inherited(subclass) # @private
+        unless @@uri.nil?
+          @@subclasses << subclass unless %w(http://www.w3.org/1999/02/22-rdf-syntax-ns#).include?(@@uri)
+          subclass.send(:private_class_method, :new)
+          @@uris[subclass] = @@uri
+          @@uri = nil
+        end
+        super
+      end
+
+      def method_missing(property, *args, &block)
+        if %w(to_ary).include?(property.to_s)
+          super
+        elsif args.empty? && !to_s.empty?
+          Term.intern([to_s, property.to_s].join(''), attributes: {vocab: self})
+        else
+          super
+        end
+      end
+
+    private
+      def props; @properties ||= {}; end
     end
 
     # Undefine all superfluous instance methods:
@@ -189,7 +424,7 @@ module RDF
     # @param  [#to_s] property
     # @return [URI]
     def [](property)
-      RDF::URI.intern([to_s, property.to_s].join(''))
+      Term.intern([to_s, property.to_s].join(''), attributes: {vocab: self.class})
     end
 
     ##
@@ -200,6 +435,9 @@ module RDF
       RDF::URI.intern(to_s)
     end
 
+    # For IRI compatibility
+    alias_method :to_iri, :to_uri
+
     ##
     # Returns a string representation of this vocabulary.
     #
@@ -223,29 +461,13 @@ module RDF
       self
     end
 
-    def self.inherited(subclass) # @private
-      @@subclasses << subclass
-      unless @@uri.nil?
-        subclass.send(:private_class_method, :new)
-        @@uris[subclass] = @@uri
-        @@uri = nil
-      end
-      super
-    end
-
-    def self.method_missing(property, *args, &block)
-      if args.empty? && @@uris.has_key?(self)
-        self[property]
-      else
-        super
-      end
-    end
-
     def method_missing(property, *args, &block)
-      if args.empty?
+      if %w(to_ary).include?(property.to_s)
+        super
+      elsif args.empty?
         self[property]
       else
-        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)")
+        super
       end
     end
 
@@ -254,73 +476,151 @@ module RDF
     @@subclasses = [::RDF] # @private
     @@uris       = {}      # @private
     @@uri        = nil     # @private
-    @@labels     = {}
-    @@comments   = {}
-  end # Vocabulary
 
-  # Represents an RDF Vocabulary. The difference from {RDF::Vocabulary} is that
-  # that every concept in the vocabulary is required to be declared. To assist
-  # in this, an existing RDF representation of the vocabulary can be loaded as
-  # the basis for concepts being available
-  class StrictVocabulary < Vocabulary
-    class << self
-      begin
-        # Redefines method_missing to the original definition
-        # By remaining a subclass of Vocabulary, we remain available to
-        # Vocabulary::each etc.
-        define_method(:method_missing, BasicObject.instance_method(:method_missing))
-      rescue NameError
-        define_method(:method_missing, Kernel.instance_method(:method_missing))
+    # A Vocabulary Term is a URI that can also act as an {Enumerable} to generate the RDF definition of vocabulary terms as defined within the vocabulary definition.
+    class Term < RDF::URI
+      # 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_accessor :attributes
+
+      ##
+      # @overload URI(uri, options = {})
+      #   @param  [URI, String, #to_s]    uri
+      #   @param  [Hash{Symbol => Object}] options
+      #   @option options [Boolean] :validate (false)
+      #   @option options [Boolean] :canonicalize (false)
+      #   @option options [Hash{Symbol,Resource => Term, #to_s}] :attributes
+      #     Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF
+      #
+      # @overload URI(options = {})
+      #   @param  [Hash{Symbol => Object}] options
+      #   @option options [Boolean] :validate (false)
+      #   @option options [Boolean] :canonicalize (false)
+      #   @option [Vocabulary] :vocab The {Vocabulary} associated with this term.
+      #   @option [String, #to_s] :scheme The scheme component.
+      #   @option [String, #to_s] :user The user component.
+      #   @option [String, #to_s] :password The password component.
+      #   @option [String, #to_s] :userinfo
+      #     The userinfo component. If this is supplied, the user and password
+      #     components must be omitted.
+      #   @option [String, #to_s] :host The host component.
+      #   @option [String, #to_s] :port The port component.
+      #   @option [String, #to_s] :authority
+      #     The authority component. If this is supplied, the user, password,
+      #     userinfo, host, and port components must be omitted.
+      #   @option [String, #to_s] :path The path component.
+      #   @option [String, #to_s] :query The query component.
+      #   @option [String, #to_s] :fragment The fragment component.
+      #   @option options [Hash{Symbol,Resource => Term, #to_s}] :attributes
+      #     Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        @attributes = options.fetch(:attributes)
+        super
       end
 
       ##
-      # @overload property
-      #   Returns `property` in the current vocabulary
-      #   @return [RDF::URI]
+      # Vocabulary of this term.
       #
-      # @overload property(name, options)
-      #   Defines a new property or class in the vocabulary.
-      #   Optional labels and comments are stripped of unnecessary whitespace.
+      # @return [RDF::Vocabulary]
+      def vocab; @attributes.fetch(:vocab); end
+
+      ##
+      # Returns a duplicate copy of `self`.
       #
-      #   @param [String, #to_s] name
-      #   @param [Hash{Symbol => Object}] options
-      #   @option options [String, #to_s] :label
-      #   @option options [String, #to_s] :comment
-      def property(*args)
-        case args.length
-        when 0
-          RDF::URI.intern("#{self}property")
-        else
-          name, options = args
-          options ||= {}
-          prop = RDF::URI.intern([to_s, name.to_s].join(''))
-          @@properties[prop] = true
-          @@labels[prop] = options[:label].to_s.strip.gsub(/\s+/m, ' ') if options[:label]
-          @@comments[prop] = options[:comment].to_s.strip.gsub(/\s+/m, ' ') if options[:comment]
-          (class << self; self; end).send(:define_method, name) { prop } unless name.to_s == "property"
-        end
+      # @return [RDF::URI]
+      def dup
+        self.class.new((@value || @object).dup, attributes: @attributes)
       end
 
       ##
-      #  @return [Array<RDF::URI>] a list of properties in the current vocabulary
-      def properties
-        @@properties.keys
+      # Determine if the URI is a valid according to RFC3987
+      #
+      # @return [Boolean] `true` or `false`
+      # @since 0.3.9
+      def valid?
+        # Validate relative to RFC3987
+        to_s.match(RDF::URI::IRI) || false
       end
 
-      def [](name)
-        prop = RDF::URI.intern([to_s, name.to_s].join(''))
-        @@properties.fetch(prop) #raises KeyError on missing value
-        return prop
+      ##
+      # Is this a class term?
+      # @return [Boolean]
+      def class?
+        !!(self.type.to_s =~ /Class/)
+      end
+
+      ##
+      # Is this a class term?
+      # @return [Boolean]
+      def property?
+        !!(self.type.to_s =~ /Property/)
+      end
+
+      ##
+      # Is this a class term?
+      # @return [Boolean]
+      def datatype?
+        !!(self.type.to_s =~ /Datatype/)
+      end
+
+      ##
+      # Is this neither a class, property or datatype term?
+      # @return [Boolean]
+      def other?
+        !!(self.type.to_s !~ /(Class|Property|Datatype)/)
+      end
+
+      ##
+      # Returns a <code>String</code> representation of the URI object's state.
+      #
+      # @return [String] The URI object's state, as a <code>String</code>.
+      def inspect
+        sprintf("#<%s:%#0x URI:%s>", Term.to_s, self.object_id, self.to_s)
+      end
+
+      # Implement accessor to symbol attributes
+      def respond_to?(method)
+        @attributes.has_key?(method) || super
+      end
+
+    protected
+      # Implement accessor to symbol attributes
+      def method_missing(method, *args, &block)
+        case method
+        when :comment
+          @attributes.fetch(method, "")
+        when :label
+          @attributes.fetch(method, to_s.split(/[\/\#]/).last)
+        when :type, :subClassOf, :subPropertyOf, :domain, :range
+          Array(@attributes[method]).map {|v| RDF::Vocabulary.expand_pname(v)}
+        else
+          super
+        end
       end
     end
+  end # Vocabulary
 
-    begin
+  # Represents an RDF Vocabulary. The difference from {RDF::Vocabulary} is that
+  # that every concept in the vocabulary is required to be declared. To assist
+  # in this, an existing RDF representation of the vocabulary can be loaded as
+  # the basis for concepts being available
+  class StrictVocabulary < Vocabulary
+    class << self
+      # Redefines method_missing to the original definition
+      # By remaining a subclass of Vocabulary, we remain available to
+      # Vocabulary::each etc.
       define_method(:method_missing, BasicObject.instance_method(:method_missing))
-    rescue NameError
-      define_method(:method_missing, Kernel.instance_method(:method_missing))
-    end
 
-    private
-    @@properties = {}
+      ##
+      # Is this a strict vocabulary, or a liberal vocabulary allowing arbitrary properties?
+      def strict?; true; end
+
+      def [](name)
+        prop = super
+        props.fetch(prop) #raises KeyError on missing value
+        return prop
+      end
+    end
   end # StrictVocabulary
 end # RDF