rdf-rdfa 2.2.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 01d81ec1f8d8b64791be947449c08434ed7c6114
-  data.tar.gz: 0ff8146b753c38d5cedc50774d2bf28c445489d7
+SHA256:
+  metadata.gz: 41a438683b553f9eaa31a244a4fbbeeb2413b999f040b4a46980fe939d1891d2
+  data.tar.gz: a191ff7cf36e120aa52491c8eea5b4cab05b48d5595c0486a6e9ed774093b39e
 SHA512:
-  metadata.gz: 0c3a56592cb54716af54e48aae735a03301cd160a05e32e183b4a467ae8d57496d6653970e17cef280df52e076e5fa8325acf6ffac45125976d262c40d1a1c70
-  data.tar.gz: 2f366a57af1e44246482fa5ad810ac5983b8b6a69bbc9e50b08d79d56f8147611d40d4767568a01d07493e5f5a8d93263c892d304fd107b752e8d90091971443
+  metadata.gz: 4e95a2ef75396bfead46f171d2366bf4019c7a6ffd9be70e1ae24614671d7f20719eb00476906ef17047bbf9ef9ed1ac7f711b5905e42c64094ac85134a48469
+  data.tar.gz: b1cd79507874df6cb7f516a6ad87450b9d0e14e63784fe90191c862cd38c35a5520b33c315b287483aadc14800de677b200d7e94dcdb5ae6c54ae9fbf0c282d1

data/README.md

@@ -16,7 +16,7 @@ RDF::RDFa parses [RDFa][RDFa 1.1 Core] into statements or triples.
 * Fully compliant RDFa 1.1 parser.
 * Template-based Writer to generate XHTML+RDFa.
   * Writer uses user-replacable [Haml][Haml]-based templates to generate RDFa.
-* If available, uses [Nokogiri][] for parsing HTML/SVG, falls back to REXML otherwise. For HTML5, include the [Nokogumbo][] gem for are pure-HTML5 parser with better error detection.
+* If available, uses [Nokogiri][] for parsing HTML/SVG, falls back to REXML otherwise. For HTML5, include the [Nokogumbo][] gem for a pure-HTML5 parser with better error detection.
 
 Install with `gem install rdf-rdfa`
 
@@ -397,12 +397,12 @@ The template hash defines four Haml templates:
     }
 
 ## Dependencies
-* [Ruby](http://ruby-lang.org/) (>= 2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.2)
-* [Haml](https://rubygems.org/gems/haml) (>= 4.0)
-* [HTMLEntities](https://rubygems.org/gems/htmlentities) (>= 4.3.1)
-* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.7.1)
-* Soft dependency on [Nokogumbo](https://github.com/rubys/nokogumbo) (>= 1.4.10)
+* [Ruby](http://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 3.1)
+* [Haml](https://rubygems.org/gems/haml) (~> 5.1)
+* [HTMLEntities](https://rubygems.org/gems/htmlentities) (>= 4.3)
+* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.10)
+* Soft dependency on [Nokogumbo](https://github.com/rubys/nokogumbo) (>= 2.0)
 
 ## Documentation
 Full documentation available on [Rubydoc.info][RDFa doc]

data/VERSION

@@ -1 +1 @@
-2.2.2
+3.1.0

data/lib/rdf/rdfa.rb

@@ -31,9 +31,9 @@ module RDF
     autoload :Reader,     'rdf/rdfa/reader'
     autoload :Writer,     'rdf/rdfa/writer'
     autoload :VERSION,    'rdf/rdfa/version'
-    
+
     HTML_RDFA_CONTEXT   = "http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"
     XHTML_RDFA_CONTEXT  = "http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"
     XML_RDFA_CONTEXT    = "http://www.w3.org/2011/rdfa-context/rdfa-1.1"
   end
-end
+end

data/lib/rdf/rdfa/context.rb

@@ -19,7 +19,7 @@ module RDF::RDFa
     # @!attribute [r] terms
     # @return [Hash{Symbol => RDF::URI}]
     attr_reader :terms
-    
+
     # Default URI defined for this vocabulary
     # @!attribute [r] vocabulary
     # @return [RDF::URI]
@@ -29,7 +29,7 @@ module RDF::RDFa
     # @!attribute [r] uri
     # @return [RDF::URI]
     attr_reader :uri
-    
+
     ##
     # Initialize a new context from the given URI.
     #
@@ -40,17 +40,17 @@ module RDF::RDFa
     # @yieldparam [RDF::RDFa::Context] context
     # @yieldreturn [void] ignored
     # @return [RDF::RDFa::Context]
-    def initialize(uri, options = {}, &block)
+    def initialize(uri, **options, &block)
       @uri = RDF::URI.intern(uri)
       @prefixes = options.fetch(:prefixes, {})
       @terms = options.fetch(:terms, {})
       @vocabulary = options[:vocabulary]
       @options = options.dup
-      
+
       yield(self) if block_given?
       self
     end
-    
+
     ##
     # @return [RDF::Util::Cache]
     # @private
@@ -67,7 +67,7 @@ module RDF::RDFa
     def self.repository
       @repository ||= RDF::Repository.new(title: "RDFa Contexts")
     end
-    
+
     ##
     # Set repository used for saving contexts
     # @param [RDF::Repository] repo
@@ -82,14 +82,14 @@ module RDF::RDFa
       end
       @repository = repo
     end
-    
+
     # Return a context faulting through the cache
     # @return [RDF::RDFa::Context]
     def self.find(uri)
       uri = RDF::URI.intern(uri)
-      
+
       return cache[uri] unless cache[uri].nil?
-      
+
       # Two part creation to prevent re-entrancy problems if p1 => p2 and p2 => p1
       # Return something to make the caller happy if we're re-entered
       cache[uri] = Struct.new(:prefixes, :terms, :vocabulary).new({}, {}, nil)
@@ -97,7 +97,7 @@ module RDF::RDFa
       cache[uri] = new(uri) do |context|
         log_debug("process_context: retrieve context <#{uri}>") if respond_to?(:log_debug)
         Context.load(uri)
-        context.parse(repository.query(graph_name: uri))
+        context.parse(repository.query({graph_name: uri}))
       end
     rescue Exception => e
       if respond_to?(:log_fatal)
@@ -112,12 +112,12 @@ module RDF::RDFa
       uri = RDF::URI.intern(uri)
       repository.load(uri.to_s, base_uri: uri, graph_name: uri) unless repository.has_graph?(uri)
     end
-    
+
     # @return [RDF::Repository]
     def repository
       Context.repository
     end
-    
+
     ##
     # Defines the given named URI prefix for this context.
     #
@@ -151,7 +151,7 @@ module RDF::RDFa
       name = name.to_s.empty? ? nil : (name.respond_to?(:to_sym) ? name.to_sym : name.to_s.to_sym)
       uri.nil? ? terms[name] : terms[name] = uri
     end
-    
+
     ##
     # Extract vocabulary, prefix mappings and terms from a enumerable object into an instance
     #
@@ -179,14 +179,14 @@ module RDF::RDFa
         log_debug("process_context: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}, vocabulary=#{vocab.inspect}") if respond_to?(:log_debug)
 
         @vocabulary = vocab if vocab
-        
+
         # For every extracted triple that is the common subject of an rdfa:prefix and an rdfa:uri
         # predicate, create a mapping from the object literal of the rdfa:prefix predicate to the
         # object literal of the rdfa:uri predicate. Add or update this mapping in the local list of
         # URI mappings after transforming the 'prefix' component to lower-case.
         # For every extracted
         prefix(prefix.downcase, uri) if uri && prefix && prefix != "_"
-      
+
         # triple that is the common subject of an rdfa:term and an rdfa:uri predicate, create a
         # mapping from the object literal of the rdfa:term predicate to the object literal of the
         # rdfa:uri predicate. Add or update this mapping in the local term mappings.

data/lib/rdf/rdfa/context/html.rb

@@ -4,8 +4,8 @@
 class RDF::RDFa::Context
   def self.find_with_html_rdfa_1_1(uri)
     if uri.to_s == "http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"
-      @_html_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"), {
-      })
+      @_html_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"),
+      )
     else
       find_without_html_rdfa_1_1(uri)
     end

data/lib/rdf/rdfa/context/xhtml.rb

@@ -4,7 +4,7 @@
 class RDF::RDFa::Context
   def self.find_with_xhtml_rdfa_1_1(uri)
     if uri.to_s == "http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"
-      @_xhtml_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"), {
+      @_xhtml_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"),
         terms: {
           alternate:  "http://www.w3.org/1999/xhtml/vocab#alternate",
           appendix:   "http://www.w3.org/1999/xhtml/vocab#appendix",
@@ -32,7 +32,7 @@ class RDF::RDFa::Context
           top:        "http://www.w3.org/1999/xhtml/vocab#top",
           up:         "http://www.w3.org/1999/xhtml/vocab#up",
         },
-      })
+      )
     else
       find_without_xhtml_rdfa_1_1(uri)
     end

data/lib/rdf/rdfa/context/xml.rb

@@ -4,8 +4,9 @@
 class RDF::RDFa::Context
   def self.find_with_rdfa_1_1(uri)
     if uri.to_s == "http://www.w3.org/2011/rdfa-context/rdfa-1.1"
-      @_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/rdfa-1.1"), {
+      @_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/rdfa-1.1"),
         prefixes: {
+          as:      "https://www.w3.org/ns/activitystreams#",
           cc:      "http://creativecommons.org/ns#",
           csvw:    "http://www.w3.org/ns/csvw#",
           ctag:    "http://commontag.org/ns#",
@@ -13,11 +14,16 @@ class RDF::RDFa::Context
           dc11:    "http://purl.org/dc/elements/1.1/",
           dcat:    "http://www.w3.org/ns/dcat#",
           dcterms: "http://purl.org/dc/terms/",
+          dqv:     "http://www.w3.org/ns/dqv#",
+          duv:     "https://www.w3.org/ns/duv#",
           foaf:    "http://xmlns.com/foaf/0.1/",
           gr:      "http://purl.org/goodrelations/v1#",
           grddl:   "http://www.w3.org/2003/g/data-view#",
           ical:    "http://www.w3.org/2002/12/cal/icaltzd#",
+          ldp:     "http://www.w3.org/ns/ldp#",
           ma:      "http://www.w3.org/ns/ma-ont#",
+          oa:      "http://www.w3.org/ns/oa#",
+          odrl:    "http://www.w3.org/ns/odrl/2/",
           og:      "http://ogp.me/ns#",
           org:     "http://www.w3.org/ns/org#",
           owl:     "http://www.w3.org/2002/07/owl#",
@@ -34,6 +40,9 @@ class RDF::RDFa::Context
           sioc:    "http://rdfs.org/sioc/ns#",
           skos:    "http://www.w3.org/2004/02/skos/core#",
           skosxl:  "http://www.w3.org/2008/05/skos-xl#",
+          sosa:    "http://www.w3.org/ns/sosa/",
+          ssn:     "http://www.w3.org/ns/ssn/",
+          time:    "http://www.w3.org/2006/time#",
           v:       "http://rdf.data-vocabulary.org/#",
           vcard:   "http://www.w3.org/2006/vcard/ns#",
           void:    "http://rdfs.org/ns/void#",
@@ -48,7 +57,7 @@ class RDF::RDFa::Context
           license:     "http://www.w3.org/1999/xhtml/vocab#license",
           role:        "http://www.w3.org/1999/xhtml/vocab#role",
         },
-      })
+      )
     else
       find_without_rdfa_1_1(uri)
     end

data/lib/rdf/rdfa/expansion.rb

@@ -17,7 +17,7 @@ module RDF::RDFa
       add_debug("expand") {"Repository has #{repository.count} statements"}
 
       # Load missing vocabularies
-      vocabs = repository.query(predicate: RDF::RDFA.usesVocabulary).to_a.map(&:object)
+      vocabs = repository.query({predicate: RDF::RDFA.usesVocabulary}).to_a.map(&:object)
       vocabs.map! do |vocab|
         begin
           # Create the name with a predictable name so that it is enumerated and can be found
@@ -108,7 +108,7 @@ module RDF::RDFa
       def consequent(subject, prediate, object)
         consequents << RDF::Query::Pattern.new(subject, prediate, object)
       end
-      
+
       ##
       # Execute the rule against queryable, yielding each consequent with bindings
       #
@@ -227,7 +227,7 @@ module RDF::RDFa
             to_add << statement
           end
         end
-        
+
         repository.insert(*to_add)
       end
     end
@@ -250,7 +250,7 @@ module RDF::RDFa
             to_add << statement
           end
         end
-        
+
         repository.insert(*to_add)
       end
 

data/lib/rdf/rdfa/patches/string_hacks.rb

@@ -6,4 +6,4 @@ class ::String
     ws = str.match(/^(\s*)\S/m) ? $1 : ''
     str.gsub(/^#{ws}/m, '')
   end
-end
+end

data/lib/rdf/rdfa/reader.rb

@@ -31,7 +31,7 @@ module RDF::RDFa
     include RDF::Util::Logger
 
     XHTML = "http://www.w3.org/1999/xhtml"
-    
+
     # Content model for @about and @resource. In RDFa 1.0, this was URIorSafeCURIE
     SafeCURIEorCURIEorIRI = {
       :"rdfa1.0" => [:safe_curie, :uri, :bnode],
@@ -83,17 +83,17 @@ module RDF::RDFa
     # @!attribute [r] host_language
     # @return [:xml, :xhtml1, :xhtml5, :html4, :html5, :svg]
     attr_reader :host_language
-    
+
     # Version
     # @!attribute [r] version
     # @return [:"rdfa1.0", :"rdfa1.1"]
     attr_reader :version
-    
+
     # Repository used for collecting triples.
     # @!attribute [r] repository
     # @return [RDF::Repository]
     attr_reader :repository
-    
+
     # Returns the XML implementation module for this reader instance.
     #
     # @!attribute [rw] implementation
@@ -124,7 +124,7 @@ module RDF::RDFa
       # @!attribute [rw] parent_subject
       # @return [RDF::URI]
       attr_accessor :parent_subject
-      
+
       ##
       # The parent object.
       #
@@ -138,14 +138,14 @@ module RDF::RDFa
       # @!attribute [rw] parent_object
       # @return [RDF::URI]
       attr_accessor :parent_object
-      
+
       ##
       # A list of current, in-scope URI mappings.
       #
       # @!attribute [rw] uri_mappings
       # @return [Hash{Symbol => String}]
       attr_accessor :uri_mappings
-      
+
       ##
       # A list of current, in-scope Namespaces. This is the subset of uri_mappings
       # which are defined using xmlns.
@@ -153,7 +153,7 @@ module RDF::RDFa
       # @!attribute [rw] namespaces
       # @return [Hash{String => Namespace}]
       attr_accessor :namespaces
-      
+
       ##
       # A list of incomplete triples.
       #
@@ -165,14 +165,14 @@ module RDF::RDFa
       # @!attribute [rw] incomplete_triples
       # @return [Array<Array<RDF::URI, RDF::Resource>>]
       attr_accessor :incomplete_triples
-      
+
       ##
       # The language. Note that there is no default language.
       #
       # @!attribute [rw] language
       # @return [Symbol]
       attr_accessor :language
-      
+
       ##
       # The term mappings, a list of terms and their associated URIs.
       #
@@ -183,7 +183,7 @@ module RDF::RDFa
       # @!attribute [rw] term_mappings
       # @return [Hash{Symbol => RDF::URI}]
       attr_accessor :term_mappings
-      
+
       ##
       # The default vocabulary
       #
@@ -230,7 +230,7 @@ module RDF::RDFa
         @namespaces = from.namespaces.clone
         @list_mapping = from.list_mapping # Don't clone
       end
-      
+
       def inspect
         v = ['base', 'parent_subject', 'parent_object', 'language', 'default_vocabulary'].map do |a|
           "#{a}=#{o = self.send(a); o.respond_to?(:to_ntriples) ? o.to_ntriples : o.inspect}"
@@ -297,7 +297,7 @@ module RDF::RDFa
     # @yieldparam  [RDF::Reader] reader
     # @yieldreturn [void] ignored
     # @raise [RDF::ReaderError] if _validate_
-    def initialize(input = $stdin, options = {}, &block)
+    def initialize(input = $stdin, **options, &block)
       super do
         @options = {reference_folding: true}.merge(@options)
         @repository = RDF::Repository.new
@@ -327,12 +327,24 @@ module RDF::RDFa
         end
         self.extend(@implementation)
 
-        detect_host_language_version(input, options)
+        detect_host_language_version(input, **options)
 
-        add_info(@doc, "version = #{@version},  host_language = #{@host_language}, library = #{@library}, rdfagraph = #{@options[:rdfagraph].inspect}, expand = #{@options[:vocab_expansion]}")
+        parse_lib = if @library == :nokogiri && @host_language == :html5
+          begin
+            require 'nokogumbo' unless defined?(::Nokogumbo)
+            :nokobumbo
+          rescue LoadError
+            :nokogiri
+          end
+        else
+          @library
+        end
+
+        parse_lib = @library == :nokogiri && defined?(::Nokogumbo) ? :nokogumbo : @library
+        add_info(@doc, "version = #{@version},  host_language = #{@host_language}, library = #{parse_lib}, rdfagraph = #{@options[:rdfagraph].inspect}, expand = #{@options[:vocab_expansion]}")
 
         begin
-          initialize_xml(input, options)
+          initialize_xml(input, **options)
         rescue
           add_error(nil, "Malformed document: #{$!.message}")
         end
@@ -369,6 +381,38 @@ module RDF::RDFa
       end
     end
 
+    ##
+    # Extracts RDF from script element, or embeded RDF/XML
+    def extract_script(el, input, type, **options, &block)
+      add_debug(el, "script element of type #{type}")
+      begin
+        # Formats don't exist unless they've been required
+        case type.to_s
+        when 'application/csvm+json' then require 'rdf/tabular'
+        when 'application/ld+json'   then require 'json/ld'
+        when 'application/rdf+xml'   then require 'rdf/rdfxml'
+        when 'text/ntriples'         then require 'rdf/ntriples'
+        when 'text/turtle'           then require 'rdf/turtle'
+        end
+      rescue LoadError
+      end
+
+      @readers ||= {}
+      reader = @readers[type.to_s] = RDF::Reader.for(content_type: type.to_s) unless @readers.has_key?(type.to_s)
+      if reader = @readers[type.to_s]
+        add_debug(el, "=> reader #{reader.to_sym}")
+        # Wrap input in a RemoteDocument with appropriate content-type and base
+        doc = if input.is_a?(String)
+          RDF::Util::File::RemoteDocument.new(input, content_type: type.to_s, **options)
+        else
+          input
+        end
+        reader.new(doc, **options).each(&block)
+      else
+        add_debug(el, "=> no reader found")
+      end
+    end
+
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -388,62 +432,19 @@ module RDF::RDFa
           # parse
           parse_whole_document(@doc, RDF::URI(base_uri))
 
-          def extract_script(el, input, type, options, &block)
-            add_debug(el, "script element of type #{type}")
-            begin
-              # Formats don't exist unless they've been required
-              case type.to_s
-              when 'application/csvm+json' then require 'rdf/tabular'
-              when 'application/ld+json'   then require 'json/ld'
-              when 'application/rdf+xml'   then require 'rdf/rdfxml'
-              when 'text/ntriples'         then require 'rdf/ntriples'
-              when 'text/turtle'           then require 'rdf/turtle'
-              end
-            rescue LoadError
-            end
-
-            if reader = RDF::Reader.for(content_type: type.to_s)
-              add_debug(el, "=> reader #{reader.to_sym}")
-              # Wrap input in a RemoteDocument with appropriate content-type and base
-              doc = if input.is_a?(String)
-                RDF::Util::File::RemoteDocument.new(input,
-                                                    options.merge(
-                                                      content_type: type.to_s,
-                                                      base_uri: base_uri
-                                                    ))
-              else
-                input
-              end
-              reader.new(doc, options).each(&block)
-            else
-              add_debug(el, "=> no reader found")
-            end
-          end
-        
           # Look for Embedded RDF/XML
           unless @root.xpath("//rdf:RDF", "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#").empty?
-            extract_script(@root, @doc, "application/rdf+xml", @options) do |statement|
+            extract_script(@root, @doc, "application/rdf+xml", **@options.merge(base_uri: base_uri)) do |statement|
               @repository << statement
             end
           end
 
-          # Look for Embedded scripts
-          @root.css("script[type]").each do |el|
-            type = el.attribute("type")
-
-            text = el.inner_html.sub(%r(\A\s*\<!\[CDATA\[)m, '').sub(%r(\]\]>\s*\Z)m, '')
-
-            extract_script(el, text, type, @options) do |statement|
-              @repository << statement
-            end
-          end
-        
           # Look for Embedded microdata
           unless @root.xpath("//@itemscope").empty?
             begin
               require 'rdf/microdata'
               add_debug(@doc, "process microdata")
-              @repository << RDF::Microdata::Reader.new(@doc, options)
+              @repository << RDF::Microdata::Reader.new(@doc, **options)
             rescue LoadError
               add_debug(@doc, "microdata detected, not processed")
             end
@@ -454,7 +455,7 @@ module RDF::RDFa
 
           # Perform vocabulary expansion
           expand(@repository) if @options[:vocab_expansion]
-        
+
           @processed = true
         end
 
@@ -493,7 +494,7 @@ module RDF::RDFa
       end
       enum_for(:each_triple)
     end
-    
+
     private
 
     # Keep track of allocated BNodes
@@ -501,12 +502,12 @@ module RDF::RDFa
       @bnode_cache ||= {}
       @bnode_cache[value.to_s] ||= RDF::Node.new(value)
     end
-    
+
     # Figure out the document path, if it is an Element or Attribute
     def node_path(node)
       "<#{base_uri}>#{node.respond_to?(:display_path) ? node.display_path : node}"
     end
-    
+
     # Add debug event to debug array, if specified
     #
     # @param [#display_path, #to_s] node XML Node or string for showing context
@@ -519,15 +520,15 @@ module RDF::RDFa
     def add_info(node, message, process_class = RDF::RDFA.Info, &block)
       add_processor_message(node, message, process_class, &block)
     end
-    
+
     def add_warning(node, message, process_class = RDF::RDFA.Warning)
       add_processor_message(node, message, process_class)
     end
-    
+
     def add_error(node, message, process_class = RDF::RDFA.Error)
       add_processor_message(node, message, process_class)
     end
-    
+
     def add_processor_message(node, message, process_class, &block)
       case process_class
       when RDF::RDFA.Error    then log_error(node_path(node), message, &block)
@@ -552,7 +553,7 @@ module RDF::RDFa
             RDF::Statement.new(nc, RDF::PTR.expression, node.path, graph_name: RDF::RDFA.ProcessorGraph)
           ]
         end
-        
+
         @repository.insert(*processor_statements)
         if cb = @options[:processor_callback]
           processor_statements.each {|s| cb.call(s)}
@@ -591,7 +592,7 @@ module RDF::RDFa
 
       # initialize the evaluation context with the appropriate base
       evaluation_context = EvaluationContext.new(base, @host_defaults)
-      
+
       if @version != :"rdfa1.0"
         # Process default vocabularies
         load_initial_contexts(@host_defaults[:initial_contexts]) do |which, value|
@@ -603,11 +604,11 @@ module RDF::RDFa
           end
         end
       end
-      
+
       traverse(root, evaluation_context)
       add_debug("", "parse_whole_doc: traversal complete'")
     end
-  
+
     # Parse and process URI mappings, Term mappings and a default vocabulary from @context
     #
     # Yields each mapping
@@ -725,7 +726,7 @@ module RDF::RDFa
         add_error(element, "Can't parse nil element")
         return nil
       end
-      
+
       add_debug(element) { "ec: #{evaluation_context.inspect}" }
 
       # local variables [7.5 Step 1]
@@ -763,6 +764,7 @@ module RDF::RDFa
         rev
         role
         src
+        type
         typeof
         value
         vocab
@@ -807,17 +809,26 @@ module RDF::RDFa
           "[Step 2] default_vocaulary: #{default_vocabulary.inspect}"
         }
       end
-      
+
       # Local term mappings [7.5 Step 3]
       # Next, the current element is then examined for URI mapping s and these are added to the local list of URI mappings.
       # Note that a URI mapping will simply overwrite any current mapping in the list that has the same name
       extract_mappings(element, uri_mappings, namespaces)
-    
+
       # Language information [7.5 Step 4]
       language = element.language || language
       language = nil if language.to_s.empty?
       add_debug(element) {"HTML5 [3.2.3.3] lang: #{language.inspect}"} if language
 
+      # Embedded scripts
+      if element.name == 'script'
+        text = element.inner_html.sub(%r(\A\s*\<!\[CDATA\[)m, '').sub(%r(\]\]>\s*\Z)m, '')
+
+        extract_script(element, text, attrs[:type], **@options.merge(base_uri: base)) do |statement|
+          @repository << statement
+        end
+      end
+
       # From HTML5, if the property attribute and the rel and/or rev attribute exists on the same element, the non-CURIE and non-URI rel and rev values are ignored. If, after this, the value of rel and/or rev becomes empty, then the processor must act as if the respective attribute is not present.
       if [:html5, :xhtml5].include?(@host_language) && attrs[:property] && (attrs[:rel] || attrs[:rev])
         old_rel, old_rev = attrs[:rel], attrs[:rev]
@@ -844,14 +855,14 @@ module RDF::RDFa
                           term_mappings: term_mappings,
                           vocab: default_vocabulary,
                           restrictions: TERMorCURIEorAbsIRI.fetch(@version, []))
-    
+
       add_debug(element) do
         "rels: #{rels.join(" ")}, revs: #{revs.join(" ")}"
       end unless (rels + revs).empty?
 
       if !(attrs[:rel] || attrs[:rev])
         # Establishing a new subject if no rel/rev [7.5 Step 5]
-        
+
         if @version == :"rdfa1.0"
           new_subject = if attrs[:about]
             process_uri(element, attrs[:about], evaluation_context, base,
@@ -989,7 +1000,7 @@ module RDF::RDFa
         new_subject ||= process_uri(element, attrs[:src], evaluation_context, base,
                                   uri_mappings: uri_mappings,
                                   restrictions: [:uri]) if @version == :"rdfa1.0"
-      
+
         # if the @typeof attribute is present, set typed resource to new subject
         typed_resource = new_subject if attrs[:typeof]
 
@@ -1008,7 +1019,7 @@ module RDF::RDFa
           evaluation_context.parent_object
           # no skip flag set this time
         end
-      
+
         # Then the current object resource is set to the URI obtained from the first match from the following rules:
         current_object_resource = process_uri(element, attrs[:resource], evaluation_context, base,
                       uri_mappings: uri_mappings,
@@ -1034,7 +1045,7 @@ module RDF::RDFa
           "typed_resource: #{typed_resource.to_ntriples rescue 'nil'}, "
         }
       end
-    
+
       # [Step 7] If in any of the previous steps a typed resource was set to a non-null value, it is now used to provide a subject for type values;
       if typed_resource
         # Typeof is TERMorCURIEorAbsIRIs
@@ -1082,7 +1093,7 @@ module RDF::RDFa
             add_triple(element, new_subject, r, current_object_resource)
           end
         end
-      
+
         revs.each do |r|
           add_triple(element, current_object_resource, r, new_subject)
         end
@@ -1090,7 +1101,7 @@ module RDF::RDFa
         # 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
         # lists: Save into list, don't generate triple
@@ -1108,12 +1119,12 @@ module RDF::RDFa
             incomplete_triples << {predicate: r, direction: :forward}
           end
         end
-      
+
         revs.each do |r|
           incomplete_triples << {predicate: r, direction: :reverse}
         end
       end
-    
+
       # Establish current object literal [Step 11]
       #
       # If the current element has a @inlist attribute, add the property to the
@@ -1267,11 +1278,11 @@ module RDF::RDFa
             add_debug(element)  {"[Step 11] add #{current_property_value.to_ntriples} to #{p.to_ntriples} #{list_mapping[p].inspect}"}
             list_mapping[p] << current_property_value
           elsif new_subject
-            add_triple(element, new_subject, p, current_property_value) 
+            add_triple(element, new_subject, p, current_property_value)
           end
         end
       end
-    
+
       if !skip and new_subject && !evaluation_context.incomplete_triples.empty?
         # Complete the incomplete triples from the evaluation context [Step 12]
         add_debug(element) do
@@ -1329,12 +1340,12 @@ module RDF::RDFa
           new_ec.list_mapping = list_mapping
           add_debug(element, "[Step 13] new ec")
         end
-      
+
         element.children.each do |child|
           # recurse only if it's an element
           traverse(child, new_ec) if child.element?
         end
-        
+
         # Step 14: after traversing through child elements, for each list associated with
         # a property
         (list_mapping || {}).each do |p, l|
@@ -1380,13 +1391,13 @@ module RDF::RDFa
     end
 
     # space-separated TERMorCURIEorAbsIRI or SafeCURIEorCURIEorIRI
-    def process_uris(element, value, evaluation_context, base, options)
+    def process_uris(element, value, evaluation_context, base, **options)
       return [] if value.to_s.empty?
       add_debug(element) {"process_uris: #{value}"}
-      value.to_s.split(/\s+/).map {|v| process_uri(element, v, evaluation_context, base, options)}.compact
+      value.to_s.split(/\s+/).map {|v| process_uri(element, v, evaluation_context, base, **options)}.compact
     end
 
-    def process_uri(element, value, evaluation_context, base, options = {})
+    def process_uri(element, value, evaluation_context, base, **options)
       return if value.nil?
       restrictions = options[:restrictions]
       add_debug(element) {"process_uri: #{value}, restrictions = #{restrictions.inspect}"}
@@ -1407,7 +1418,7 @@ module RDF::RDFa
         # TERMorCURIEorAbsIRI
         # If the value is an NCName, then it is evaluated as a term according to General Use of Terms in
         # Attributes. Note that this step may mean that the value is to be ignored.
-        uri = process_term(element, value.to_s, options)
+        uri = process_term(element, value.to_s, **options)
         add_debug(element) {"process_uri: #{value} => term => #{uri ? uri.to_base : 'nil'}"}
         uri
       else
@@ -1444,16 +1455,16 @@ module RDF::RDFa
         add_warning(element, "Relative URI #{value}")
       end
     end
-    
+
     # [7.4.3] General Use of Terms in Attributes
-    def process_term(element, value, options)
+    def process_term(element, value, **options)
       if options[:vocab]
         # If there is a local default vocabulary, the IRI is obtained by concatenating that value and the term
         return uri(options[:vocab] + value)
       elsif options[:term_mappings].is_a?(Hash)
         # If the term is in the local term mappings, use the associated URI (case sensitive).
         return uri(options[:term_mappings][value.to_s.to_sym]) if options[:term_mappings].has_key?(value.to_s.to_sym)
-      
+
         # Otherwise, check for case-insensitive match
         options[:term_mappings].each_pair do |term, uri|
           return uri(uri) if term.to_s.downcase == value.to_s.downcase