atom-tools 0.9.2 → 0.9.3

data/README

@@ -10,7 +10,7 @@ It handles all the nasty XML and HTTP details so that you don't have to.
 
   feed = Atom::Feed.new "http://www.tbray.org/ongoing/ongoing.atom"
     # => <http://www.tbray.org/ongoing/ongoing.atom entries: 0 title=''>
-  
+
   feed.update!
   feed.entries.length
     # => 20
@@ -29,7 +29,7 @@ It handles all the nasty XML and HTTP details so that you don't have to.
 
   entry.links.last
     # => {"href"=>"http://www.tbray.org/ongoing/When/200x/2006/11/07/Munich#comments", "rel"=>"replies", "type" => "application/xhtml+xml"}
-  
+
   entry.summary.to_s
     # => "That local spelling is nicer than the ugly English [...]"
 

data/Rakefile

@@ -6,7 +6,7 @@ require "rake/gempackagetask"
 require "rake/clean"
 
 NAME = "atom-tools"
-VERS = "0.9.2"
+VERS = "0.9.3"
 
 # the following from markaby-0.5's tools/rakehelp
 def setup_tests

data/bin/atom-client.rb

@@ -1,7 +1,29 @@
 #!/usr/bin/ruby
 
-# syntax: ./atom-client.rb <introspection-url> [username] [password]
-#   a really simple YAML-and-$EDITOR based Publishing Protocol client
+require "optparse"
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]"
+
+  opts.on("-c", "--coll-url [URL]", "URL of the collection you would like to manipulate") do |url|
+    options[:url] = url
+  end
+
+  opts.on("-u", "--user [USERNAME]", "Username to authenticate with") do |user|
+    options[:user] = user
+  end
+
+  opts.on("-p", "--password [PASSWORD]", "Password to authenticate with") do |pass|
+    options[:pass] = pass
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse!
 
 require "tempfile"
 
@@ -57,21 +79,20 @@ class Atom::Entry
 
   def edit
     yaml = YAML.load(self.to_yaml)
-    
-    # humans don't care about these things, we can replace it later
+   
+    # human readability
     yaml.delete "id"
 
     if yaml["links"]
-      yaml["links"].delete(yaml["links"].find { |l| l["rel"] == "edit" })
-      yaml["links"].delete(yaml["links"].find { |l| l["rel"] == "alternate" })
+      yaml["links"].find_all { |l| l["rel"] == "alternate" or l["rel"] == "edit" }.each { |l| yaml["links"].delete(l) }
       yaml.delete("links") if yaml["links"].empty?
     end
-
-    entry = write_entry(yaml.to_yaml)
+    
+    new_yaml, entry = write_entry(yaml.to_yaml)
     
     entry.id = self.id
 
-    entry
+    [new_yaml["slug"], entry]
   end
 end
 
@@ -95,24 +116,6 @@ def choose_from list
   item
 end
 
-def choose_collection server
-  puts "which collection?"
-
-  collections = []
-
-  # flatten it out into one big workspace
-  server.workspaces.each do |ws|
-    puts ws.title.to_s + ":"
-    ws.collections.each_with_index do |coll, index|
-      collections << coll
-
-      puts "#{index}: #{coll.title}"
-    end
-  end
-
-  choose_from collections
-end
-
 def choose_entry_url coll
   puts "which entry?"
 
@@ -134,11 +137,13 @@ def write_entry(editstring = "")
     edited = editstring.edit_externally
 
     if edited == editstring
-      puts "unchanged content, aborted"
+      puts "You didn't edit anything, aborting."
       exit
     end
 
-    entry = Atom::Entry.from_yaml edited
+    yaml = YAML.load(edited)
+
+    entry = Atom::Entry.from_yaml yaml
 
     entry.prepare_for_output
 
@@ -167,29 +172,46 @@ def write_entry(editstring = "")
     retry
   end
 
-  entry
+  [yaml, entry]
 end
 
 module Atom
-  class InvalidEntry < RuntimeError
-  end
+  class InvalidEntry < RuntimeError; end
 end
 
 EDITOR = ENV["EDITOR"] || "env vim"
 
-# now that i'm supporting -07 the interface has been shittified. apologies.
-introspection_url = ARGV[0]
-
 http = Atom::HTTP.new
-http.user = ARGV[1]
-http.pass = ARGV[2]
 
-server = Atom::Service.new(introspection_url, http)
+url = if options[:url]
+  options[:url]
+else
+  yaml = YAML.load(File.read("#{ENV["HOME"]}/.atom-client"))
+  collections = yaml["collections"]
 
-coll = choose_collection server
+  puts "which collection?"
+
+  collections.keys.each_with_index do |name,index|
+    puts "#{index}: #{name}"
+  end
 
-# XXX the server should *probably* replace this, but who knows yet?
-CLIENT_ID = "http://necronomicorp.com/dev/null"
+  tmp = choose_from collections.values
+
+  http.user = tmp["user"] if tmp["user"]
+  http.pass = tmp["pass"] if tmp["pass"]
+
+  tmp["url"]
+end
+
+http.user = options[:user] if options[:user]
+http.pass = options[:pass] if options[:pass]
+
+# this is where all the Atom stuff starts
+
+coll = Atom::Collection.new(url, http)
+
+# XXX generate a real id
+CLIENT_ID = "http://necronomicorp.com/nil"
 
 new = lambda do
   entry = Atom::Entry.new
@@ -197,12 +219,12 @@ new = lambda do
   entry.title = ""
   entry.content = ""
 
-  entry = entry.edit
+  slug, entry = entry.edit
 
   entry.id = CLIENT_ID
   entry.published = Time.now.iso8601
 
-  res = coll.post! entry
+  res = coll.post! entry, slug
 
   # XXX error recovery here, lost updates suck
   puts res.body
@@ -219,9 +241,13 @@ edit = lambda do
 
   url = entry.edit_url
 
+  raise "this entry has no edit link" unless url
+
   entry = http.get_atom_entry url
 
-  res = coll.put! entry.edit, url
+  slug, new_entry = entry.edit
+
+  res = coll.put! new_entry, url
 
   # XXX error recovery here, lost updates suck
   puts res.body
@@ -229,7 +255,7 @@ end
 
 delete = lambda do
   coll.update!
-  
+
   coll.entries.each_with_index do |entry,idx|
     puts "#{idx} #{entry.title}"
   end

data/lib/atom/element.rb

@@ -32,6 +32,11 @@ module Atom # :nodoc:
         item
       end
 
+      def << item
+        raise ArgumentError, "this can only hold items of class #{self.class.holds}" unless item.is_a? self.class.holds
+        super(item)
+      end
+
       def to_element
         collect do |item| item.to_element end
       end
@@ -42,6 +47,8 @@ module Atom # :nodoc:
     end
   end
 
+  # The Class' methods provide a DSL for describing Atom's structure
+  #   (and more generally for describing simple namespaced XML)
   class Element < Hash 
     # a REXML::Element that shares this element's extension attributes
     # and child elements
@@ -50,8 +57,6 @@ module Atom # :nodoc:
     # this element's xml:base
     attr_accessor :base
 
-    # The following is a DSL for describing an atom element.
-
     # this element's attributes
     def self.attrs # :nodoc:
       @attrs || []

data/lib/atom/entry.rb

@@ -5,6 +5,7 @@ require "atom/text"
 
 module Atom
   NS = "http://www.w3.org/2005/Atom"
+  PP_NS = "http://purl.org/atom/app#"
 
   # An individual entry in a feed. As an Atom::Element, it can be
   # manipulated using accessors for each of its child elements. You
@@ -33,31 +34,31 @@ module Atom
     element :id, String, true
     element :title, Atom::Text, true
     element :content, Atom::Content, true
-    
+
     element :rights, Atom::Text
     # element :source, Atom::Feed  # complicated, eg. serialization
-    
+
     element :authors, Atom::Multiple(Atom::Author)
     element :contributors, Atom::Multiple(Atom::Contributor)
-    
+
     element :categories, Atom::Multiple(Atom::Category)
     element :links, Atom::Multiple(Atom::Link)
-    
+
     element :published, Atom::Time
     element :updated, Atom::Time, true
-    
+
     element :summary, Atom::Text
 
     def initialize # :nodoc:
       super "entry"
-     
+
       # XXX I don't think I've ever actually used this
       yield self if block_given?
     end
 
     # parses XML into an Atom::Entry
-    # 
-    # +base+ is the absolute URI the document was fetched from 
+    #
+    # +base+ is the absolute URI the document was fetched from
     # (if there is one)
     def self.parse xml, base = ""
       if xml.respond_to? :to_atom_entry
@@ -80,11 +81,12 @@ module Atom
       self.updated = Time.now
     end
 
-    # categorize the entry based on a space-separated string
-    def tag_with string
-      return if string.nil?
+    # categorize the entry with each of an array or a space-separated
+    #   string
+    def tag_with tags
+      return unless tags
 
-      string.split.each do |tag|
+      (tags.is_a?(String) ? tags.split : tags).each do |tag|
         categories.new["term"] = tag
       end
     end
@@ -102,6 +104,39 @@ module Atom
       end
     end
 
+    def draft
+      elem = REXML::XPath.first(extensions, "app:control/app:draft", {"app" => PP_NS})
+
+      elem and elem.text == "yes"
+    end
+
+    def draft= is_draft
+      nses = {"app" => PP_NS}
+      draft_e = REXML::XPath.first(extensions, "app:control/app:draft", nses)
+      control_e = REXML::XPath.first(extensions, "app:control", nses)
+
+      if is_draft and not draft
+        unless draft_e
+          unless control_e
+            control_e = REXML::Element.new("control")
+            control_e.add_namespace PP_NS
+
+            extensions << control_e
+          end
+
+          draft_e = REXML::Element.new("draft")
+          control_e << draft_e
+        end
+
+        draft_e.text = "yes"
+      elsif not is_draft and draft
+        draft_e.remove
+        control_e.remove if control_e.elements.empty?
+      end
+
+      is_draft
+    end
+
 # XXX this needs a test suite before it can be trusted.
 =begin
     # tests the entry's validity
@@ -126,18 +161,18 @@ module Atom
 
       alternates.each do |link|
         if alternates.find do |x|
-          not x == link and 
-            x["type"] == link["type"] and 
+          not x == link and
+            x["type"] == link["type"] and
             x["hreflang"] == link["hreflang"]
           end
-         
+
           return [ false, 'more than one atom:link with a rel attribute value of "alternate" that has the same combination of type and hreflang attribute values.' ]
         end
       end
 
       type = @content["type"]
 
-      base64ed = (not ["", "text", "html", "xhtml"].member? type) and 
+      base64ed = (not ["", "text", "html", "xhtml"].member? type) and
         type.match(/^text\/.*/).nil? and  # not text
         type.match(/.*[\+\/]xml$/).nil?   # not XML
 

data/lib/atom/feed.rb

@@ -167,11 +167,6 @@ module Atom
 
       res = @http.get(@uri, headers)
 
-      # we'll be forgiving about feed content types.
-      res.validate_content_type(["application/atom+xml", 
-                                  "application/xml", 
-                                  "text/xml"])
-
       if res.code == "304"
         # we're already all up to date
         return self
@@ -181,7 +176,12 @@ module Atom
         raise Atom::HTTPException, "Unexpected HTTP response code: #{res.code}"
       end
        
-      @etag = res["Etag"] if res["Etag"]
+      # we'll be forgiving about feed content types.
+      res.validate_content_type(["application/atom+xml", 
+                                  "application/xml", 
+                                  "text/xml"])
+
+      @etag = res["ETag"] if res["ETag"]
       @last_modified = res["Last-Modified"] if res["Last-Modified"]
 
       xml = res.body

data/lib/atom/http.rb

@@ -14,7 +14,7 @@ class String # :nodoc:
 end
 
 module Atom
-  UA = "atom-tools 0.9.2"
+  UA = "atom-tools 0.9.3"
 
   module DigestAuth
     CNONCE = Digest::MD5.new("%x" % (Time.now.to_i + rand(65535))).hexdigest
@@ -172,12 +172,11 @@ module Atom
     #
     # the default is to use the values of @user and @pass.
     #
-    # your block will be called with two parameters
+    # your block will be called with two parameters:
     # abs_url:: the base URL of the request URL
-    # realm:: the realm used in the WWW-Authenticate header 
-    # (will be nil if there is no WWW-Authenticate header)
-    # 
-    # it should return a value of the form [username, password]
+    # realm:: the realm used in the WWW-Authenticate header (maybe nil)
+    #
+    # your block should return [username, password], or nil
     def when_auth &block # :yields: abs_url, realm
       @get_auth_details = block
     end
@@ -186,14 +185,14 @@ module Atom
     def get_atom_entry(url)
       res = get(url, "Accept" => "application/atom+xml")
 
-      # be picky for atom:entrys
-      res.validate_content_type( [ "application/atom+xml" ] )
-
       # XXX handle other HTTP codes
       if res.code != "200"
-        raise Atom::HTTPException, "expected Atom::Entry, didn't get it"
+        raise Atom::HTTPException, "failed to fetch entry: expected 200 OK, got #{res.code}"
       end
 
+      # be picky for atom:entrys
+      res.validate_content_type( [ "application/atom+xml" ] )
+
       Atom::Entry.parse(res.body, url)
     end
 
@@ -201,10 +200,10 @@ module Atom
     def put_atom_entry(entry, url = entry.edit_url)
       raise "Cowardly refusing to PUT a non-Atom::Entry (#{entry.class})" unless entry.is_a? Atom::Entry
       headers = {"Content-Type" => "application/atom+xml" }
-      
+
       put(url, entry.to_s, headers)
     end
-    
+
     private
     # parses plain quoted-strings
     def parse_quoted_wwwauth param_string
@@ -229,13 +228,13 @@ module Atom
     def wsse_authenticate(req, url, params = {})
       user, pass = username_and_password_for_realm(url, params["realm"])
 
-      nonce = Array.new(10){ rand(0x100000000) }.pack('I*')
-      nonce_b64 = [nonce].pack("m").chomp
+      # thanks to Sam Ruby
+      nonce = rand(16**32).to_s(16)
+      now = Time.now.gmtime.iso8601
 
-      now = Time.now.iso8601
       digest = [Digest::SHA1.digest(nonce + now + pass)].pack("m").chomp
       
-      req['X-WSSE'] = %Q<UsernameToken Username="#{user}", PasswordDigest="#{digest}", Nonce="#{nonce_b64}", Created="#{now}">
+      req['X-WSSE'] = %Q<UsernameToken Username="#{user}", PasswordDigest="#{digest}", Nonce="#{nonce}", Created="#{now}">
       req["Authorization"] = 'WSSE profile="UsernameToken"'
     end
 
@@ -264,8 +263,13 @@ module Atom
       elsif www_authenticate
         # XXX multiple challenges, multiple headers
         param_string = www_authenticate.sub!(/^(\w+) /, "")
-        auth_type = $~[1]
-        self.send("#{auth_type.downcase}_authenticate", req, url, param_string)
+        auth_method = ($~[1].downcase + "_authenticate").to_sym
+
+        if self.respond_to? auth_method, true # includes private methods
+          self.send(auth_method, req, url, param_string)
+        else
+          raise "No support for #{$~[1]} authentication"
+        end
       end
 
       http_obj = Net::HTTP.new(url.host, url.port)
@@ -317,7 +321,7 @@ module Atom
   module HTTPResponse
     # this should probably support ranges (eg. text/*)
     def validate_content_type( valid )
-      raise Atom::HTTPException, "HTTP response contains no Content-Type!" unless self.content_type
+      raise Atom::HTTPException, "HTTP response contains no Content-Type!" if not self.content_type or self.content_type.empty?
 
       media_type = self.content_type.split(";").first