Update Term#attributes to take over changes to Term#properties, which allows equivalent hash access for both.

Author: gkellogg

lib/rdf/vocab/writer.rb

@@ -169,16 +169,17 @@ module #{module_name}
           ).each do |attr|
             next unless vocab.ontology.attributes[attr]
             Array(vocab.ontology.attributes[attr]).each do |v|
-              ont_doc << "  #   # " + v.to_s.gsub(/\n/, ' ')
+              ont_doc << "  #   # " + v.to_s.gsub(/\s+/, ' ')
             end
           end
           @output.puts ont_doc.join("\n  #   #\n") unless ont_doc.empty?
           # Version Info
-          Array(vocab.ontology.attributes[:"owl:versionInfo"]).each do |vers|
+          # See Also
+          Array(vocab.ontology.attributes[:'http://www.w3.org/2002/07/owl#versionInfo']).each do |vers|
             @output.puts "  #   # @version #{vers}"
           end
           # See Also
-          Array(vocab.ontology.attributes[:"rdfs:seeAlso"]).each do |see|
+          Array(vocab.ontology.attributes[:'http://www.w3.org/2000/01/rdf-schema#seeAlso']).each do |see|
             @output.puts "  #   # @see #{see}"
           end
         end
@@ -222,7 +223,7 @@ module #{module_name}
             # Only document terms that can be accessed like a Ruby attribute
             next unless name.to_s.match?(/^[_[:alpha:]](?:\w*)[!?=]?$/)
             @output.puts(Array(attributes[:comment]).map do |comment|
-              "  #     # #{comment.to_s.gsub(/\n/, ' ')}"
+              "  #     # #{comment.to_s.gsub(/\s+/, ' ')}"
             end.join("\n  #     #\n")) if attributes[:comment]
             @output.puts "  #     # @return [RDF::Vocabulary::Term]"
             @output.puts "  #     attr_reader :#{name}"

lib/rdf/vocabulary.rb

@@ -297,7 +297,7 @@ def property(*args)
             #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)
+            prop = Term.intern(uri_str, vocab: self, attributes: options || {})
             props[name.to_sym] = prop
 
             # If name is empty, also treat it as the ontology
@@ -361,7 +361,7 @@ def ontology(*args)
           uri, options = args
           URI.cache.delete(uri.to_s.to_sym)  # Clear any previous entry
           # Term attributes passed in a block for lazy evaluation. This helps to avoid load-time circular dependencies
-          @ontology = Term.intern(uri.to_s, vocab: self, attributes: options)
+          @ontology = Term.intern(uri.to_s, vocab: self, attributes: options || {})
 
           # If the URI is the same as the vocabulary namespace, also define it as a term
           props[:""] ||= @ontology if self.to_s == uri.to_s
@@ -932,23 +932,36 @@ module Term
       attr_reader :vocab
 
       # Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF.
+      #
+      # Attributes 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.
+      #
+      # Symbols which are accessors may also be looked up by their associated URI.
+      #
+      # @note lookup by PName is DEPRECATED and will be removed in a future version.
+      #
+      # @example looking up term label
+      #   RDF::RDFS.Literal.attributes[:label] #=> "Literal"
+      #   RDF::RDFS.Literal.attributes[:"rdfs:label"] #=> "Literal"
+      #   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}]
       attr_reader :attributes
 
       ##
       # @overload new(uri, attributes:, **options)
       #   @param  [URI, String, #to_s]    uri
       #   @param [Vocabulary] vocab Vocabulary of this term.
-      #   @param [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
+      #   @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 => Object}] options
       #     Options from {URI#initialize}
       #
       # @overload new(attributes:, **options)
       #   @param  [Hash{Symbol => Object}] options
       #   @param [Vocabulary] vocab Vocabulary of this term.
-      #   @param [Hash{Symbol => String,Array<String,Term>}] attributes
-      #     Attributes of this vocabulary term, used for finding `label` and `comment` and to serialize the term back to RDF.
+      #   @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 => Object}] options
       #     Options from {URI#initialize}
       def self.new(*args, vocab: nil, attributes: {}, **options)
@@ -963,6 +976,28 @@ def self.new(*args, vocab: nil, attributes: {}, **options)
         else RDF::URI
         end
 
+        # Create default proc on attributes to allow lookup by different key types.
+        attributes = attributes.dup if attributes.frozen?
+        attributes.default_proc = -> (hash, key) do
+          sym = case key
+          when RDF::URI
+            URI_ATTRs.fetch(key, key.to_s.to_sym)
+          when String
+            URI_ATTRs.fetch(RDF::URI(key), key.to_s.to_sym)
+          when Symbol
+            case key.to_s
+            when /^https?:/
+              # Lookup by associated attribute, or pname
+              URI_ATTRs.fetch(RDF::URI(key.to_s), RDF::URI(key).pname.to_sym)
+            when /:/
+              uri = RDF::Vocabulary.expand_pname(key)
+              # Lookup by associated attribute or URI
+              URI_ATTRs.fetch(uri, uri.to_s.to_sym)
+            end
+          end
+          hash.fetch(sym, nil)
+        end
+
         term = klass.allocate.extend(Term)
         term.send(:initialize, *args)
         term.instance_variable_set(:@vocab, vocab)
@@ -1067,38 +1102,7 @@ def other?
       #
       # @return [Hash{Symbol => Array<RDF::Value>}]
       def properties
-        Hash.new do |hash, key|
-          case key
-          when RDF::URI
-            sym = URI_ATTRs.fetch(key, key.to_s.to_sym)
-            attribute_value(sym)
-          when String
-            sym = URI_ATTRs.fetch(RDF::URI(key), key.to_s.to_sym)
-            attribute_value(sym)
-          when Symbol
-            sym = case key.to_s
-            when /^https?:/
-              if attributes.key?(key)
-                key
-              else
-                # Lookup by associated attribute, or pname
-                URI_ATTRs.fetch(RDF::URI(key.to_s), RDF::URI(key).pname.to_sym)
-              end
-            when /:/
-              if attributes.key?(key)
-                key
-              else
-                uri = RDF::Vocabulary.expand_pname(key)
-                # Lookup by associated attribute or URI
-                URI_ATTRs.fetch(uri, uri.to_s.to_sym)
-              end
-            else
-              key
-            end
-            attribute_value(sym)
-          else nil
-          end
-        end
+        Hash.new {|hash, key| attribute_value(key)}
       end
 
       ##

spec/vocabulary_spec.rb

@@ -591,6 +591,21 @@
 
       its(:label) {is_expected.to eq RDF::Literal("Literal")}
 
+      describe "#attributes" do
+        [
+          :label,
+          :'rdfs:label',
+          "http://www.w3.org/2000/01/rdf-schema#label",
+          :"http://www.w3.org/2000/01/rdf-schema#label",
+          RDF::RDFS.label,
+        ].each do |key|
+          it key.inspect do
+            expect(subject.attributes[key]).to be_a String
+            expect(subject.attributes[key]).to eql "Literal"
+          end
+        end
+      end
+
       describe "#properties" do
         [
           :label,