thomaskay-curb-fu 0.2.2

data/lib/curb-fu/authentication.rb

@@ -0,0 +1,5 @@
+module CurbFu
+  module Authentication
+    BASIC = Curl::CURLAUTH_BASIC
+  end
+end

data/lib/curb-fu/core_ext.rb

@@ -0,0 +1,59 @@
+require 'cgi'
+
+##
+# ActiveSupport look alike for to_param. Very useful.
+module CurbFu
+  module HashExtensions
+    def self.included(base)
+      base.send(:include, InstanceMethods) unless base.methods.include?(:to_param)
+      #base.extend(ClassMethods)
+    end
+    
+    module InstanceMethods
+      def to_param(prefix)
+        collect do |k, v|
+          key_prefix = prefix ? "#{prefix}[#{k}]" : k
+          v.to_param(key_prefix)
+        end.join("&")
+      end
+    end
+  end
+  
+  module ObjectExtensions
+    def self.included(base)
+      base.send(:include, InstanceMethods) unless base.methods.include?(:to_param)
+      #base.extend(ClassMethods)
+    end
+    
+    module InstanceMethods
+      def to_param(prefix)
+        value = CGI::escape(to_s)
+        "#{prefix}=#{value}"
+      end
+    end
+  end
+  
+  module ArrayExtensions
+    def self.included(base)
+      base.send(:include, InstanceMethods) unless base.methods.include?(:to_param)
+      #base.extend(ClassMethods)
+    end
+    
+    module InstanceMethods
+      def to_param(prefix)
+        prefix = "#{prefix}[]"
+        collect { |item| "#{item.to_param(prefix)}" }.join('&')
+      end
+    end
+  end
+end
+
+class Hash
+  include CurbFu::HashExtensions
+end
+class Array
+  include CurbFu::ArrayExtensions
+end
+class Object
+  include CurbFu::ObjectExtensions
+end

data/lib/curb-fu/request/base.rb

@@ -0,0 +1,104 @@
+module CurbFu
+  class Request
+    module Base
+      include Common
+      
+      def build(url_params, query_params = {})
+        curb = Curl::Easy.new(build_url(url_params, query_params))
+        unless url_params.is_a?(String)
+          curb.userpwd = "#{url_params[:username]}:#{url_params[:password]}" if url_params[:username]
+          if url_params[:authtype]
+            curb.http_auth_types = url_params[:authtype]
+          elsif url_params[:username]
+            curb.http_auth_types = CurbFu::Authentication::BASIC
+          end
+
+          curb.headers = url_params[:headers] || {}
+        end
+
+        curb.timeout = @timeout
+
+        curb
+      end
+      
+      def get(url, params = {})
+        curb = self.build(url, params)
+        curb.http_get
+        CurbFu::Response::Base.from_curb_response(curb)
+      end
+
+      def put(url, params = {})
+        fields = create_put_fields(params)
+
+        curb = self.build(url)
+        curb.http_put(fields)
+        CurbFu::Response::Base.from_curb_response(curb)
+      end
+
+      def post(url, params = {})
+        fields = create_post_fields(params)
+
+        curb = self.build(url)
+        curb.headers["Expect:"] = ''
+        curb.http_post(*fields)
+        CurbFu::Response::Base.from_curb_response(curb)
+      end
+
+      def post_file(url, params = {}, filez = {})
+        fields = create_post_fields(params)
+        fields += create_file_fields(filez)
+
+        curb = self.build(url)
+        curb.multipart_form_post = true
+        curb.http_post(*fields)
+        CurbFu::Response::Base.from_curb_response(curb)
+      end
+
+      def delete(url)
+        curb = self.build(url)
+        curb.http_delete
+        CurbFu::Response::Base.from_curb_response(curb)
+      end
+
+    private
+      def create_post_fields(params)
+        return params if params.is_a? String
+        
+        fields = []
+        params.each do |name, value|
+          value_string = value if value.is_a?(String)
+          value_string = value.join(',') if value.is_a?(Array)
+          value_string ||= value.to_s
+
+          fields << Curl::PostField.content(name,value_string)
+        end
+        return fields
+      end
+      
+      def create_put_fields(params)
+        return params if params.is_a? String
+        
+        params.inject([]) do |list, (k,v)|
+          v = v.is_a?(Array) ? v.join(',') : v
+          list << "#{k}=#{v}"
+          list
+        end.join('&')
+      end
+
+      def create_file_fields(filez)
+        fields = []
+        filez.each do |name, data|
+          if data.instance_of?File
+            fields << Curl::PostField.file(name, data.path)
+          else
+            post_field = Curl::PostField.content(name, data.read)
+            post_field.remote_file = data.original_filename
+            post_field.content_type = 'application/octet-stream'
+            fields << post_field            
+          end
+        end
+        fields
+      end
+    end
+  end
+end

data/lib/curb-fu/request/common.rb

@@ -0,0 +1,32 @@
+module CurbFu
+  class Request
+    module Common
+      def timeout=(val)
+        @timeout = val
+      end
+
+      def timeout
+        @timeout.nil? ? 60 : @timeout
+      end
+
+      def build_url(url_params, query_params = {})
+        if url_params.is_a? String
+          built_url = url_params
+        else
+          built_url = "http://#{url_params[:host]}"
+          built_url += ":" + url_params[:port].to_s if url_params[:port]
+          built_url += url_params[:path] if url_params[:path]
+        end
+        if query_params.is_a? String
+          built_url += query_params
+        elsif !query_params.empty?
+          built_url += "?"
+          built_url += query_params.collect do |name, value|
+            CurbFu::Request::Parameter.new(name, value).to_uri_param
+          end.join('&')
+        end
+        built_url
+      end
+    end
+  end
+end

data/lib/curb-fu/request/parameter.rb

@@ -0,0 +1,33 @@
+module CurbFu
+  class Request
+    class Parameter
+      attr_accessor :name, :value
+      
+      def initialize(name, value)
+        self.name = name
+        self.value = value
+      end
+      
+      def self.build_uri_params(param_hash)
+        param_hash.to_param
+      end
+      
+      def self.build_post_fields(param_hash)
+        param_hash.to_post_fields
+      end
+      
+      def to_uri_param
+        value.to_param(name)
+      end
+      
+      def to_curl_post_field
+        field_string = value.to_param(name)
+        fields = field_string.split('&').collect do |field_value_pair|
+          field_name, field_value = field_value_pair.split('=')
+          Curl::PostField.content(field_name, CGI::unescape(field_value))
+        end
+        fields.length == 1 ? fields[0] : fields
+      end
+    end
+  end
+end

data/lib/curb-fu/request/test.rb

@@ -0,0 +1,119 @@
+require 'rack/test'
+
+module CurbFu
+  class Request
+    module Test
+      include Common
+      
+      def self.included(target)
+        target.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def get(url, params = {})
+          request_options = build_request_options(url)
+          respond(request_options[:interface], :get, request_options[:url],
+            params, request_options[:headers], request_options[:username], request_options[:password])
+        end
+        
+        def post(url, params = {})
+          request_options = build_request_options(url)
+          respond(request_options[:interface], :post, request_options[:url],
+            params, request_options[:headers], request_options[:username], request_options[:password])
+        end
+        
+        def post_file(url, params = {}, filez = {})
+          request_options = build_request_options(url)
+          uploaded_files = filez.inject({}) { |hsh, f| hsh["file_#{hsh.keys.length}"] = Rack::Test::UploadedFile.new(f.last.path); hsh }
+          respond(request_options[:interface], :post, request_options[:url], 
+            params.merge(uploaded_files), request_options[:headers], request_options[:username], request_options[:password])
+        end
+        
+        def put(url, params = {})
+          request_options = build_request_options(url)
+          respond(request_options[:interface], :put, request_options[:url],
+            params, request_options[:headers], request_options[:username], request_options[:password])
+        end
+        
+        def delete(url, params = {})
+          request_options = build_request_options(url)
+          respond(request_options[:interface], :delete, request_options[:url],
+            params, request_options[:headers], request_options[:username], request_options[:password])
+        end
+        
+        def build_request_options(url)
+          options = {}
+          options[:headers] = (url.is_a?(String)) ? nil : url.delete(:headers)
+          options[:url] = build_url(url)
+          options[:username], options[:password] = get_auth(url)
+          options[:interface] = get_interface(url)
+          options
+        end
+        
+        def respond(interface, operation, url, params, headers, username = nil, password = nil)
+          if interface.nil?
+            raise Curl::Err::ConnectionFailedError
+          else
+            unless headers.nil?
+              process_headers(headers).each do |name, value|
+                interface.header(name, value)
+              end
+            end
+            interface.authorize(username, password) unless username.nil?
+            response = interface.send(operation, url, params)
+            CurbFu::Response::Base.from_rack_response(response)
+          end
+        end
+        
+        def process_headers(headers)
+          headers.inject({}) do |accum, (header_name, value)|
+            key = header_name.gsub("-", "_").upcase
+            key = "HTTP_" + key unless key =~ /^HTTP_/
+            accum[key] = value
+            accum
+          end
+        end
+        
+        def get_interface(url)
+          if url.is_a?(Hash)
+            host = url[:host]
+          else
+            host = parse_hostname(url)
+          end
+          match_host(host)
+        end
+        
+        def parse_hostname(uri)
+          parsed_hostname = URI.parse(uri)
+          parsed_hostname.host || parsed_hostname.path
+        end
+        
+        def match_host(host)
+          match = CurbFu.stubs.find do |(hostname, interface)|
+            hostname == host
+          end
+          match.last unless match.nil?
+        end
+        
+        def get_auth(url)
+          username = password = nil
+          if url.is_a?(Hash) && url[:username]
+            username = url[:username]
+            password = url[:password]
+          end
+          [username, password]
+        end
+      end
+    
+      class Interface
+        include Rack::Test::Methods
+        
+        attr_accessor :app
+        
+        def initialize(app)
+          @app = app
+        end
+      end
+    end
+  end
+end

data/lib/curb-fu/request.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'curb'
+require 'curb-fu/request/common'
+require 'curb-fu/request/base'
+require 'curb-fu/request/parameter'
+require 'curb-fu/request/test'
+
+module CurbFu
+  class Request
+    extend Base
+  end
+end

data/lib/curb-fu/response.rb

@@ -0,0 +1,170 @@
+module CurbFu
+  module Response
+    class Base
+      attr_accessor :status, :body, :headers
+      
+      def initialize(status, headers, body)
+        @status = status
+        set_response_type(status)
+        @body = body
+        @headers = headers.is_a?(String) ? parse_headers(headers) : headers
+      end
+      
+      def success?
+        self.is_a?(CurbFu::Response::Success)
+      end
+      
+      def redirect?
+        self.is_a?(CurbFu::Response::Redirection)
+      end
+      
+      def failure?
+        !(success? || redirect?)
+      end
+      
+      def server_fail?
+        self.is_a?(CurbFu::Response::ServerError)
+      end
+      
+      def client_fail?
+        self.is_a?(CurbFu::Response::ClientError)
+      end
+      
+      def parse_headers(header_string)
+        header_lines = header_string.split($/)
+        header_lines.shift
+        header_lines.inject({}) do |hsh, line|
+          whole_enchillada, key, value = /^(.*?):\s*(.*)$/.match(line.chomp).to_a
+          hsh[key] = value unless whole_enchillada.nil?
+          hsh
+        end
+      end
+      
+      def set_response_type(status)
+        case status
+        when 100..199 then
+          self.extend CurbFu::Response::Information
+          case self.status
+          when 101 then self.extend CurbFu::Response::Continue
+          when 102 then self.extend CurbFu::Response::SwitchProtocl
+          end
+        when 200..299 then
+          self.extend CurbFu::Response::Success
+          case self.status
+          when 200 then self.extend CurbFu::Response::OK
+          when 201 then self.extend CurbFu::Response::Created
+          when 202 then self.extend CurbFu::Response::Accepted
+          when 203 then self.extend CurbFu::Response::NonAuthoritativeInformation
+          when 204 then self.extend CurbFu::Response::NoContent
+          when 205 then self.extend CurbFu::Response::ResetContent
+          when 206 then self.extend CurbFu::Response::PartialContent
+          end
+        when 300..399 then
+          self.extend CurbFu::Response::Redirection
+          case self.status
+          when 300 then self.extend CurbFu::Response::MultipleChoice
+          when 301 then self.extend CurbFu::Response::MovedPermanently
+          when 302 then self.extend CurbFu::Response::Found
+          when 303 then self.extend CurbFu::Response::SeeOther
+          when 304 then self.extend CurbFu::Response::NotModified
+          when 305 then self.extend CurbFu::Response::UseProxy
+          when 307 then self.extend CurbFu::Response::TemporaryRedirect
+          end
+        when 400..499 then
+          self.extend CurbFu::Response::ClientError
+          case self.status
+          when 400 then self.extend CurbFu::Response::BadRequest
+          when 401 then self.extend CurbFu::Response::Unauthorized
+          when 402 then self.extend CurbFu::Response::PaymentRequired
+          when 403 then self.extend CurbFu::Response::Forbidden
+          when 404 then self.extend CurbFu::Response::NotFound
+          when 405 then self.extend CurbFu::Response::MethodNotAllowed
+          when 406 then self.extend CurbFu::Response::NotAcceptable
+          when 407 then self.extend CurbFu::Response::ProxyAuthenticationRequired
+          when 408 then self.extend CurbFu::Response::RequestTimeOut
+          when 409 then self.extend CurbFu::Response::Conflict
+          when 410 then self.extend CurbFu::Response::Gone
+          when 411 then self.extend CurbFu::Response::LengthRequired
+          when 412 then self.extend CurbFu::Response::PreconditionFailed
+          when 413 then self.extend CurbFu::Response::RequestEntityTooLarge
+          when 414 then self.extend CurbFu::Response::RequestURITooLong
+          when 415 then self.extend CurbFu::Response::UnsupportedMediaType
+          when 416 then self.extend CurbFu::Response::UnsupportedMediaType
+          when 417 then self.extend CurbFu::Response::ExpectationFailed
+          end
+        when 500..599 then
+          self.extend CurbFu::Response::ServerError
+          case self.status
+          when 500 then self.extend CurbFu::Response::InternalServerError
+          when 501 then self.extend CurbFu::Response::NotImplemented
+          when 502 then self.extend CurbFu::Response::BadGateway
+          when 503 then self.extend CurbFu::Response::ServiceUnavailable
+          when 504 then self.extend CurbFu::Response::GatewayTimeOut
+          when 505 then self.extend CurbFu::Response::VersionNotSupported
+          end
+        else
+          self.extend CurbFu::Response::UnknownResponse
+        end
+      end
+      
+      class << self
+        def from_rack_response(rack)
+          raise ArgumentError.new("Rack response may not be nil") if rack.nil?
+          response = self.new(rack.status, rack.headers, rack.body)
+        end
+      
+        def from_curb_response(curb)
+          response = self.new(curb.response_code, curb.header_str, curb.body_str)
+          response
+        end
+      end
+    end
+          
+    module Information; end
+      module Continue;                           def self.to_i; 100; end; end
+      module SwitchProtocl; end
+    module Success;                              def self.to_i; 200; end; end
+      module OK;                                 def self.to_i; 200; end; end
+      module Created;                            def self.to_i; 201; end; end
+      module Accepted;                           def self.to_i; 202; end; end
+      module NonAuthoritativeInformation; end
+      module NoContent; end
+      module ResetContent; end
+      module PartialContent; end
+    module Redirection; end                    # 3xx
+      module MultipleChoice; end                 # 300
+      module MovedPermanently; end               # 301
+      module Found;                              def self.to_i; 302; end; end
+      module SeeOther; end                       # 303
+      module NotModified; end                    # 304
+      module UseProxy; end                       # 305
+      module TemporaryRedirect; end              # 307
+    module ClientError; end                    # 4xx
+      module BadRequest; end                     # 400
+      module Unauthorized; end                   # 401
+      module PaymentRequired; end                # 402
+      module Forbidden; end                      # 403
+      module NotFound;                           def self.to_i; 404; end; end
+      module MethodNotAllowed; end               # 405
+      module NotAcceptable; end                  # 406
+      module ProxyAuthenticationRequired; end    # 407
+      module RequestTimeOut; end                 # 408
+      module Conflict; end                       # 409
+      module Gone;                               def self.to_i; 410; end; end
+      module LengthRequired; end                 # 411
+      module PreconditionFailed; end             # 412
+      module RequestEntityTooLarge; end          # 413
+      module RequestURITooLong; end              # 414
+      module UnsupportedMediaType; end           # 415
+      module RequestedRangeNotSatisfiable; end   # 416
+      module ExpectationFailed; end              # 417
+    module ServerError; end                    # 5xx
+      module InternalServerError;                def self.to_i; 500; end; end
+      module NotImplemented; end                 # 501
+      module BadGateway; end                     # 502
+      module ServiceUnavailable;                 def self.to_i; 503; end; end
+      module GatewayTimeOut; end                 # 504
+      module VersionNotSupported; end            # 505
+    module UnknownResponse; end
+  end
+end

data/lib/curb-fu.rb

@@ -0,0 +1,43 @@
+dir = File.dirname(__FILE__)
+$:.unshift(dir) unless $:.include?(dir)
+require 'curb-fu/response'
+require 'curb-fu/request'
+require 'curb-fu/authentication'
+require 'curb-fu/core_ext'
+
+module CurbFu
+  class << self
+    def get(*args)
+      CurbFu::Request.get(*args)
+    end
+
+    def post(*args)
+      CurbFu::Request.post(*args)
+    end
+
+    def put(*args)
+      CurbFu::Request.put(*args)
+    end
+
+    def delete(*args)
+      CurbFu::Request.delete(*args)
+    end
+  
+    attr_accessor :stubs
+    
+    def stubs=(val)
+      if val
+        @stubs = val.inject({}) do |hsh, (hostname, rack_app)|
+          hsh[hostname] = CurbFu::Request::Test::Interface.new(rack_app)
+          hsh
+        end
+      
+        unless CurbFu::Request.include?(CurbFu::Request::Test)
+          CurbFu::Request.send(:include, CurbFu::Request::Test)
+        end
+      else
+        @stubs = nil
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: thomaskay-curb-fu
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: ruby
+authors: 
+- Phil Green, Derek Kastner, Matt Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: taf2-curb
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.8.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+description: 
+email: support@greenviewdata.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/curb-fu.rb
+- lib/curb-fu/authentication.rb
+- lib/curb-fu/core_ext.rb
+- lib/curb-fu/request.rb
+- lib/curb-fu/response.rb
+- lib/curb-fu/request/base.rb
+- lib/curb-fu/request/common.rb
+- lib/curb-fu/request/parameter.rb
+- lib/curb-fu/request/test.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Friendly wrapper for curb
+test_files: []
+