partigi-partigirb 0.2.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alvaro Bautista & Fernando Blat
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,9 @@
+= partigirb
+
+Wrapper for the Partigi API.
+
+Adapted from Hayes Davis grackle gem (http://github.com/hayesdavis/grackle/tree/master)
+
+== Copyright
+
+Copyright (c) 2009 Alvaro Bautista & Fernando Blat, released under MIT license

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "partigirb"
+    gem.summary = %Q{TODO}
+    gem.email = ["alvarobp@gmail.com", "ferblape@gmail.com"]
+    gem.homepage = "http://github.com/partigi/partigirb"
+    gem.authors = ["Alvaro Bautista", "Fernando Blat"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "partigirb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/lib/partigirb/client.rb

@@ -0,0 +1,190 @@
+module Partigirb
+  
+  class PartigiStruct < OpenStruct
+    attr_accessor :id 
+  end
+  
+  #Raised by methods which call the API if a non-200 response status is received 
+  class PartigiError < StandardError
+    attr_accessor :response_object
+  end
+  
+  class Client
+    class Request #:nodoc:
+      attr_accessor :client, :path, :method, :api_version
+      
+      def initialize(client,api_version=Partigirb::CURRENT_API_VERSION)
+        self.client = client
+        self.api_version = api_version
+        self.method = :get
+        self.path = ''
+      end
+      
+      def <<(path)
+        self.path << path
+      end
+      
+      def path?
+        path.length > 0
+      end
+    
+      def url
+        "#{scheme}://#{host}/api/v#{self.api_version}#{path}"
+      end
+         
+      def host
+        client.api_host
+      end
+    
+      def scheme
+        'http'
+      end
+    end
+    
+    VALID_METHODS = [:get,:post,:put,:delete]
+    VALID_FORMATS = [:atom,:xml,:json]
+
+    PARTIGI_API_HOST = "www.partigi.com"
+    TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%SZ'
+    
+    attr_accessor :default_format, :headers, :api_version, :transport, :request, :api_host, :auth, :handlers
+    
+    def initialize(options={})
+      self.transport = Transport.new
+      self.api_host = PARTIGI_API_HOST.clone
+      self.api_version = options[:api_version] || Partigirb::CURRENT_API_VERSION
+      self.headers = {"User-Agent"=>"Partigirb/#{Partigirb::VERSION}"}.merge!(options[:headers]||{})
+      self.default_format = options[:default_format] || :atom
+      self.handlers = {
+        :json => Partigirb::Handlers::JSONHandler.new,
+        :xml => Partigirb::Handlers::XMLHandler.new,
+        :atom => Partigirb::Handlers::AtomHandler.new,
+        :unknown => Partigirb::Handlers::StringHandler.new
+      }
+      self.handlers.merge!(options[:handlers]||{})
+      
+      # Authentication param should be a hash with keys:
+      # login (required)
+      # api_secret (required)
+      # nonce (optional, would be automatically generated if missing)
+      # timestamp (optional, current timestamp will be automatically used if missing)
+      self.auth = options[:auth]
+    end
+    
+    def method_missing(name,*args)
+      # If method is a format name, execute using that format
+      if format_invocation?(name)
+        return call_with_format(name,*args)
+      end
+      # If method ends in ! or ? use that to determine post or get
+      if name.to_s =~ /^(.*)(!|\?)$/
+        name = $1.to_sym
+        # ! is a post, ? is a get
+        self.request.method = ($2 == '!' ? :post : :get)          
+        if format_invocation?(name)
+          return call_with_format(name,*args)
+        else
+          self.request << "/#{$1}"
+          return call_with_format(self.default_format,*args)
+        end
+      end
+      # Else add to the request path
+      self.request << "/#{name}"
+      self
+    end
+    
+    # Clears any pending request built up by chained methods but not executed
+    def clear
+      self.request = nil
+    end
+    
+    def request
+      @request ||= Request.new(self,api_version)
+    end
+    
+    protected
+    
+    def call_with_format(format,params={})
+      request << ".#{format}"
+      res = send_request(params)
+      process_response(format,res)
+    ensure
+      clear
+    end
+    
+    def send_request(params)
+      begin
+        set_authentication_headers
+        
+        transport.request(
+          request.method, request.url, :headers=>headers, :params=>params
+        )
+      rescue => e
+        puts e
+      end        
+    end
+    
+    def process_response(format, res)
+      fmt_handler = handler(format)
+      
+      begin
+        if res.code.to_i != 200
+          handle_error_response(res, Partigirb::Handlers::XMLHandler)
+        else
+          fmt_handler.decode_response(res.body)
+        end
+      end
+    end
+    
+    # TODO: Test for errors
+    def handle_error_response(res, handler)
+      err = Partigirb::PartigiError.new
+      err.response_object = handler.decode_response(res.body)
+      raise err        
+    end
+    
+    def format_invocation?(name)
+      self.request.path? && VALID_FORMATS.include?(name)
+    end
+    
+    def handler(format)
+      handlers[format] || handlers[:unknown]
+    end
+    
+    # Adds the proper WSSE headers if there are the right authentication parameters
+    def set_authentication_headers
+      unless self.auth.nil? || self.auth === Hash || self.auth.empty?
+        auths = self.auth.stringify_keys
+      
+        if auths.has_key?('login') &&  auths.has_key?('api_secret')
+          if !auths['timestamp'].nil?
+            timestamp = case auths['timestamp']
+            when Time
+              auths['timestamp'].strftime(TIMESTAMP_FORMAT)
+            when String
+              auths['timestamp']
+            end
+          else
+            timestamp = Time.now.strftime(TIMESTAMP_FORMAT) if timestamp.nil?
+          end
+        
+          nonce = auths['nonce'] || generate_nonce
+          password_digest = generate_password_digest(nonce, timestamp, auths['login'], auths['api_secret'])
+          headers.merge!({
+            'Authorization' => "WSSE realm=\"#{PARTIGI_API_HOST}\", profile=\"UsernameToken\"",
+            'X-WSSE' => "UsernameToken Username=\"#{auths['login']}\", PasswordDigest=\"#{password_digest}\", Nonce=\"#{nonce}\", Created=\"#{timestamp}\""
+          })
+        end
+      end
+    end
+    
+    def generate_nonce
+      o =  [('a'..'z'),('A'..'Z')].map{|i| i.to_a}.flatten
+      Digest::MD5.hexdigest((0..10).map{o[rand(o.length)]}.join)
+    end
+    
+    def generate_password_digest(nonce, timestamp, login, secret)
+      Base64.encode64(Digest::SHA1.hexdigest("#{nonce}#{timestamp}#{login}#{secret}")).chomp
+    end
+  end
+end

data/lib/partigirb/core_ext.rb

@@ -0,0 +1,78 @@
+# Ruby Hash extensions from ActiveSupport
+
+class Hash
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
+    end
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+end
+
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # to
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+    
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/partigirb/handlers/atom_handler.rb

@@ -0,0 +1,24 @@
+module Partigirb
+  module Handlers
+    class AtomHandler < XMLHandler
+      def decode_response(body)
+        return REXML::Document.new if body.blank?
+        xml = REXML::Document.new(body.gsub(/>\s+</,'><'))
+        
+        if xml.root.name == 'feed'
+          entries = xml.root.get_elements('entry')
+          
+          # Depending on whether we have one or more entries we return an PartigiStruct or an array of PartigiStruct
+          if entries.size == 1
+            load_recursive(entries.first)
+          else
+            entries.map{|e| load_recursive(e)}
+          end
+        else
+          # We just parse as a common XML
+          load_recursive(xml.root)
+        end
+      end
+    end
+  end
+end

data/lib/partigirb/handlers/json_handler.rb

@@ -0,0 +1,10 @@
+module Partigirb
+  module Handlers
+    class JSONHandler
+      def decode_response( body )
+        # TODO: Implement when API JSON format is ready
+        body
+      end
+    end
+  end
+end

data/lib/partigirb/handlers/string_handler.rb

@@ -0,0 +1,9 @@
+module Partigirb
+  module Handlers
+    class StringHandler
+      def decode_response( body )
+        body
+      end
+    end
+  end
+end

data/lib/partigirb/handlers/xml_handler.rb

@@ -0,0 +1,51 @@
+module Partigirb
+  module Handlers
+    class XMLHandler
+      def decode_response(body)
+        return REXML::Document.new if body.blank?
+        xml = REXML::Document.new(body.gsub(/>\s+</,'><'))
+        load_recursive(xml.root)
+      end
+      
+      private
+        def load_recursive(node)
+          if array_node?(node)
+            node.elements.map {|e| load_recursive(e)}
+          elsif node.elements.size > 0
+            build_struct(node)
+          elsif node.elements.size == 0
+            value = node.text
+            fixnum?(value) ? value.to_i : value
+          end
+        end
+      
+        def build_struct(node)
+          ts = PartigiStruct.new
+          node.elements.each do |e|
+            property = ""
+            
+            if !e.namespace.blank?
+              ns = e.namespaces.invert[e.namespace]
+              property << "#{ns}_" unless ns == 'xmlns'
+            end
+            
+            property << e.name
+            ts.send("#{property}=", load_recursive(e))
+          end
+          ts
+        end
+        
+        # Most of the time Twitter specifies nodes that contain an array of 
+        # sub-nodes with a type="array" attribute. There are some nodes that 
+        # they dont' do that for, though, including the <ids> node returned 
+        # by the social graph methods. This method tries to work in both situations.
+        def array_node?(node)
+          node.attributes['type'] == 'collection'
+        end
+      
+        def fixnum?(value)
+          value =~ /^\d+$/
+        end
+    end
+  end
+end

data/lib/partigirb/transport.rb

@@ -0,0 +1,160 @@
+module Partigirb
+  
+  class Response #:nodoc:
+    attr_accessor :method, :request_uri, :status, :body
+    
+    def initialize(method,request_uri,status,body)
+      self.method = method
+      self.request_uri = request_uri
+      self.status = status
+      self.body = body
+    end
+  end
+  
+  class Transport
+    
+    attr_accessor :debug
+  
+    CRLF = "\r\n"
+    
+    def req_class(method)
+      case method
+        when :get then Net::HTTP::Get
+        when :post then Net::HTTP::Post
+        when :put then Net::HTTP::Put
+        when :delete then Net::HTTP::Delete
+      end
+    end
+    
+    # Options are one of
+    # - :params - a hash of parameters to be sent with the request. If a File is a parameter value, \
+    #             a multipart request will be sent. If a Time is included, .httpdate will be called on it.
+    # - :headers - a hash of headers to send with the request
+    def request(method, string_url, options={})
+      params = stringify_params(options[:params])
+      if method == :get && params
+        string_url << query_string(params)
+      end
+      url = URI.parse(string_url)
+      begin
+        execute_request(method,url,options)
+      rescue Timeout::Error
+        raise "Timeout while #{method}ing #{url.to_s}"
+      end
+    end
+    
+    def execute_request(method,url,options={})
+      conn = Net::HTTP.new(url.host, url.port)
+      #conn.use_ssl = (url.scheme == 'https')
+      conn.start do |http|
+        req = req_class(method).new(url.request_uri)
+        
+        add_headers(req,options[:headers])
+        if file_param?(options[:params])
+          add_multipart_data(req,options[:params])
+        else
+          add_form_data(req,options[:params])
+        end
+        
+        dump_request(req) if debug
+        res = http.request(req)
+        dump_response(res) if debug
+        res
+      end
+    end
+
+    def query_string(params)
+      query = case params
+        when Hash then params.map{|key,value| url_encode_param(key,value) }.join("&")
+        else url_encode(params.to_s)
+      end
+      if !(query == nil || query.length == 0) && query[0,1] != '?'
+        query = "?#{query}"
+      end
+      query
+    end      
+  
+    private
+      def stringify_params(params)
+        return nil unless params
+        params.inject({}) do |h, pair|
+          key, value = pair
+          if value.respond_to? :httpdate
+            value = value.httpdate
+          end
+          h[key] = value
+          h
+        end
+      end
+      
+      def file_param?(params)
+        return false unless params
+        params.any? {|key,value| value.respond_to? :read }
+      end
+      
+      def url_encode(value)
+        require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+        CGI.escape(value.to_s)
+      end
+      
+      def url_encode_param(key,value)
+        "#{url_encode(key)}=#{url_encode(value)}"
+      end
+      
+      def add_headers(req,headers)
+        if headers
+          headers.each do |header, value|
+            req[header] = value
+          end
+        end        
+      end
+    
+      def add_form_data(req,params)
+        if req.request_body_permitted? && params
+          req.set_form_data(params)
+        end
+      end
+    
+      def add_multipart_data(req,params)
+        boundary = Time.now.to_i.to_s(16)
+        req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+        body = ""
+        params.each do |key,value|
+          esc_key = url_encode(key)
+          body << "--#{boundary}#{CRLF}"
+          if value.respond_to?(:read)
+            mime_type = MIME::Types.type_for(value.path)[0] || MIME::Types["application/octet-stream"][0]
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{File.basename(value.path)}\"#{CRLF}"
+            body << "Content-Type: #{mime_type.simplified}#{CRLF*2}"
+            body << value.read
+          else
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"#{CRLF*2}#{value}"
+          end
+          body << CRLF
+        end
+        body << "--#{boundary}--#{CRLF*2}"
+        req.body = body
+        req["Content-Length"] = req.body.size
+      end
+
+      private
+        
+        def dump_request(req)
+          puts "Sending Request"
+          puts"#{req.method} #{req.path}"
+          dump_headers(req)
+        end
+      
+        def dump_response(res)
+          puts "Received Response"
+          dump_headers(res)
+          puts res.body
+        end
+      
+        def dump_headers(msg)
+          msg.each_header do |key, value|
+            puts "\t#{key}=#{value}"
+          end
+        end
+  end
+end

data/lib/partigirb.rb

@@ -0,0 +1,25 @@
+module Partigirb
+  VERSION='0.1.0'
+  CURRENT_API_VERSION=1
+end
+
+$:.unshift File.dirname(__FILE__)
+
+require 'open-uri'
+require 'net/http'
+require 'base64'
+require 'digest'
+require 'rexml/document'
+require 'mime/types'
+require 'ostruct'
+
+require 'partigirb/core_ext'
+
+require 'partigirb/handlers/xml_handler'
+require 'partigirb/handlers/atom_handler'
+require 'partigirb/handlers/json_handler'
+require 'partigirb/handlers/string_handler'
+
+require 'partigirb/transport'
+require 'partigirb/client'
+