rdf-rdfa 0.0.1 → 0.0.2

data/lib/rdf/rdfa.rb

@@ -0,0 +1,38 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'rdf'
+
+module RDF
+  ##
+  # **`RDF::RDFa`** is an RDFa plugin for RDF.rb.
+  #
+  # @example Requiring the `RDF::RDFa` module
+  #   require 'rdf/rdfa'
+  #
+  # @example Parsing RDF statements from an XHTML+RDFa file
+  #   RDF::RDFa::Reader.open("etc/foaf.html") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into a XHTML+RDFa file
+  #   RDF::RDFa::Writer.open("etc/test.xml") do |writer|
+  #     reader.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @see http://rdf.rubyforge.org/
+  # @see http://www.w3.org/TR/xhtml-rdfa-primer/
+  # @see http://www.w3.org/2010/02/rdfa/wiki/Main_Page
+  # @see http://www.w3.org/TR/2010/WD-rdfa-core-20100422/
+  # @see http://www.w3.org/TR/2010/WD-xhtml-rdfa-20100422/
+  #
+  # @author [Gregg Kellogg](http://kellogg-assoc.com/)
+  module RDFa
+    require 'rdfa/format'
+    autoload :Reader,  'rdf/rdfa/reader'
+    autoload :Writer,  'rdf/rdfa/writer'
+    autoload :VERSION, 'rdf/rdfa/version'
+  end
+end\

data/lib/rdf/rdfa/format.rb

@@ -0,0 +1,28 @@
+module RDF::RDFa
+  ##
+  # RDFa format specification.
+  #
+  # @example Obtaining an RDFa format class
+  #   RDF::Format.for(:rdfa)     #=> RDF::RDFa::Format
+  #   RDF::Format.for("etc/foaf.html")
+  #   RDF::Format.for(:file_name      => "etc/foaf.html")
+  #   RDF::Format.for(:file_extension => "html")
+  #   RDF::Format.for(:content_type   => "text/html")
+  #   RDF::Format.for(:content_type   => "application/xhtml+xml")
+  #
+  # @example Obtaining serialization format MIME types
+  #   RDF::Format.content_types      #=> {"text/html" => [RDF::RDFa::Format]}
+  #
+  # @example Obtaining serialization format file extension mappings
+  #   RDF::Format.file_extensions    #=> {:xhtml => "application/xhtml+xml"}
+  #
+  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
+  class Format < RDF::Format
+    content_type     'text/html', :extension => :html
+    content_type     'application/xhtml+xml', :extension => :xhtml
+    content_encoding 'utf-8'
+
+    reader { RDF::RDFa::Reader }
+    XMLNS = 'http://www.w3.org/1999/xhtml'  # FIXME: This or XHV or none at all?
+  end
+end

data/lib/{rdfa → rdf/rdfa}/reader.rb

@@ -1,20 +1,15 @@
-require 'nokogiri'
+require 'nokogiri'  # FIXME: Implement using different modules as in RDF::TriX
 require 'rdf'
+require 'rdf/rdfa/vocab'
 
 module RDF::RDFa
   ##
   # An RDFa parser in Ruby
   #
-  # Based on processing rules described here:
-  #   file:///Users/gregg/Projects/rdf_context/RDFa%20Core%201.1.html#sequence
-  #
-  # Ben Adida
-  # 2008-05-07
-  # Gregg Kellogg
-  # 2009-08-04
+  # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Reader < RDF::Reader
-    autoload :Namespace, 'rdfa/reader/namespace'
-    autoload :VERSION,   'rdfa/reader/version'
+    format Format
+    autoload :VERSION,   'rdf/rdfa/version'
   
     NC_REGEXP = Regexp.new(
       %{^
@@ -29,24 +24,8 @@ module RDF::RDFa
       $},
       Regexp::EXTENDED)
   
-    #XML_LITERAL = Literal::Encoding.xmlliteral
     XML_LITERAL = RDF['XMLLiteral']
     
-    
-    # FIXME: use RDF::URI.qname instead
-    RDF_NS      = Namespace.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdf")
-    RDFA_NS     = Namespace.new("http://www.w3.org/ns/rdfa#", "rdfa")
-    RDFS_NS     = Namespace.new("http://www.w3.org/2000/01/rdf-schema#", "rdfs")
-    XHV_NS      = Namespace.new("http://www.w3.org/1999/xhtml/vocab#", "xhv")
-    XML_NS      = Namespace.new("http://www.w3.org/XML/1998/namespace", "xml")
-    XSD_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema#", "xsd")
-    XSI_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema-instance", "xsi")
-    XH_MAPPING  = {"" => Namespace.new("http://www.w3.org/1999/xhtml/vocab\#", nil)}
-  
-
-    require 'rdfa/format'
-    format RDFa::Format
-
     attr_reader :debug
 
     ##
@@ -124,8 +103,6 @@ module RDF::RDFa
       end
     end
 
-
-
     # Parse XHTML+RDFa document from a string or input stream to closure or graph.
     #
     # If the parser is called with a block, triples are passed to the block rather
@@ -159,8 +136,6 @@ module RDF::RDFa
         @base_uri = RDF::URI.parse(@base_uri) if @base_uri.is_a?(String)
         @named_bnodes = {}
         @@vocabulary_cache ||= {}
-        @nsbinding = {}
-        @uri_binding = {}
 
         @doc = case input
         when Nokogiri::HTML::Document then input
@@ -183,14 +158,13 @@ module RDF::RDFa
         @host_defaults = {}
         @host_defaults = case @host_language
         when :xhtml
-          bind(XHV_NS)
           {
-            :vocabulary => XHV_NS.uri,
-            :prefix     => XHV_NS,
+            :vocabulary => RDF::XHV["uri"],
+            :prefix     => "xhv",
             :term_mappings => %w(
               alternate appendix bookmark cite chapter contents copyright first glossary help icon index
               last license meta next p3pv1 prev role section stylesheet subsection start top up
-              ).inject({}) { |hash, term| hash[term] = XHV_NS.send("#{term}_"); hash },
+              ).inject({}) { |hash, term| hash[term] = RDF::XHV[term]; hash },
           }
         else
           {}
@@ -203,6 +177,7 @@ module RDF::RDFa
     end
 
 
+    # XXX Invoke the parser, and allow add_triple to make the callback?
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -224,27 +199,6 @@ module RDF::RDFa
     def each_triple(&block)
       @graph.each_triple(&block)
     end
-
-    # Bind namespace to store, returns bound namespace
-    def bind(namespace)
-      # Over-write an empty prefix
-      uri = namespace.uri.to_s
-      @uri_binding.delete(uri)
-      @nsbinding.delete_if {|prefix, ns| namespace.prefix == prefix}
-
-      @uri_binding[uri] = namespace
-      @nsbinding[namespace.prefix.to_s] = namespace
-    end
-
-    # Namespace for prefix
-    def namespace(prefix)
-      @nsbinding[prefix.to_s]
-    end
-    
-    # Prefix for namespace
-    def prefix(namespace)
-      namespace.is_a?(Namespace) ? @uri_binding[namespace.uri.to_s].prefix : @uri_binding[namespace].prefix
-    end
     
     private
 
@@ -266,26 +220,19 @@ module RDF::RDFa
       @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
     end
 
-    # add a triple, object can be literal or URI or bnode
-    #
-    # If the parser is called with a block, triples are passed to the block rather
-    # than added to the graph.
+    # add a statement, object can be literal or URI or bnode
     #
     # @param [Nokogiri::XML::Node, any] node:: XML Node or string for showing context
-    # @param [URI, BNode] subject:: the subject of the triple
-    # @param [URI] predicate:: the predicate of the triple
-    # @param [URI, BNode, Literal] object:: the object of the triple
-    # @return [Array]:: An array of the triples (leaky abstraction? consider returning the graph instead)
-    # @raise [Error]:: Checks parameter types and raises if they are incorrect if parsing mode is _strict_.
+    # @param [URI, BNode] subject:: the subject of the statement
+    # @param [URI] predicate:: the predicate of the statement
+    # @param [URI, BNode, Literal] object:: the object of the statement
+    # @return [Statement]:: Added statement
+    # @raise [Exception]:: Checks parameter types and raises if they are incorrect if parsing mode is _strict_.
     def add_triple(node, subject, predicate, object)
-      triple = RDF::Statement.new(subject, predicate, object)
-      add_debug(node, "triple: #{triple}")
-      if @callback
-        @callback.call(triple)  # Perform yield to saved block
-      else
-        @graph << triple
-      end
-      triple
+      statement = RDF::Statement.new(subject, predicate, object)
+      add_debug(node, "statement: #{statement}")
+      @graph << statement
+      statement
     # FIXME: rescue RdfException => e
     rescue Exception => e
       add_debug(node, "add_triple raised #{e.class}: #{e.message}")
@@ -355,9 +302,9 @@ module RDF::RDFa
               
               # If one of the objects is not a Literal or if there are additional rdfa:uri or rdfa:term
               # predicates sharing the same subject, no mapping is created.
-              uri = props[RDFA_NS.uri.to_s]
-              term = props[RDFA_NS.term_.to_s]
-              prefix = props[RDFA_NS.prefix_.to_s]
+              uri = props[RDF::RDFA["uri"].to_s]
+              term = props[RDF::RDFA["term"].to_s]
+              prefix = props[RDF::RDFA["prefix"].to_s]
               add_debug(element, "extract_mappings: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}")
 
               next if !uri || (!term && !prefix)
@@ -377,12 +324,12 @@ module RDF::RDFa
               # 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
-              um[prefix.to_s.downcase] = bind(Namespace.new(uri.to_s, prefix.to_s.downcase)) if prefix
+              um[prefix.to_s.downcase] = RDF::URI.new(uri) if 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.
-              tm[term.to_s] = RDF::URI.new(uri.to_s) if term
+              tm[term.to_s] = RDF::URI.new(uri) if term
             end
           rescue ParserException
             add_debug(element, "extract_mappings: profile subject #{subject.to_s}: #{e.message}")
@@ -406,7 +353,7 @@ module RDF::RDFa
       element.namespaces.each do |attr_name, attr_value|
         begin
           abbr, prefix = attr_name.split(":")
-          uri_mappings[prefix.to_s.downcase] = bind(Namespace.new(attr_value, prefix.to_s.downcase)) if abbr.downcase == "xmlns" && prefix
+          uri_mappings[prefix.to_s.downcase] = RDF::URI.new(attr_value) if abbr.downcase == "xmlns" && prefix
         # FIXME: rescue RdfException => e
         rescue Exception => e
           add_debug(element, "extract_mappings raised #{e.class}: #{e.message}")
@@ -425,7 +372,7 @@ module RDF::RDFa
         next unless prefix.match(/:$/)
         prefix.chop!
         
-        uri_mappings[prefix] = bind(Namespace.new(uri, prefix))
+        uri_mappings[prefix] = RDF::URI.new(uri)
       end
       
       add_debug(element, "uri_mappings: #{uri_mappings.values.map{|ns|ns.to_s}.join(", ")}")
@@ -481,7 +428,7 @@ module RDF::RDFa
           # Set default_vocabulary to host language default
           @host_defaults.fetch(:voabulary, nil)
         else
-          vocab.to_s
+          RDF::URI.new(vocab)
         end
         add_debug(element, "[Step 2] traverse, default_vocaulary: #{default_vocabulary.inspect}")
       end
@@ -498,8 +445,8 @@ module RDF::RDFa
       #   attribute in no namespace must be ignored for the purposes of determining the element's
       #   language.
       language = case
-      when element.at_xpath("@xml:lang", "xml" => XML_NS.uri.to_s)
-        element.at_xpath("@xml:lang", "xml" => XML_NS.uri.to_s).to_s
+      when element.at_xpath("@xml:lang", "xml" => RDF::XML["uri"].to_s)
+        element.at_xpath("@xml:lang", "xml" => RDF::XML["uri"].to_s).to_s
       when element.at_xpath("lang")
         element.at_xpath("lang").to_s
       else
@@ -735,7 +682,7 @@ module RDF::RDFa
           add_debug(element, "process_uri: #{value} => CURIE => <#{uri}>")
         else
           #FIXME: uri = URIRef.new(value, evaluation_context.base)
-          uri = RDF::URI.new(value)
+          uri = RDF::URI.new(evaluation_context.base + value)
           add_debug(element, "process_uri: #{value} => URI => <#{uri}>")
         end
         uri
@@ -756,7 +703,7 @@ module RDF::RDFa
         options[:term_mappings][value.to_s.downcase]
       when options[:vocab]
         # Otherwise, if there is a local default vocabulary the URI is obtained by concatenating that value and the term.
-        options[:vocab] + value
+        options[:vocab].join(value)
       else
         # Finally, if there is no local default vocabulary, the term has no associated URI and must be ignored.
         nil
@@ -765,7 +712,7 @@ module RDF::RDFa
 
     # From section 6. CURIE Syntax Definition
     def curie_to_resource_or_bnode(element, curie, uri_mappings, subject)
-      # URI mappings for CURIEs default to XH_MAPPING, rather than the default doc namespace
+      # URI mappings for CURIEs default to XHV, rather than the default doc namespace
       prefix, reference = curie.to_s.split(":")
 
       # consider the bnode situation
@@ -776,18 +723,18 @@ module RDF::RDFa
       elsif curie.to_s.match(/^:/)
         # Default prefix
         if uri_mappings[""]
-          uri_mappings[""].send("#{reference}_")
+          uri_mappings[""].join(reference)
         elsif @host_defaults[:prefix]
-          @host_defaults[:prefix].send("#{reference}_")
+          @host_defaults[:prefix].join(reference)
         end
       elsif !curie.to_s.match(/:/)
         # No prefix, undefined (in this context, it is evaluated as a term elsewhere)
         nil
       else
-        # XXX Spec Confusion, are prefixes always downcased?
+        # Prefixes always downcased
         ns = uri_mappings[prefix.to_s.downcase]
         if ns
-          ns + reference
+          ns.join(reference)
         else
           add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix.downcase}")
           nil

data/lib/{rdfa/reader → rdf/rdfa}/version.rb

@@ -1,8 +1,8 @@
 module RDFa
   module VERSION
     MAJOR = 0
-    MINOR = 1
-    TINY  = 0
+    MINOR = 0
+    TINY  = 2
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/rdf/rdfa/vocab.rb

@@ -0,0 +1,7 @@
+module RDF
+  class RDFA < Vocabulary("http://www.w3.org/ns/rdfa#"); end
+  class XHV < Vocabulary("http://www.w3.org/1999/xhtml/vocab#"); end
+  class XML < Vocabulary("http://www.w3.org/XML/1998/namespace"); end
+  class XSI < Vocabulary("http://www.w3.org/2001/XMLSchema-instance"); end
+  class OWL < Vocabulary("http://www.w3.org/2002/07/owl#"); end
+end

data/pkg/.gitignore

@@ -0,0 +1 @@
+/*.gem

data/rdf-rdfa.gemspec

@@ -0,0 +1,195 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rdf-rdfa}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gregg Kellogg", "Nicholas Humfrey"]
+  s.date = %q{2010-06-03}
+  s.description = %q{    RDF::RDFa is an RDFa parser for Ruby using the RDF.rb library suite.
+}
+  s.email = %q{gregg@kellogg-assoc.com}
+  s.extra_rdoc_files = [
+    "AUTHORS",
+     "History.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    "AUTHORS",
+     "History.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "etc/foaf.html",
+     "etc/xhv.html",
+     "example.rb",
+     "lib/rdf/rdfa.rb",
+     "lib/rdf/rdfa/format.rb",
+     "lib/rdf/rdfa/reader.rb",
+     "lib/rdf/rdfa/reader/exceptions.rb",
+     "lib/rdf/rdfa/version.rb",
+     "lib/rdf/rdfa/vocab.rb",
+     "pkg/.gitignore",
+     "rdf-rdfa.gemspec",
+     "script/console",
+     "spec/rdfa-triples/0001.nt",
+     "spec/rdfa-triples/0006.nt",
+     "spec/rdfa-triples/0007.nt",
+     "spec/rdfa-triples/0008.nt",
+     "spec/rdfa-triples/0009.nt",
+     "spec/rdfa-triples/0010.nt",
+     "spec/rdfa-triples/0011.nt",
+     "spec/rdfa-triples/0012.nt",
+     "spec/rdfa-triples/0013.nt",
+     "spec/rdfa-triples/0014.nt",
+     "spec/rdfa-triples/0015.nt",
+     "spec/rdfa-triples/0017.nt",
+     "spec/rdfa-triples/0018.nt",
+     "spec/rdfa-triples/0019.nt",
+     "spec/rdfa-triples/0020.nt",
+     "spec/rdfa-triples/0021.nt",
+     "spec/rdfa-triples/0023.nt",
+     "spec/rdfa-triples/0025.nt",
+     "spec/rdfa-triples/0026.nt",
+     "spec/rdfa-triples/0027.nt",
+     "spec/rdfa-triples/0029.nt",
+     "spec/rdfa-triples/0030.nt",
+     "spec/rdfa-triples/0031.nt",
+     "spec/rdfa-triples/0032.nt",
+     "spec/rdfa-triples/0033.nt",
+     "spec/rdfa-triples/0034.nt",
+     "spec/rdfa-triples/0035.nt",
+     "spec/rdfa-triples/0036.nt",
+     "spec/rdfa-triples/0037.nt",
+     "spec/rdfa-triples/0038.nt",
+     "spec/rdfa-triples/0039.nt",
+     "spec/rdfa-triples/0040.nt",
+     "spec/rdfa-triples/0041.nt",
+     "spec/rdfa-triples/0042.nt",
+     "spec/rdfa-triples/0046.nt",
+     "spec/rdfa-triples/0047.nt",
+     "spec/rdfa-triples/0048.nt",
+     "spec/rdfa-triples/0049.nt",
+     "spec/rdfa-triples/0050.nt",
+     "spec/rdfa-triples/0051.nt",
+     "spec/rdfa-triples/0052.nt",
+     "spec/rdfa-triples/0053.nt",
+     "spec/rdfa-triples/0054.nt",
+     "spec/rdfa-triples/0055.nt",
+     "spec/rdfa-triples/0056.nt",
+     "spec/rdfa-triples/0057.nt",
+     "spec/rdfa-triples/0058.nt",
+     "spec/rdfa-triples/0059.nt",
+     "spec/rdfa-triples/0060.nt",
+     "spec/rdfa-triples/0061.nt",
+     "spec/rdfa-triples/0062.nt",
+     "spec/rdfa-triples/0063.nt",
+     "spec/rdfa-triples/0064.nt",
+     "spec/rdfa-triples/0065.nt",
+     "spec/rdfa-triples/0066.nt",
+     "spec/rdfa-triples/0067.nt",
+     "spec/rdfa-triples/0068.nt",
+     "spec/rdfa-triples/0069.nt",
+     "spec/rdfa-triples/0070.nt",
+     "spec/rdfa-triples/0071.nt",
+     "spec/rdfa-triples/0072.nt",
+     "spec/rdfa-triples/0073.nt",
+     "spec/rdfa-triples/0074.nt",
+     "spec/rdfa-triples/0075.nt",
+     "spec/rdfa-triples/0076.nt",
+     "spec/rdfa-triples/0077.nt",
+     "spec/rdfa-triples/0078.nt",
+     "spec/rdfa-triples/0079.nt",
+     "spec/rdfa-triples/0080.nt",
+     "spec/rdfa-triples/0081.nt",
+     "spec/rdfa-triples/0082.nt",
+     "spec/rdfa-triples/0083.nt",
+     "spec/rdfa-triples/0084.nt",
+     "spec/rdfa-triples/0085.nt",
+     "spec/rdfa-triples/0086.nt",
+     "spec/rdfa-triples/0087.nt",
+     "spec/rdfa-triples/0088.nt",
+     "spec/rdfa-triples/0089.nt",
+     "spec/rdfa-triples/0090.nt",
+     "spec/rdfa-triples/0091.nt",
+     "spec/rdfa-triples/0092.nt",
+     "spec/rdfa-triples/0093.nt",
+     "spec/rdfa-triples/0094.nt",
+     "spec/rdfa-triples/0099.nt",
+     "spec/rdfa-triples/0100.nt",
+     "spec/rdfa-triples/0101.nt",
+     "spec/rdfa-triples/0102.nt",
+     "spec/rdfa-triples/0103.nt",
+     "spec/rdfa-triples/0104.nt",
+     "spec/rdfa-triples/0105.nt",
+     "spec/rdfa-triples/0106.nt",
+     "spec/rdfa-triples/0107.nt",
+     "spec/rdfa-triples/0108.nt",
+     "spec/rdfa-triples/0109.nt",
+     "spec/rdfa-triples/0110.nt",
+     "spec/rdfa-triples/0111.nt",
+     "spec/rdfa-triples/0112.nt",
+     "spec/rdfa-triples/0113.nt",
+     "spec/rdfa-triples/0114.nt",
+     "spec/rdfa-triples/0115.nt",
+     "spec/rdfa-triples/0116.nt",
+     "spec/rdfa-triples/0117.nt",
+     "spec/rdfa-triples/0118.nt",
+     "spec/rdfa-triples/0119.nt",
+     "spec/rdfa-triples/0120.nt",
+     "spec/rdfa-triples/0121.nt",
+     "spec/rdfa-triples/0122.nt",
+     "spec/rdfa-triples/0123.nt",
+     "spec/rdfa-triples/0124.nt",
+     "spec/rdfa-triples/0125.nt",
+     "spec/rdfa-triples/0126.nt",
+     "spec/rdfa-triples/1001.nt",
+     "spec/rdfa_helper.rb",
+     "spec/rdfa_reader_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/gkellogg/rdf-rdfa}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{RDFa parser for RDF.rb.}
+  s.test_files = [
+    "spec/rdfa_helper.rb",
+     "spec/rdfa_reader_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rdf>, [">= 0.1.6"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.3.3"])
+      s.add_runtime_dependency(%q<patron>, [">= 0.4.6"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<rdf-spec>, [">= 0"])
+      s.add_development_dependency(%q<activesupport>, [">= 2.3.0"])
+    else
+      s.add_dependency(%q<rdf>, [">= 0.1.6"])
+      s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
+      s.add_dependency(%q<patron>, [">= 0.4.6"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<rdf-spec>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 2.3.0"])
+    end
+  else
+    s.add_dependency(%q<rdf>, [">= 0.1.6"])
+    s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
+    s.add_dependency(%q<patron>, [">= 0.4.6"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<rdf-spec>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 2.3.0"])
+  end
+end
+