curb-fu 0.4.3

data/lib/curb-fu.rb

@@ -0,0 +1,64 @@
+dir = File.dirname(__FILE__)
+$:.unshift(dir) unless $:.include?(dir)
+require 'curb-fu/response'
+require 'curb-fu/request'
+require 'curb-fu/entity'
+require 'curb-fu/authentication'
+require 'curb-fu/core_ext'
+require 'curb-fu/test'
+
+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.each do |hostname, rack_app|
+          stub(hostname, rack_app)
+        end
+      
+        unless CurbFu::Request.include?(CurbFu::Request::Test)
+          CurbFu::Request.send(:include, CurbFu::Request::Test)
+        end
+      else
+        @stubs = nil
+      end
+    end
+
+    def stub(hostname, rack_app)
+      raise "You must use CurbFu.stubs= to define initial stubs before using stub()" if @stubs.nil?
+      @stubs[hostname] = CurbFu::Request::Test::Interface.new(rack_app, hostname)
+    end
+    
+    def stubs
+      @stubs
+    end
+    
+    def debug=(val)
+      @debug = val ? true : false
+    end
+    
+    def debug?
+      @debug
+    end
+    
+    
+  end
+end

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/entity.rb

@@ -0,0 +1,54 @@
+require 'json'
+require 'uri'
+
+module CurbFu
+  class Entity
+    attr_accessor :content_type, :data
+    
+    def initialze(data)
+      self.data = data
+    end
+    
+    def data
+      @data ||= ''
+    end
+    
+    def to_request_data
+      return data if data.is_a?(String)
+      
+      case content_type
+      when :uri then 
+        to_uri
+      when 'application/json',:json then 
+        to_json
+      # when 'application/xml',:xml then to_xml
+      when 'text/www-form-urlencoded',:form,:url then 
+        to_www_form_url_encoded
+      end
+    end
+    
+    # def to_xml
+    #   "XML"
+    # end
+    
+    def to_uri
+      strings = data.inject([]) do |acc, (name, value)|
+        acc << "#{name.to_s}=#{value}"
+        acc
+      end
+      URI.escape(strings.join('&'))
+    end
+    
+    def to_json
+      data.to_json
+    end
+    
+    def to_www_form_url_encoded
+      strings = data.inject([]) do |acc, (name, value)|
+        acc << "#{CGI.escape(name.to_s)}=#{CGI.escape(value)}"
+        acc
+      end
+      strings.join('&')
+    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/request/base.rb

@@ -0,0 +1,118 @@
+module CurbFu
+  class Request
+    module Base
+      include Common
+      
+      def build(url_params, query_params = {})
+        curb = Curl::Easy.new(build_url(url_params, query_params))
+
+        headers = global_headers
+        
+        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
+
+          headers = headers.merge(url_params[:headers]) unless url_params[:headers].nil?
+          headers["Expect"] = '' unless url_params[:headers] && url_params[:headers]["Expect"]
+        end
+        
+        curb.headers = headers
+        curb.timeout = @timeout
+
+        curb
+      end
+      
+      # Set headers to be used for every request
+      # * headers: hash of header names and values
+      def global_headers=(headers)
+        @global_headers = headers
+      end
+      
+      # Headers to be used for every request
+      # Returns: hash of header names and values
+      def global_headers
+        @global_headers ||= {}
+      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 = {})
+        curb = self.build(url, params)
+        curb.http_put("")
+        CurbFu::Response::Base.from_curb_response(curb)
+      end
+
+      def post(url, params = {})
+        fields = create_post_fields(params)
+        fields = [fields] if fields.is_a?(String)
+
+        curb = self.build(url)
+        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
+        
+        begin
+          curb.http_post(*fields)
+        rescue Curl::Err::InvalidPostFieldError => e
+          field_list = (params.merge(filez)).inject([]) { |list, (name, value)| list << "#{name} => #{value.to_s[0..49].inspect}"; list }
+          raise e, "There was an attempt to post invalid fields.  The fields were:\n#{field_list.join("\n")}"
+        end
+        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.to_s,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, path|
+          fields << Curl::PostField.file(name, path)
+        end
+        fields
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module CurbFu
+  class Request
+    module Common
+      def timeout=(val)
+        @timeout = val
+      end
+
+      def timeout
+        @timeout.nil? ? 10 : @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
+        
+        # TODO: update for use with CurbFu::Entity
+        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,153 @@
+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)
+          params = hashify_params(params) if params.is_a?(String)
+          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({}) do |hsh, (name, path)|
+            hsh[name] = Rack::Test::UploadedFile.new(path)
+            hsh
+          end
+          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)
+          params = hashify_params(params) if params.is_a?(String)
+          respond(request_options[:interface], :delete, request_options[:url],
+            params, request_options[:headers], request_options[:username], request_options[:password])
+        end
+        
+        def hashify_params(param_string)
+          param_string.sub!(/^\?/,'')
+          param_string.split('&').inject({}) do |hsh, pair|
+            key, value = pair.split('=')
+            
+            if key.match(/(.+)\[\]$/)
+              key = $1
+              hsh[key] ||= []
+              hsh[key] << value
+            elsif key.match(/([^\[]+)\[(.+)\]$/)
+              key = $1
+              subkey = $2
+              hsh[key] ||= {}
+              hsh[key].update( subkey => value )
+            else
+              hsh[key] = value
+            end
+
+            hsh
+          end
+        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?
+            puts "sending #{operation} to #{url} with params #{params.inspect} using interface #{interface.inspect}" if CurbFu.debug?
+            begin
+              response = interface.send(operation, url, params, 'SERVER_NAME' => interface.hostname)
+            rescue => e
+              puts "Caught error: #{e}, #{e.backtrace.join("\n")}" if CurbFu.debug?
+              raise e
+            end
+            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, :hostname
+        
+        def initialize(app, hostname = 'example.org')
+          self.app = app
+          self.hostname = hostname
+        end
+      end
+    end
+  end
+end