ape 1.5.1 → 1.6.0

data/README

@@ -29,7 +29,7 @@ If you've downloaded APE's source code you can execute it from the command line
  $ rake ape:go:text['service document uri', 'username', 'password']
  $ rake ape:go:atom['service document uri', 'username', 'password']
 
-The username and password paramenters are not mandatory, and the format response depends of the executed task.
+The username and password parameters are not mandatory, and the format response depends on the executed task.
 
 == The Source
 

data/Rakefile

@@ -2,6 +2,7 @@ require 'rake'
 require 'rake/clean'
 require 'rake/gempackagetask'
 require 'rake/testtask'
+require 'rake/rdoctask'
 
 $:.unshift File.dirname(__FILE__) + '/lib'
 require 'ape'
@@ -11,9 +12,9 @@ def spec
     s.platform = Gem::Platform::RUBY
     s.name = 'ape'
     s.version = Ape::VERSION::STRING
-    s.author = 'Tim Bray'
-    s.email = 'tim.bray@sun.com'
-    s.homepage = 'ape.rubyforge.org'
+    s.authors = ['Tim Bray', 'David Calavera']
+    s.email = ['tim.bray@sun.com', 'calavera@apache.org']
+    s.homepage = 'http://ape.rubyforge.org'
     s.summary = 'The Atom Protocol Exerciser'
 
     s.files = FileList['lib/**/*', 'samples/*', 'test/**/*', 'web/*',
@@ -21,7 +22,7 @@ def spec
     s.bindir = 'bin'
     s.executable = 'ape_server'
 
-    s.has_rdoc = false
+    s.has_rdoc = true
     s.extra_rdoc_files = ['README', 'LICENSE']
 
     s.rubyforge_project = 'ape'
@@ -45,7 +46,7 @@ task :setup do
   installed = Gem::SourceIndex.from_installed_gems  
   dependencies = spec.dependencies
   dependencies.select { |dep|
-    installed.search(dep.name, dep.version_requirements).empty? }.each do |dep|
+    installed.find_name(dep.name, dep.version_requirements).empty? }.each do |dep|
       puts "Installing #{dep} ..."
       install_gem dep.name, "-v '#{dep.version_requirements.to_s}'"
     end
@@ -63,4 +64,11 @@ task :test => [:test_units]
 Rake::TestTask.new("test_units") do |t|
   t.test_files = FileList['test/unit/*test.rb']
   t.verbose = false  
-end
+end
+
+# Rdoc ---------------------------------------------------------------
+
+Rake::RDocTask.new do |t|
+  t.main = 'README'
+  t.rdoc_files.include('README', 'LICENSE', 'lib/**/*.rb')
+end

data/bin/ape_server

@@ -20,7 +20,7 @@ parser = OptionParser.new do |opts|
   opts.separator ''
   opts.on('-a', '--address ADDRESS', 'Address to bind to', "default: #{OPTIONS[:host]}") { |v| OPTIONS[:host] = v }
   opts.on('-p', '--port PORT', 'Port to bind to', "default: #{OPTIONS[:port]}") { |v| OPTIONS[:port] = v }
-  opts.on('-d', '--directory DIRECTORY', 'ape home directory', "default: #{Ape::Ape.home}") { |v| OPTIONS[:home] = v }
+  opts.on('-d', '--directory DIRECTORY', 'ape home directory', "default: #{::Ape.home}") { |v| OPTIONS[:home] = v }
   opts.on('-h', '--help', 'Displays this help') { puts opts; exit }
   opts.parse!(ARGV)
 end

data/lib/ape.rb

@@ -4,7 +4,7 @@ $:.unshift File.dirname(__FILE__)
 module Ape
   require 'rubygems'
   
-  Dir[File.dirname(__FILE__) + '/ape/*.rb'].each { |l| require l }
+  Dir[File.dirname(__FILE__) + '/ape/*.rb'].sort.each { |l| require l }
   
   @CONF = {}
 
@@ -12,32 +12,28 @@ module Ape
     @CONF
   end
   
-  class Ape
-    attr_reader :aperc, :reporter
-    
-    @@home = nil
-    def self.home=(home)
-      @@home = home
-    end
+  def Ape.home=(home)
+    @CONF[:HOME] = home
+  end
 
-    def self.home
-      @@home || ENV["APE_HOME"] || File.join(home_directory,".ape")
-    end
+  def Ape.home
+    @CONF[:HOME] || ENV["APE_HOME"] || File.join(home_directory,".ape")
+  end
 
-    #recipe from cap
-    def self.home_directory
-      ENV["HOME"] || (ENV["HOMEPATH"] && "#{ENV["HOMEDRIVE"]}#{ENV["HOMEPATH"]}") || "/"
-    end
-    
+  def Ape.home_directory
+    ENV["HOME"] || (ENV["HOMEPATH"] && "#{ENV["HOMEDRIVE"]}#{ENV["HOMEPATH"]}") || "/"
+  end
+  
+  class Ape
     # Creates an Ape instance with options given in the +args+ Hash.
     #
     # ==== Options
-    #   * :output - one of 'text' or 'html'. #report will output in this format. Defaults to 'html'.
+    #   * :output - one of 'text' or 'html' or 'atom'. #report will output in this format. Defaults to 'html'.
     #   * :debug  - enables debug information at each step in the output
     def initialize(args = {})
       output = args[:output] || 'html'
       @reporter = Reporter.instance(output, args)
-      load File.join(Ape.home, 'aperc') if File.exist?(File.join(Ape.home, 'aperc'))
+      load File.join(::Ape.home, 'aperc') if File.exist?(File.join(::Ape.home, 'aperc'))
     end
 
     # Checks the AtomPub server at +uri+ for sanity.
@@ -46,44 +42,54 @@ module Ape
     #   * uri - the URI of the AtomPub server. Required.
     #   * username - an optional username for authentication
     #   * password - if a username is provided, a password is required. See Ape::Authent for more information.
+    #   * service_doc - an optional service document. It'll be used instead of getting it from the uri.
     #   * requested_e_coll - a preferred entry collection to check
     #   * requested_m_coll - a preferred media collection to check 
-    def check(uri, username=nil, password=nil,
+    def check(uri, username=nil, password=nil, service_doc = nil,
         requested_e_coll = nil, requested_m_coll = nil)
       
       @authent = Authent.new(username, password)
-      reporter.header = uri
+      @reporter.header = uri
       ::Ape.conf[:REQUESTED_ENTRY_COLLECTION] = requested_e_coll if requested_e_coll
       ::Ape.conf[:REQUESTED_MEDIA_COLLECTION] = requested_m_coll if requested_m_coll
       begin
-        might_fail(uri)
+        might_fail(uri, service_doc)
       rescue Exception
-        reporter.error(self, "Ouch! Ape fall down go boom; details: " +
+        @reporter.error(self, "Ouch! Ape fall down go boom; details: " +
           "#{$!}\n#{$!.class}\n#{$!.backtrace}")
       end
     end
 
-    def might_fail(uri)
-      service_validator = Validator.instance(:service_document, @reporter, @authent)
-      service_validator.validate(:uri => uri)
-      @service = service_validator.service_document
+    def might_fail(uri, service = nil)
+      unless (service)
+        service_validator = Validator.instance(:service_document, @reporter, @authent)
+        service_validator.validate(:uri => uri)
+        @service = service_validator.service_document
+      else
+        @service = service.instance_of?(String)?
+          REXML::Document.new(service, { :raw => nil }) : service
+      end
       @entry_collections = service_validator.entry_collections
       @media_collections = service_validator.media_collections
       
-      if @entry_collections && true != ::Ape.conf[:ENTRY_VALIDATION_DISABLED]
-        [:entry_posts, :sorting, :sanitization].each do |option|
-          check_validator(option)
+      unless true == ::Ape.conf[:ENTRY_VALIDATION_DISABLED]
+        if @entry_collections
+          [:entry_posts, :sorting, :sanitization].each do |option|
+            check_validator(option)
+          end
+        else
+          @reporter.warning(self, "No collection for 'application/atom+xml;type=entry', won't test entry posting.")
         end
-      else
-        reporter.warning(self, "No collection for 'application/atom+xml;type=entry', won't test entry posting.")
       end
 
-      if @media_collections && true != ::Ape.conf[:MEDIA_VALIDATION_DISABLED]
-        [:media_posts, :media_linkage].each do |option|
-          check_validator(option)
+      unless true == ::Ape.conf[:MEDIA_VALIDATION_DISABLED]
+        if @media_collections
+          [:media_posts, :media_linkage].each do |option|
+            check_validator(option)
+          end
+        else
+          @reporter.warning(self, "No collection for 'image/jpeg', won't test media posting.")
         end
-      else
-        reporter.warning(self, "No collection for 'image/jpeg', won't test media posting.")
       end
       
       #custom validators
@@ -92,6 +98,13 @@ module Ape
         break if !validator.validate(opts) && validator.deterministic?
       end
     end
+
+    def error_count
+      @reporter.errors.size
+    end
+    def warning_count
+      @reporter.warnings.size
+    end
     
     def report(output=STDOUT)
       @reporter.report(output)

data/lib/ape/atomURI.rb

@@ -1,10 +1,10 @@
-#   Copyright (c) 2006 Sun Microsystems, Inc. All rights reserved
+  #   Copyright (c) 2006 Sun Microsystems, Inc. All rights reserved
 #   Use is subject to license terms - see file "LICENSE"
 require 'uri'
 
 module Ape
   class AtomURI
-
+    
     def initialize base_uri
       if base_uri.kind_of? URI
         @base = base_uri

data/lib/ape/coll_element.rb

@@ -0,0 +1,67 @@
+#   Copyright (c) 2006 Sun Microsystems, Inc. All rights reserved
+#   Use is subject to license terms - see file "LICENSE"
+
+# Represents an <app:collection> element as found in an AtomPub Service Doc
+
+module Ape
+  class CollElement
+    
+    @@mime_re = %r{^(.*)/(.*)$}
+    
+    attr_reader :title, :accept, :href, :xml
+    
+    def CollElement::find_colls(source, doc_uri = nil)
+      els = REXML::XPath.match(source, '//app:collection', Names::XmlNamespaces)
+      els.map { |el| CollElement.new(el, doc_uri) }
+    end
+    
+    def initialize(el, doc_uri = nil)
+      @xml = el
+      @accept = []
+      @title = REXML::XPath.first(el, './atom:title', Names::XmlNamespaces)
+
+      # sigh, RNC validation *should* take care of this
+      raise(SyntaxError, "Collection is missing required 'atom:title'") unless @title
+      @title = @title.texts.join
+
+      if doc_uri
+        uris = AtomURI.new(doc_uri)
+        @href = uris.absolutize(el.attributes['href'], el)
+      else
+        @href = el.attributes['href']
+      end
+
+      # now we have to go looking for the accept
+      @accept = REXML::XPath.match(@xml, './app:accept/(text)', Names::XmlNamespaces)
+      @accept = [ Names::AtomEntryMediaType ] if @accept.empty?
+    end
+
+    # check if the collection accepts a given mime type; watch out for wildcards    
+    def accept?(mime_type)
+      if mime_type =~ @@mime_re
+        p1, p2 = $1, $2
+      else
+        return false # WTF?
+      end
+      @accept.each do |pat|
+        pat = pat.to_s # working around REXML ticket 164
+        if pat =~ @@mime_re
+          if ($1 == p1 || $1 == "*") && ($2 == p2 || $2 == "*")
+            return true
+          elsif ((pat == Names::AtomMediaType && mime_type == Names::AtomFeedMediaType) ||
+                (pat == Names::AtomFeedMediaType && mime_type == Names::AtomMediaType))
+            return true  
+          end
+        end
+      end
+      return false
+    end
+    
+    # the name is supposed to suggest multiple instances of "categories"
+    def catses
+      REXML::XPath.match(@xml, './app:categories', Names::XmlNamespaces)
+    end
+    
+
+  end 
+end

data/lib/ape/collection.rb

@@ -1,47 +1,44 @@
 #   Copyright (c) 2006 Sun Microsystems, Inc. All rights reserved
 #   Use is subject to license terms - see file "LICENSE"
+
+# Represents an AtomPub collection, which offers feed-reading and resource-CRUD
+#  services
 require 'rexml/xpath'
 
 module Ape
   class Collection 
-    attr_reader :title, :accept, :href
-
-    def initialize(input, doc_uri = nil)
-      @input = input
-      @accept = []
-      @title = REXML::XPath.first(input, './atom:title', Names::XmlNamespaces)
 
-      # sigh, RNC validation *should* take care of this
-      raise(SyntaxError, "Collection is missing required 'atom:title'") unless @title
-      @title = @title.texts.join
+    # The argument has to be an absolute URI
+    #
+    def initialize(uri, authent = nil)
+      @uri = uri      
+      @authent = authent
+    end
 
-      if doc_uri
-        uris = AtomURI.new(doc_uri)
-        @href = uris.absolutize(input.attributes['href'], input)
+    # Post a new element to this collection; return either an Ape::Entry or
+    #  an error-message
+    #
+    # ==== Options
+    #   * :data - element to post as a string
+    #   * :type - content type. By default 'application/atom+xml;type=entry'
+    #   * :slug - slug header
+    #
+    def post(opts = {})
+      return ':data argument not provided' unless opts[:data]
+      
+      type = opts[:type] || Names::AtomEntryMediaType
+      @invoker = Poster.new(@uri, @authent)
+      @invoker['Slug'] = opts[:slug] if opts[:slug]
+      
+      if @invoker.post(type, opts[:data]) 
+        @invoker.entry 
       else
-        @href = input.attributes['href']
+        @invoker.last_error    
       end
-
-      # now we have to go looking for the accept
-      @accept = []
-      REXML::XPath.each(input, './app:accept', Names::XmlNamespaces) do |a|
-        @accept << a.texts.join
-      end
-
-      @accept = [ Names::AtomEntryMediaType ] if @accept.empty?
     end
-
-    def to_s
-      @input.to_s
-    end
-
-    def to_str
-      to_s
-    end
-
-    # the name is supposed to suggest multiple instances of "categories"
-    def catses
-      REXML::XPath.match(@input, './app:categories', Names::XmlNamespaces)
+    
+    def crumbs
+      return @invoker.crumbs
     end
   end
 end

data/lib/ape/entry.rb

@@ -10,18 +10,26 @@ module Ape
   class Entry
     # @element is the REXML dom
     # @base is the base URI if known
+    attr_reader :uri
 
-    def initialize(node, uri = nil)
-      if node.class == String
-        @element = REXML::Document.new(node, { :raw => nil }).root
+    def initialize(opts)
+      if opts[:xml]
+        @element = opts[:xml]
+      elsif opts[:text]
+        @element = REXML::Document.new(opts[:text], { :raw => nil }).root
       else
-        @element = node
+        raise(ArgumentError, "Neither :xml nor :text provided")
       end
-      if uri
-        @base = AtomURI.new(uri)
+      
+      if opts[:uri]
+        @uri = opts[:uri]
+        @base = AtomURI.new(@uri)
       else
-        @base = nil
+        @base = @uri = nil
       end
+      
+      @authoritative = opts[:authoritative] || false
+      @etag = opts[:etag] || nil
     end
 
     def to_s
@@ -29,7 +37,7 @@ module Ape
     end
 
     def content_src
-      content = REXML::XPath.first(@element, './atom:content', Names::XmlNamespaces)
+      content = REXML::XPath.first(@element, './atom:content[@src]', Names::XmlNamespaces)
       if content
         cs = content.attributes['src']
         cs = @base.absolutize(cs, @element) if @base
@@ -40,9 +48,8 @@ module Ape
 
     def get_child(field, namespace = nil)
       if (namespace)
-        thisNS = {}
         prefix = 'NN'
-        thisNS[prefix] = namespace
+        thisNS = { prefix => namespace }
       else
         prefix = 'atom'
         thisNS = Names::XmlNamespaces
@@ -147,5 +154,10 @@ module Ape
       end
       Nodes.each_node(node.getChildNodes) {|child| dump(child, depth+1)}
     end
+    
+    def to_s
+      @element.to_s
+    end
+        
   end
 end

data/lib/ape/feed.rb

@@ -63,7 +63,7 @@ module Ape
           reporter.info(self, "#{label} has no entries.")
         end
 
-        entries += page_entries.map { |e| Entry.new(e, next_page)}
+        entries += page_entries.map { |e| Entry.new(:xml => e, :uri => next_page)}
         
         next_link = REXML::XPath.first(feed, "./atom:link[@rel=\"next\"]", Names::XmlNamespaces)
         if next_link

data/lib/ape/invoker.rb

@@ -8,6 +8,8 @@ module Ape
     
     def initialize(uriString, authent)
       @last_error = nil
+      
+      # XXX really need a way to turn crumbs on/off, mostly off
       @crumbs = Crumbs.new
       @uri = AtomURI.check(uriString)
       if (@uri.class == String)
@@ -15,6 +17,21 @@ module Ape
       end   
       @authent = authent
       @authent_checker = 0
+      @headers = {}
+    end
+    
+    #Add a new request header
+    def []=(name, val)
+      set_header(name, val)
+    end
+    
+    #get a request header
+    def [](name)
+      @headers[name]
+    end
+    
+    def set_header(name, val)
+      @headers[name] = val
     end
     
     def header(which)