holoserve 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 Skrill Holdings Ltd
+
+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,131 @@
+
+= HoloServe - Simple faking of HTTP APIs
+
+This tool can be used to fake HTTP web APIs. It's meant to be used in a testing environment, to make the test suite
+run faster and be independent from other API and network problems.
+
+== Concept
+
+HoloServe runs a rack application server, that matches any incoming request to a list of request profiles defined in
+the server layout. If a match is found, the defined static response is returned. The name of the matched
+request/response pair is saved in a request history. If no match is found, a 404 is returned and the
+request data is stored in the bucket for unhandeled requests. These informations can be used to extend the server layout
+with missing request handlers.
+
+Layouts, history and bucket can be accessed via control routes, which are described below.
+
+== Control routes
+
+=== POST /_control/layouts
+
+It should receive a parameter named <tt>file</tt> that contains an uploaded YML file with the server layouts. See
+{YML server layouts file format}[rdoc-label:YML-server-layouts-file-format] below.
+
+=== DELETE /_control/layouts
+
+Removes all server layouts.
+
+=== GET /_control/layouts/ids
+
+Returns the list of ids of all server layouts.
+
+==== Response example
+
+  [ "one", "two" ]
+
+=== PUT /_control/layouts/:id/current
+
+Makes the layout with id <tt>:id</tt> the currently active one.
+
+=== GET /_control/layouts/current
+
+Returns the id of the current layout.
+
+==== Response example
+
+  one
+
+=== GET /_control/bucket/requests
+
+Returns a list of all requests that has been received, but couldn't be handled.
+
+==== Response example
+
+  [
+    {
+      "method": "POST",
+      "path": "test",
+      "headers": {
+        "REMOTE_ADDR": "127.0.0.1",
+        "REQUEST_METHOD": "GET",
+        "REQUEST_PATH": "/test",
+        "PATH_INFO": "/test",
+        "REQUEST_URI": "/test",
+        "SERVER_PROTOCOL": "HTTP/1.1",
+        "HTTP_VERSION": "HTTP/1.1",
+        "HTTP_ACCEPT": "*/*",
+        "HTTP_USER_AGENT": "Ruby",
+        "HTTP_HOST": "localhost:8080",
+        "SERVER_NAME": "localhost",
+        "SERVER_PORT": "8080",
+        "QUERY_STRING": "",
+        "SCRIPT_NAME": "",
+        "SERVER_SOFTWARE": "Unicorn 4.1.1"
+      }
+    }
+  ]
+
+=== GET /_control/history
+
+Returns a list of all names of pairs that has been triggered.
+
+==== Response example
+
+  [ "create_received", "update_received" ]
+
+=== DELETE /_control/history
+
+Removes all entries from the history.
+
+== YML server layouts file format
+
+The server layouts file should have the following format.
+
+  one:
+    -
+      name: "test_received"
+      request:
+        method: "POST"
+        path: "/test"
+        headers:
+          HTTP_USER_AGENT: "Ruby"
+          HTTP_AUTHORIZATION: "OAuth oauth_token=12345"
+        body:
+          "test=value"
+        parameters:
+          test: "value"
+        oauth:
+          oauth_token: "12345"
+      response:
+        status: 200
+        body:
+          "ok"
+    -
+      request:
+        method: "GET"
+        path: "/test"
+      response:
+        status: 200
+        body:
+          "ok too"
+
+This example would define a server layout named <tt>one</tt> that has two request/response pairs. The first pair would
+have the name <tt>test_received</tt> and would match a <tt>POST</tt> request to the path <tt>/test</tt>.
+
+Notice, that the given request attributes are the _minimal_ values that have to match the incomong one. An incoming
+request may has much more attributes (see bucket example above). If a request is matched, the corresponding pair name is
+placed in the history.
+
+As the sections <tt>headers</tt> and <tt>body</tt> are raw values from the request, the sections <tt>parameters</tt> and
+<tt>oauth</tt> contain high-level values. The <tt>parameters</tt> hash is taken from the request body or the query and
+the hash containing the OAuth values is parsed from a fitting <tt>HTTP_AUTHORIZATION</tt> header.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler/setup'
+
+desc "Runs the unicorn interface server."
+task :server do
+  system "bundle exec unicorn"
+end
+
+desc "Runs the shotgun interface server."
+task :shotgun do
+  system "bundle exec shotgun"
+end
+
+begin
+  require 'cucumber'
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new(:features) do |task|
+    task.cucumber_opts = "features --format pretty"
+  end
+
+  namespace :features do
+    Cucumber::Rake::Task.new(:wip) do |task|
+      task.cucumber_opts = "features --format pretty --tags @wip"
+    end
+  end
+rescue LoadError
+end
+
+begin
+  require 'rdoc'
+  require 'rdoc/task'
+
+  Rake::RDocTask.new do |rdoc|
+    rdoc.main = "README.rdoc"
+    rdoc.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  end
+rescue LoadError
+end
+
+namespace :gem do
+
+  desc "Builds the gem"
+  task :build do
+    system "gem build *.gemspec && mkdir -p pkg/ && mv *.gem pkg/"
+  end
+
+  desc "Builds and installs the gem"
+  task :install => :build do
+    system "gem install pkg/"
+  end
+
+end

data/bin/holoserve

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'optparse'
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "holoserve"))
+
+options = { }
+OptionParser.new do |parser|
+  parser.banner = "Usage: holoserve [options]"
+  parser.separator ""
+  parser.separator "Options:"
+  parser.on("-p", "--port PORT", Integer, "The port holoserve should listen to.") do |value|
+    options[:port] = value
+  end
+  parser.on("-f", "--layouts-file FILE", "Load the specified layouts file on startup.") do |value|
+    options[:layouts_filename] = value
+  end
+  parser.on("-l", "--layout LAYOUT", "Selects the specified layout as the current one.") do |value|
+    options[:layout] = value
+  end
+  parser.on_tail("-h", "--help", "Shows the help message.") do
+    puts parser
+    exit
+  end
+end.parse!(ARGV)
+
+runner = Holoserve::Runner.new options
+runner.run

data/lib/holoserve/bucket.rb

@@ -0,0 +1,10 @@
+
+class Holoserve::Bucket
+
+  attr_reader :requests
+
+  def initialize
+    @requests = [ ]
+  end
+
+end

data/lib/holoserve/configuration.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+class Holoserve::Configuration
+
+  attr_reader :logger
+
+  attr_reader :layouts
+  attr_reader :layout_id
+
+  def initialize(logger)
+    @logger = logger
+  end
+
+  def layouts=(hash)
+    @layouts = Holoserve::Tool::Hash::KeySymbolizer.new(hash).hash
+  end
+
+  def layout_id=(value)
+    @layout_id = value.to_sym
+    logger.info "made '#{value}' the current layout"
+  end
+
+  def clear_layouts!
+    self.layouts = nil
+  end
+
+  def layout_ids
+    self.layouts ? self.layouts.keys : [ ]
+  end
+
+  def layout_id?(id)
+    self.layout_ids.include? id.to_sym
+  end
+
+  def layout
+    self.layouts ? self.layouts[self.layout_id] : nil
+  end
+
+  def load_layouts_from_yml_file(file)
+    self.layouts = YAML::load_file file
+    logger.info "loaded layouts from file #{file.path}"
+    logger.info "available layout(s): #{self.layout_ids.join(", ")}"
+  rescue Psych::SyntaxError => error
+    self.clear_layouts!
+    raise error
+  end
+
+end

data/lib/holoserve/history.rb

@@ -0,0 +1,14 @@
+
+class Holoserve::History
+
+  attr_reader :pair_names
+
+  def initialize
+    @pair_names = [ ]
+  end
+
+  def clear!
+    @pair_names.clear
+  end
+
+end

data/lib/holoserve/interface/control.rb

@@ -0,0 +1,74 @@
+require 'sinatra'
+require 'yaml'
+require 'json'
+
+class Holoserve::Interface::Control < Sinatra::Base
+
+  post "/_control/layouts" do
+    begin
+      configuration.load_layouts_from_yml_file params["file"][:tempfile]
+      respond_json_acknowledgement
+    rescue Psych::SyntaxError => error
+      error 400, error.inspect
+    end
+  end
+
+  delete "/_control/layouts" do
+    configuration.clear_layouts!
+    respond_json_acknowledgement
+  end
+
+  get "/_control/layouts/ids" do
+    respond_json configuration.layout_ids
+  end
+
+  put "/_control/layouts/:id/current" do |id|
+    if configuration.layout_id?(id)
+      configuration.layout_id = id
+      respond_json_acknowledgement
+    else
+      not_found
+    end
+  end
+
+  get "/_control/layouts/current" do
+    configuration.layout_id.to_s
+  end
+
+  get "/_control/bucket/requests" do
+    respond_json bucket.requests
+  end
+
+  get "/_control/history" do
+    respond_json history.pair_names
+  end
+
+  delete "/_control/history" do
+    history.clear!
+    respond_json_acknowledgement
+  end
+
+  private
+
+  def respond_json_acknowledgement
+    respond_json :ok => true
+  end
+
+  def respond_json(object)
+    content_type "application/json"
+    JSON.dump object
+  end
+
+  def bucket
+    Holoserve.instance.bucket
+  end
+
+  def history
+    Holoserve.instance.history
+  end
+
+  def configuration
+    Holoserve.instance.configuration
+  end
+
+end

data/lib/holoserve/interface/fake.rb

@@ -0,0 +1,47 @@
+require 'pp'
+
+class Holoserve::Interface::Fake
+
+  def call(env)
+    request = Holoserve::Request::Decomposer.new(env).hash
+    pair = Holoserve::Pair::Finder.new(configuration, request).pair
+    if pair
+      if name = pair[:name]
+        history.pair_names << name
+        logger.info "received handled request with name '#{name}'"
+      end
+      Holoserve::Response::Composer.new(pair[:response]).response_array
+    else
+      bucket.requests << request
+      logger.error "received unhandled request\n" + request.pretty_inspect
+      not_found
+    end
+  end
+
+  private
+
+  def not_found
+    [ 404, { "Content-Type" => "text/plain" }, [ "no response found for this request" ] ]
+  end
+
+  def logger
+    configuration.logger
+  end
+
+  def layout
+    configuration.layout
+  end
+
+  def bucket
+    Holoserve.instance.bucket
+  end
+
+  def history
+    Holoserve.instance.history
+  end
+
+  def configuration
+    Holoserve.instance.configuration
+  end
+
+end

data/lib/holoserve/interface.rb

@@ -0,0 +1,7 @@
+
+module Holoserve::Interface
+
+  autoload :Control, File.join(File.dirname(__FILE__), "interface", "control")
+  autoload :Fake, File.join(File.dirname(__FILE__), "interface", "fake")
+
+end

data/lib/holoserve/pair/finder.rb

@@ -0,0 +1,21 @@
+
+class Holoserve::Pair::Finder
+
+  def initialize(configuration, request)
+    @configuration, @request = configuration, request
+  end
+
+  def pair
+    return nil unless layout
+    layout.detect do |pair|
+      Holoserve::Request::Matcher.new(@request, pair[:request]).match?
+    end
+  end
+
+  private
+
+  def layout
+    @configuration.layout
+  end
+
+end

data/lib/holoserve/pair.rb

@@ -0,0 +1,6 @@
+
+module Holoserve::Pair
+
+  autoload :Finder, File.join(File.dirname(__FILE__), "pair", "finder")
+
+end

data/lib/holoserve/request/decomposer.rb

@@ -0,0 +1,65 @@
+
+class Holoserve::Request::Decomposer
+
+  def initialize(request)
+    @request = request
+  end
+
+  def hash
+    hash = {
+      :method => @request["REQUEST_METHOD"],
+      :path => @request["PATH_INFO"]
+    }
+    hash.merge! :headers => headers unless headers.empty?
+    hash.merge! :body => body unless body.nil?
+    hash.merge! :parameters => parameters unless parameters.empty?
+    hash.merge! :oauth => oauth unless oauth.empty?
+    hash
+  end
+
+  private
+
+  def headers
+    headers = { }
+    @request.each do |key, value|
+      headers[ key.to_sym ] = value unless key =~ /^rack\./
+    end
+    headers
+  end
+
+  def body
+    @body ||= begin
+      body = @request["rack.input"].read
+      body && body != "" ? body : nil
+    end
+  end
+
+  def parameters
+    Holoserve::Tool::Hash::KeySymbolizer.new(query_hash.merge(form_hash)).hash
+  end
+
+  def query_hash
+    @request["rack.request.query_hash"] || { }
+  end
+
+  def form_hash
+    @request["rack.request.form_hash"] || { }
+  end
+
+  def oauth
+    @oauth ||= begin
+      oauth = { }
+      http_authorization = @request["HTTP_AUTHORIZATION"]
+      if http_authorization && http_authorization =~ /^OAuth/
+        http_authorization = http_authorization.sub /^OAuth/, ""
+        pairs = http_authorization.split ","
+        pairs.each do |pair|
+          key, value = *pair.strip.split("=")
+          oauth[ key.to_sym ] = value.sub(/^\\"/, "").sub(/\\"$/, "").gsub(/"/, "")
+        end
+      end
+      oauth
+    end
+  end
+
+end

data/lib/holoserve/request/matcher.rb

@@ -0,0 +1,61 @@
+
+class Holoserve::Request::Matcher
+
+  def initialize(request, request_subset)
+    @request, @request_subset = request, request_subset
+  end
+
+  def match?
+    match_method? &&
+      match_path? &&
+      match_headers? &&
+      match_body? &&
+      match_parameters? &&
+      match_oauth?
+  end
+
+  private
+  
+  def match_method?
+    @request_subset[:method] ?
+      @request[:method] == @request_subset[:method] :
+      true
+  end
+
+  def match_path?
+    @request_subset[:path] ?
+      @request[:path] == @request_subset[:path] :
+      true
+  end
+
+  def match_headers?
+    match = true
+    (@request_subset[:headers] || { }).each do |key, value|
+      match &&= @request[:headers][key] == value
+    end
+    match
+  end
+
+  def match_body?
+    @request_subset[:body] ?
+      @request[:body] == @request_subset[:body] :
+      true
+  end
+
+  def match_parameters?
+    match = true
+    (@request_subset[:parameters] || { }).each do |key, value|
+      match &&= @request[:parameters][key] == value
+    end
+    match
+  end
+
+  def match_oauth?
+    match = true
+    (@request_subset[:oauth] || { }).each do |key, value|
+      match &&= @request[:oauth][key] == value
+    end
+    match
+  end
+
+end

data/lib/holoserve/request.rb

@@ -0,0 +1,7 @@
+
+module Holoserve::Request
+
+  autoload :Decomposer, File.join(File.dirname(__FILE__), "request", "decomposer")
+  autoload :Matcher, File.join(File.dirname(__FILE__), "request", "matcher")
+
+end

data/lib/holoserve/response/composer.rb

@@ -0,0 +1,35 @@
+require 'json'
+
+class Holoserve::Response::Composer
+
+  def initialize(response)
+    @response = response
+  end
+
+  def response_array
+    [ status, headers, [ body ] ]
+  end
+
+  private
+
+  def status
+    @response[:status]
+  end
+
+  def headers
+    @response[:headers] || { }
+  end
+
+  def body
+    @body ||= begin
+      if @response.has_key?(:body)
+        @response[:body]
+      elsif @response.has_key?(:json)
+        JSON.dump @response[:json]
+      else
+        nil
+      end
+    end
+  end
+
+end

data/lib/holoserve/response.rb

@@ -0,0 +1,6 @@
+
+module Holoserve::Response
+
+  autoload :Composer, File.join(File.dirname(__FILE__), "response", "composer")
+
+end

data/lib/holoserve/runner.rb

@@ -0,0 +1,68 @@
+require 'unicorn'
+require 'transport'
+
+class Holoserve::Runner
+
+  attr_reader :port
+
+  def initialize(options = { })
+    @port = options[:port] || 4250
+    @layouts_filename = options[:layouts_filename]
+    @layout = options[:layout]
+
+    @rackup_options = Unicorn::Configurator::RACKUP
+    @rackup_options[:port] = @port
+    @rackup_options[:set_listener] = true
+    @options = @rackup_options[:options]
+
+    @unicorn = Unicorn::HttpServer.new rack, @options
+  end
+
+  def start
+    @unicorn.start
+    upload_layouts if @layouts_filename
+    set_layout if @layout
+  end
+
+  def join
+    return unless @unicorn
+    @unicorn.join
+  end
+
+  def stop
+    return unless @unicorn
+    @unicorn.stop
+    @unicorn = nil
+  end
+
+  def run
+    self.start
+    self.join
+  end
+
+  private
+
+  def upload_layouts
+    Holoserve::Tool::Uploader.new(
+      @layouts_filename,
+      :post,
+      "http://localhost:#{port}/_control/layouts",
+      :expected_status_code => 200
+    ).upload
+    nil
+  end
+
+  def set_layout
+    Transport::JSON.request :put, "http://localhost:#{port}/_control/layouts/#{@layout}/current", :expected_status_code => 200
+    nil
+  end
+
+  def rack
+    instance.rack
+  end
+
+  def instance
+    Holoserve.instance
+  end
+
+end

data/lib/holoserve/tool/hash/key_symbolizer.rb

@@ -0,0 +1,41 @@
+
+class Holoserve::Tool::Hash::KeySymbolizer
+
+  def initialize(hash)
+    @hash = hash
+  end
+
+  def hash
+    symbolize_keys @hash
+  end
+
+  private
+
+  def symbolize_keys(hash)
+    return nil unless hash.is_a?(Hash)
+    result = { }
+    hash.each do |key, value|
+      result[ key.to_sym ] = if value.is_a?(Hash)
+        symbolize_keys value
+      elsif value.is_a?(Array)
+        symbolize_keys_of_all value
+      else
+        value
+      end
+    end
+    result
+  end
+
+  def symbolize_keys_of_all(array)
+    array.map do |item|
+      if item.is_a?(Hash)
+        symbolize_keys item
+      elsif item.is_a?(Array)
+        symbolize_keys_of_all item
+      else
+        item
+      end
+    end
+  end
+
+end

data/lib/holoserve/tool/hash.rb

@@ -0,0 +1,6 @@
+
+module Holoserve::Tool::Hash
+
+  autoload :KeySymbolizer, File.join(File.dirname(__FILE__), "hash", "key_symbolizer")
+
+end

data/lib/holoserve/tool/uploader.rb

@@ -0,0 +1,36 @@
+require 'transport'
+
+class Holoserve::Tool::Uploader
+
+  def initialize(filename, http_method, url, options = { })
+    @filename, @http_method, @url, @options = filename, http_method, url, options
+  end
+
+  def upload
+    options = @options
+    options[:headers] = (@options[:headers] || { }).merge(headers)
+    options[:body] = body
+    Transport::HTTP.request @http_method, @url, options
+  end
+
+  private
+
+  def headers
+    { "Content-Type" => "multipart/form-data, boundary=#{boundary}" }
+  end
+
+  def body
+    "--#{boundary}\r\n" +
+    "Content-Disposition: form-data; name=\"file\"; filename=\"#{File.basename(@filename)}\"\r\n" +
+    "Content-Type: application/x-yaml\r\n" +
+    "\r\n" +
+    File.read(@filename) +
+    "\r\n" +
+    "--#{boundary}--\r\n"
+  end
+
+  def boundary
+    "xxx12345xxx"
+  end
+
+end

data/lib/holoserve/tool.rb

@@ -0,0 +1,7 @@
+
+module Holoserve::Tool
+
+  autoload :Hash, File.join(File.dirname(__FILE__), "tool", "hash")
+  autoload :Uploader, File.join(File.dirname(__FILE__), "tool", "uploader")
+
+end

data/lib/holoserve.rb

@@ -0,0 +1,59 @@
+require 'rack/builder'
+require 'logger'
+
+class Holoserve
+
+  autoload :Bucket, File.join(File.dirname(__FILE__), "holoserve", "bucket")
+  autoload :Configuration, File.join(File.dirname(__FILE__), "holoserve", "configuration")
+  autoload :History, File.join(File.dirname(__FILE__), "holoserve", "history")
+  autoload :Interface, File.join(File.dirname(__FILE__), "holoserve", "interface")
+  autoload :Pair, File.join(File.dirname(__FILE__), "holoserve", "pair")
+  autoload :Request, File.join(File.dirname(__FILE__), "holoserve", "request")
+  autoload :Response, File.join(File.dirname(__FILE__), "holoserve", "response")
+  autoload :Runner, File.join(File.dirname(__FILE__), "holoserve", "runner")
+  autoload :Tool, File.join(File.dirname(__FILE__), "holoserve", "tool")
+
+  attr_reader :logger
+  attr_reader :configuration
+  attr_reader :bucket
+  attr_reader :history
+  attr_reader :rack
+
+  def initialize
+    initialize_logger
+    initialize_configuration
+    initialize_bucket
+    initialize_history
+    initialize_rack
+  end
+
+  private
+
+  def initialize_logger
+    @logger = Logger.new STDOUT
+  end
+
+  def initialize_configuration
+    @configuration = Configuration.new @logger
+  end
+
+  def initialize_bucket
+    @bucket = Bucket.new
+  end
+
+  def initialize_history
+    @history = History.new
+  end
+
+  def initialize_rack
+    @rack = Rack::Builder.new do
+      use Interface::Control
+      run Interface::Fake.new
+    end
+  end
+
+  def self.instance
+    @instance ||= self.new
+  end
+
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: holoserve
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Philipp Brüll
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70258362918600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258362918600
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &70258366899940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258366899940
+- !ruby/object:Gem::Dependency
+  name: unicorn
+  requirement: &70258366896080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258366896080
+- !ruby/object:Gem::Dependency
+  name: transport
+  requirement: &70258366894700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258366894700
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &70258366892660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258366892660
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70258366891240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258366891240
+- !ruby/object:Gem::Dependency
+  name: transport
+  requirement: &70258366890200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258366890200
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: &70258366889100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258366889100
+description: This tool can be used to fake webservice APIs for testing proposals.
+email: philipp.bruell@skrill.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- LICENSE
+- Rakefile
+- bin/holoserve
+- lib/holoserve/bucket.rb
+- lib/holoserve/configuration.rb
+- lib/holoserve/history.rb
+- lib/holoserve/interface/control.rb
+- lib/holoserve/interface/fake.rb
+- lib/holoserve/interface.rb
+- lib/holoserve/pair/finder.rb
+- lib/holoserve/pair.rb
+- lib/holoserve/request/decomposer.rb
+- lib/holoserve/request/matcher.rb
+- lib/holoserve/request.rb
+- lib/holoserve/response/composer.rb
+- lib/holoserve/response.rb
+- lib/holoserve/runner.rb
+- lib/holoserve/tool/hash/key_symbolizer.rb
+- lib/holoserve/tool/hash.rb
+- lib/holoserve/tool/uploader.rb
+- lib/holoserve/tool.rb
+- lib/holoserve.rb
+homepage: http://github.com/skrill/holoserve
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3189243162952921439
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: holoserve
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Tool to fake HTTP APIs.
+test_files: []