rdf-microdata 1.1.2 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6e7808ba9a859c54b20c2d1afab262c8a72f392
-  data.tar.gz: d8444062fdb0099f152d89285dfe568aae19cb48
+  metadata.gz: d7797313b5b2b13d2c97e2ca613839ca72525064
+  data.tar.gz: 6b955e34556a727e14b88a9b776b10b0d14f2f29
 SHA512:
-  metadata.gz: 79400d78724736c4e8a147f7ecb042f1df956b8ace50157baab1be14a9531aa6a892546728a8085cc37b4a93e9376fbdfe3da069ecf23fd744bf6d6e9c64b97f
-  data.tar.gz: 2e70ab743786160758ee287450f59e21946131001663577436e38bfc2361ffd9e6146d661c06dbc9e4eeb5da8ff88bcb4339c752c3523930193e892bc39e07ba
+  metadata.gz: 4a68bb3d267426ffaa041f84f5f1b6cf195f15546593701c95c9bcfc672903726c421bed60546d330d80437c23adcd264b1b2c0ac7b27baeb11422744d3c1d3e
+  data.tar.gz: da17e2b59b28bca0ca9c65476ef44486ce81058254655389bea7fa447860ec562100783c81d24b0597487def25443f135e132eb0b0148d6b6db1bd614dfb6f59

data/README

@@ -29,8 +29,14 @@ The parser uses a build-in version of the [Microdata RDF][] registry.
 
 ### Reading RDF data in the Microdata format
 
-    graph = RDF::Graph.load("etc/foaf.html", :format => :microdata)
+    require 'rdf/microdata'
+    graph = RDF::Graph.load("etc/doap.html", :format => :microdata)
 
+### Reading using content-negotation
+
+    require 'rdf/microdata'
+    graph = RDF::Graph.load("etc/doap.html", :content_type => "text/html")
+    
 ## Note
 This spec is based on the W3C HTML Data Task Force specification and does not support
 GRDDL-type triple generation, such as for html>head>title anchor tags.

data/VERSION

@@ -1 +1 @@
-1.1.2
+2.0

data/etc/doap.nt

@@ -16,6 +16,3 @@
 <http://rubygems.org/gems/rdf-microdata> <http://usefulinc.com/ns/doap#homepage> <http://github.com/ruby-rdf/rdf-microdata> .
 <http://rubygems.org/gems/rdf-microdata> <http://usefulinc.com/ns/doap#license> <http://creativecommons.org/licenses/publicdomain/> .
 <http://rubygems.org/gems/rdf-microdata> <http://usefulinc.com/ns/doap#mailing-list> <http://lists.w3.org/Archives/Public/public-rdf-ruby/> .
-_:g2162899420 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://rubygems.org/gems/rdf-microdata> .
-_:g2162899420 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
-<http://example.com> <http://www.w3.org/ns/md#item> _:g2162899420 .

data/etc/registry.json

@@ -1,46 +1,8 @@
 {
   "http://schema.org/": {
-    "propertyURI":    "vocabulary",
-    "multipleValues": "unordered",
     "properties": {
-      "additionalType": {"subPropertyOf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"},
-      "blogPosts": {"multipleValues": "list"},
-      "blogPosts": {"multipleValues": "list"},
-      "breadcrumb": {"multipleValues": "list"},
-      "byArtist": {"multipleValues": "list"},
-      "creator": {"multipleValues": "list"},
-      "episode": {"multipleValues": "list"},
-      "episodes": {"multipleValues": "list"},
-      "event": {"multipleValues": "list"},
-      "events": {"multipleValues": "list"},
-      "founder": {"multipleValues": "list"},
-      "founders": {"multipleValues": "list"},
-      "itemListElement": {"multipleValues": "list"},
-      "musicGroupMember": {"multipleValues": "list"},
-      "performerIn": {"multipleValues": "list"},
-      "actor": {"multipleValues": "list"},
-      "actors": {"multipleValues": "list"},
-      "performer": {"multipleValues": "list"},
-      "performers": {"multipleValues": "list"},
-      "producer": {"multipleValues": "list"},
-      "recipeInstructions": {"multipleValues": "list"},
-      "season": {"multipleValues": "list"},
-      "seasons": {"multipleValues": "list"},
-      "subEvent": {"multipleValues": "list"},
-      "subEvents": {"multipleValues": "list"},
-      "track": {"multipleValues": "list"},
-      "tracks": {"multipleValues": "list"}
+      "additionalType": {"subPropertyOf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}
     }
   },
-  "http://microformats.org/profile/hcard": {
-    "propertyURI":    "vocabulary",
-    "multipleValues": "unordered"
-  },
-  "http://microformats.org/profile/hcalendar#": {
-    "propertyURI":    "vocabulary",
-    "multipleValues": "unordered",
-    "properties": {
-      "categories": {"multipleValues": "list"}
-    }
-  }
+  "http://microformats.org/profile/hcard": {}
 }

data/lib/rdf/microdata/reader.rb

@@ -37,10 +37,12 @@ module RDF::Microdata
 
     # Interface to registry
     class Registry
-      # @!attribute [r] uri
       # @return [RDF::URI] Prefix of vocabulary
       attr_reader :uri
 
+      # @return [Hash] properties
+      attr_reader :properties
+
       ##
       # Initialize the registry from a URI or file path
       #
@@ -53,39 +55,23 @@ module RDF::Microdata
         @prefixes = {}
         json.each do |prefix, elements|
           next unless elements.is_a?(Hash)
-          propertyURI = elements.fetch("propertyURI", "vocabulary").to_sym
-          multipleValues = elements.fetch("multipleValues", "unordered").to_sym
           properties = elements.fetch("properties", {})
-          @prefixes[prefix] = Registry.new(prefix, propertyURI, multipleValues, properties)
+          @prefixes[prefix] = Registry.new(prefix, properties)
         end
         @registry_uri = registry_uri
       end
-      
-      ##
-      # True if registry has already been loaded
-      def self.loaded?
-        @prefixes.is_a?(Hash)
-      end
 
       ##
       # Initialize registry for a particular prefix URI
       #
       # @param [RDF::URI] prefixURI
-      # @param [#to_sym] propertyURI (:vocabulary)
-      # @param [#to_sym] multipleValues (:unordered)
       # @param [Hash] properties ({})
-      def initialize(prefixURI, propertyURI = :vocabulary, multipleValues = :unordered, properties = {})
+      def initialize(prefixURI, properties = {})
         @uri = prefixURI
-        @scheme = propertyURI.to_sym
-        @multipleValues = multipleValues.to_sym
         @properties = properties
-        if @scheme == :vocabulary
-          @property_base = prefixURI.to_s
-          # Append a '#' for fragment if necessary
-          @property_base += '#' unless %w(/ #).include?(@property_base[-1,1])
-        else
-          @property_base = 'http://www.w3.org/ns/md?type='
-        end
+        @property_base = prefixURI.to_s
+        # Append a '#' for fragment if necessary
+        @property_base += '#' unless %w(/ #).include?(@property_base[-1,1])
       end
 
       ##
@@ -94,6 +80,7 @@ module RDF::Microdata
       # @param [RDF::URI] type
       # @return [Registry]
       def self.find(type) 
+        @prefixes ||= {}
         k = @prefixes.keys.detect {|key| type.to_s.index(key) == 0 }
         @prefixes[k] if k
       end
@@ -116,75 +103,34 @@ module RDF::Microdata
           u = RDF::URI(ec[:document_base].to_s)
           u.fragment = frag_escape(name)
           u
-        elsif @scheme == :vocabulary
+        else
           # 4) If scheme is vocabulary return the URI reference constructed by appending the fragment escaped value of name to current vocabulary, separated by a U+0023 NUMBER SIGN character (#) unless the current vocabulary ends with either a U+0023 NUMBER SIGN character (#) or SOLIDUS U+002F (/).
           RDF::URI(@property_base + n)
-        else  # @scheme == :contextual
-          if ec[:current_name].to_s.index(@property_base) == 0
-            # 5.2) return the concatenation of s, a U+002E FULL STOP character (.) and the fragment-escaped value of name.
-            RDF::URI(ec[:current_name] + '.' + n)
-          else
-            # 5.3) return the concatenation of http://www.w3.org/ns/md?type=, the fragment-escaped value of current type, the string &prop=, and the fragment-escaped value of name
-            RDF::URI(@property_base +
-                     frag_escape(ec[:current_type]) +
-                     '&prop=' + n)
-          end
-        end
-      end
-
-      ##
-      # Turn a predicateURI into a simple token
-      # @param [RDF::URI] predicateURI
-      # @return [String]
-      def tokenize(predicateURI)
-        case @scheme
-        when :vocabulary
-          predicateURI.to_s.sub(@property_base, '')
-        when :contextual
-          predicateURI.to_s.split('?prop=').last.split('.').last
         end
       end
 
       ##
-      # Determine if property should be serialized as a list or not
+      # Yield a equivalentProperty or subPropertyOf if appropriate
       #
       # @param [RDF::URI] predicateURI
-      # @return [Boolean]
-      def as_list(predicateURI)
+      # @yield equiv
+      # @yieldparam [RDF::URI] equiv
+      def expand(predicateURI)
         tok = tokenize(predicateURI)
-        if @properties[tok].is_a?(Hash) &&
-           @properties[tok].has_key?("multipleValues")
-          @properties[tok]["multipleValues"].to_sym == :list
-        else
-          @multipleValues == :list
+        if @properties[tok].is_a?(Hash)
+          value = @properties[tok].fetch("subPropertyOf", nil)
+          value ||= @properties[tok].fetch("equivalentProperty", nil)
+
+          Array(value).each {|equiv| yield RDF::URI(equiv)}
         end
       end
 
       ##
-      # Yield a equivalentProperty or subPropertyOf if appropriate
-      #
+      # Turn a predicateURI into a simple token
       # @param [RDF::URI] predicateURI
-      # @yield statement
-      # @yieldparam [RDF::Statement] statement
-      # @return [Boolean]
-      def expand(predicateURI)
-        tok = tokenize(predicateURI)
-        if @properties[tok].is_a?(Hash)
-          if value = @properties[tok]["equivalentProperty"]
-            Array(value).each do |v|
-              yield RDF::Statement.new(predicateURI,
-                                       RDF::OWL.equivalentProperty,
-                                       RDF::URI(v))
-            end
-          elsif value = @properties[tok]["subPropertyOf"]
-            Array(value).each do |v|
-              yield RDF::Statement.new(predicateURI,
-                                       RDF::RDFS.subPropertyOf,
-                                       RDF::URI(v))
-            end
-          end
-          value = @properties[tok]
-        end
+      # @return [String]
+      def tokenize(predicateURI)
+        predicateURI.to_s.sub(@property_base, '')
       end
 
       ##
@@ -211,9 +157,7 @@ module RDF::Microdata
     #   whether to intern all parsed URIs
     # @option options [#to_s]    :base_uri     (nil)
     #   the base URI to use when resolving relative URIs
-    # @option options [#to_s]    :registry_uri (DEFAULT_REGISTRY)
-    # @option options [Boolean]  :vocab_expansion (true)
-    #   whether to perform OWL2 expansion on the resulting graph
+    # @option options [#to_s]    :registry
     # @option options [Array] :debug
     #   Array to place debug messages
     # @return [reader]
@@ -224,7 +168,6 @@ module RDF::Microdata
     def initialize(input = $stdin, options = {}, &block)
       super do
         @debug = options[:debug]
-        @vocab_expansion = options.fetch(:vocab_expansion, true)
 
         @library = :nokogiri
 
@@ -240,12 +183,12 @@ module RDF::Microdata
         errors = doc_errors.reject {|e| e.to_s =~ /Tag (audio|source|track|video|time) invalid/}
         raise RDF::ReaderError, "Syntax errors:\n#{errors}" if !errors.empty? && validate?
 
-        add_debug(@doc, "library = #{@library}, expand = #{@vocab_expansion}")
+        add_debug(@doc, "library = #{@library}")
 
         # Load registry
         begin
-          registry_uri = options[:registry_uri] || DEFAULT_REGISTRY
-          add_debug(@doc, "registry = #{registry_uri}")
+          registry_uri = options.fetch(:registry, DEFAULT_REGISTRY)
+          add_debug(@doc, "registry = #{registry_uri.inspect}")
           Registry.load_registry(registry_uri)
         rescue JSON::ParserError => e
           raise RDF::ReaderError, "Failed to parse registry: #{e.message}"
@@ -270,16 +213,10 @@ module RDF::Microdata
     # @return [void]
     def each_statement(&block)
       if block_given?
-        if @vocab_expansion
-          @vocab_expansion = false
-          expand.each_statement(&block)
-          @vocab_expansion = true
-        else
-          @callback = block
+        @callback = block
 
-          # parse
-          parse_whole_document(@doc, base_uri)
-        end
+        # parse
+        parse_whole_document(@doc, base_uri)
       end
       enum_for(:each_statement)
     end
@@ -365,29 +302,14 @@ module RDF::Microdata
 
       ec = {
         :memory             => {},
-        :current_name       => nil,
         :current_type       => nil,
         :current_vocabulary => nil,
         :document_base      => base,
       }
-      items = []
-      # 1) For each element that is also a top-level item run the following algorithm:
-      #
-      #   1) Generate the triples for an item item, using the evaluation context. Let result be the (URI reference or blank node) subject returned.
-      #   2) Append result to item list.
+      # 1) For each element that is also a top-level item, Generate the triples for that item using the evaluation context.
       getItems.each do |el|
-        result = generate_triples(el, ec)
-        items << result
+        generate_triples(el, ec)
       end
-      
-      # 2) Generate an RDF Collection list from the ordered list of values. Set value to the value returned from generate an RDF Collection.
-      value = generateRDFCollection(root, items)
-
-      # 3) Generate the following triple:
-      #     subject Document base
-      #     predicate http://www.w3.org/1999/xhtml/microdata#item
-      #     object value
-      add_triple(doc, base, RDF::MD.item, value) if value
 
       add_debug(doc, "parse_whole_doc: traversal complete")
     end
@@ -422,146 +344,94 @@ module RDF::Microdata
         type ||= t
         add_triple(item, subject, RDF.type, t)
       end
-      
-      # 5) If type is an absolute URL, set current name in evaluation context to null.
-      ec[:current_name] = nil if type
 
-      # 6) Otherwise, set type to current type from the Evaluation Context if not empty.
+      # 4) Set type to the first value returned from element.itemType of the element defining the item.
+
+      # 5) Otherwise, set type to current type from the Evaluation Context if not empty.
       type ||= ec[:current_type]
-      add_debug(item)  {"gentrips(6): type=#{type.inspect}"}
+      add_debug(item)  {"gentrips(5): type=#{type.inspect}"}
 
-      # 7) If the registry contains a URI prefix that is a character for character match of type up to the length of the URI prefix, set vocab as that URI prefix and generate the following triple (unless it has already been generated):
+      # 6) If the registry contains a URI prefix that is a character for character match of type up to the length of the URI prefix, set vocab as that URI prefix.
       vocab = Registry.find(type)
-      add_debug(item)  {"gentrips(7): vocab=#{vocab.inspect}"}
-      add_triple(item, base_uri, USES_VOCAB, RDF::URI(vocab.uri)) if vocab
 
-      # 8) Otherwise, if type is not empty, construct vocab by removing everything following the last SOLIDUS U+002F ("/") or NUMBER SIGN U+0023 ("#") from the path component of type.
+      # 7) Otherwise, if type is not empty, construct vocab by removing everything following the last SOLIDUS U+002F ("/") or NUMBER SIGN U+0023 ("#") from the path component of type.
       vocab ||= begin
         type_vocab = type.to_s.sub(/([\/\#])[^\/\#]*$/, '\1')
-        add_debug(item)  {"gentrips(8): type_vocab=#{type_vocab.inspect}"}
-        Registry.new(type_vocab) # if type
+        add_debug(item)  {"gentrips(7): type_vocab=#{type_vocab.inspect}"}
+        Registry.new(type_vocab)
       end
 
-      # 9) Update evaluation context setting current vocabulary to vocab.
+      # 8) Update evaluation context setting current vocabulary to vocab.
       ec[:current_vocabulary] = vocab
 
-      # 10) Set property list to an empty mapping between properties and one or more ordered values as established below.
-      property_list = {}
-
-      # 11. For each element _element_ that has one or more property names and is one of the properties of the item _item_, in the order those elements are given by the algorithm that returns the properties of an item, run the following substep:
+      # 9. For each element _element_ that has one or more property names and is one of the properties of the item _item_, run the following substep:
       props = item_properties(item)
-      # 11.1. For each name name in element's property names, run the following substeps:
+      # 9.1. For each name name in element's property names, run the following substeps:
       props.each do |element|
         element.attribute('itemprop').to_s.split(' ').compact.each do |name|
-          add_debug(item) {"gentrips(11.1): name=#{name.inspect}, type=#{type}"}
-          # 11.1.1) Let context be a copy of evaluation context with current type set to type and current vocabulary set to vocab.
+          add_debug(item) {"gentrips(9.1): name=#{name.inspect}, type=#{type}"}
+          # 9.1.1) Let context be a copy of evaluation context with current type set to type and current vocabulary set to vocab.
           ec_new = ec.merge({:current_type => type, :current_vocabulary => vocab})
           
-          # 11.1.2) Let predicate be the result of generate predicate URI using context and name. Update context by setting current name to predicate.
+          # 9.1.2) Let predicate be the result of generate predicate URI using context and name. Update context by setting current name to predicate.
           predicate = vocab.predicateURI(name, ec_new)
-          
-          # (Generate Predicate URI steps 6 and 7)
-          vocab.expand(predicate) do |statement|
-            add_debug(item) {
-              "gentrips(11.1.2): expansion #{statement.inspect}"
-            }
-            @callback.call(statement)
-          end
 
-          ec_new[:current_name] = predicate
-          add_debug(item) {"gentrips(11.1.2): predicate=#{predicate}"}
-          
-          # 11.1.3) Let value be the property value of element.
+          # 9.1.3) Let value be the property value of element.
           value = property_value(element)
-          add_debug(item) {"gentrips(11.1.3) value=#{value.inspect}"}
+          add_debug(item) {"gentrips(9.1.3) value=#{value.inspect}"}
           
-          # 11.1.4) If value is an item, then generate the triples for value context. Replace value by the subject returned from those steps.
+          # 9.1.4) If value is an item, then generate the triples for value context. Replace value by the subject returned from those steps.
           if value.is_a?(Hash)
             value = generate_triples(element, ec_new) 
-            add_debug(item) {"gentrips(11.1.4): value=#{value.inspect}"}
+            add_debug(item) {"gentrips(9.1.4): value=#{value.inspect}"}
           end
 
-          # 11.1.5) Add value to property list for predicate
-          property_list[predicate] ||= []
-          property_list[predicate] << value
+          # 9.1.4) Generate the following triple:
+          add_triple(item, subject, predicate, value)
+
+          # 9.1.5) If an entry exists in the registry for name in the vocabulary associated with vocab having the key subPropertyOf or equivalentProperty
+          vocab.expand(predicate) do |equiv|
+            # for each such value equiv, generate the following triple
+            add_triple(item, subject, equiv, value)
+          end 
         end
       end
 
-      # 11r. For each element _element_ that has one or more property names and is one of the reverse properties of the item _item_, in the order those elements are given by the algorithm that returns the properties of an item, run the following substep:
+      # 10. For each element element that has one or more reverse property names and is one of the reverse properties of the item item, run the following substep:
       props = item_properties(item, true)
-      # 11r.1. For each name name in element's reverse property names, run the following substeps:
+      # 10.1. For each name name in element's reverse property names, run the following substeps:
       props.each do |element|
         element.attribute('itemprop-reverse').to_s.split(' ').compact.each do |name|
-          add_debug(item) {"gentrips(11r.1): name=#{name.inspect}, type=#{type}"}
-          # 11r.1.1) Let context be a copy of evaluation context with current type set to type and current vocabulary set to vocab.
+          add_debug(item) {"gentrips(10.1): name=#{name.inspect}"}
+          # 10.1.1) Let context be a copy of evaluation context with current type set to type and current vocabulary set to vocab.
           ec_new = ec.merge({:current_type => type, :current_vocabulary => vocab})
           
-          # 11r.1.2) Let predicate be the result of generate predicate URI using context and name. Update context by setting current name to predicate.
+          # 10.1.2) Let predicate be the result of generate predicate URI using context and name. Update context by setting current name to predicate.
           predicate = vocab.predicateURI(name, ec_new)
           
-          # (Generate Predicate URI steps 6 and 7)
-          vocab.expand(predicate) do |statement|
-            add_debug(item) {
-              "gentrips(11.1.2): expansion #{statement.inspect}"
-            }
-            @callback.call(statement)
-          end
-
-          ec_new[:current_name] = predicate
-          add_debug(item) {"gentrips(11r.1.2): predicate=#{predicate}"}
-          
-          # 11r.1.3) Let value be the property value of element.
+          # 10.1.3) Let value be the property value of element.
           value = property_value(element)
-          add_debug(item) {"gentrips(11r.1.3) value=#{value.inspect}"}
+          add_debug(item) {"gentrips(10.1.3) value=#{value.inspect}"}
 
-          # 11r.1.4) If value is an item, then generate the triples for value context. Replace value by the subject returned from those steps.
+          # 10.1.4) If value is an item, then generate the triples for value context. Replace value by the subject returned from those steps.
           if value.is_a?(Hash)
             value = generate_triples(element, ec_new) 
-            add_debug(item) {"gentrips(11.1.4): value=#{value.inspect}"}
+            add_debug(item) {"gentrips(10.1.4): value=#{value.inspect}"}
           elsif value.is_a?(RDF::Literal)
-            # 11r.1.4r) Otherwise, if value is a literal, ignore the value and continue to the next name; it is an error for the value of @itemprop-reverse to be a literal
+            # 10.1.5) Otherwise, if value is a literal, ignore the value and continue to the next name; it is an error for the value of @itemprop-reverse to be a literal
             add_error(element, "Value of @itemprop-reverse may not be a literal: #{value.inspect}")
             next
           end
 
-          # 11r.1.5r) Generate a property value using value as the subject and subject as the object
-          generatePropertyValues(item, value, predicate, [subject])
+          # 10.1.6) Generate the following triple
+          add_triple(item, value, predicate, subject)
         end
       end
 
-      # 12) For each predicate in property list
-      property_list.each do |predicate, values|
-        generatePropertyValues(item, subject, predicate, values)
-      end
-      
+      # 11) Return subject
       subject
     end
 
-    def generatePropertyValues(element, subject, predicate, values)
-      # If the registry contains a URI prefix that is a character for character match of predicate up to the length of the URI prefix, set vocab as that URI prefix. Otherwise set vocab to null
-      registry = Registry.find(predicate)
-      add_debug("generatePropertyValues") { "list(#{predicate})? #{registry.as_list(predicate).inspect}"} if registry
-      if registry && registry.as_list(predicate)
-        value = generateRDFCollection(element, values)
-        add_triple(element, subject, predicate, value)
-      else
-        values.each {|v| add_triple(element, subject, predicate, v)}
-      end
-    end
-
-    ##
-    # Called when values has more than one entry
-    # @param [Nokogiri::XML::Element] element
-    # @param [Array<RDF::Value>] values
-    # @return [RDF::Node]
-    def generateRDFCollection(element, values)
-      list = RDF::List.new(nil, nil, values)
-      list.each_statement do |st|
-        add_triple(element, st.subject, st.predicate, st.object) unless st.object == RDF.List
-      end
-      list.subject
-    end
-
     ##
     # To find the properties of an item defined by the element root, the user agent must try to crawl the properties of the element root, with an empty list as the value of memory: if this fails, then the properties of the item defined by the element root is an empty list; otherwise, it is the returned list.
     #
@@ -670,8 +540,15 @@ module RDF::Microdata
         {}
       when element.name == 'meta'
         RDF::Literal.new(element.attribute('content').to_s, :language => element.language)
-      when element.name == 'data'
+      when %w(data meter).include?(element.name)
         RDF::Literal.new(element.attribute('value').to_s, :language => element.language)
+        # Lexically scan value and assign appropriate type, otherwise, leave untyped
+        v = element.attribute('value').to_s
+        datatype = %w(Integer Float Double).map {|t| RDF::Literal.const_get(t)}.detect do |dt|
+          v.match(dt::GRAMMAR)
+        end || RDF::Literal
+        datatype = RDF::Literal::Double if datatype == RDF::Literal::Float
+        datatype.new(v)
       when %w(audio embed iframe img source track video).include?(element.name)
         uri(element.attribute('src'), base)
       when %w(a area link).include?(element.name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-microdata
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: '2.0'
 platform: ruby
 authors:
 - Gregg
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-02 00:00:00.000000000 Z
+date: 2014-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -82,53 +82,75 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.3'
 - !ruby/object:Gem::Dependency
-  name: open-uri-cached
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
-    - - ">="
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: spira
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.12
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.12
+- !ruby/object:Gem::Dependency
+  name: rack-cache
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
-    - - ">="
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: spira
+  name: rest-client-components
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.12
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.12
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -253,7 +275,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rdf-microdata
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Microdata reader for Ruby.