More corner-cases on Term propertie and some documentation.

gkellogg · gkellogg · commit 0b9904fdd6bf · 2021-02-14T14:09:48.000-08:00
diff --git a/lib/rdf/vocab/xsd.rb b/lib/rdf/vocab/xsd.rb
@@ -47,7 +47,7 @@ module RDF
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :Name
   #
-  #     #      QName represents XML qualified names. The ·value space· of QName is the set     of tuples {namespace name, local part}, where namespace name is an anyURI     and local part is an NCName. The ·lexical space· of QName is the set of     strings that ·match· the QName production of [Namespaces in XML].   
+  #     #      QName represents XML qualified names. The ·value space· of QName is the set     of tuples `{namespace name, local part}`, where namespace name is an anyURI     and local part is an NCName. The ·lexical space· of QName is the set of     strings that ·match· the QName production of [Namespaces in XML].   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :QName
   #
@@ -139,35 +139,35 @@ module RDF
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :int
   #
-  #     #       integer is ·derived· from decimal by fixing the value of ·fractionDigits·      to be 0 and disallowing the trailing decimal point. This results in the      standard mathematical concept of the integer numbers. The ·value space· of      integer is the infinite set {...,-2,-1,0,1,2,...}. The ·base type· of      integer is decimal.   
+  #     #       integer is ·derived· from decimal by fixing the value of ·fractionDigits·      to be 0 and disallowing the trailing decimal point. This results in the      standard mathematical concept of the integer numbers. The ·value space· of      integer is the infinite set `{...,-2,-1,0,1,2,...}`. The ·base type· of      integer is decimal.   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :integer
   #
-  #     #      language represents formal natural language identifiers, as defined by [BCP     47] (currently represented by [RFC 4646] and [RFC 4647]) or its     successor(s). The ·value space· and ·lexical space· of language are the set     of all strings that conform to the pattern [a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*   
+  #     #      language represents formal natural language identifiers, as defined by [BCP     47] (currently represented by [RFC 4646] and [RFC 4647]) or its     successor(s). The ·value space· and ·lexical space· of language are the set     of all strings that conform to the pattern `[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*`   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :language
   #
   #     #       long is ·derived· from integer by setting the value of ·maxInclusive· to      be 9223372036854775807 and ·minInclusive· to be -9223372036854775808. The      ·base type· of long is integer.   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :long
   #
-  #     #       negativeInteger is ·derived· from nonPositiveInteger by setting the value      of ·maxInclusive· to be -1. This results in the standard mathematical      concept of the negative integers. The ·value space· of negativeInteger is      the infinite set {...,-2,-1}. The ·base type· of negativeInteger is      nonPositiveInteger.   
+  #     #       negativeInteger is ·derived· from nonPositiveInteger by setting the value      of ·maxInclusive· to be -1. This results in the standard mathematical      concept of the negative integers. The ·value space· of negativeInteger is      the infinite set `{...,-2,-1}`. The ·base type· of negativeInteger is      nonPositiveInteger.   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :negativeInteger
   #
-  #     #       nonNegativeInteger is ·derived· from integer by setting the value of      ·minInclusive· to be 0. This results in the standard mathematical concept      of the non-negative integers. The ·value space· of nonNegativeInteger is      the infinite set {0,1,2,...}. The ·base type· of nonNegativeInteger is      integer.   
+  #     #       nonNegativeInteger is ·derived· from integer by setting the value of      ·minInclusive· to be 0. This results in the standard mathematical concept      of the non-negative integers. The ·value space· of nonNegativeInteger is      the infinite set `{0,1,2,...}`. The ·base type· of nonNegativeInteger is      integer.   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :nonNegativeInteger
   #
-  #     #      nonPositiveInteger is ·derived· from integer by setting the value of     ·maxInclusive· to be 0. This results in the standard mathematical concept     of the non-positive integers. The ·value space· of nonPositiveInteger is     the infinite set {...,-2,-1,0}. The ·base type· of nonPositiveInteger is     integer.   
+  #     #      nonPositiveInteger is ·derived· from integer by setting the value of     ·maxInclusive· to be 0. This results in the standard mathematical concept     of the non-positive integers. The ·value space· of nonPositiveInteger is     the infinite set `{...,-2,-1,0}`. The ·base type· of nonPositiveInteger is     integer.   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :nonPositiveInteger
   #
   #     #      normalizedString represents white space normalized strings. The ·value     space· of normalizedString is the set of strings that do not contain the     carriage return (#xD), line feed (#xA) nor tab (#x9) characters. The     ·lexical space· of normalizedString is the set of strings that do not     contain the carriage return (#xD), line feed (#xA) nor tab (#x9)     characters. The ·base type· of normalizedString is string.   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :normalizedString
   #
-  #     #       positiveInteger is ·derived· from nonNegativeInteger by setting the value      of ·minInclusive· to be 1. This results in the standard mathematical      concept of the positive integer numbers. The ·value space· of      positiveInteger is the infinite set {1,2,...}. The ·base type· of      positiveInteger is nonNegativeInteger.   
+  #     #       positiveInteger is ·derived· from nonNegativeInteger by setting the value      of ·minInclusive· to be 1. This results in the standard mathematical      concept of the positive integer numbers. The ·value space· of      positiveInteger is the infinite set `{1,2,...}`. The ·base type· of      positiveInteger is nonNegativeInteger.   
   #     # @return [RDF::Vocabulary::Term]
   #     attr_reader :positiveInteger
   #
diff --git a/lib/rdf/vocabulary.rb b/lib/rdf/vocabulary.rb
@@ -766,7 +766,9 @@ def self.camelize(str)
 
     # A Vocabulary Term is a {RDF::Resource} that can also act as an {Enumerable} to generate the RDF definition of vocabulary terms as defined within the vocabulary definition.
     #
-    # Terms include `attributes` where values a embedded resources, lists or other terms. This allows, for example, navigation of a concept heirarchy.
+    # Terms include {Term#attributes} where values a embedded resources, lists or other terms. This allows, for example, navigation of a concept heirarchy.
+    #
+    # Term attributes can also be accessed using {Term#properties} where the attribute values are transformed into different types of {RDF::Value}. Properties can be indexed by key, where a key is defined (See {Term::ATTR_URIs}), absolute URI, or PName, where the prefix is associated with a loaded vocabulary.
     module Term
       include RDF::Resource
 
@@ -1049,31 +1051,47 @@ def other?
       # Enumerate attributes with values transformed into {RDF::Value} instances
       # Uses an empty hash with a default_proc which looks up values in attributes.
       #
-      # Properties are indexed by symbol. Symbols directly interpreted by a term are the accessors defined for the {RDF::Vocabulary::Term} class. Other keys are interpreted as absolute URIs or PNames for properties defined on this term.
+      # 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.
       #
       # 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.label #=> RDF::Literal("Literal")
+      #   RDF::RDFS.Literal.properties[:label] #=> RDF::Literal("Literal")
+      #   RDF::RDFS.Literal.properties[:"rdfs:label"] #=> RDF::Literal("Literal")
+      #   RDF::RDFS.Literal.properties[RDF::RDFS.label] #=> RDF::Literal("Literal")
+      #   RDF::RDFS.Literal.properties["http://www.w3.org/2000/01/rdf-schema#label"] #=> RDF::Literal("Literal")
+      #   RDF::RDFS.Literal.properties[:"http://www.w3.org/2000/01/rdf-schema#label"] #=> RDF::Literal("Literal")
+      #
       # @return [Hash{Symbol => Array<RDF::Value>}]
       def properties
         Hash.new do |hash, key|
           case key
-          when RDF::URI, String then attribute_value(key.to_s.to_sym)
+          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?:/
-              # FIXME: transitional code to look for pname attributes first
               if attributes.key?(key)
                 key
-              elsif URI_ATTRs.key?(key)
-                URI_ATTRs[key]
               else
-                RDF::URI(key).pname.to_sym
+                # Lookup by associated attribute, or pname
+                URI_ATTRs.fetch(RDF::URI(key.to_s), RDF::URI(key).pname.to_sym)
               end
             when /:/
-              # FIXME: transitional code to look for pname attributes first
-              attributes.key?(key) ? key : RDF::Vocabulary.expand_pname(key).to_s.to_sym
+              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
diff --git a/spec/vocabulary_spec.rb b/spec/vocabulary_spec.rb
@@ -584,6 +584,28 @@
       its(:vocab) {is_expected.to eql RDF::RDFS}
     end
 
+    context RDF::RDFS.Literal do
+      subject {RDF::RDFS.Literal}
+      specify {is_expected.not_to be_property}
+      specify {is_expected.to be_class}
+
+      its(:label) {is_expected.to eq RDF::Literal("Literal")}
+
+      describe "#properties" 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.properties[key]).to eq RDF::Literal("Literal")
+          end
+        end
+      end
+    end
+
     context RDF::RDFS.Class do
       subject {RDF::RDFS.Class}
       specify {is_expected.to respond_to(:vocab)}

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ module RDF`
`47`	`47`	`# # @return [RDF::Vocabulary::Term]`
`48`	`48`	`# attr_reader :Name`
`49`	`49`	`#`
`50`		`- # # QName represents XML qualified names. The ·value space· of QName is the set of tuples {namespace name, local part}, where namespace name is an anyURI and local part is an NCName. The ·lexical space· of QName is the set of strings that ·match· the QName production of [Namespaces in XML].`
	`50`	+ # # QName represents XML qualified names. The ·value space· of QName is the set of tuples `{namespace name, local part}`, where namespace name is an anyURI and local part is an NCName. The ·lexical space· of QName is the set of strings that ·match· the QName production of [Namespaces in XML].
`51`	`51`	`# # @return [RDF::Vocabulary::Term]`
`52`	`52`	`# attr_reader :QName`
`53`	`53`	`#`
`@@ -139,35 +139,35 @@ module RDF`
`139`	`139`	`# # @return [RDF::Vocabulary::Term]`
`140`	`140`	`# attr_reader :int`
`141`	`141`	`#`
`142`		`- # # integer is ·derived· from decimal by fixing the value of ·fractionDigits· to be 0 and disallowing the trailing decimal point. This results in the standard mathematical concept of the integer numbers. The ·value space· of integer is the infinite set {...,-2,-1,0,1,2,...}. The ·base type· of integer is decimal.`
	`142`	+ # # integer is ·derived· from decimal by fixing the value of ·fractionDigits· to be 0 and disallowing the trailing decimal point. This results in the standard mathematical concept of the integer numbers. The ·value space· of integer is the infinite set `{...,-2,-1,0,1,2,...}`. The ·base type· of integer is decimal.
`143`	`143`	`# # @return [RDF::Vocabulary::Term]`
`144`	`144`	`# attr_reader :integer`
`145`	`145`	`#`
`146`		`- # # language represents formal natural language identifiers, as defined by [BCP 47] (currently represented by [RFC 4646] and [RFC 4647]) or its successor(s). The ·value space· and ·lexical space· of language are the set of all strings that conform to the pattern [a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*`
	`146`	+ # # language represents formal natural language identifiers, as defined by [BCP 47] (currently represented by [RFC 4646] and [RFC 4647]) or its successor(s). The ·value space· and ·lexical space· of language are the set of all strings that conform to the pattern `[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*`
`147`	`147`	`# # @return [RDF::Vocabulary::Term]`
`148`	`148`	`# attr_reader :language`
`149`	`149`	`#`
`150`	`150`	`# # long is ·derived· from integer by setting the value of ·maxInclusive· to be 9223372036854775807 and ·minInclusive· to be -9223372036854775808. The ·base type· of long is integer.`
`151`	`151`	`# # @return [RDF::Vocabulary::Term]`
`152`	`152`	`# attr_reader :long`
`153`	`153`	`#`
`154`		`- # # negativeInteger is ·derived· from nonPositiveInteger by setting the value of ·maxInclusive· to be -1. This results in the standard mathematical concept of the negative integers. The ·value space· of negativeInteger is the infinite set {...,-2,-1}. The ·base type· of negativeInteger is nonPositiveInteger.`
	`154`	+ # # negativeInteger is ·derived· from nonPositiveInteger by setting the value of ·maxInclusive· to be -1. This results in the standard mathematical concept of the negative integers. The ·value space· of negativeInteger is the infinite set `{...,-2,-1}`. The ·base type· of negativeInteger is nonPositiveInteger.
`155`	`155`	`# # @return [RDF::Vocabulary::Term]`
`156`	`156`	`# attr_reader :negativeInteger`
`157`	`157`	`#`
`158`		`- # # nonNegativeInteger is ·derived· from integer by setting the value of ·minInclusive· to be 0. This results in the standard mathematical concept of the non-negative integers. The ·value space· of nonNegativeInteger is the infinite set {0,1,2,...}. The ·base type· of nonNegativeInteger is integer.`
	`158`	+ # # nonNegativeInteger is ·derived· from integer by setting the value of ·minInclusive· to be 0. This results in the standard mathematical concept of the non-negative integers. The ·value space· of nonNegativeInteger is the infinite set `{0,1,2,...}`. The ·base type· of nonNegativeInteger is integer.
`159`	`159`	`# # @return [RDF::Vocabulary::Term]`
`160`	`160`	`# attr_reader :nonNegativeInteger`
`161`	`161`	`#`
`162`		`- # # nonPositiveInteger is ·derived· from integer by setting the value of ·maxInclusive· to be 0. This results in the standard mathematical concept of the non-positive integers. The ·value space· of nonPositiveInteger is the infinite set {...,-2,-1,0}. The ·base type· of nonPositiveInteger is integer.`
	`162`	+ # # nonPositiveInteger is ·derived· from integer by setting the value of ·maxInclusive· to be 0. This results in the standard mathematical concept of the non-positive integers. The ·value space· of nonPositiveInteger is the infinite set `{...,-2,-1,0}`. The ·base type· of nonPositiveInteger is integer.
`163`	`163`	`# # @return [RDF::Vocabulary::Term]`
`164`	`164`	`# attr_reader :nonPositiveInteger`
`165`	`165`	`#`
`166`	`166`	`# # normalizedString represents white space normalized strings. The ·value space· of normalizedString is the set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters. The ·lexical space· of normalizedString is the set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters. The ·base type· of normalizedString is string.`
`167`	`167`	`# # @return [RDF::Vocabulary::Term]`
`168`	`168`	`# attr_reader :normalizedString`
`169`	`169`	`#`
`170`		`- # # positiveInteger is ·derived· from nonNegativeInteger by setting the value of ·minInclusive· to be 1. This results in the standard mathematical concept of the positive integer numbers. The ·value space· of positiveInteger is the infinite set {1,2,...}. The ·base type· of positiveInteger is nonNegativeInteger.`
	`170`	+ # # positiveInteger is ·derived· from nonNegativeInteger by setting the value of ·minInclusive· to be 1. This results in the standard mathematical concept of the positive integer numbers. The ·value space· of positiveInteger is the infinite set `{1,2,...}`. The ·base type· of positiveInteger is nonNegativeInteger.
`171`	`171`	`# # @return [RDF::Vocabulary::Term]`
`172`	`172`	`# attr_reader :positiveInteger`
`173`	`173`	`#`