excon 0.0.2 → 0.0.3

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/excon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{excon}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Wesley Beary"]
-  s.date = %q{2009-10-31}
+  s.date = %q{2009-11-03}
   s.description = %q{speed, persistence, http(s)}
   s.email = %q{wbeary@engineyard.com}
   s.extra_rdoc_files = [

data/lib/excon.rb

@@ -8,14 +8,36 @@ require 'openssl'
 require 'socket'
 require 'uri'
 
-require 'excon/connection'
 require 'excon/errors'
 require 'excon/response'
 
 module Excon
 
+  CHUNK_SIZE = 1048576 # 1 megabyte
+
+  def self.reload
+    load 'excon/connection.rb'
+  end
+
+  def self.mock!
+    @mocking = true
+    @mocks = {}
+
+    def self.mocks
+      @mocks
+    end
+
+    self.reload
+  end
+
+  def self.mocking?
+    !!@mocking
+  end
+
   def self.new(url)
     Excon::Connection.new(url)
   end
 
 end
+
+Excon.reload

data/lib/excon/connection.rb

@@ -1,111 +1,142 @@
-module Excon
-  class Connection
+unless Excon.mocking?
 
-    unless defined?(:CHUNK_SIZE)
-      CHUNK_SIZE = 1048576 # 1 megabyte
-    end
+  module Excon
+    class Connection
 
-    def initialize(url)
-      @uri = URI.parse(url)
-    end
+      def initialize(url)
+        @uri = URI.parse(url)
+      end
 
-    def request(params)
-      begin
-        params[:path] ||= ''
-        unless params[:path][0..0] == '/'
-          params[:path] = "/#{params[:path]}"
-        end
-        if params[:query] && !params[:query].empty?
-          params[:path] << "?#{params[:query]}"
-        end
-        request = "#{params[:method]} #{params[:path]} HTTP/1.1\r\n"
-        params[:headers] ||= {}
-        params[:headers]['Host'] = params[:host] || @uri.host
-        if params[:body] && !params[:headers]['Content-Length']
-          params[:headers]['Content-Length'] = params[:body].length
-        end
-        for key, value in params[:headers]
-          request << "#{key}: #{value}\r\n"
-        end
-        request << "\r\n"
-        connection.write(request)
-
-        if params[:body]
-          if params[:body].is_a?(String)
-            connection.write(params[:body])
-          else
-            while chunk = params[:body].read(CHUNK_SIZE)
-              connection.write(chunk)
-            end
+      def request(params)
+        begin
+          params[:path] ||= ''
+          unless params[:path][0..0] == '/'
+            params[:path] = "/#{params[:path]}"
           end
-        end
+          if params[:query] && !params[:query].empty?
+            params[:path] << "?#{params[:query]}"
+          end
+          request = "#{params[:method]} #{params[:path]} HTTP/1.1\r\n"
+          params[:headers] ||= {}
+          params[:headers]['Host'] = params[:host] || @uri.host
+          if params[:body] && !params[:headers]['Content-Length']
+            params[:headers]['Content-Length'] = params[:body].length
+          end
+          for key, value in params[:headers]
+            request << "#{key}: #{value}\r\n"
+          end
+          request << "\r\n"
+          connection.write(request)
 
-        response = Excon::Response.new
-        response.status = connection.readline[9..11].to_i
-        while true
-          data = connection.readline.chop!
-          unless data.empty?
-            header = data.split(': ')
-            response.headers[header[0]] = header[1]
-          else
-            break
+          if params[:body]
+            if params[:body].is_a?(String)
+              connection.write(params[:body])
+            else
+              while chunk = params[:body].read(CHUNK_SIZE)
+                connection.write(chunk)
+              end
+            end
           end
-        end
 
-        unless params[:method] == 'HEAD'
-          unless params[:block] || ![*params[:expects]].compact.include?(response.status)
-            response.body = ''
-            params[:block] = lambda { |chunk| response.body << chunk }
+          response = Excon::Response.new
+          response.status = connection.readline[9..11].to_i
+          while true
+            data = connection.readline.chop!
+            unless data.empty?
+              header = data.split(': ')
+              response.headers[header[0]] = header[1]
+            else
+              break
+            end
           end
 
-          if response.headers['Content-Length']
-            remaining = response.headers['Content-Length'].to_i
-            while remaining > 0
-              params[:block].call(connection.read([CHUNK_SIZE, remaining].min))
-              remaining -= CHUNK_SIZE
+          unless params[:method] == 'HEAD'
+            if !params[:block] || (params[:expects] && ![*params[:expects]].include?(response.status))
+              response.body = ''
+              params[:block] = lambda { |chunk| response.body << chunk }
             end
-          elsif response.headers['Transfer-Encoding'] == 'chunked'
-            while true
-              chunk_size = connection.readline.chomp!.to_i(16)
-              chunk = connection.read(chunk_size + 2).chop! # 2 == "/r/n".length
-              if chunk_size > 0
-                params[:block].call(chunk)
-              else
-                break
+
+            if response.headers['Content-Length']
+              remaining = response.headers['Content-Length'].to_i
+              while remaining > 0
+                params[:block].call(connection.read([CHUNK_SIZE, remaining].min))
+                remaining -= CHUNK_SIZE
+              end
+            elsif response.headers['Transfer-Encoding'] == 'chunked'
+              while true
+                chunk_size = connection.readline.chomp!.to_i(16)
+                chunk = connection.read(chunk_size + 2).chop! # 2 == "/r/n".length
+                if chunk_size > 0
+                  params[:block].call(chunk)
+                else
+                  break
+                end
               end
+            elsif response.headers['Connection'] == 'close'
+              params[:block].call(connection.read)
+              @connection = nil
             end
-          elsif response.headers['Connection'] == 'close'
-            params[:block].call(connection.read)
-            @connection = nil
           end
+        rescue => connection_error
+          @connection = nil
+          raise(connection_error)
+        end
+
+        if params[:expects] && ![*params[:expects]].include?(response.status)
+          raise(Excon::Errors.status_error(params[:expects], response.status, response))
+        else
+          response
         end
-      rescue => connection_error
-        @connection = nil
-        raise(connection_error)
       end
 
-      if params[:expects] && ![*params[:expects]].include?(response.status)
-        raise(Excon::Errors.status_error(params[:expects], response.status, response))
-      else
-        response
+      private
+
+      def connection
+        if !@connection || @connection.closed?
+          @connection = TCPSocket.open(@uri.host, @uri.port)
+          if @uri.scheme == 'https'
+            @ssl_context = OpenSSL::SSL::SSLContext.new
+            @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            @connection = OpenSSL::SSL::SSLSocket.new(@connection, @ssl_context)
+            @connection.sync_close = true
+            @connection.connect
+          end
+        end
+        @connection
       end
+
     end
+  end
+
+else
 
-    private
-
-    def connection
-      if !@connection || @connection.closed?
-        @connection = TCPSocket.open(@uri.host, @uri.port)
-        if @uri.scheme == 'https'
-          @ssl_context = OpenSSL::SSL::SSLContext.new
-          @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          @connection = OpenSSL::SSL::SSLSocket.new(@connection, @ssl_context)
-          @connection.sync_close = true
-          @connection.connect
+  module Excon
+    class Connection
+
+      def initialize(url)
+      end
+
+      def request(params)
+        for key in Excon.mocks.keys
+          if key == params
+            response = Excon.mocks[key]
+            break
+          end
+        end
+        unless response
+          response = Excon::Response.new
+          response.status = 404
+          response.headers = { 'Content-Length' => 0 }
+        end
+
+        if params[:expects] && ![*params[:expects]].include?(response.status)
+          raise(Excon::Errors.status_error(params[:expects], response.status, response))
+        else
+          response
         end
       end
-      @connection
-    end
 
+    end
   end
+
 end

data/lib/excon/response.rb

@@ -3,9 +3,10 @@ module Excon
 
     attr_accessor :body, :headers, :status
 
-    def initialize
-      @body = ''
-      @headers = {}
+    def initialize(attributes = {})
+      @body    = attributes[:body] || ''
+      @headers = attributes[:headers] || {}
+      @status  = attributes[:status]
     end
 
   end

data/test/test.rb

@@ -1,11 +1,26 @@
 require File.join(File.dirname(__FILE__), '..', 'lib/excon')
 
+Excon.mock!
+
+request = {
+  :host   => 'www.google.com',
+  :method => 'GET',
+  :path   => '/'
+}
+response = {
+  :status   => 200,
+  :headers  => { 'Content-Length' => '11' },
+  :body     => 'Hello World'
+}
+Excon.mocks[request] = response
+
 x = Excon.new('http://www.google.com')
 
 10.times do
 p x.request(
+  :host   => 'www.google.com',
   :method => 'GET',
-  :path => '/'
+  :path   => '/'
 )
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: excon
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Wesley Beary
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-31 00:00:00 -07:00
+date: 2009-11-03 00:00:00 -08:00
 default_executable: 
 dependencies: []