rdf-microdata 0.2.5 → 0.3.0

data/README

@@ -1,4 +1,5 @@
 # RDF::Microdata reader/writer
+[![Build Status](https://secure.travis-ci.org/ruby-rdf/rdf-microdata.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf-microdata)
 
 [Microdata][] parser for RDF.rb.
 
@@ -28,7 +29,9 @@ The parser uses a build-in version of the [Microdata RDF][] registry.
 
 ## 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 and <a>
+GRDDL-type triple generation, such as for html>head>title anchor tags.
+
+If the `RDFa` parser is available, {RDF::Microdata::Format} will not assert content type `text/html` or file extension `.html`, as this is also asserted by RDFa. Instead, the RDFa reader will invoke the microdata reader if an `@itemscope` attribute is detected.
   
 ## Dependencies
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
@@ -93,5 +96,5 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
 [Microdata]:        http://dev.w3.org/html5/md/Overview.html                                      "HTML Microdata"
-[Microdata RDF]:    https://dvcs.w3.org/hg/htmldata/raw-file/default/microdata-rdf/index.html     "Microdata to RDF"
+[Microdata RDF]:    http://dvcs.w3.org/hg/htmldata/raw-file/default/microdata-rdf/index.html     "Microdata to RDF"
 [Microdata doc]:    http://rubydoc.info/github/ruby-rdf/rdf-microdata/frames

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.3.0

data/etc/registry.json

@@ -3,21 +3,32 @@
     "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"}
     }
   },

data/lib/rdf/microdata.rb

@@ -20,11 +20,14 @@ module RDF
   #
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   module Microdata
+    USES_VOCAB = RDF::URI("http://www.w3.org/ns/rdfa#usesVocabulary")
+
     require 'rdf/microdata/format'
     require 'rdf/microdata/vocab'
-    autoload :Profile, 'rdf/microdata/profile'
-    autoload :Reader,  'rdf/microdata/reader'
-    autoload :VERSION, 'rdf/microdata/version'
+    autoload :Expansion,  'rdf/microdata/expansion'
+    autoload :Profile,    'rdf/microdata/profile'
+    autoload :Reader,     'rdf/microdata/reader'
+    autoload :VERSION,    'rdf/microdata/version'
     
     def self.debug?; @debug; end
     def self.debug=(value); @debug = value; end

data/lib/rdf/microdata/expansion.rb

@@ -0,0 +1,159 @@
+module RDF::Microdata
+  ##
+  # The Expansion module performs a subset of OWL entailment rules on the base class,
+  # which implementes RDF::Readable.
+  module Expansion
+    ##
+    # Perform vocabulary expansion on the resulting default graph.
+    #
+    #   Vocabulary expansion relies on a sub-set of OWL [OWL2-PROFILES](http://www.w3.org/TR/2009/REC-owl2-profiles-20091027/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules) entailment to add triples to the default graph based on rules and property/class relationships described in referenced vocabularies.
+    #
+    # For all objects that are the target of an rdfa:usesVocabulary property, load the IRI into a repository.
+    #
+    # Subsequently, perform OWL expansion using rules prp-spo1, prp-eqp1, and prp-eqp2 placing resulting triples into the default graph. Iterate on this step until no more triples are added.
+    #
+    # @example
+    #    scm-spo
+    #    {pq rdfs:subPropertyOf pw . pw rdfs:subPropertyOf p3}
+    #       => {p1 rdfs:subPropertyOf p3}
+    #
+    #    rdprp-spo1fs7
+    #    {p1 rdfs:subPropertyOf p2 . x p1 y} => {x p2 y}
+    #
+    # @return [RDF::Graph]
+    # @see [OWL2 PROFILES][]
+    def expand
+      repo = RDF::Repository.new
+      repo << self  # Add default graph
+      
+      count = repo.count
+      add_debug("expand") {"Loaded #{repo.size} triples into default graph"}
+      
+      repo = owl_entailment(repo)
+
+      # Return graph with default context
+      graph = RDF::Graph.new
+      repo.statements.each {|st| graph << st if st.context.nil?}
+      graph
+    end
+
+    def rule(name, &block)
+      Rule.new(name, block)
+    end
+
+    ##
+    # An entailment rule
+    #
+    # Takes a list of antecedent patterns used to find solutions against a queryable
+    # object. Yields each consequent with bindings from the solution
+    class Rule
+      # @attr [Array<RDF::Query::Pattern>]
+      attr_reader :antecedents
+
+      # @attr [Array<RDF::Query::Pattern>]
+      attr_reader :consequents
+
+      # @attr [String] name
+      attr_reader :name
+
+      ##
+      # @example
+      #   r = Rule.new("scm-spo") do
+      #     antecedent :p1, RDF::RDFS.subPropertyOf, :p2
+      #     antecedent :p2, RDF::RDFS.subPropertyOf, :p3
+      #     consequent :p1, RDF::RDFS.subPropertyOf, :p3, "t-box"
+      #   end
+      #
+      #   r.execute(queryable) {|statement| puts statement.inspect}
+      #
+      # @param [String] name
+      def initialize(name, &block)
+        @antecedents = []
+        @consequents = []
+        @name = name
+
+        if block_given?
+          case block.arity
+            when 1 then block.call(self)
+            else instance_eval(&block)
+          end
+        end
+      end
+
+      def antecedent(subject, prediate, object, context = nil)
+        antecedents << RDF::Query::Pattern.new(subject, prediate, object, :context => context)
+      end
+
+      def consequent(subject, prediate, object, context = nil)
+        consequents << RDF::Query::Pattern.new(subject, prediate, object, :context => context)
+      end
+      
+      ##
+      # Execute the rule against queryable, yielding each consequent with bindings
+      #
+      # @param [RDF::Queryable] queryable
+      # @yield [statement]
+      # @yieldparam [RDF::Statement] statement
+      def execute(queryable)
+        RDF::Query.new(antecedents).execute(queryable).each do |solution|
+          nodes = {}
+          consequents.each do |consequent|
+            terms = {}
+            [:subject, :predicate, :object, :context].each do |r|
+              terms[r] = case o = consequent.send(r)
+              when RDF::Node            then nodes[o] ||= RDF::Node.new
+              when RDF::Query::Variable then solution[o]
+              else                           o
+              end
+            end
+
+            yield RDF::Statement.from(terms)
+          end
+        end
+      end
+    end
+
+  private
+
+    RULES = [
+      Rule.new("prp-spo1") do
+        antecedent :p1, RDF::RDFS.subPropertyOf, :p2
+        antecedent :x, :p1, :y
+        consequent :x, :p2, :y
+      end,
+      Rule.new("prp-eqp1") do
+        antecedent :p1, RDF::OWL.equivalentProperty, :p2
+        antecedent :x, :p1, :y
+        consequent :x, :p2, :y
+      end,
+      Rule.new("prp-eqp2") do
+        antecedent :p1, RDF::OWL.equivalentProperty, :p2
+        antecedent :x, :p2, :y
+        consequent :x, :p1, :y
+      end,
+    ]
+
+    ##
+    # Perform OWL entailment rules on enumerable
+    # @param [RDF::Enumerable] repo
+    # @return [RDF::Enumerable]
+    def owl_entailment(repo)
+      old_count = 0
+
+      while old_count < (count = repo.count)
+        add_debug("entailment", "old: #{old_count} count: #{count}")
+        old_count = count
+
+        RULES.each do |rule|
+          rule.execute(repo) do |statement|
+            add_debug("entailment(#{rule.name})") {statement.inspect}
+            repo << statement
+          end
+        end
+      end
+      
+      add_debug("entailment", "final count: #{count}")
+      repo
+    end
+  end
+end

data/lib/rdf/microdata/reader.rb

@@ -13,15 +13,16 @@ module RDF::Microdata
   #
   # Based on processing rules, amended with the following:
   #
-  # @see https://dvcs.w3.org/hg/htmldata/raw-file/0d6b89f5befb/microdata-rdf/index.html
+  # @see http://dvcs.w3.org/hg/htmldata/raw-file/0d6b89f5befb/microdata-rdf/index.html
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   class Reader < RDF::Reader
     format Format
+    include Expansion
     URL_PROPERTY_ELEMENTS = %w(a area audio embed iframe img link object source track video)
     DEFAULT_REGISTRY = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "etc", "registry.json"))
-    
-    class CrawlFailure < StandardError  #:nodoc:
-    end
+
+    # @private
+    class CrawlFailure < StandardError; end
 
     # Returns the HTML implementation module for this reader instance.
     #
@@ -42,6 +43,9 @@ module RDF::Microdata
 
     # Interface to registry
     class Registry
+      # @attr_reader [RDF::URI] uri Prefix of vocabulary
+      attr_reader :uri
+
       ##
       # Initialize the registry from a URI or file path
       #
@@ -50,7 +54,7 @@ module RDF::Microdata
         return if @registry_uri == registry_uri
         
         json = RDF::Util::File.open_file(registry_uri) { |f| JSON.load(f) }
-        
+
         @prefixes = {}
         json.each do |prefix, elements|
           next unless elements.is_a?(Hash)
@@ -76,6 +80,7 @@ module RDF::Microdata
       # @param [#to_sym] multipleValues (:unordered)
       # @param [Hash] properties ({})
       def initialize(prefixURI, propertyURI = :vocabulary, multipleValues = :unordered, properties = {})
+        @uri = prefixURI
         @scheme = propertyURI.to_sym
         @multipleValues = multipleValues.to_sym
         @properties = properties
@@ -112,29 +117,26 @@ module RDF::Microdata
         n = frag_escape(name)
         if ec[:current_type].nil?
           # 2) If current type from context is null, there can be no current vocabulary.
-          #    Return the URI reference that is the document base with its fragment set to
-          #    the fragment-escaped value of name
+          #    Return the URI reference that is the document base with its fragment set to the fragment-escaped value of name
           u = RDF::URI(ec[:document_base].to_s)
           u.fragment = frag_escape(name)
           u
         elsif @scheme == :vocabulary
-          # 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 (/).
+          # 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)
+            # 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
@@ -154,13 +156,40 @@ module RDF::Microdata
       # @return [Boolean]
       def as_list(predicateURI)
         tok = tokenize(predicateURI)
-        if @properties[tok].is_a?(Hash)
+        if @properties[tok].is_a?(Hash) &&
+           @properties[tok].has_key?("multipleValues")
           @properties[tok]["multipleValues"].to_sym == :list
         else
           @multipleValues == :list
         end
       end
 
+      ##
+      # Yield a equivalentProperty or subPropertyOf if appropriate
+      # @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"]
+            [value].flatten.each do |v|
+              yield RDF::Statement.new(predicateURI,
+                                       RDF::OWL.equivalentProperty,
+                                       RDF::URI(v))
+            end
+          elsif value = @properties[tok]["subPropertyOf"]
+            [value].flatten.each do |v|
+              yield RDF::Statement.new(predicateURI,
+                                       RDF::RDFS.subPropertyOf,
+                                       RDF::URI(v))
+            end
+          end
+          value = @properties[tok]
+        end
+      end
+
       ##
       # Fragment escape a name
       def frag_escape(name)
@@ -188,16 +217,19 @@ module RDF::Microdata
     # @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 [Array] :debug
     #   Array to place debug messages
     # @return [reader]
     # @yield  [reader] `self`
     # @yieldparam  [RDF::Reader] reader
     # @yieldreturn [void] ignored
-    # @raise [Error]:: Raises RDF::ReaderError if _validate_
+    # @raise [Error] Raises `RDF::ReaderError` when validating
     def initialize(input = $stdin, options = {}, &block)
       super do
         @debug = options[:debug]
+        @vocab_expansion = options.fetch(:vocab_expansion, true)
 
         @library = case options[:library]
           when nil
@@ -223,11 +255,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}")
+        add_debug(@doc, "library = #{@library}, expand = #{@vocab_expansion}")
 
         # Load registry
         begin
           registry_uri = options[:registry_uri] || DEFAULT_REGISTRY
+          add_debug(@doc, "registry = #{registry_uri}")
           Registry.load_registry(registry_uri)
         rescue JSON::ParserError => e
           raise RDF::ReaderError, "Failed to parse registry: #{e.message}"
@@ -245,14 +278,22 @@ module RDF::Microdata
     ##
     # Iterates the given block for each RDF statement in the input.
     #
+    # Reads to graph and performs expansion if required.
+    #
     # @yield  [statement]
     # @yieldparam [RDF::Statement] statement
     # @return [void]
     def each_statement(&block)
-      @callback = block
+      if @vocab_expansion
+        @vocab_expansion = false
+        expand.each_statement(&block)
+        @vocab_expansion = true
+      else
+        @callback = block
 
-      # parse
-      parse_whole_document(@doc, base_uri)
+        # parse
+        parse_whole_document(@doc, base_uri)
+      end
     end
 
     ##
@@ -396,9 +437,10 @@ module RDF::Microdata
       type ||= ec[:current_type]
       add_debug(item)  {"gentrips(6): 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
+      # 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):
       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.
@@ -427,6 +469,15 @@ module RDF::Microdata
           
           # 11.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}"}
           
@@ -459,6 +510,7 @@ module RDF::Microdata
       # 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)

data/lib/rdf/microdata/reader/nokogiri.rb

@@ -26,7 +26,7 @@ module RDF::Microdata
         ##
         # Element language
         #
-        # From HTML5 [3.2.3.3]
+        # From HTML5 3.2.3.3
         #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
         #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
         #   attribute in no namespace must be ignored for the purposes of determining the element's
@@ -124,8 +124,8 @@ module RDF::Microdata
         ##
         # Return a proxy for each child
         #
-        # @yield(child)
-        # @yieldparam(NodeProxy)
+        # @yield child
+        # @yieldparam [NodeProxy] child
         def each
           @node_set.each do |c|
             yield NodeProxy.new(c, parent)

data/lib/rdf/microdata/reader/rexml.rb

@@ -28,7 +28,7 @@ module RDF::Microdata
         ##
         # Element language
         #
-        # From HTML5 [3.2.3.3]
+        # From HTML5 3.2.3.3
         #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
         #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
         #   attribute in no namespace must be ignored for the purposes of determining the element's
@@ -162,8 +162,8 @@ module RDF::Microdata
         ##
         # Return a proxy for each child
         #
-        # @yield(child)
-        # @yieldparam(NodeProxy)
+        # @yield child
+        # @yieldparam [NodeProxy] child
         def each
           @node_set.each do |c|
             yield NodeProxy.new(c, parent)
@@ -179,7 +179,7 @@ module RDF::Microdata
 
         ##
         # Add NodeSetProxys
-        # @param [NodeSetProxy, Nokogiri::XML::Node] other
+        # @param [NodeSetProxy, REXML::Element] other
         # @return [NodeSetProxy]
         def +(other)
           new_ns = node_set.clone
@@ -189,7 +189,7 @@ module RDF::Microdata
 
         ##
         # Add a NodeProxy
-        # @param [NodeProxy, Nokogiri::XML::Node] elem
+        # @param [NodeProxy, REXML::Element] elem
         # @return [NodeSetProxy]
         def <<(elem)
           node_set << (elem.is_a?(NodeProxy) ? elem.node : elem)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-microdata
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-26 00:00:00.000000000 Z
+date: 2012-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -108,6 +108,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.2.8
+- !ruby/object:Gem::Dependency
+  name: open-uri-cached
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -172,6 +188,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.3.4
+- !ruby/object:Gem::Dependency
+  name: rdf-rdfa
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.15
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
@@ -214,6 +246,7 @@ files:
 - README
 - UNLICENSE
 - VERSION
+- lib/rdf/microdata/expansion.rb
 - lib/rdf/microdata/format.rb
 - lib/rdf/microdata/reader/nokogiri.rb
 - lib/rdf/microdata/reader/rexml.rb