ape 1.0.0

data/lib/ape/atomURI.rb

@@ -0,0 +1,73 @@
+#   Copyright © 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
+      else
+        @base = URI.parse base_uri
+      end
+    end
+
+    # Given a URI pulled out of the middle of an XML doc ('context' provides
+    #  containing element) absolutize it if it's relative, with proper regard
+    #  for xml:base 
+    #
+    def absolutize uri_s, context
+      begin
+        uri = URI.parse uri_s
+        return uri_s if uri.absolute?
+
+        path_base = @base
+        path_to(context).each do |node|
+          if (xb = node.attributes['xml:base'])
+            xb = URI.parse xb
+            if xb.absolute? then path_base = xb else path_base.merge! xb end
+          end
+        end
+
+        return path_base.merge(uri).to_s
+      rescue URI::InvalidURIError
+        return nil
+      end
+    end
+
+    def path_to node
+      if node.class == REXML::Element
+        path_to(node.parent) << node
+      else
+        [ ]
+      end
+    end
+    
+    def AtomURI.check(uri_string)
+      if uri_string.kind_of? URI
+        uri = uri_string
+      else
+        begin
+          uri = URI.parse(uri_string)
+        rescue URI::InvalidURIError
+          return "Invalid URI: #{$!}"
+        end
+      end
+
+      unless uri.scheme =~ /^https?$/ 
+        return "URI scheme must be 'http' or 'https', not '#{uri.scheme}'"
+      else
+        return uri
+      end
+    end
+
+    def AtomURI.on_the_wire uri
+      if uri.query
+        "#{uri.path}?#{uri.query}"
+      else
+        uri.path
+      end
+    end
+  end
+end

data/lib/ape/auth/google_login_credentials.rb

@@ -0,0 +1,96 @@
+require 'net/http'
+require 'net/https'
+require 'cgi'
+
+module Ape
+  class GoogleLoginAuthError < StandardError ; end
+  class GoogleLoginAuthUnknownError < GoogleLoginAuthError ; end
+
+  class GoogleLoginCredentials
+    
+    GOOGLE_ERROR_MESSAGES = {
+      "BadAuthentication" =>  "The login request used a username or password that is not recognized.",
+      "NotVerified" =>        "The account email address has not been verified. The user will need to access their Google account directly to resolve the issue before logging in using a non-Google application.",
+      "TermsNotAgreed" =>     "The user has not agreed to terms. The user will need to access their Google account directly to resolve the issue before logging in using a non-Google application.",
+      "CaptchaRequired" =>    "Please visit https://www.google.com/accounts/DisplayUnlockCaptcha to enable access.",
+      "Unknown" =>            "The error is unknown or unspecified; the request contained invalid input or was malformed.",
+      "AccountDeleted" =>     "The user account has been deleted.",
+      "AccountDisabled" =>    "The user account has been disabled.",
+      "ServiceDisabled" =>    "The user's access to the specified service has been disabled. (The user account may still be valid.)",
+      "ServiceUnavailable" => "The service is not available; try again later.",
+    } unless defined?(GOOGLE_ERROR_MESSAGES)
+    
+    def initialize
+      @credentials = nil
+    end
+
+    def add_credentials(req, auth, user, password)
+      unless @credentials
+        challenge = parse_www_authenticate(auth)
+        @credentials = googlelogin(username, password, 'ruby-ape-1.0', challenge)
+      end
+      req['Authorization'] = "GoogleLogin auth=#{@credentials}"
+    end
+    
+    private
+    
+    def parse_www_authenticate(authenticate)
+      # Returns a dictionary of dictionaries, one dict
+      # per auth-scheme. The dictionary for each auth-scheme
+      # contains all the auth-params.
+      retval = {}
+      authenticate.chomp()
+      # Break off the scheme at the beginning of the line
+      auth_scheme, the_rest = authenticate.split(/ /, 2)
+      # Now loop over all the key value pairs that come after the scheme
+      keyvalues = the_rest.split(/[ ,]/)
+      auth_params = {}
+      keyvalues.each do |keyvalue|
+        if keyvalue.include?("=")
+          key, value = keyvalue.split(/=/, 2)
+          if value.scan(/^\"/).size > 0
+            value = value.strip()[1..-2]
+          end
+          auth_params[key.downcase()] = value.gsub(/\\(.)/, "\\1")
+        elsif keyvalue.size > 0 
+          retval[auth_scheme.downcase()] = auth_params
+          auth_scheme = keyvalue
+          auth_params = {}
+        end
+      end
+      retval[auth_scheme.downcase()] = auth_params
+      return retval
+    end
+
+    def googlelogin(name, password, useragent, challenge)
+      service = challenge['googlelogin']['service']
+
+      h = Net::HTTP.new('www.google.com', 443)
+      h.use_ssl = true
+      params = {'Email'=>name, 'Passwd'=>password, 'service'=>service, 'source'=>useragent}
+      data = params.map {|k,v| "#{CGI::escape(k.to_s)}=#{CGI::escape(v.to_s)}" }.join('&')
+      res = h.request_post('/accounts/ClientLogin', data, {'Content-Type' => 'application/x-www-form-urlencoded'})
+      d = {}
+      res.body.split(/\n/).each do |keyvalue|
+        key, value = keyvalue.split(/=/)
+        d[key] = value
+      end
+      auth = ""
+      if res == Net::HTTPForbidden
+        if d.has_key?('Error')
+          errorname = d['Error']
+          if GOOGLE_ERROR_MESSAGES.has_key?(errorname)
+            raise GoogleLoginAuthError, GOOGLE_ERROR_MESSAGES[errorname]
+          else
+            raise GoogleLoginAuthUnknownError, errorname
+          end
+        else
+          raise res.error!
+        end
+      else
+        auth = d['Auth']
+      end
+      return auth
+    end 
+  end
+end

data/lib/ape/auth/wsse_credentials.rb

@@ -0,0 +1,25 @@
+require 'base64'
+require 'digest/sha1'
+
+module Ape
+  class WsseCredentials
+    def initialize
+      @credentials = nil
+    end
+    
+    def add_credentials(req, auth, user, password)
+      wsse_auth(user, password) unless @credentials
+      req['X-WSSE'] = @credentials
+      req['Authorization'] = auth
+    end
+    
+    def wsse_auth(user, password)
+      nonce = Array.new(10){ rand(0x1000000) }.pack('I*')
+      nonce_b64 = [nonce].pack("m").chomp
+      now = Time.now.gmtime.strftime("%FT%TZ")
+      digest = [Digest::SHA1.digest(nonce_b64 + now + password)].pack("m").chomp
+
+      @credentials = %Q<UsernameToken Username="#{user}", PasswordDigest="#{digest}", Nonce="#{nonce_b64}", Created="#{now}">
+    end
+  end
+end

data/lib/ape/authent.rb

@@ -0,0 +1,42 @@
+#   Copyright © 2006 Sun Microsystems, Inc. All rights reserved
+#   Use is subject to license terms - see file "LICENSE"
+
+module Ape
+  class AuthenticationError < StandardError ; end
+  
+  class Authent  
+    def initialize(username, password, scheme=nil)
+      @username = username
+      @password = password
+      @auth_plugin = nil
+    end
+    
+    def add_to(req, authentication = nil)
+      return unless @username && @password
+      if (authentication)
+        if authentication.strip.downcase.include? 'basic'
+          req.basic_auth @username, @password
+        else
+          @auth_plugin = resolve_plugin(authentication) unless @auth_plugin
+          @auth_plugin.add_credentials(req, authentication, @username, @password)
+        end
+      else
+        req.basic_auth @username, @password
+      end
+    end
+    
+    def resolve_plugin(authentication)
+      Dir.glob(File.join(File.dirname(__FILE__), 'auth/*.rb')).each do |file|
+        plugin_name = file.gsub(/(.+\/auth\/)(.+)(_credentials.rb)/, '\2').gsub(/_/, '')
+        plugin_class = file.gsub(/(.+\/auth\/)(.+)(.rb)/, '\2').gsub(/(^|_)(.)/) { $2.upcase }
+        
+        if (authentication.strip.downcase.include?(plugin_name))
+          return eval("#{plugin_class}.new", binding, __FILE__, __LINE__)
+        end
+      end
+      raise AuthenticationError, "Unknown authentication method: #{authentication}"
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/auth/*.rb'].each { |l| require l }

data/lib/ape/categories.rb

@@ -0,0 +1,95 @@
+#   Copyright © 2006 Sun Microsystems, Inc. All rights reserved
+#   Use is subject to license terms - see file "LICENSE"
+
+require 'rexml/document'
+require 'rexml/xpath'
+
+module Ape
+  class Categories
+    attr_reader :fixed
+
+    def Categories.from_collection(collection, authent, ape=nil)
+
+      # "catses" because if cats is short for categories, then catses 
+      #  suggests multiple <app:categories> elements
+      catses = collection.catses
+
+      catses.collect! do |cats|
+        if cats.attribute(:href)
+          getter = Getter.new(cats.attribute(:href).value, authent)
+          if getter.last_error # wonky URI
+            ape.error getter.last_error if ape
+            nil
+          end
+
+          if !getter.get('application/atomcat+xml')
+            ape.error "Can't fetch categories doc " + 
+              "'#{cats.attribute(:href).value}': getter.last_error" if ape
+            nil
+          end
+
+          ape.warning(getter.last_error) if ape && getter.last_error
+          REXML::Document.new(getter.body).root
+        else
+          # no href attribute
+          cats
+        end
+      end
+      catses.compact
+    end
+
+  end
+
+  # Decorate an entry which is about to be posted to a collection with some
+  #  categories.  For each fixed categories element, pick one of the categories
+  #  and add that.  If there are no categories elements at all, or if there's
+  #  at least one with fixed="no", also add a syntho-cat that we make up.
+  #  Return the list of categories that we added.
+  #
+  def Categories.add_cats(entry, collection, authent, ape=nil)
+
+    added = []
+    c = from_collection(collection, authent)
+    if c.empty?
+      add_syntho = true
+    else
+      add_syntho = false
+
+      # for each <app:categories>
+      c.each do |cats|
+        
+        default_scheme = cats.attributes['scheme']
+
+        # if it's fixed, pick the first one
+        if cats.attributes['fixed'] == "yes"
+          cat_list = REXML::XPath.match(cats, './atom:category', Names::XmlNamespaces)
+          if cat_list
+
+            # for each <app:category> take the first one whose attribute "term" is not empty
+            cat_list.each do |cat|
+              if cat.attributes['term'].empty?
+                ape.warning 'A mangled category is present in your categories list' if ape
+              else
+                scheme = cat.attributes['scheme']
+                if !scheme
+                  scheme = default_scheme
+                end              
+                added << entry.add_category(cat.attributes['term'], scheme)
+                break
+              end
+            end
+          end
+        else
+          add_syntho = true
+        end
+
+      end
+    end
+
+    if add_syntho
+      added << entry.add_category('simians', 'http://tbray.org/cat-test')
+    end
+    added
+  end
+end
+

data/lib/ape/collection.rb

@@ -0,0 +1,51 @@
+#   Copyright © 2006 Sun Microsystems, Inc. All rights reserved
+#   Use is subject to license terms - see file "LICENSE"
+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
+      unless @title
+        raise(SyntaxError, "Collection is missing required 'atom:title'")
+      end
+      @title = @title.texts.join
+
+      if doc_uri
+        uris = AtomURI.new(doc_uri)
+        @href = uris.absolutize(input.attributes['href'], input)
+      else
+        @href = input.attributes['href']
+      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
+
+      if @accept.empty?
+        @accept = [ Names::AtomEntryMediaType ]
+      end
+    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)
+    end
+  end
+end

data/lib/ape/crumbs.rb

@@ -0,0 +1,39 @@
+#   Copyright © 2006 Sun Microsystems, Inc. All rights reserved
+#   Use is subject to license terms - see file "LICENSE"
+
+# All the methods (getter/poster/putter/deleter) use the set_debug_output method
+#  of Net::HTTP to capture the dialogue.  This class is what gets passed to
+#  set_debug_output; it exists to define << to save only the interesting bits
+#  of the dialog.
+#
+module Ape
+  class Crumbs
+    def initialize
+      @crumbs = []
+      @keep_next = false
+    end
+
+    def grep(pattern)
+      @crumbs.grep(pattern)
+    end
+
+    def << data
+      if @keep_next
+        @crumbs << "> #{data}"
+        @keep_next = false
+      elsif data =~ /^->/
+        @crumbs << "< #{data.gsub(/^.../, '')}"
+      elsif data =~ /^<-/
+        @keep_next = true
+      end
+    end
+
+    def each
+      @crumbs.each { |c| yield c }
+    end
+
+    def to_s
+      "  " + @crumbs.join("...\n")
+    end
+  end
+end

data/lib/ape/entry.rb

@@ -0,0 +1,151 @@
+#   Copyright © 2006 Sun Microsystems, Inc. All rights reserved
+#   Use is subject to license terms - see file "LICENSE"
+
+require 'rexml/document'
+require 'rexml/xpath'
+require 'cgi'
+
+# represents an Atom Entry
+module Ape
+  class Entry
+    # @element is the REXML dom
+    # @base is the base URI if known
+
+    def initialize(node, uri = nil)
+      if node.class == String
+        @element = REXML::Document.new(node, { :raw => nil }).root
+      else
+        @element = node
+      end
+      if uri
+        @base = AtomURI.new(uri)
+      else
+        @base = nil
+      end
+    end
+
+    def to_s
+      "<?xml version='1.0' ?>\n" + @element.to_s
+    end
+
+    def content_src
+      content = REXML::XPath.first(@element, './atom:content', Names::XmlNamespaces)
+      if content
+        cs = content.attributes['src']
+        cs = @base.absolutize(cs, @element) if @base
+      else
+        nil
+      end
+    end
+
+    def get_child(field, namespace = nil)
+      if (namespace)
+        thisNS = {}
+        prefix = 'NN'
+        thisNS[prefix] = namespace
+      else
+        prefix = 'atom'
+        thisNS = Names::XmlNamespaces
+      end
+      xpath = "./#{prefix}:#{field}"
+      return REXML::XPath.first(@element, xpath, thisNS)
+    end
+
+    def add_category(term, scheme = nil, label = nil)
+      c = REXML::Element.new('atom:category', @element)
+      c.add_namespace('atom', Names::AtomNamespace)
+      c.add_attribute('term', term)
+      c.add_attribute('scheme', scheme) if scheme
+      c.add_attribute('label', label) if label
+      c
+    end
+
+    def has_cat(cat)
+      xpath = "./atom:category[@term=\"#{cat.attributes['term']}\""
+      if cat.attributes['scheme']
+        xpath += "and @scheme=\"#{cat.attributes['scheme']}\""
+      end
+      xpath += "]"
+      REXML::XPath.first(@element, xpath, Names::XmlNamespaces)
+    end
+
+    def delete_category(c)
+      @element.delete_element c
+    end
+
+    def child_type(field)
+      n = get_child(field, nil)
+      return nil unless n
+      return n.attributes['type'] || "text"
+    end
+
+    def child_content(field, namespace = nil)
+      n = get_child(field, namespace)
+      return nil unless n
+      
+      # if it's type="xhtml", we'll get the content out of the contained
+      #  XHTML <div> rather than this element
+      if n.attributes['type'] == 'xhtml'
+        n = REXML::XPath.first(n, "./xhtml:div", Names::XmlNamespaces)
+        unless n
+          return "Error: required xhtml:div child of #{field} is missing"
+        end
+      end 
+    
+      text_from n
+    end
+
+    def text_from node
+      text = ''
+      is_html = node.name =~ /(rights|subtitle|summary|title|content)$/ && node.attributes['type'] == 'html'
+      node.find_all do | child |
+        if child.kind_of? REXML::Text
+          v = child.value
+          v = CGI.unescapeHTML(v).gsub(/&apos;/, "'") if is_html
+          text << v
+        elsif child.kind_of? REXML::Element
+          text << text_from(child)
+        end
+      end
+      text
+    end
+
+    def link(rel, ape=nil)
+      l = nil
+      a = REXML::XPath.first(@element, "./atom:link[@rel=\"#{rel}\"]", Names::XmlNamespaces)
+      if a
+        l = a.attributes['href']
+        l = @base.absolutize(l, @element) if @base
+      end
+      l
+    end
+    
+    def alt_links
+      REXML::XPath.match(@element, "./atom:link", Names::XmlNamespaces).select do |l|
+        l.attributes['rel'] == nil || l.attributes['rel'] == 'alternate'
+      end
+    end
+
+    def summarize
+      child_content('title')
+    end
+    
+    # utility routine
+    def xpath_match(xp)
+      REXML::XPath.match(@element, xp, Names::XmlNamespaces)
+    end
+
+    # debugging
+    def Entry.dump(node, depth=0)
+      prefix = '.' * depth
+      name = node.getNodeName
+      uri = node.getNamespaceURI
+      if uri
+        puts "#{prefix} #{uri}:#{node.getNodeName}"
+      else
+        puts "#{prefix} #{node.getNodeName}"
+      end
+      Nodes.each_node(node.getChildNodes) {|child| dump(child, depth+1)}
+    end
+  end
+end