fredo 0.1.3

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Leandro Pedroni
+
+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,48 @@
+= Fredo
+==== Stubs web services by plugging a sinatra-y DSL on Net::Http 
+
+I know it was you, Fredo[http://www.youtube.com/watch?v=FcFlp6kl508]
+
+I needed a slightly more articulated stub behaviour than the one provided by fakeweb[http://github.com/chrisk/fakeweb] to mimic S3 uploads and external APIs to process my attachments.
+Inside my simple cucumber steps.
+
+== Install
+On the console:
+    >> gem install fredo
+    
+In your app:
+    # config/environments/test.rb, config/environments/cucumber.rb
+    config.gem 'fredo'
+
+== Usage
+
+I borrowed the sinatra router, fakeweb's Net::Http extension and glued them together with Rack like returns and accepts:
+
+    # and in your s3_steps.rb or what not:
+    Fredo.put "http://s3.amazonaws.com/*/:size.:ext" do
+      [200, {}, 'OK']
+    end
+
+    Fredo.get "http://s3.amazonaws.com/*/:size.:ext" do
+      fixture_path = File.expand_path("../../support/s3/placeholder_#{params[:size]}.#{params[:ext]}", __FILE__)
+      [200, {'ContentType' => "image/#{params[:ext]}"}, File.read]
+    end
+    
+  
+== Bugs
+This is in a very early stage for the project, feel free to provide feedback. Please use the Github issues.
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Leandro Pedroni. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fredo"
+    gem.summary = %Q{Mocks web services by plugging Net::Http straight into Rack}
+    gem.description = %Q{Mocks web services by plugging Net::Http straight into Rack}
+    gem.email = "ilpoldo@gmail.com"
+    gem.homepage = "http://github.com/ilpoldo/fredo"
+    gem.authors = ["ilpoldo"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "fredo #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.3

data/fredo.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fredo}
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["ilpoldo"]
+  s.date = %q{2010-03-24}
+  s.description = %q{Mocks web services by plugging Net::Http straight into Rack}
+  s.email = %q{ilpoldo@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "fredo.gemspec",
+     "lib/fredo.rb",
+     "lib/fredo/ext/mongrel_handler.rb",
+     "lib/fredo/ext/net_http.rb",
+     "lib/fredo/handler.rb",
+     "lib/fredo/registry.rb",
+     "lib/fredo/response.rb",
+     "lib/fredo/stub_socket.rb",
+     "spec/fredo_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ilpoldo/fredo}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Mocks web services by plugging Net::Http straight into Rack}
+  s.test_files = [
+    "spec/fredo_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/fredo.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'uri'
+require 'rack'
+
+require 'fredo/ext/net_http'
+require 'fredo/stub_socket'
+require 'fredo/registry'
+require 'fredo/handler'
+require 'fredo/response'
+
+module Fredo
+
+  # Returns the version string for the Fredo you have loaded.
+  VERSION = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  # Resets Fredo's Registry. This will force all subsequent web requests to
+  # behave as real requests.
+  def self.clean_registry
+    Registry.instance.clean_registry
+  end
+  
+  # Registers get url that will make Fredo an OK response or the response generated 
+  # in the block passed to get.
+  def self.get(path, opts={}, &bk);    Registry.route 'GET',    path, opts, &bk end
+  def self.put(path, opts={}, &bk);    Registry.route 'PUT',    path, opts, &bk end
+  def self.post(path, opts={}, &bk);   Registry.route 'POST',   path, opts, &bk end
+  def self.delete(path, opts={}, &bk); Registry.route 'DELETE', path, opts, &bk end
+  def self.head(path, opts={}, &bk);   Registry.route 'HEAD',   path, opts, &bk end  
+  
+  # Enables or disables real HTTP connections for requests that don't match
+  # registered URIs.
+  #
+  # If you set <tt>Fredo.allow_net_connect = false</tt> and subsequently try
+  # to make a request to a URI you haven't registered with #register_uri, a
+  # NetConnectNotAllowedError will be raised. This is handy when you want to
+  # make sure your tests are self-contained, or want to catch the scenario
+  # when a URI is changed in implementation code without a corresponding test
+  # change.
+  #
+  # When <tt>Fredo.allow_net_connect = true</tt> (the default), requests to
+  # URIs not stubbed with Fredo are passed through to Net::HTTP.
+  def self.allow_net_connect=(allowed)
+    @allow_net_connect = allowed
+  end
+  
+  # Returns +true+ if requests to URIs not registered with Fredo are passed
+  # through to Net::HTTP for normal processing (the default). Returns +false+
+  # if an exception is raised for these requests.
+  def self.allow_net_connect?
+    @allow_net_connect || true
+  end
+  
+  # This exception is raised if you set <tt>Fredo.allow_net_connect =
+  # false</tt> and subsequently try to make a request to a URI you haven't
+  # stubbed.
+  class NetConnectNotAllowedError < StandardError
+    def initialize(uri)
+      super "Connection to #{uri} is disabled"
+    end
+  end
+  
+  # This exception is raised if something goes wrong on Fredo's end during
+  # the test.
+  class Mixup < Exception; end;
+  
+  # This exception is raised if Fredo can't match the request URI
+  class NotFound < Exception; end;
+  
+  def self.call(env)
+    Handler.new.call(env)
+  end
+  
+  def self.forget
+    Registry.clear
+  end
+end

data/lib/fredo/ext/mongrel_handler.rb

@@ -0,0 +1,42 @@
+# File lib/rack/handler/mongrel.rb
+def process(request, response)
+  env = {}.replace(request.params)
+  env.delete "HTTP_CONTENT_TYPE"
+  env.delete "HTTP_CONTENT_LENGTH"
+
+  env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+  env.update({"rack.version" => [0,1],
+               "rack.input" => request.body || StringIO.new(""),
+               "rack.errors" => $stderr,
+
+               "rack.multithread" => true,
+               "rack.multiprocess" => false, # ???
+               "rack.run_once" => false,
+
+               "rack.url_scheme" => "http",
+             })
+  env["QUERY_STRING"] ||= ""
+  env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+
+  status, headers, body = @app.call(env)
+
+  begin
+    response.status = status.to_i
+    response.send_status(nil)
+
+    headers.each { |k, vs|
+      vs.split("\n").each { |v|
+        response.header[k] = v
+      }
+    }
+    response.send_header
+
+    body.each { |part|
+      response.write part
+      response.socket.flush
+    }
+  ensure
+    body.close  if body.respond_to? :close
+  end
+end

data/lib/fredo/ext/net_http.rb

@@ -0,0 +1,99 @@
+require 'net/http'
+require 'net/https'
+require 'stringio'
+
+module Net  #:nodoc: all
+
+  class BufferedIO
+    def initialize_with_fredo(io, debug_output = nil)
+      @read_timeout = 60
+      @rbuf = ''
+      @debug_output = debug_output
+
+      @io = case io
+      when Socket, OpenSSL::SSL::SSLSocket, IO
+        io
+      when String
+        if !io.include?("\0") && File.exists?(io) && !File.directory?(io)
+          File.open(io, "r")
+        else
+          StringIO.new(io)
+        end
+      end
+      raise "Unable to create local socket" unless @io
+    end
+    alias_method :initialize_without_fredo, :initialize
+    alias_method :initialize, :initialize_with_fredo
+  end
+
+  class HTTP
+    # class << self
+    #   def socket_type_with_fredo
+    #     Fredo::StubSocket
+    #   end
+    #   alias_method :socket_type_without_fredo, :socket_type
+    #   alias_method :socket_type, :socket_type_with_fredo
+    # end
+
+    def request_with_fredo(request, body = nil, &block)
+      request_body = body
+      
+      uri = URI.parse(request.path)
+      protocol = use_ssl? ? "https" : "http"
+      full_path = "#{protocol}://#{self.address}:#{self.port}#{request.path}"
+      
+      rack_env ={'REQUEST_METHOD'    => request.method,
+                 'SCRIPT_NAME'       => '',
+                 'PATH_INFO'         => uri.path,
+                 'QUERY_STRING'      => (uri.query || ''),
+                 'SERVER_NAME'       => self.address,
+                 'SERVER_PORT'       => self.port,
+                 'rack.version'      => [1,1],
+                 'rack.url_scheme'   => protocol,
+                 'rack.input'        => body || StringIO.new,
+                 'rack.errors'       => $stderr,
+                 'rack.multithread'  => true,
+                 'rack.multiprocess' => true,
+                 'rack.run_once'     => false}
+
+      # @socket = Net::HTTP.socket_type.new
+      # Perform the request
+      status, header, body = Fredo.call(rack_env)
+      # body = body.to_s # should write to rocket or do something fancier?
+      
+      response = Net::HTTPResponse.send(:response_class, "#{status}").new("1.0", "#{status}", body)
+      response.instance_variable_set(:@body, body)
+      header.each { |name, value| response[name] = value }
+      response.instance_variable_set(:@read, true)
+      
+      def response.read_body(*args, &block)
+        yield @body if block_given?
+        @body
+      end
+
+      yield response if block_given?
+      response
+      
+    rescue Fredo::NotFound
+      
+      raise Fredo::NetConnectNotAllowedError.new(full_path) unless Fredo.allow_net_connect?
+      connect_without_fredo
+      return request_without_fredo(request, request_body, &block)
+      
+    end
+    alias_method :request_without_fredo, :request
+    alias_method :request, :request_with_fredo
+
+
+    def connect_with_fredo
+      unless @@alredy_checked_for_net_http_replacement_libs ||= false
+        # Fredo::Utility.puts_warning_for_net_http_replacement_libs_if_needed
+        @@alredy_checked_for_net_http_replacement_libs = true
+      end
+      nil
+    end
+    alias_method :connect_without_fredo, :connect
+    alias_method :connect, :connect_with_fredo
+  end
+
+end

data/lib/fredo/handler.rb

@@ -0,0 +1,115 @@
+module Fredo
+  class Handler #:nodoc:
+    
+    attr_accessor :env, :request, :response, :params
+    
+    def call(env)
+      @env      = env
+      @request  = Rack::Request.new(env)
+      @params   = @request.params
+      @response = Response.new([],200,{})
+      
+      dispatch!
+      
+      respond!
+    end
+    
+    # Dispatch a request with error handling.
+    def dispatch!
+      route!
+    end
+    
+    def routes_for_host?
+      Registry.routes[@request.request_method][@request.host]
+    rescue
+      false
+    end
+    
+    def route!
+      
+      if routes = routes_for_host?
+        path = URI.unescape(@request.path_info)
+        routes.each do |pattern, keys, conditions, block|
+          if match = pattern.match(path)
+            values = match.captures.to_a
+            params =
+              if keys.any?
+                keys.zip(values).inject({}) do |hash,(k,v)|
+                  if k == :splat
+                    (hash[k] ||= []) << v
+                  else
+                    hash[k.to_sym] = v
+                  end
+                  hash
+                end
+              elsif values.any?
+                {'captures' => values}
+              else
+                {}
+              end
+            @params.merge!(params)
+            perform!(&block)
+            return
+          end
+        end
+        
+      end
+      
+      raise NotFound
+    end
+    
+    def handle_not_found!(boom)
+      @env['fredo.error'] = boom
+      @response.status    = 404
+      @response.body      = ['<h1>Not Found</h1>']
+    end
+    
+    def handle_exception!(boom)
+      @env['fredo.error'] = boom
+      @response.body   = ["<h1>You broke my heart Fredo!</h1><h5>Fredo raised an exception.</h5><tt>#{boom.inspect}</tt>"]
+      @response.status = 500
+      # raise Mixup.new("original error: #{boom.inspect}") if Fredo.allow_exceptions?
+    end
+    
+    def perform!(&block)
+      if block_given?
+        @response['Content-Type']= 'text/html'
+        
+        res = instance_eval(&block)
+        case
+        when res.respond_to?(:to_str)
+          @response.body = [res]
+        when res.respond_to?(:to_ary)
+          res = res.to_ary
+          if Fixnum === res.first
+            if res.length == 3
+              @response.status, headers, body = res
+              @response.body = body if body
+              headers.each { |k, v| @response.headers[k] = v } if headers
+            elsif res.length == 2
+              @response.status = res.first
+              @response.body   = res.last
+            else
+              raise TypeError, "#{res.inspect} not supported"
+            end
+          else
+            @response.body = res
+          end
+        when res.respond_to?(:each)
+          @response.body = res
+        when (100...599) === res
+          @response.status = res
+        end
+        
+      end
+    rescue ::Exception => boom
+      handle_exception!(boom)
+    end
+    
+    def respond!
+      status, header, body = @response.finish
+      [status, header, body]
+    end
+    
+  end
+end

data/lib/fredo/registry.rb

@@ -0,0 +1,52 @@
+module Fredo
+  class Registry #:nodoc:
+    
+    def self.route(verb, uri, options={}, &block)
+      uri = URI.parse(uri)
+      uri.path = '/' if uri.path.empty? 
+      pattern, keys = compile(uri.path)
+
+      @routes ||={}
+      @routes[verb] ||= {}
+      (@routes[verb][uri.host] ||= []).
+        push([pattern, keys, options, block]).last
+    end
+    
+    def self.routes
+      @routes
+    end
+    
+    def self.clear
+      @routes = {}
+    end
+    
+    def self.compile(path)
+      keys = []
+      if path.respond_to? :to_str
+        special_chars = %w{. + ( )}
+        pattern =
+          path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+            case match
+            when "*"
+              keys << 'splat'
+              "(.*?)"
+            when *special_chars
+              Regexp.escape(match)
+            else
+              keys << $2[1..-1]
+              "([^/?&#]+)"
+            end
+          end
+        [/^#{pattern}$/, keys]
+      elsif path.respond_to?(:keys) && path.respond_to?(:match)
+        [path, path.keys]
+      elsif path.respond_to? :match
+        [path, keys]
+      else
+        raise TypeError, path
+      end
+    end
+    
+    
+  end
+end

data/lib/fredo/response.rb

@@ -0,0 +1,19 @@
+module Fredo
+  class Response < Rack::Response
+    def finish
+      @body = block if block_given?
+      if [204, 304].include?(status.to_i)
+        header.delete "Content-Type"
+        [status.to_i, header.to_hash, []]
+      else
+        body = @body || []
+        body = [body] if body.respond_to? :to_str
+        if body.respond_to?(:to_ary)
+          header["Content-Length"] = body.to_ary.
+            inject(0) { |len, part| len + part.bytesize }.to_s
+        end
+        [status.to_i, header.to_hash, body]
+      end
+    end
+  end
+end

data/lib/fredo/stub_socket.rb

@@ -0,0 +1,15 @@
+module Fredo
+  class StubSocket #:nodoc:
+
+    def initialize(*args)
+    end
+
+    def closed?
+      @closed ||= true
+    end
+
+    def readuntil(*args)
+    end
+
+  end
+end

data/spec/fredo_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Fredo do
+  context "initialization" do
+    
+    it "loads"
+    
+    it "hijacks Net::Http"
+    
+  end
+
+  context "request handling" do
+    
+    it "falls back to normal behaviour" do
+      response = open('http://www.google.com')
+      response.status.first.should eql('200')
+    end
+    
+    it "can hijack a request and return a value"
+    
+    it "can prevent external resources to be called"
+    
+    it "can hijack a get request" do
+      body = "Today ain't your lucky day, kid."
+      
+      Fredo.get 'http://www.google.com' do
+        body
+      end
+      
+      response = open('http://www.google.com')
+      response.read.should eql(body)
+      # response.header["Content-Type"].should eql("text/html")
+    end
+  end
+  
+  context "registry" do
+    
+    it "behaves" do
+      Fredo.get 'http://google.com'
+      Fredo::Registry.routes['GET'].should_not be_empty
+    end
+    
+    it "is clears in every spec" do
+      # Automate?
+      Fredo.forget
+      Fredo::Registry.routes.should be_empty
+    end
+    
+  end
+  
+  context "parameters" do
+    it "parses url parameters" do
+      
+      Fredo.get 'http://www.twitter.com/:name' do
+        "It ain't #{params[:name]} talking"
+      end
+      
+      response = open('http://www.twitter.com/sam')
+      response.read.should include('It ain\'t sam')
+    end
+    
+    it "plays nice with regex" do
+      Fredo.get 'http://www.google.com/*' do
+        "Everything google!"
+      end
+
+      response = open('http://google.com/something')
+      response.read.should include('Everything google!')
+      
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'fredo'
+require 'spec'
+require 'spec/autorun'
+require 'open-uri'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: fredo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 3
+  version: 0.1.3
+platform: ruby
+authors: 
+- ilpoldo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-24 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: Mocks web services by plugging Net::Http straight into Rack
+email: ilpoldo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- fredo.gemspec
+- lib/fredo.rb
+- lib/fredo/ext/mongrel_handler.rb
+- lib/fredo/ext/net_http.rb
+- lib/fredo/handler.rb
+- lib/fredo/registry.rb
+- lib/fredo/response.rb
+- lib/fredo/stub_socket.rb
+- spec/fredo_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/ilpoldo/fredo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Mocks web services by plugging Net::Http straight into Rack
+test_files: 
+- spec/fredo_spec.rb
+- spec/spec_helper.rb