restful_mapper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77221199e858bff0473e341caeb476fab4a9f20f
+  data.tar.gz: 012a9f9893e7fed2f917715ee605f08e7e3f5840
+SHA512:
+  metadata.gz: 4c351450ae1850ba7a5c87aa7c0cc4b3af691dc6756aa62ae1ef0276fd14b9cf7b28de5486130f54b395d581c8aa28f8c1e7bf4b6ec9b50e0bcb83c05ce866d6
+  data.tar.gz: 4cb445bb1cd7f9c60b9cfb5131a8ae9f50d083a5e38290351721403c0bebefa852b6c3572d9e0cc225bcd1cb7e9a3de98313528fa46c31e0ba6ea81561216fd7

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in restful_mapper.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dragan Milic
+
+MIT License
+
+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.md

@@ -0,0 +1,121 @@
+# RestfulMapper
+
+Provides DSL for describing RESTFul services using JSON transport.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'restful_mapper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install restful_mapper
+
+## Usage
+
+RestfulMapper provides a way to integrate calls to RESTful services into your code without much fuss. It gives you control over the format of the outgoing messages, request parameters and request paths. It also maps response codes to Ruby objects using structure_mapper gem.
+
+The best way to learn about the DSL is to try combining features demonstrated by examples:
+
+### Get request
+In order to invoke a simple get request without any parameters, one can use following mapping:
+
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple"        
+        responses 200 => true, 0 => false
+      end
+    end
+
+Invoking SimpleService.simple_endpoint will return 'true' value if the response code of the service http://localhost:8765/simple is 200 and false for any other response code.
+
+### Get request with request parameters
+In order to add parameter to a simple service definition, one has to add 'query_parameters' array:
+
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple"
+        query_parameters [:name]      
+        responses 200 => true, 0=>false
+      end
+
+    end
+
+When invoked with 'SimpleService.simple_endpoint name: "test"' RestfulMapper will perform a GET request to http://localhost:8765/simple?name=test.
+
+### Get request with path parameters
+Path of the service can be parametrized using Mustache syntax:
+
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple/{{name}}"        
+        responses 200 => true, 0=>false
+      end
+    end
+
+Calling 'SimpleService.simple_endpoint name: "test"' will perform GET request to http://localhost:8765/simple/test.
+
+
+### Post request with JSON body
+In order to use parameter as JSON body, one has to declare it using 'body_parameter' directive
+
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      post :simple_endpoint do
+        path "/simple/{{name}}"        
+        body_parameter :body
+        responses 200 => true, 0=>false
+      end
+    end
+
+Calling 'SimpleService.simple_endpoint name: "test", body: {'a' => 'b'}' will perform POST request to http://localhost:8765/simple/test with body '{"a":"b"}'.
+
+### Mapping JSON response to Ruby objects
+Thanks to structure_mapper, one can easily transform JSON returned by the service into Ruby object. First we
+need definition of the object:
+
+    class SimpleResponse
+      include StructureMapper::Hash
+
+      attribute a: String
+    end
+
+And then we need to use the defined object as response mapping:
+
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple"        
+        responses 200 => SimpleResponse, 0 => false
+      end
+    end
+
+If http://localhost:8765/simple returns 200 and a JSON body '{"a":"b"}' then calling 'SimpleService.simple_endpoint'
+will return instance of SimpleResponse with property 'a' set to 'b'.
+
+### Basic Authentication
+TBD
+
+### Raising Exception
+TBD
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/restful_mapper/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/rubygems.rb

@@ -0,0 +1,42 @@
+require 'restful_mapper'
+require 'pp'
+
+class Dependency
+  include StructureMapper::Hash
+  attribute name: String
+  attribute requirements: String
+end
+
+class RubyGemInfo
+  include StructureMapper::Hash
+  attribute name: String
+  attribute downloads: Fixnum
+  attribute version: String
+  attribute version_downloads: Fixnum
+  attribute platform: String
+  attribute authors: String
+  attribute info: String
+  attribute licenses: []
+  attribute project_uri: String
+  attribute gem_uri: String
+  attribute homepage_uri: String
+  attribute wiki_uri: String
+  attribute documentation_uri: String
+  attribute mailing_list_uri: String
+  attribute source_code_uri: String
+  attribute bug_tracker_uri: String
+  attribute dependencies: {String => [Dependency]}
+end
+
+class RubyGemsService < RestfulMapper::Service
+  
+  base_url 'https://rubygems.org/api/v1'
+
+  get :gems do
+    path 'gems/rails.json', {}
+    responses 200 => RubyGemInfo
+  end
+end
+
+
+pp RubyGemsService.gems({})

data/features/basic_authentication.feature

@@ -0,0 +1,49 @@
+Feature: basic authentication
+
+Scenario: basic authentication of a GET request
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      default_parameters name: 'test'
+
+      basic_authentication 'username', 'password'
+
+      get :simple_endpoint do
+        path "/simple"
+
+        query_parameters [:name]
+        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint"    
+    And the endpoint should receive request header "Authorization" with value "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
+
+Scenario: basic authentication using parameters for username and password
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      default_parameters name: 'test'
+
+      basic_authentication :user, :password
+
+      get :simple_endpoint do
+        path "/simple"
+
+        query_parameters [:name]
+        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint user: 'username', password: 'password' "    
+    And the endpoint should receive request header "Authorization" with value "Basic dXNlcm5hbWU6cGFzc3dvcmQ="

data/features/default_parameters.feature

@@ -0,0 +1,55 @@
+Feature: default parameters
+
+Scenario: simple get request with default request parameters
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      default_parameters name: 'test'
+
+      get :simple_endpoint do
+        path "/simple"
+
+        query_parameters [:name]
+        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint"
+    Then the endpoint should receive request
+    """
+    GET /simple?name=test HTTP/1.1
+
+    """
+
+
+
+Scenario: overriding default parameters with method parameters
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      default_parameters name: 'test'
+
+      get :simple_endpoint do
+        path "/simple"
+
+        query_parameters [:name]
+        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint name: 'test2'"
+    Then the endpoint should receive request
+    """
+    GET /simple?name=test2 HTTP/1.1
+
+    """

data/features/delete_request.feature

@@ -0,0 +1,25 @@
+Feature: delete request
+
+  Scenario: simple get request with a body and no other parameters that returns 200
+    Given following service definition
+    """    
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      delete :simple_endpoint do
+        path "/simple"
+        
+        responses 201 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint"
+    And the endpoint should receive request
+    """
+    DELETE /simple HTTP/1.1
+    """
+    
+
+ 

data/features/get_request.feature

@@ -0,0 +1,124 @@
+Feature: get request
+
+  Scenario: simple get request without any parameters that returns 200
+    Given following service definition
+    """    
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple"
+        
+        responses 200 => {String => String}
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 responds with following http response:
+    """
+    HTTP/1.1 200 OK    
+    Connection: close
+    Content-Type: application/json
+
+    {"a": "b"}
+    """
+    When I call service "SimpleService.simple_endpoint"
+    Then the result should be equal to:
+    """
+      {"a" => "b"}
+    """
+
+ Scenario: simple get request without any parameters that returns 302
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple"
+        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 responds with following http response:
+    """
+    HTTP/1.1 302 OK    
+    Connection: close
+    Content-Type: application/json
+
+    """
+    When I call service "SimpleService.simple_endpoint"
+    Then the result should be equal to:
+    """
+      true
+    """
+
+ Scenario: simple get request with request parameters
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple"
+
+        query_parameters [:name]
+        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint name: 'test'"
+    Then the endpoint should receive request
+    """
+    GET /simple?name=test HTTP/1.1
+
+    """
+
+Scenario: simple get request with path parameters
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple/{{name}}"
+        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint name: 'test'"
+    Then the endpoint should receive request
+    """
+    GET /simple/test HTTP/1.1
+    
+    """
+
+Scenario: simple get request with path and query parameters
+    Given following service definition
+    """
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      get :simple_endpoint do
+        path "/simple/{{name}}"
+        query_parameters [:name]        
+        responses 302 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint name: 'test'"
+    Then the endpoint should receive request
+    """
+    GET /simple/test?name=test HTTP/1.1
+    
+    """

data/features/post_request.feature

@@ -0,0 +1,31 @@
+Feature: post request
+
+  Scenario: simple get request with a body and no other parameters that returns 200
+    Given following service definition
+    """    
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      post :simple_endpoint do
+        path "/simple"
+
+        body_parameter :body
+        
+        responses 201 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint body: {'p1' => 'v1'}"
+    And the endpoint should receive request
+    """
+    POST /simple HTTP/1.1
+    """
+    And request body should be
+    """
+    {"p1":"v1"}
+    """
+    
+
+ 

data/features/put_request.feature

@@ -0,0 +1,31 @@
+Feature: put request
+
+  Scenario: simple get request with a body and no other parameters that returns 200
+    Given following service definition
+    """    
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      put :simple_endpoint do
+        path "/simple"
+
+        body_parameter :body
+        
+        responses 201 => true
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint body: {'p1' => 'v1'}"
+    And the endpoint should receive request
+    """
+    PUT /simple HTTP/1.1
+    """
+    And request body should be
+    """
+    {"p1":"v1"}
+    """
+    
+
+ 

data/features/raising_exceptions.feature

@@ -0,0 +1,30 @@
+Feature: raising exception when return structure is an instance of exception
+
+
+  Scenario: raising exception when structure is exception
+    Given following service definition
+    """
+    class ExceptionResponse < Exception
+      include StructureMapper::Hash
+      attribute a: String      
+    end    
+    class SimpleService < RestfulMapper::Service
+      base_url "http://localhost:8765"
+
+      put :simple_endpoint do
+        path "/simple"
+
+        body_parameter :body
+        
+        responses 201 => ExceptionResponse
+      end
+
+    end
+    """
+    And the service endpoint at port 8765 is running
+    When I call service "SimpleService.simple_endpoint body: {'p1' => 'v1'}" expecting exception    
+    And exception should be raised
+    """
+    ExceptionResponse.new
+    """
+    

data/features/step_definitions/basic_authentication_steps.rb

@@ -0,0 +1,6 @@
+Then(/^the endpoint should receive request header "(.*?)" with value "(.*?)"$/) do |name, value|
+  headers=@response_headers_channel.receive.first
+  # raise headers.inspect
+  headers.should have_key name
+  headers[name].should == value
+end

data/features/step_definitions/get_request_steps.rb

@@ -0,0 +1,75 @@
+Given(/^following service definition$/) do |code|
+  pretext="require 'restful_mapper'\n"
+  @module.module_eval "%s%s" % [pretext,code], "cucuber", 1
+end
+
+Given(/^the service endpoint at port (\d+) responds with following http response:$/) do |port, response|
+  server=TCPServer.new port.to_i
+  go! do
+    connection=server.accept
+    connection.readline
+    connection.write(response)
+    connection.close
+    server.close
+  end
+end
+
+
+When(/^I call service "(.*?)"$/) do |code|
+  @result=@module.module_eval code
+end
+
+Then(/^the result should be equal to:$/) do |expected|
+  @result.should == @module.module_eval(expected)
+end
+
+Given(/^the service endpoint at port (\d+) is running$/) do |port|
+  server=TCPServer.new port.to_i
+  response = "HTTP/1.1 201 OK\n\n"
+  channel=channel! String,1
+  response_channel=channel! String, 1
+  headers_channel=channel! Hash, 1
+  @server_channel=channel
+  @response_body_channel=response_channel
+  @response_headers_channel=headers_channel
+
+  go! do
+    connection=server.accept
+    channel << connection.readline()
+    content_length=nil
+    headers={}
+    while (line=connection.readline()) != "\r\n"
+      # puts "line: %s" % line
+      name, value=line.split(":",2)
+      if name == "Content-Length"
+        content_length=value.to_i
+        # puts "content length: %s" % content_length
+      end
+      headers[name]=value.gsub(/\n|\r/,'').strip
+    end
+
+    headers_channel << headers
+
+    # puts "content length: %d" % content_length
+
+    data=(content_length ? connection.read(content_length) : "")
+
+    # puts "data: %s" % data
+
+    response_channel << data
+
+    connection.write(response)
+    connection.close
+    server.close
+
+  end
+end
+
+Then(/^the endpoint should receive request$/) do |request|
+  @server_channel.receive.first.gsub(/\r|\n/,'').should == request.gsub(/\r|\n/,'')
+end
+
+When(/^request body should be$/) do |expected|
+  @response_body_channel.receive.first.should == expected
+end
+

data/features/step_definitions/raising_exceptions_steps.rb

@@ -0,0 +1,15 @@
+When(/^exception should be raised$/) do |code|
+  @exception.should == @module.module_eval(code)
+end
+
+When(/^I call service "(.*?)" expecting exception$/) do |code|
+  failed=true
+  begin
+    @result=@module.module_eval code
+    failed=false
+  rescue Exception => e
+    @exception=e
+  end
+
+  raise "expected to raise exception" unless failed
+end

data/features/support/env.rb

@@ -0,0 +1,6 @@
+require 'agent'
+
+
+Before do
+  @module=Module.new
+end

data/lib/restful_mapper/version.rb

@@ -0,0 +1,3 @@
+module RestfulMapper
+  VERSION = "0.0.1"
+end

data/lib/restful_mapper.rb

@@ -0,0 +1,156 @@
+require 'faraday'
+require 'json'
+require "restful_mapper/version"
+require 'structure_mapper'
+require 'multi_json'
+require 'mustache'
+
+
+class Object # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+  def meta_def name, &blk
+    (class << self; self; end).instance_eval { define_method name, &blk }
+  end
+end
+
+
+module RestfulMapper
+
+  class EndpointDefinition
+
+    def initialize base_url, method, basic_authentication
+      @base_url=base_url
+      @query_parameters=[]
+      @method=method
+      @basic_authentication=basic_authentication
+    end
+
+    def path path, options={}
+      @path=path
+    end
+
+    def responses response_mapping={}
+      @response_mapping=response_mapping
+    end
+
+    def body_parameter body_parameter
+      @body_parameter=body_parameter
+    end
+
+
+    def query_parameters parameters
+      @query_parameters=parameters.dup
+    end
+
+
+    def filter_parameters hash
+      hash.dup.delete_if do |k,v|
+        not (@query_parameters.include?(k.to_sym) || @query_parameters.include?(k.to_s))
+      end
+    end
+
+    def call_service params
+      conn = Faraday.new(:url => @base_url) do |faraday|
+        # faraday.response :logger                  # log requests to STDOUT
+        faraday.adapter Faraday.default_adapter  # make requests with Net::HTTP
+      end
+
+      if has_basic_authentication?
+        conn.basic_auth(*basic_authentication_data(params))
+      end
+
+      response=conn.run_request(@method, Mustache.render(@path, params), nil, {'Content-Type' => 'application/json'}) { |request|
+        request.params.update(filter_parameters(params)) if filter_parameters(params)
+        if @body_parameter
+          request.body=MultiJson.dump(params[@body_parameter].to_structure)
+        end
+
+
+      }
+
+
+      status=response.status
+      status_class=@response_mapping[status]
+      status_class||=@response_mapping[0]
+      body=response.body
+      result=deserialize body, status_class
+      if Exception === result
+        raise result
+      end
+      result
+    end
+
+    def has_basic_authentication?
+      @basic_authentication
+    end
+
+    def basic_authentication_data params
+      @basic_authentication.map{|name| Symbol === name ? params[name] : name}
+    end
+
+
+    def deserialize json, mapping
+      if json && !json.empty?
+        mapping.from_structure(MultiJson.load(json))
+      else
+        if Hash == mapping || Array == mapping || mapping.is_a?(Class)
+          mapping.new
+        else
+          mapping
+        end
+      end
+    end
+
+
+  end
+
+
+
+
+  class Service
+
+    def self.base_url base_url
+      @base_url=base_url
+    end
+
+    attr_reader :base_url
+
+
+    def self.get name, &definition
+      service_method name, definition, :get
+    end
+
+    def self.post name, &definition
+      service_method name, definition, :post
+    end
+
+    def self.put name, &definition
+      service_method name, definition, :put
+    end
+
+    def self.delete name, &definition
+      service_method name, definition, :delete
+    end
+
+    def self.default_parameters parameters
+      @default_parameters=parameters
+    end
+
+    def self.basic_authentication username, password
+      @basic_authentication=[username,password]
+    end
+
+    private
+
+    def self.service_method name, definition, method
+      endpoint_definition=EndpointDefinition.new @base_url, method, @basic_authentication
+      endpoint_definition.instance_exec(&definition)
+      self.meta_def(name.to_sym) do |params={}|
+        copy=(@default_parameters || {}).merge(params)
+        endpoint_definition.call_service copy
+      end
+
+    end
+
+  end
+
+end

data/restful_mapper.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'restful_mapper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "restful_mapper"
+  spec.version       = RestfulMapper::VERSION
+  spec.authors       = ["Dragan Milic"]
+  spec.email         = ["dragan@netice9.com"]
+  spec.summary       = %q{Mapper of RESTful services to ruby objects. Makes calling RESTful services and parsing responses a breeze.}
+  spec.description   = %q{Mapper of RESTful services to ruby objects. Makes calling RESTful services and parsing responses a breeze.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "autotest"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "puma"
+  spec.add_development_dependency "sinatra"
+  spec.add_development_dependency "agent"
+  spec.add_dependency "faraday"
+  spec.add_dependency "multi_json"
+  spec.add_dependency "structure_mapper"
+  spec.add_dependency "mustache"
+end

metadata

@@ -0,0 +1,245 @@
+--- !ruby/object:Gem::Specification
+name: restful_mapper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dragan Milic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: agent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: structure_mapper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Mapper of RESTful services to ruby objects. Makes calling RESTful services
+  and parsing responses a breeze.
+email:
+- dragan@netice9.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/rubygems.rb
+- features/basic_authentication.feature
+- features/default_parameters.feature
+- features/delete_request.feature
+- features/get_request.feature
+- features/post_request.feature
+- features/put_request.feature
+- features/raising_exceptions.feature
+- features/step_definitions/basic_authentication_steps.rb
+- features/step_definitions/get_request_steps.rb
+- features/step_definitions/raising_exceptions_steps.rb
+- features/support/env.rb
+- lib/restful_mapper.rb
+- lib/restful_mapper/version.rb
+- restful_mapper.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Mapper of RESTful services to ruby objects. Makes calling RESTful services
+  and parsing responses a breeze.
+test_files:
+- features/basic_authentication.feature
+- features/default_parameters.feature
+- features/delete_request.feature
+- features/get_request.feature
+- features/post_request.feature
+- features/put_request.feature
+- features/raising_exceptions.feature
+- features/step_definitions/basic_authentication_steps.rb
+- features/step_definitions/get_request_steps.rb
+- features/step_definitions/raising_exceptions_steps.rb
+- features/support/env.rb