rdf-rdfa 0.3.3 → 0.3.3.1

data/lib/rdf/rdfa/format.rb

@@ -22,7 +22,6 @@ module RDF::RDFa
     content_type     'text/html', :extension => :html
     reader { RDF::RDFa::Reader }
     writer { RDF::RDFa::Writer }
-    XMLNS = 'http://www.w3.org/1999/xhtml'  # FIXME: This or XHV or none at all?
   end
 
   # Aliases for RDFa::Format

data/lib/rdf/rdfa/reader.rb

@@ -12,6 +12,7 @@ module RDF::RDFa
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Reader < RDF::Reader
     format Format
+    XHTML = "http://www.w3.org/1999/xhtml"
     
     SafeCURIEorCURIEorURI = {
       :"rdfa1.0" => [:term, :safe_curie, :uri, :bnode],
@@ -191,33 +192,20 @@ module RDF::RDFa
         @debug = options[:debug]
         @base_uri = uri(options[:base_uri])
 
-        @host_language = options[:host_language]
+        detect_host_language_version(input, options)
+        
         @processor_graph = options[:processor_graph]
 
         @doc = case input
-        when Nokogiri::HTML::Document
-          @host_language ||= :xhtml1
-        when Nokogiri::XML::Document
+        when Nokogiri::HTML::Document, Nokogiri::XML::Document
           input
         else
-          # Intuit from content type
-          @host_language ||= case input.respond_to?(:content_type) && input.content_type
-          when "text/xml", "application/xml"
-            :xml1
-          when "text/html", "application/xhtml+xml"
-            :xhtml1
-          when "image/svg+xml"
-            :svg
-          end
-          
-          # Intuit from file extension
-          @host_language ||= case input.respond_to?(:path) && File.extname(input.path.to_s)
-          when ".html"  then :html5
-          when ".xhtml" then :xhtml1
-          when ".svg"   then :svg
+          case @host_language
+          when :html4, :html5
+            Nokogiri::HTML.parse(input, @base_uri.to_s)
+          else
+            Nokogiri::XML.parse(input, @base_uri.to_s)
           end
- 
-          Nokogiri::XML.parse(input, @base_uri.to_s)
         end
         
         if (@doc.nil? || @doc.root.nil?)
@@ -226,33 +214,6 @@ module RDF::RDFa
         end
         add_warning(nil, "Synax errors:\n#{@doc.errors}", RDF::RDFA.DocumentError) if !@doc.errors.empty? && validate?
 
-        @version = options[:version] ? options[:version].to_sym : nil
-        
-        # Check for version of the processor to use:
-        # * Check document type for "XHTML+RDFa 1.0"
-        # * Check @version attribute on the html element for the value "XHTML+RDFa 1.0"
-        @version ||= :"rdfa1.0" if @doc.doctype.to_s =~ /RDFa 1\.0/
-        @version ||= :"rdfa1.0" if @doc.root && @doc.root.attribute("version").to_s =~ /RDFa 1\.0/
-        @version ||= :"rdfa1.1" if @doc.root && @doc.root.attribute("version").to_s =~ /RDFa 1\.1/
-        @version ||= :"rdfa1.1"
-
-        # Intuit host_language from doctype
-        @host_language ||= case @doc.doctype.to_s
-        when /html 4/i      then :html4
-        when /xhtml\+rdfa/i then :xhtml1
-        when /html/         then :html5
-        end
-        
-        # Determine host language from element name
-        @host_language ||= case @doc.root.name.downcase.to_sym
-        when :html  then :xhtml1
-        when :svg   then :svg
-        else             :xml
-        end
-
-        # Otherwise, treat it as XML
-        @host_language ||= :xml1
-
         # Section 4.2 RDFa Host Language Conformance
         #
         # The Host Language may require the automatic inclusion of one or more default RDFa Profiles.
@@ -284,6 +245,76 @@ module RDF::RDFa
       self.profile_repository = options[:profile_repository] if options[:profile_repository]
     end
 
+    # Determine the host language and/or version from options and the input document
+    def detect_host_language_version(input, options)
+      @host_language = options[:host_language] ? options[:host_language].to_sym : nil
+      @version = options[:version] ? options[:version].to_sym : nil
+      return if @host_language && @version
+      
+      # Snif version based on input
+      case input
+      when Nokogiri::XML::Document, Nokogiri::HTML::Document
+        doc_type_string = input.doc_type.to_s
+        version_attr = input.root && @doc.root.attribute("version").to_s
+        root_element = input.root.name.downcase
+        root_namespace = input.root.namespace.to_s
+        root_attrs = input.root.attributes
+        content_type = case
+        when root_element == "html" && input.is_a?(Nokogiri::HTML::Document)
+          "text/html"
+        when root_element == "html" && input.is_a?(Nokogiri::XML::Document)
+          "application/xhtml+html"
+        end
+      else
+        content_type = input.content_type if input.respond_to?(:content_type)
+
+        # Determine from head of document
+        head = if input.respond_to?(:read)
+          input.rewind
+          string = input.read(1000)
+          input.rewind
+          string
+        else
+          input.to_s[0..1000]
+        end
+        
+        doc_type_string = head.match(%r(<!DOCTYPE[^>]*>)m).to_s
+        root = head.match(%r(<[^!\?>]*>)m).to_s
+        root_element = root.match(%r(^<(\S+)[ >])) ? $1 : ""
+        version_attr = root.match(/version\s+=\s+(\S+)[\s">]/m) ? $1 : ""
+      end
+
+      # Already using XML parser, determine from DOCTYPE and/or root element
+      @version ||= :"rdfa1.0" if doc_type_string =~ /RDFa 1\.0/
+      @version ||= :"rdfa1.0" if version_attr =~ /RDFa 1\.0/
+      @version ||= :"rdfa1.1" if version_attr =~ /RDFa 1\.1/
+      @version ||= :"rdfa1.1"
+
+      @host_language ||= case content_type
+      when "application/xml"  then :xml1
+      when "image/svg+xml"    then :svg
+      when "text/html"
+        case doc_type_string
+        when /html 4/i        then :html4
+        when /xhtml/i         then :xhtml1
+        when /html/i          then :html5
+        end
+      when "application/xhtml+xml"
+        case doc_type_string
+        when /html 4/i        then :html4
+        when /xhtml/i         then :xhtml1
+        when /html/i          then :xhtml5
+        end
+      else
+        case root_element
+        when /svg/i           then :svg
+        when /html/i          then :html4
+        end
+      end
+      
+      @host_language ||= :xml1
+    end
+    
     # @return [RDF::Repository]
     def profile_repository
       Profile.repository

data/rdf-rdfa.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rdf-rdfa}
-  s.version = "0.3.3"
+  s.version = "0.3.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gregg Kellogg"]
-  s.date = %q{2011-04-25}
+  s.date = %q{2011-04-26}
   s.description = %q{    RDF::RDFa is an RDFa reader/writer for Ruby using the RDF.rb library suite.
 }
   s.email = %q{gregg@kellogg-assoc.com}
@@ -34,6 +34,8 @@ Gem::Specification.new do |s|
     "etc/foaf.html",
     "etc/profile.html",
     "etc/xhv.html",
+    "example-files/bb-test.rb",
+    "example-files/best-buy.html",
     "example-files/data-view.xhtml",
     "example-files/erdf_profile.html",
     "example-files/payswarm.html",

data/script/tc

@@ -76,7 +76,7 @@ opts = GetoptLong.new(
   ["--quiet", GetoptLong::NO_ARGUMENT],
   ["--validate", GetoptLong::NO_ARGUMENT],
   ["--verbose", GetoptLong::NO_ARGUMENT],
-  ["--version", "-v", GetoptLong::OPTIONAL_ARGUMENT],
+  ["--version", "-v", GetoptLong::OPTIONAL_ARGUMENT]
 )
 
 def help(options)

data/spec/reader_spec.rb

@@ -528,12 +528,26 @@ describe "RDF::RDFa::Reader" do
               specify "test #{t.name}: #{t.title}#{",  (negative test)" if t.expectedResults.false?}" do
                 begin
                   t.debug = []
-                  graph = RDF::Graph.load(t.input(host_language, version), :debug => t.debug, :format => :rdfa)
+                  reader = RDF::Reader.open(t.input(host_language, version),
+                    :base_uri => t.input(host_language, version),
+                    :debug => t.debug,
+                    :format => :rdfa)
+                  reader.should be_a RDF::Reader
+
+                  # Make sure auto-detect works
+                  unless host_language =~ /svg/
+                    reader.host_language.should == host_language.to_sym
+                    reader.version.should == version.to_sym
+                  end
+
+                  graph = RDF::Graph.new << reader
                   query = Kernel.open(t.results(host_language, version))
                   graph.should pass_query(query, t)
                 rescue RSpec::Expectations::ExpectationNotMetError => e
                   if %w(0198).include?(t.name) || query =~ /XMLLiteral/m
                     pending("XMLLiteral canonicalization not implemented yet")
+                  elsif %w(html4 html5).include?(host_language) && Kernel.open(t.input(host_language, version)) {|f| f.read =~ /xmlns/}
+                    pending("HTML parsing does not use xmlns")
                   elsif classification != "required"
                     pending("#{classification} test") {  raise }
                   else

metadata

@@ -2,7 +2,7 @@
 name: rdf-rdfa
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.3
+  version: 0.3.3.1
 platform: ruby
 authors: 
 - Gregg Kellogg
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-25 00:00:00 -07:00
+date: 2011-04-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -281,6 +281,8 @@ files:
 - etc/foaf.html
 - etc/profile.html
 - etc/xhv.html
+- example-files/bb-test.rb
+- example-files/best-buy.html
 - example-files/data-view.xhtml
 - example-files/erdf_profile.html
 - example-files/payswarm.html