rdf-rdfa 0.3.6 → 0.3.7

data/README

@@ -45,13 +45,13 @@ One significant RDF feature missing from RDFa was support for ordered collection
       )
     ]
 
-defines a playlist with an ordered set of tracks. RDFa adds the @member attribute, which is used to identify values (object or literal) that are to be placed in a list. The same playlist might be defined in RDFa as follows:
+defines a playlist with an ordered set of tracks. RDFa adds the @inlist attribute, which is used to identify values (object or literal) that are to be placed in a list. The same playlist might be defined in RDFa as follows:
 
     <div vocab="http://schema.org/" typeof="MusicPlaylist">
       <span property="name">Classic Rock Playlist</span>
       <meta property="numTracks" content="5"/>
 
-      <div rel="tracks" member="">
+      <div rel="tracks" inlist="">
         <div typeof="MusicRecording">
           1.<span property="name">Sweet Home Alabama</span> -
           <span property="byArtist">Lynard Skynard</span>
@@ -160,27 +160,27 @@ The template hash defines four Haml templates:
     as those provided by a previous Reader. _title_ is taken from the first top-level subject
     having an appropriate title property (as defined by the _heading_predicates_ option).
 
-*   _subject_: Subject Template, take a _subject_ and an order list of _predicate_s and yields
+*   _subject_: Subject Template, take a _subject_ and an ordered list of _predicate_s and yields
     each _predicate_ to be rendered. Described further in {RDF::RDFa::Writer#render_subject}.
     
         - if element == :li
-          %li{:about => get_curie(subject), :typeof => typeof}
+          %li{:rel => rel, :resource => resource, :inlist => inlist}
             - if typeof
-              %span.type!= typeof
+              %span{:rel => 'rdf:type', :resource => typeof}.type!= typeof
             - predicates.each do |predicate|
               != yield(predicate)
         - elsif rel && typeof
-          %div{:rel => get_curie(rel)}
-            %div{:about => get_curie(subject), :typeof => typeof}
+          %div{:rel => rel}
+            %div{:about => resource, :typeof => typeof}
               %span.type!= typeof
               - predicates.each do |predicate|
                 != yield(predicate)
         - elsif rel
-          %div{:rel => get_curie(rel), :resource => get_curie(subject)}
+          %div{:rel => rel, :resource => resource}
             - predicates.each do |predicate|
               != yield(predicate)
         - else
-          %div{:about => get_curie(subject), :typeof => typeof}
+          %div{:about => about, :typeof => typeof}
             - if typeof
               %span.type!= typeof
             - predicates.each do |predicate|
@@ -198,27 +198,27 @@ The template hash defines four Haml templates:
 *   _property\_value_: Property Value Template, used for predicates having a single value; takes
     a _predicate_, and a single-valued Array of _objects_. Described further in {RDF::RDFa::Writer#render\_property}.
     
-        - object = objects.first
         - if heading_predicates.include?(predicate) && object.literal?
-          %h1{:property => get_curie(predicate), :content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object)}&= get_value(object)
+          %h1{:property => get_curie(predicate), :content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object), :inlist => inlist}= escape_entities(get_value(object))
         - else
           %div.property
             %span.label
               = get_predicate_name(predicate)
             - if res = yield(object)
               != res
+            - elsif get_curie(object) == 'rdf:nil'
+              %span{:rel => get_curie(predicate), :inlist => ''}
             - elsif object.node?
-              %span{:resource => get_curie(object), :rel => get_curie(predicate)}= get_curie(object)
+              %span{:resource => get_curie(object), :rel => get_curie(predicate), :inlist => inlist}= get_curie(object)
             - elsif object.uri?
-              %a{:href => object.to_s, :rel => get_curie(predicate)}= object.to_s
+              %a{:href => object.to_s, :rel => get_curie(predicate), :inlist => inlist}= object.to_s
             - elsif object.datatype == RDF.XMLLiteral
-              %span{:property => get_curie(predicate), :lang => get_lang(object), :datatype => get_dt_curie(object)}<!= get_value(object)
+              %span{:property => get_curie(predicate), :lang => get_lang(object), :datatype => get_dt_curie(object), :inlist => inlist}<!= get_value(object)
             - else
-              %span{:property => get_curie(predicate), :content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object)}&= get_value(object)
+              %span{:property => get_curie(predicate), :content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object), :inlist => inlist}= escape_entities(get_value(object))
    
-    In addition to _predicate_ and _objects_, the template takes locals _property_ and/or _rel_, which are
-    copies of _predicate_ and indicate use in the @property or @rel attributes. Either or both may be
-    specified, as the conditions dictate.
+    In addition to _predicate_ and _objects_, the template takes _inlist_ to indicate that the
+    property is part of an rdf:List.
 
     Also, if the predicate is identified as a _heading predicate_ (via _:heading\_predicates_ option),
     it will generate a heading element, and may use the value as the document title.
@@ -244,19 +244,19 @@ The template hash defines four Haml templates:
         %div.property
           %span.label
             = get_predicate_name(predicate)
-          %ul{:rel => (get_curie(rel) if rel), :property => (get_curie(property) if property)}
+          %ul
             - objects.each do |object|
               - if res = yield(object)
                 != res
               - elsif object.node?
-                %li{:resource => get_curie(object)}= get_curie(object)
+                %li{:rel => get_curie(predicate), :resource => get_curie(object), :inlist => inlist}= get_curie(object)
               - elsif object.uri?
                 %li
-                  %a{:href => object.to_s}= object.to_s
+                  %a{:rel => get_curie(predicate), :href => object.to_s, :inlist => inlist}= object.to_s
               - elsif object.datatype == RDF.XMLLiteral
-                %li{:lang => get_lang(object), :datatype => get_curie(object.datatype)}<!= get_value(object)
+                %li{:property => get_curie(predicate), :lang => get_lang(object), :datatype => get_curie(object.datatype), :inlist => inlist}<!= get_value(object)
               - else
-                %li{:content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object)}&= get_value(object)
+                %li{:property => get_curie(predicate), :content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object), :inlist => inlist}= escape_entities(get_value(object))
   
     In this case, and unordered list is used for output. Creates output similar to the following:
     
@@ -330,7 +330,7 @@ Full documentation available on [Rubydoc.info][RDFa doc]
 ## Resources
 * [RDF.rb][RDF.rb]
 * [Distiller](http://rdf.greggkellogg.net/distiller)
-* [Documentation](http://rdf.rubyforge.org/rdfa)
+* [Documentation][RDFa doc]
 * [History](file:file.History.html)
 * [RDFa 1.1 Core][RDFa 1.1 Core]
 * [XHTML+RDFa 1.1][XHTML+RDFa 1.1]
@@ -375,6 +375,6 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [RDFa 1.1 Core]:    http://www.w3.org/TR/2011/WD-rdfa-core-20110331/     "RDFa 1.1 Core"
 [XHTML+RDFa 1.1]:   http://www.w3.org/TR/2011/WD-xhtml-rdfa-20110331/   "XHTML+RDFa 1.1"
 [RDFa-test-suite]:  http://rdfa.digitalbazaar.com/test-suite/           "RDFa test suite"
-[RDFa doc]:         http://rubydoc.info/github/gkellogg/rdf-rdfa/master/file/README.markdown
+[RDFa doc]:         http://rubydoc.info/github/gkellogg/rdf-rdfa/frames
 [Haml]:             http://haml-lang.com/
 [Turtle]:           http://www.w3.org/TR/2011/WD-turtle-20110809/

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.3.7

data/lib/rdf/rdfa/expansion.rb

@@ -19,17 +19,18 @@ module RDF::RDFa
     # Subsequently, perform RDFS expansion using rules rdfs5, rdfs7, rdfs9, and rdfs11 placing
     # resulting triples into the default graph. Iterate on this step until no more triples are added.
     #
+    # @example
     #    rdfs5
-    #    {uuu rdfs:subPropertyOf vvv . vvv rdfs:subPropertyOf xxx} => { uuu rdfs:subPropertyOf xxx}
+    #    {uuu rdfs:subPropertyOf vvv . vvv rdfs:subPropertyOf xxx} => {uuu rdfs:subPropertyOf xxx}
     #
     #    rdfs7
-    #    {aaa rdfs:subPropertyOf bbb . uuu aaa yyy} => { uuu bbb yyy}
+    #    {aaa rdfs:subPropertyOf bbb . uuu aaa yyy} => {uuu bbb yyy}
     #
     #    rdfs9
-    #    {uuu rdfs:subClassOf xxx . vvv rdf:type uuu} => { vvv rdf:type xxx}
+    #    {uuu rdfs:subClassOf xxx . vvv rdf:type uuu} => {vvv rdf:type xxx}
     #
     #    rdfs11
-    #    {uuu rdfs:subClassOf vvv . vvv rdfs:subClassOf xxx} => { uuu rdfs:subClassOf xxx}
+    #    {uuu rdfs:subClassOf vvv . vvv rdfs:subClassOf xxx} => {uuu rdfs:subClassOf xxx}
     #
     # @return [RDF::Graph]
     def expand
@@ -41,9 +42,8 @@ module RDF::RDFa
       
       # Vocabularies managed in vocab_repo, and copied to repo for processing.
       # This allows for persistent storage of vocabularies
-      @@vocab_repo ||= @options[:vocab_repository] || begin
-        RDF::Repository.new.insert(*COOKED_VOCAB_STATEMENTS)
-      end
+      @@vocab_repo = @options[:vocab_repository] if @options.has_key?(:vocab_repository)
+      @@vocab_repo ||= RDF::Repository.new.insert(*COOKED_VOCAB_STATEMENTS)
       
       vocabs = repo.query(:predicate => RDF::RDFA.hasVocabulary).to_a.map(&:object)
       vocabs.each do |vocab|

data/lib/rdf/rdfa/format.rb

@@ -22,6 +22,21 @@ module RDF::RDFa
     content_type     'text/html', :extension => :html
     reader { RDF::RDFa::Reader }
     writer { RDF::RDFa::Writer }
+
+    ##
+    # Sample detection to see if it matches RDFa (not RDF/XML or Microdata)
+    #
+    # Use a text sample to detect the format of an input file. Sub-classes implement
+    # a matcher sufficient to detect probably format matches, including disambiguating
+    # between other similar formats.
+    #
+    # @param [String] sample Beginning several bytes (~ 1K) of input.
+    # @return [Boolean]
+    def self.detect(sample)
+      (sample.match(/<[^>]*(about|resource|prefix|typeof|property|vocab)\s*="[^>]*>/m) ||
+       sample.match(/<[^>]*DOCTYPE\s+html[^>]*>.*xmlns:/im)
+      ) && !sample.match(/<(\w+:)?(RDF)/)
+    end
   end
 
   # Aliases for RDFa::Format
@@ -34,7 +49,6 @@ module RDF::RDFa
   #   RDF::Format.for(:html).writer  # RDF::RDFa::Writer
   class HTML < RDF::Format
     content_encoding 'utf-8'
-    content_type     'text/html', :extension => :html
     reader { RDF::RDFa::Reader }
     writer { RDF::RDFa::Writer }
   end

data/lib/rdf/rdfa/reader.rb

@@ -1,4 +1,5 @@
 require 'nokogiri'  # FIXME: Implement using different modules as in RDF::TriX
+require 'rdf/ntriples'
 
 module RDF::RDFa
   ##
@@ -50,12 +51,6 @@ module RDF::RDFa
     # @attr [:"rdfa1.0", :"rdfa1.1"]
     attr_reader :version
     
-    ##
-    # Returns the base URI determined by this reader.
-    #
-    # @attr [RDF::URI]
-    attr_reader :base_uri
-
     # The Recursive Baggage
     # @private
     class EvaluationContext # :nodoc:
@@ -143,11 +138,11 @@ module RDF::RDFa
       attr :default_vocabulary, true
 
       ##
-      # collections
+      # lists
       #
-      # A hash associating collections with properties.
+      # A hash associating lists with properties.
       # @attr [Hash{RDF::URI => Array<RDF::Resource>}]
-      attr :collection_mappings, true
+      attr :list_mapping, true
 
       # @param [RDF::URI] base
       # @param [Hash] host_defaults
@@ -174,7 +169,7 @@ module RDF::RDFa
         @uri_mappings = from.uri_mappings.clone
         @incomplete_triples = from.incomplete_triples.clone
         @namespaces = from.namespaces.clone
-        @collection_mappings = from.collection_mappings # Don't clone
+        @list_mapping = from.list_mapping # Don't clone
       end
       
       def inspect
@@ -184,7 +179,7 @@ module RDF::RDFa
         v << "uri_mappings[#{uri_mappings.keys.length}]"
         v << "incomplete_triples[#{incomplete_triples.length}]"
         v << "term_mappings[#{term_mappings.keys.length}]"
-        v << "collections[#{collection_mappings.keys.length}]" if collection_mappings
+        v << "lists[#{list_mapping.keys.length}]" if list_mapping
         v.join(", ")
       end
     end
@@ -228,7 +223,6 @@ module RDF::RDFa
     def initialize(input = $stdin, options = {}, &block)
       super do
         @debug = options[:debug]
-        @base_uri = uri(options[:base_uri])
 
         detect_host_language_version(input, options)
         
@@ -246,17 +240,17 @@ module RDF::RDFa
 
           case @host_language
           when :html4, :html5
-            Nokogiri::HTML.parse(input, @base_uri.to_s, options[:encoding])
+            Nokogiri::HTML.parse(input, base_uri.to_s, options[:encoding])
           else
-            Nokogiri::XML.parse(input, @base_uri.to_s, options[:encoding])
+            Nokogiri::XML.parse(input, base_uri.to_s, options[:encoding])
           end
         end
         
-        if (@doc.nil? || @doc.root.nil?)
+        if ((@doc.nil? || @doc.root.nil?) && validate?)
           add_error(nil, "Empty document", RDF::RDFA.DocumentError)
           raise RDF::ReaderError, "Empty Document"
         end
-        add_warning(nil, "Synax errors:\n#{@doc.errors}", RDF::RDFA.DocumentError) if !@doc.errors.empty? && validate?
+        add_warning(nil, "Syntax errors:\n#{@doc.errors}", RDF::RDFA.DocumentError) if !@doc.errors.empty? && validate?
 
         # Section 4.2 RDFa Host Language Conformance
         #
@@ -316,7 +310,7 @@ module RDF::RDFa
           input.rewind
           string = input.read(1000)
           input.rewind
-          string
+          string.to_s
         else
           input.to_s[0..1000]
         end
@@ -394,7 +388,7 @@ module RDF::RDFa
         end
 
         # parse
-        parse_whole_document(@doc, @base_uri)
+        parse_whole_document(@doc, RDF::URI(base_uri))
       end
     end
 
@@ -422,7 +416,7 @@ module RDF::RDFa
     
     # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
     def node_path(node)
-      "<#{@base_uri}>" + case node
+      "<#{base_uri}>" + case node
       when Nokogiri::XML::Node then node.display_path
       else node.to_s
       end
@@ -460,7 +454,7 @@ module RDF::RDFa
         @processor_graph << RDF::Statement.new(n, RDF["type"], process_class)
         @processor_graph << RDF::Statement.new(n, RDF::DC.description, message)
         @processor_graph << RDF::Statement.new(n, RDF::DC.date, RDF::Literal::Date.new(DateTime.now))
-        @processor_graph << RDF::Statement.new(n, RDF::RDFA.context, @base_uri)
+        @processor_graph << RDF::Statement.new(n, RDF::RDFA.context, base_uri)
         nc = RDF::Node.new
         @processor_graph << RDF::Statement.new(nc, RDF["type"], RDF::PTR.XPathPointer)
         @processor_graph << RDF::Statement.new(nc, RDF::PTR.expression, node.path) if node.respond_to?(:path)
@@ -528,7 +522,7 @@ module RDF::RDFa
         map {|uri| uri(uri).normalize}.
         each do |uri|
         # Don't try to open ourselves!
-        if @base_uri == uri
+        if base_uri == uri
           add_debug(element, "process_profile: skip recursive profile <#{uri}>")
           next
         end
@@ -637,7 +631,7 @@ module RDF::RDFa
       language = evaluation_context.language
       term_mappings = evaluation_context.term_mappings.clone
       default_vocabulary = evaluation_context.default_vocabulary
-      collection_mappings = evaluation_context.collection_mappings
+      list_mapping = evaluation_context.list_mapping
 
       # shortcut
       attrs = element.attributes
@@ -659,12 +653,12 @@ module RDF::RDFa
       rel = attrs['rel'].to_s.strip if attrs['rel']
       rev = attrs['rev'].to_s.strip if attrs['rev']
 
-      # Collections:
-      # @member
+      # Lists:
+      # @inlist
       #   an attribute (value ignored) used to indicate that the object associated with a
-      #   @rel or @property attribute on the same element is to be added to the collection
-      #   for that property. Causes a collection to be created if it does not already exist.
-      member = attrs['member'].to_s.strip if attrs.has_key?('member')
+      #   @rel or @property attribute on the same element is to be added to the list
+      #   for that property. Causes a list to be created if it does not already exist.
+      inlist = attrs['inlist'].to_s.strip if attrs.has_key?('inlist')
 
       add_debug(element) do
         attrs = {
@@ -679,7 +673,7 @@ module RDF::RDFa
           :datatype => datatype,
           :rel => rel,
           :rev => rev,
-          :member => member,
+          :inlist => inlist,
         }.select {|k,v| v}
 
         "attrs " + attrs.map {|a| "#{a.first}: #{a.last}"}.join(", ")
@@ -738,12 +732,12 @@ module RDF::RDFa
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
-                          :restrictions => TERMorCURIEorAbsURI[@version])
+                          :restrictions => TERMorCURIEorAbsURI.fetch(@version, []))
       revs = process_uris(element, rev, evaluation_context, base,
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
-                          :restrictions => TERMorCURIEorAbsURI[@version])
+                          :restrictions => TERMorCURIEorAbsURI.fetch(@version, []))
     
       add_debug(element) do
         "rels: #{rels.join(" ")}, revs: #{revs.join(" ")}"
@@ -755,15 +749,15 @@ module RDF::RDFa
         new_subject = if about
           process_uri(element, about, evaluation_context, base,
                       :uri_mappings => uri_mappings,
-                      :restrictions => SafeCURIEorCURIEorURI[@version])
-        elsif src
-          process_uri(element, src, evaluation_context, base, :restrictions => [:uri])
+                      :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
         elsif resource
           process_uri(element, resource, evaluation_context, base,
                       :uri_mappings => uri_mappings,
-                      :restrictions => SafeCURIEorCURIEorURI[@version])
+                      :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
         elsif href
           process_uri(element, href, evaluation_context, base, :restrictions => [:uri])
+        elsif src
+          process_uri(element, src, evaluation_context, base, :restrictions => [:uri])
         end
 
         # If no URI is provided by a resource attribute, then the first match from the following rules
@@ -786,17 +780,17 @@ module RDF::RDFa
           skip = true unless property
           evaluation_context.parent_object
         end
-        add_debug(element, "[Step 5] new_subject: #{new_subject}, skip = #{skip}")
+        add_debug(element, "[Step 5] new_subject: #{new_subject.to_ntriples rescue 'nil'}, skip = #{skip}")
       else
         # [7.5 Step 6]
         # If the current element does contain a @rel or @rev attribute, then the next step is to
         # establish both a value for new subject and a value for current object resource:
         new_subject = process_uri(element, about, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
-                                  :restrictions => SafeCURIEorCURIEorURI[@version]) ||
-                      process_uri(element, src, evaluation_context, base,
+                                  :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
+        new_subject ||= process_uri(element, src, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
-                                  :restrictions => [:uri])
+                                  :restrictions => [:uri]) if @version == :"rdfa1.0"
       
         # If no URI is provided then the first match from the following rules will apply
         new_subject ||= if element == @doc.root && base
@@ -818,10 +812,13 @@ module RDF::RDFa
         current_object_resource = if resource
           process_uri(element, resource, evaluation_context, base,
                       :uri_mappings => uri_mappings,
-                      :restrictions => SafeCURIEorCURIEorURI[@version])
+                      :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
         elsif href
           process_uri(element, href, evaluation_context, base,
                       :restrictions => [:uri])
+        elsif src && @version != :"rdfa1.0"
+          process_uri(element, src, evaluation_context, base,
+                      :restrictions => [:uri])
         end
 
         add_debug(element, "[Step 6] new_subject: #{new_subject}, current_object_resource = #{current_object_resource.nil? ? 'nil' : current_object_resource}")
@@ -834,40 +831,41 @@ module RDF::RDFa
                             :uri_mappings => uri_mappings,
                             :term_mappings => term_mappings,
                             :vocab => default_vocabulary,
-                            :restrictions => TERMorCURIEorAbsURI[@version])
+                            :restrictions => TERMorCURIEorAbsURI.fetch(@version, []))
         add_debug(element, "typeof: #{typeof}")
         types.each do |one_type|
           add_triple(element, new_subject, RDF["type"], one_type)
         end
       end
 
-      # Collections: If new subject is set and is not the same as parent subject,
-      # replace the collection mappings taken from
-      # the evaluation context with a new empty mappings.
-      if (new_subject && new_subject != evaluation_context.parent_subject) || collection_mappings.nil?
-        collection_mappings = {}
+      # Create new List mapping [step 8]
+      #
+      # If in any of the previous steps a new subject was set to a non-null value different from the parent object;
+      # The list mapping taken from the evaluation context is set to a new, empty mapping.
+      if (new_subject && (new_subject != evaluation_context.parent_subject || list_mapping.nil?))
+        list_mapping = {}
         add_debug(element) do
-          "collections: create new collection mappings(#{collection_mappings.object_id}) " +
-            "ns: #{new_subject}, " +
-            "ps: #{evaluation_context.parent_subject}"
+          "[Step 8]: create new list mapping(#{list_mapping.object_id}) " +
+            "ns: #{new_subject.to_ntriples}, " +
+            "ps: #{evaluation_context.parent_subject.to_ntriples rescue 'nil'}"
         end
       end
 
-      # Generate triples with given object [Step 8]
+      # Generate triples with given object [Step 9]
       #
-      # Collections: if the current element has a @member attribute, add the property to the
-      # collection associated with that property, creating a new collection if necessary.
+      # If the current element has a @inlist attribute, add the property to the
+      # list associated with that property, creating a new list if necessary.
       if new_subject and current_object_resource
         rels.each do |r|
-          if member
-            # If the current collection mappings does not contain a collection associated with this IRI,
-            # instantiate a new collection
-            unless collection_mappings[r]
-              collection_mappings[r] = RDF::List.new
-              add_debug(element) {"collections(#{r}): create #{collection_mappings[r]}"}
+          if inlist
+            # If the current list mapping does not contain a list associated with this IRI,
+            # instantiate a new list
+            unless list_mapping[r]
+              list_mapping[r] = RDF::List.new
+              add_debug(element) {"list(#{r}): create #{list_mapping[r].inspect}"}
             end
-            add_debug(element, "member: add #{current_object_resource} to #{r} collection")
-            collection_mappings[r] << current_object_resource
+            add_debug(element, "[Step 9] add #{current_object_resource.to_ntriples} to #{r} #{list_mapping[r].inspect}")
+            list_mapping[r] << current_object_resource
           else
             add_triple(element, new_subject, r, current_object_resource)
           end
@@ -877,23 +875,23 @@ module RDF::RDFa
           add_triple(element, current_object_resource, r, new_subject)
         end
       elsif rel || rev
-        # Incomplete triples and bnode creation [Step 9]
-        add_debug(element) {"[Step 9] incompletes: rels: #{rels}, revs: #{revs}"}
+        # Incomplete triples and bnode creation [Step 10]
+        add_debug(element) {"[Step 10] incompletes: rels: #{rels}, revs: #{revs}"}
         current_object_resource = RDF::Node.new
       
         # predicate: full IRI
         # direction: forward/reverse
-        # collection: Save into collection, don't generate triple
+        # lists: Save into list, don't generate triple
 
         rels.each do |r|
-          if member
-            # If the current collection mappings does not contain a collection associated with this IRI,
-            # instantiate a new collection
-            unless collection_mappings[r]
-              collection_mappings[r] = RDF::List.new
-              add_debug(element) {"collections(#{r}): create #{collection_mappings[r]}"}
+          if inlist
+            # If the current list mapping does not contain a list associated with this IRI,
+            # instantiate a new list
+            unless list_mapping[r]
+              list_mapping[r] = RDF::List.new
+              add_debug(element) {"[Step 10] list(#{r}): create #{list_mapping[r].inspect}"}
             end
-            incomplete_triples << {:collection => collection_mappings[r]}
+            incomplete_triples << {:list => list_mapping[r], :direction => :none}
           else
             incomplete_triples << {:predicate => r, :direction => :forward}
           end
@@ -904,22 +902,22 @@ module RDF::RDFa
         end
       end
     
-      # Establish current object literal [Step 10]
+      # Establish current object literal [Step 11]
       #
-      # Collections: if the current element has a @member attribute, add the property to the
-      # collection associated with that property, creating a new collection if necessary.
+      # If the current element has a @inlist attribute, add the property to the
+      # list associated with that property, creating a new list if necessary.
       if property
         properties = process_uris(element, property, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :term_mappings => term_mappings,
                                   :vocab => default_vocabulary,
-                                  :restrictions => TERMorCURIEorAbsURIprop[@version])
+                                  :restrictions => TERMorCURIEorAbsURIprop.fetch(@version, []))
 
         properties.reject! do |p|
           if p.is_a?(RDF::URI)
             false
           else
-            add_debug(element, "predicate #{p.inspect} must be a URI")
+            add_debug(element, "[Step 11] predicate #{p.to_ntriples} must be a URI")
             true
           end
         end
@@ -932,16 +930,16 @@ module RDF::RDFa
                               :uri_mappings => uri_mappings,
                               :term_mappings => term_mappings,
                               :vocab => default_vocabulary,
-                              :restrictions => TERMorCURIEorAbsURI[@version]) unless datatype.to_s.empty?
+                              :restrictions => TERMorCURIEorAbsURI.fetch(@version, [])) unless datatype.to_s.empty?
         begin
           current_object_literal = if !datatype.to_s.empty? && datatype.to_s != RDF.XMLLiteral.to_s
             # typed literal
-            add_debug(element, "[Step 10] typed literal (#{datatype})")
+            add_debug(element, "[Step 11] typed literal (#{datatype})")
             RDF::Literal.new(content || element.inner_text.to_s, :datatype => datatype, :language => language, :validate => validate?, :canonicalize => canonicalize?)
           elsif @version == :"rdfa1.1"
             if datatype.to_s == RDF.XMLLiteral.to_s
               # XML Literal
-              add_debug(element) {"[Step 10(1.1)] XML Literal: #{element.inner_html}"}
+              add_debug(element) {"[Step 11(1.1)] XML Literal: #{element.inner_html}"}
 
               # In order to maintain maximum portability of this literal, any children of the current node that are
               # elements must have the current in scope XML namespace declarations (if any) declared on the
@@ -961,17 +959,17 @@ module RDF::RDFa
               end
             else
               # plain literal
-              add_debug(element, "[Step 10(1.1)] plain literal")
+              add_debug(element, "[Step 11(1.1)] plain literal")
               RDF::Literal.new(content || element.inner_text.to_s, :language => language, :validate => validate?, :canonicalize => canonicalize?)
             end
           else
             if content || (children_node_types == [Nokogiri::XML::Text]) || (element.children.length == 0) || datatype == ""
               # plain literal
-              add_debug(element, "[Step 10 (1.0)] plain literal")
+              add_debug(element, "[Step 11 (1.0)] plain literal")
               RDF::Literal.new(content || element.inner_text.to_s, :language => language, :validate => validate?, :canonicalize => canonicalize?)
             elsif children_node_types != [Nokogiri::XML::Text] and (datatype == nil or datatype.to_s == RDF.XMLLiteral.to_s)
               # XML Literal
-              add_debug(element) {"[Step 10 (1.0)] XML Literal: #{element.inner_html}"}
+              add_debug(element) {"[Step 11 (1.0)] XML Literal: #{element.inner_html}"}
               recurse = false
               RDF::Literal.new(element.inner_html,
                                :datatype => RDF.XMLLiteral,
@@ -987,16 +985,16 @@ module RDF::RDFa
 
         # add each property
         properties.each do |p|
-          # Collections: If element has an @member attribute, add the value to a collection
-          if member
-            # If the current collection mappings does not contain a collection associated with this IRI,
-            # instantiate a new collection
-            unless collection_mappings[p]
-              collection_mappings[p] = RDF::List.new
-              add_debug(element) {"collections(#{p}): create #{collection_mappings[p]}"}
+          # Lists: If element has an @inlist attribute, add the value to a list
+          if inlist
+            # If the current list mapping does not contain a list associated with this IRI,
+            # instantiate a new list
+            unless list_mapping[p]
+              list_mapping[p] = RDF::List.new
+              add_debug(element) {"[Step 11] lists(#{p}): create #{list_mapping[p].inspect}"}
             end
-            add_debug(element)  {"member: add #{current_object_literal} to #{p} collection"}
-            collection_mappings[p] << current_object_literal
+            add_debug(element)  {"[Step 11] add #{current_object_literal.to_ntriples} to #{p.to_ntriples} #{list_mapping[p].inspect}"}
+            list_mapping[p] << current_object_literal
           elsif new_subject
             add_triple(element, new_subject, p, current_object_literal) 
           end
@@ -1004,26 +1002,27 @@ module RDF::RDFa
       end
     
       if not skip and new_subject && !evaluation_context.incomplete_triples.empty?
-        # Complete the incomplete triples from the evaluation context [Step 11]
+        # Complete the incomplete triples from the evaluation context [Step 12]
         add_debug(element) do
-          "[Step 11] complete incomplete triples: " +
-          "new_subject=#{new_subject.inspect}, " +
+          "[Step 12] complete incomplete triples: " +
+          "new_subject=#{new_subject.to_ntriples}, " +
           "completes=#{evaluation_context.incomplete_triples.inspect}"
         end
 
         evaluation_context.incomplete_triples.each do |trip|
-          if trip[:collection]
-            add_debug(element) {"member: add #{current_object_resource} to #{trip[:collection]} collection"}
-            trip[:collection] << new_subject
-          elsif trip[:direction] == :forward
+          case trip[:direction]
+          when :none
+            add_debug(element) {"[Step 12] add #{new_subject.to_ntriples} to #{trip[:list].inspect}"}
+            trip[:list] << new_subject
+          when :forward
             add_triple(element, evaluation_context.parent_subject, trip[:predicate], new_subject)
-          elsif trip[:direction] == :reverse
+          when :reverse
             add_triple(element, new_subject, trip[:predicate], evaluation_context.parent_subject)
           end
         end
       end
 
-      # Create a new evaluation context and proceed recursively [Step 12]
+      # Create a new evaluation context and proceed recursively [Step 13]
       if recurse
         if skip
           if language == evaluation_context.language &&
@@ -1031,9 +1030,9 @@ module RDF::RDFa
               term_mappings == evaluation_context.term_mappings &&
               default_vocabulary == evaluation_context.default_vocabulary &&
               base == evaluation_context.base &&
-              collection_mappings == evaluation_context.collection_mappings
+              list_mapping == evaluation_context.list_mapping
             new_ec = evaluation_context
-            add_debug(element, "[Step 12] skip: reused ec")
+            add_debug(element, "[Step 13] skip: reused ec")
           else
             new_ec = evaluation_context.clone
             new_ec.base = base
@@ -1042,8 +1041,8 @@ module RDF::RDFa
             new_ec.namespaces = namespaces
             new_ec.term_mappings = term_mappings
             new_ec.default_vocabulary = default_vocabulary
-            new_ec.collection_mappings = collection_mappings
-            add_debug(element, "[Step 12] skip: cloned ec")
+            new_ec.list_mapping = list_mapping
+            add_debug(element, "[Step 13] skip: cloned ec")
           end
         else
           # create a new evaluation context
@@ -1056,8 +1055,8 @@ module RDF::RDFa
           new_ec.language = language
           new_ec.term_mappings = term_mappings
           new_ec.default_vocabulary = default_vocabulary
-          new_ec.collection_mappings = collection_mappings
-          add_debug(element, "[Step 12] new ec")
+          new_ec.list_mapping = list_mapping
+          add_debug(element, "[Step 13] new ec")
         end
       
         element.children.each do |child|
@@ -1065,25 +1064,25 @@ module RDF::RDFa
           traverse(child, new_ec) if child.class == Nokogiri::XML::Element
         end
         
-        # Collections: after traversing through child elements, for each collection associated with
+        # Step 14: after traversing through child elements, for each list associated with
         # a property
-        collection_mappings.each do |p, c|
-          # if that collection is different from the evaluation context
-          ec_col = evaluation_context.collection_mappings[p] if evaluation_context.collection_mappings
-          add_debug(element) {"collections: time to create #{c}? #{(ec_col != c).inspect}"}
-          if ec_col != c
-            add_debug(element) {"collection(#{p}) create #{c}"}
-            # Generate an rdf:List with the elements of that collection.
-            c.each_statement do |st|
+        (list_mapping || {}).each do |p, l|
+          # if that list is different from the evaluation context
+          ec_list = evaluation_context.list_mapping[p] if evaluation_context.list_mapping
+          add_debug(element) {"[Step 14] time to create #{l.inspect}? #{(ec_list != l).inspect}"}
+          if ec_list != l
+            add_debug(element) {"[Step 14] list(#{p}) create #{l.inspect}"}
+            # Generate an rdf:List with the elements of that list.
+            l.each_statement do |st|
               add_triple(element, st.subject, st.predicate, st.object) unless st.object == RDF.List
             end
 
-            # Generate a triple relating new_subject, property and the collection BNode,
-            # or rdf:nil if the collection is empty.
-            if c.empty?
+            # Generate a triple relating new_subject, property and the list BNode,
+            # or rdf:nil if the list is empty.
+            if l.empty?
               add_triple(element, new_subject, p, RDF.nil)
             else
-              add_triple(element, new_subject, p, c.subject)
+              add_triple(element, new_subject, p, l.subject)
             end
           end
         end