rest_chain 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b52975f97979dfa59a9c6ce08c761c5f04b8e85
+  data.tar.gz: 6bc0900a599d7c35f3d15939ed97a31bfed2d547
+SHA512:
+  metadata.gz: db20f8c62207117469e4eec63e15ee561d378dcd16f1bff847174148b10c2ff9467ca2bff05fc1dd00ba09a71d4874d647c4a21f7831cd7761b6012d5b949f1d
+  data.tar.gz: 74252ca8c40db09432d786e511a228c1ad2f64b5279c4629de40c90302e2dcab859457eb6a9e90146ccc55969e1cfea907cd1db7713cace0134707f6f9f7c74c

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Peter Wood
+
+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,108 @@
+# RestChain
+
+RestChain is a library to wrap REST API calls and make their use look and feel
+like standard method calls. RestChain is based on the Rest Client library.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rest_chain'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rest_chain
+
+## Usage
+
+First thing to do is to require in the library. Do this bad adding a line like
+the following to the top of your script...
+
+```ruby
+require "rest_chain"
+```
+
+Next you need to create a ```RestChain::Chain``` object. The ```Chain``` class
+constructor takes a Hash of setting options and recognises the following keys
+in this Hash...
+
+ * ```:host``` A String containing the name of the host on which the REST API
+               service is running. You must specify this value.
+
+ * ```:logger``` A Logger class instance that the ```Chain``` will use for
+                 logging purposes. This is optional.
+
+ * ```:parameters``` A Hash of common parameters (i.e. parameters that are to
+                     be part of all requests). This is optional.
+
+ * ```:path``` An Array or String of the common parts of the path used in REST
+               API URLs. For example if the path for all REST API URLs started
+               with /api/v1/ you could specify these in this parameter to avoid
+               having to repeatedly specify them on chained REST calls. This is
+               optional.
+
+ * ```:port``` The port number the REST API service is listening on. Only needed
+               if the service is running on a non-standard port (i.e. 80 for HTTP
+               services or 443 for HTTPS services). This is optional.
+
+ * ```:scheme``` The protocol scheme to be used when making REST API requests.
+                 Options are "http" or "https". This is optional with the default
+                 being "https".
+
+So creating a new ```Chain``` object might look as follows...
+
+```ruby
+chain = RestChain::Chain.new(host: "myresthost.com", path: ["api", "v1"])
+```
+
+Once you have a ```Chain``` object you can make requests against it. Lets say
+you wished to fetch the details for a specific user from your REST service and
+the URL to do that looked as follows
+
+```
+https://myresthost.com/api/v1/users/<user id>
+```
+
+Where the ```<user id>``` part will be replaced by the unique identifier of the
+users whose details are to be retrieved. You could use the ```Chain``` object to
+fetch a user with an id of 123 as follows...
+
+```ruby
+response = chain.users(123).get
+```
+
+Note that if there were parameters that you wanted to append to the request (e.g.
+a session id) then you can specify them as part of the 'verb' method that is used
+to initiate the request. So, using the previous example as a basis, you could add
+the session id like this...
+
+```ruby
+response = chain.users(123).get(session_id: session.id)
+```
+
+Methods are provided for the ```delete```, ```get```, ```patch```, ```post``` and
+```put``` verbs that all work in a similar fashion.
+
+This call would return a ```RestChain::RestResponse``` object. This object will
+possess details for the response received for the request including the status
+code of the response, the headers and the response body. If you knew your response
+would contain JSON formatted content then you could convert that directly to a
+Ruby equivalent using...
+
+```ruby
+response.json
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rest_chain/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 a new Pull Request

data/Rakefile

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

data/lib/rest_chain/chain.rb

@@ -0,0 +1,56 @@
+require "stringio"
+
+module RestChain
+  class Chain < Link
+    DEFAULT_SCHEME             = "https".freeze
+
+    # Constructor for the Chain class.
+    #
+    # ==== Parameters
+    # settings::  A Hash of the settings for the chain. Currently recognised
+    #             settings are...
+    #              * :host        The REST API host to be interacted with, this
+    #                             must be specified.
+    #              * :logger      The Logger to be used in the Chain.
+    #              * :parameters  A Hash of default parameters that get sent
+    #                             with all requests.
+    #              * :path        Either a String or an Array. If its an array
+    #                             the elements will be concatentated together
+    #                             into a String. This specifies common elements
+    #                             of the path to avoid having to repeatedly
+    #                             specify them as part of the chain.
+    #              * :port        The port number to contact the REST API host
+    #                             on. Need not be specified if the default port
+    #                             (80 for HTTP and 443 for HTTPS) are to be used.
+    #              * :scheme      Should be given a value of either "http" or "https".
+    #                             This is the scheme that will be used when talking
+    #                             to the REST API. Defaults to "https" if not 
+    #                             explicitly specified.
+    def initialize(settings={})
+      super("", nil, settings[:logger])
+      @host   = settings.fetch(:host, "").strip
+      raise RestChainError.new("No REST API host specified when creating a chain.") if @host == ""
+
+      @port   = settings[:port]
+      @scheme = settings.fetch(:scheme, DEFAULT_SCHEME).downcase
+      @path   = settings.fetch(:path, [])
+      @path   = @path.split("/").delete_if {|s| s == ""} if @path.kind_of?(String)
+      @parameters = {}.merge(settings.fetch(:parameters, {}))
+    end
+
+    attr_reader :host, :path, :port, :scheme
+
+    def full_parameters(extras={})
+      {}.merge(@parameters).merge(extras)
+    end
+
+    def url
+      text = StringIO.new
+      text << @scheme << "://" << @host
+      text << ":#{@port}" if @port
+      text << "/" if text.string[-1,1] != "/"
+      text << "#{@path.join('/')}"
+      text.string
+    end
+  end
+end

data/lib/rest_chain/exceptions.rb

@@ -0,0 +1,9 @@
+module RestChain
+  class RestChainError < StandardError
+    def initialize(message, cause=nil)
+      super(message)
+      @cause = cause
+    end
+    attr_reader :cause
+  end
+end

data/lib/rest_chain/http_driver_class_factory.rb

@@ -0,0 +1,7 @@
+module RestChain
+  class HTTPDriverClassFactory
+    def self.manufacture(log)
+      RestClientDriver
+    end
+  end
+end

data/lib/rest_chain/link.rb

@@ -0,0 +1,62 @@
+require "logger"
+
+module RestChain
+  class Link
+    def initialize(name, predecessor=nil, logger=nil)
+      @name        = name
+      @predecessor = predecessor
+      @logger      = logger ? logger : log
+    end
+
+    attr_reader :name, :predecessor
+
+    def delete(parameters={})
+      dispatch(:delete, parameters)
+    end
+
+    def dispatch(verb, parameters={})
+      driver = HTTPDriverClassFactory.manufacture(log).new(log)
+      driver.send(verb, url, parameters)
+    end
+
+    def get(parameters={})
+      dispatch(:get, parameters)
+    end
+
+    def log
+      if !@logger
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::UNKNOWN
+      end
+      @logger
+    end
+    alias :logger :log
+
+    def method_missing(name, *arguments, &block)
+      arguments.inject(Link.new(name.to_s, self, log)) do |parent, argument|
+        Link.new(argument.to_s, parent, log)
+      end
+    end
+
+    def patch(parameters={})
+      dispatch(:patch, parameters)
+    end
+
+    def post(parameters={})
+      dispatch(:post, parameters)
+    end
+
+    def put(parameters={})
+      dispatch(:put, parameters)
+    end
+
+    def respond_to?(name, include_private=false)
+      true
+    end
+
+    def url
+      base = (@predecessor ? @predecessor.url : "")
+      @predecessor ? "#{base}#{base[-1,1] == '/' ? '' : '/'}#{@name}" : "/#{@name}"
+    end
+  end
+end

data/lib/rest_chain/rest_client_driver.rb

@@ -0,0 +1,43 @@
+require "rest_client"
+
+module RestChain
+  class RestClientDriver
+    def initialize(logger)
+      @logger = logger
+    end
+    attr_reader :logger
+    alias :log :logger
+
+    def delete(url, parameters={})
+      dispatch(:delete, url, parameters)
+    end
+
+    def get(url, parameters={})
+      dispatch(:get, url, parameters)
+    end
+
+    def patch(url, parameters={})
+      dispatch(:patch, url, parameters)
+    end
+
+    def post(url, parameters={})
+      dispatch(:post, url, parameters)
+    end
+
+    def put(url, parameters={})
+      dispatch(:put, url, parameters)
+    end
+
+    def dispatch(verb, url, parameters={})
+      log.debug "Dispatching a #{verb.to_s.upcase} request to #{url} with parameters: #{parameters}"
+      response = RestClient::Request.execute(headers: {params: parameters},
+                                             method:  verb,
+                                             url:     url)
+      RestResponse.new(response.code, response.headers, response.body)
+    rescue RestClient::Exception => error
+      log.debug "#{verb.to_s.upcase} request to #{url} raised a #{error.class.name} exception."
+      response = error.response
+      RestResponse.new(response.code, response.headers, response.body)
+    end
+  end
+end

data/lib/rest_chain/rest_response.rb

@@ -0,0 +1,20 @@
+require "json"
+
+module RestChain
+  class RestResponse
+    def initialize(status, headers, body)
+      @status  = status
+      @headers = headers
+      @body    = body
+    end
+    attr_reader :status, :headers, :body
+
+    def success?
+      (200..299).include?(@status)
+    end
+
+    def json(options={})
+      JSON.parse(body, options)
+    end
+  end
+end

data/lib/rest_chain/version.rb

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

data/lib/rest_chain.rb

@@ -0,0 +1,11 @@
+require "rest_client"
+require "rest_chain/version"
+require "rest_chain/exceptions"
+require "rest_chain/link"
+require "rest_chain/rest_client_driver"
+require "rest_chain/http_driver_class_factory"
+require "rest_chain/chain"
+require "rest_chain/rest_response"
+
+module RestChain
+end

data/rest_chain.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rest_chain/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rest_chain"
+  spec.version       = RestChain::VERSION
+  spec.authors       = ["Peter Wood"]
+  spec.email         = ["peter.wood@longboat.com"]
+  spec.summary       = %q{A library that abstracts the use of a REST interface.}
+  spec.description   = %q{REST chain is a library that abstracts the path elements of making a REST API call to appear as method calls in Ruby.}
+  spec.homepage      = "https://github.com/free-beer/rest_chain"
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "webmock", "~> 1.24"
+
+  spec.add_dependency "rest-client", "~> 1.8"
+end

data/spec/lib/rest_chain/chain_spec.rb

@@ -0,0 +1,64 @@
+describe RestChain::Chain do
+  let(:host) {
+    "localhost"
+  }
+
+  let(:path) {
+    ["one", "two", "three"]
+  }
+
+  let(:port) {
+    3645
+  }
+
+  let(:logger) {
+    Logger.new(STDOUT)
+  }
+
+  describe "#initialize()" do
+    subject {
+      RestChain::Chain
+    }
+
+    it "assigns values from the settings passed in" do
+      chain = subject.new(host: host, logger: logger, path: "/one/two/three", port: port, scheme: "http")
+      expect(chain.host).to eq(host)
+      expect(chain.logger).to eq(logger)
+      expect(chain.path).to eq(path)
+      expect(chain.port).to eq(port)
+      expect(chain.scheme).to eq("http")
+    end
+
+    it "accepts an array for the path setting" do
+      chain = subject.new(host: host, path: path)
+      expect(chain.path).to eq(path)
+    end
+
+    it "defaults to the HTTPS scheme" do
+      chain = subject.new(host: host)
+      expect(chain.scheme).to eq(RestChain::Chain::DEFAULT_SCHEME)
+    end
+
+    it "creates a default logger if one is not specified" do
+      chain = subject.new(host: host)
+      expect(chain.logger).not_to be_nil
+      expect(chain.log).to eq(chain.logger)
+    end
+
+    it "raises an exception is a host is not specified" do
+      expect {
+        subject.new
+      }.to raise_exception(RestChain::RestChainError, "No REST API host specified when creating a chain.")
+    end
+  end
+
+  describe "#url()" do
+    subject {
+      RestChain::Chain.new(host: host, logger: logger, path: "/one/two/three", port: port, scheme: "http")
+    }
+
+    it "include scheme, host, port and path elements" do
+      expect(subject.url).to eq("http://#{host}:#{port}/#{path.join('/')}")
+    end
+  end
+end

data/spec/lib/rest_chain/link_spec.rb

@@ -0,0 +1,238 @@
+describe RestChain::Link do
+  #-----------------------------------------------------------------------------
+  # initialize()
+  #-----------------------------------------------------------------------------
+  describe "#initialize()" do
+    let(:subject) {
+      RestChain::Link
+    }
+
+    it "accepts just a single name parameter" do
+      expect {
+        subject.new("test_link")
+      }.not_to raise_exception
+    end
+
+    it "accepts a name and precessor parameters" do
+      link = subject.new("root")
+      expect {
+        subject.new("first", link)
+      }.not_to raise_exception
+    end
+
+    it "accepts a name, precessor and logger parameters" do
+      link = subject.new("root")
+      expect {
+        subject.new("first", link, Logger.new(STDOUT))
+      }.not_to raise_exception
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # name()
+  #-----------------------------------------------------------------------------
+  describe "#name()" do
+    let(:subject) {
+      RestChain::Link.new("test_link")
+    }
+
+    it "returns the name assigned to the link" do
+      expect(subject.name).to eq("test_link")
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # predecessor()
+  #-----------------------------------------------------------------------------
+  describe "#predecessor()" do
+    let(:predecessor) {
+      RestChain::Link.new("Level1")
+    }
+
+    let(:subject) {
+      RestChain::Link.new("Level2", predecessor)
+    }
+
+    it "returns the name assigned to the link" do
+      expect(subject.predecessor).to eq(predecessor)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # log()
+  #-----------------------------------------------------------------------------
+  describe "#log()" do
+    let(:logger) {
+      Logger.new(STDOUT)
+    }
+
+    let(:subject) {
+      RestChain::Link.new("test_link", nil, logger)
+    }
+
+    it "returns the name assigned to the link" do
+      expect(subject.log).to eq(logger)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # delete()
+  #-----------------------------------------------------------------------------
+  describe "#delete()" do
+    let(:parameters) {
+      {one: 1, two: "Two"}
+    }
+
+    let(:subject) {
+      RestChain::Link.new("test_link")
+    }
+
+    it "invokes the #dispatch() method" do
+      expect(subject).to receive(:dispatch).with(:delete, {}).once
+      subject.delete
+    end
+
+    it "passes through any parameters specified to it" do
+      expect(subject).to receive(:dispatch).with(:delete, parameters).once
+      subject.delete(parameters)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # get()
+  #-----------------------------------------------------------------------------
+  describe "#get()" do
+    let(:parameters) {
+      {one: 1, two: "Two"}
+    }
+
+    let(:subject) {
+      RestChain::Link.new("test_link")
+    }
+
+    it "invokes the #dispatch() method" do
+      expect(subject).to receive(:dispatch).with(:get, {}).once
+      subject.get
+    end
+
+    it "passes through any parameters specified to it" do
+      expect(subject).to receive(:dispatch).with(:get, parameters).once
+      subject.get(parameters)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # patch()
+  #-----------------------------------------------------------------------------
+  describe "#patch()" do
+    let(:parameters) {
+      {one: 1, two: "Two"}
+    }
+
+    let(:subject) {
+      RestChain::Link.new("test_link")
+    }
+
+    it "invokes the #dispatch() method" do
+      expect(subject).to receive(:dispatch).with(:patch, {}).once
+      subject.patch
+    end
+
+    it "passes through any parameters specified to it" do
+      expect(subject).to receive(:dispatch).with(:patch, parameters).once
+      subject.patch(parameters)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # post()
+  #-----------------------------------------------------------------------------
+  describe "#post()" do
+    let(:parameters) {
+      {one: 1, two: "Two"}
+    }
+
+    let(:subject) {
+      RestChain::Link.new("test_link")
+    }
+
+    it "invokes the #dispatch() method" do
+      expect(subject).to receive(:dispatch).with(:post, {}).once
+      subject.post
+    end
+
+    it "passes through any parameters specified to it" do
+      expect(subject).to receive(:dispatch).with(:post, parameters).once
+      subject.post(parameters)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # put()
+  #-----------------------------------------------------------------------------
+  describe "#put()" do
+    let(:parameters) {
+      {one: 1, two: "Two"}
+    }
+
+    let(:subject) {
+      RestChain::Link.new("test_link")
+    }
+
+    it "invokes the #dispatch() method" do
+      expect(subject).to receive(:dispatch).with(:put, {}).once
+      subject.put
+    end
+
+    it "passes through any parameters specified to it" do
+      expect(subject).to receive(:dispatch).with(:put, parameters).once
+      subject.put(parameters)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # url()
+  #-----------------------------------------------------------------------------
+  describe "#url()" do
+    let(:predecessor) {
+      RestChain::Link.new("level1")
+    }
+
+    let(:subject) {
+      RestChain::Link.new("level2", predecessor)
+    }
+
+    it "returns a String based on the link structure" do
+      expect(subject.url).to eq("/level1/level2")
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # dispatch()
+  #-----------------------------------------------------------------------------
+  describe "#dispatch()" do
+    let!(:driver) {
+      object = OpenStruct.new(get: nil)
+      object.define_singleton_method(:get) {|verb, parameters|}
+      object
+    }
+
+    let(:parameters) {
+      {one: 1, two: "Two"}
+    }
+
+    subject {
+      RestChain::Link.new("level2", RestChain::Link.new("level1"))
+    }
+
+    before do
+      allow(RestChain::HTTPDriverClassFactory).to receive(:manufacture).and_return(OpenStruct)
+      allow(OpenStruct).to receive(:new).and_return(driver)
+    end
+
+    it "invokes the appropriate driver method and specifies an URL and parameters" do
+      expect(driver).to receive(:get).with(subject.url, parameters).once
+      subject.dispatch(:get, parameters)
+    end
+  end
+end

data/spec/lib/rest_chain/rest_client_driver_spec.rb

@@ -0,0 +1,137 @@
+require "rest_chain/rest_client_driver"
+require "stringio"
+
+describe RestChain::RestClientDriver do
+	let(:logger) {
+		Logger.new(StringIO.new)
+	}
+
+	let(:output) {
+		RestChain::RestResponse.new(200, [], "")
+	}
+
+	let(:parameters) {
+		{one: 1, two: "Two"}
+	}
+
+	let(:url) {
+		"http://www.unittest.com/api/v1/users"
+	}
+
+  subject {
+  	 RestChain::RestClientDriver.new(logger)
+  }
+
+  #-----------------------------------------------------------------------------
+  # logger()
+  #-----------------------------------------------------------------------------
+  describe "#logger()" do
+  	it "retrieves the driver logger instance" do
+  		expect(subject.logger).to eq(logger)
+  	end
+  end
+
+  #-----------------------------------------------------------------------------
+  # delete()
+  #-----------------------------------------------------------------------------
+  describe "#delete()" do
+  	it "makes a delete dispatch request" do
+  		expect(subject).to receive(:dispatch).with(:delete, url, {}).and_return(output).once
+  		subject.delete(url)
+  	end
+
+  	it "passes parameters it receives to the dispatch call" do
+  		expect(subject).to receive(:dispatch).with(:delete, url, parameters).and_return(output).once
+  		subject.delete(url, parameters)
+  	end
+  end
+
+  #-----------------------------------------------------------------------------
+  # get()
+  #-----------------------------------------------------------------------------
+  describe "#get()" do
+  	it "makes a get dispatch request" do
+  		expect(subject).to receive(:dispatch).with(:get, url, {}).and_return(output).once
+  		subject.get(url)
+  	end
+
+  	it "passes parameters it receives to the dispatch call" do
+  		expect(subject).to receive(:dispatch).with(:get, url, parameters).and_return(output).once
+  		subject.get(url, parameters)
+  	end
+  end
+
+  #-----------------------------------------------------------------------------
+  # patch()
+  #-----------------------------------------------------------------------------
+  describe "#patch()" do
+  	it "makes a patch dispatch request" do
+  		expect(subject).to receive(:dispatch).with(:patch, url, {}).and_return(output).once
+  		subject.patch(url)
+  	end
+
+  	it "passes parameters it receives to the dispatch call" do
+  		expect(subject).to receive(:dispatch).with(:patch, url, parameters).and_return(output).once
+  		subject.patch(url, parameters)
+  	end
+  end
+
+  #-----------------------------------------------------------------------------
+  # post()
+  #-----------------------------------------------------------------------------
+  describe "#post()" do
+  	it "makes a post dispatch request" do
+  		expect(subject).to receive(:dispatch).with(:post, url, {}).and_return(output).once
+  		subject.post(url)
+  	end
+
+  	it "passes parameters it receives to the dispatch call" do
+  		expect(subject).to receive(:dispatch).with(:post, url, parameters).and_return(output).once
+  		subject.post(url, parameters)
+  	end
+  end
+
+  #-----------------------------------------------------------------------------
+  # put()
+  #-----------------------------------------------------------------------------
+  describe "#put()" do
+  	it "makes a put dispatch request" do
+  		expect(subject).to receive(:dispatch).with(:put, url, {}).and_return(output).once
+  		subject.put(url)
+  	end
+
+  	it "passes parameters it receives to the dispatch call" do
+  		expect(subject).to receive(:dispatch).with(:put, url, parameters).and_return(output).once
+  		subject.put(url, parameters)
+  	end
+  end
+
+  #-----------------------------------------------------------------------------
+  # dispatch()
+  #-----------------------------------------------------------------------------
+  describe "#dispatch()" do
+  	let(:success_response) {
+  		OpenStruct.new(body: "", code: 200, headers: [])
+  	}
+
+  	let(:exception) {
+  		exception = RestClient::Exception.new("Something went wrong!")
+  		exception.define_singleton_method(:response) do
+  			OpenStruct.new(body: "", code: 500, headers: [])
+  		end
+  		exception
+  	}
+
+  	it "calls execute() using the parameters it is passed" do
+  		expect(RestClient::Request).to receive(:execute).with({headers: {params: parameters}, method: :delete, url: url}).and_return(success_response).once
+  		subject.dispatch(:delete, url, parameters)
+  	end
+
+  	it "doesn't raise an exception even if the request does" do
+  		expect(RestClient::Request).to receive(:execute).and_raise(exception)
+  		expect {
+  			subject.dispatch(:put, url)
+  		}.not_to raise_exception
+  	end
+  end
+end

data/spec/lib/rest_chain/rest_response_spec.rb

@@ -0,0 +1,30 @@
+describe RestChain::RestResponse do
+  describe "#success?()" do
+  	it "returns true for responses with a status code between 200 and 299" do
+  		expect(RestChain::RestResponse.new(250, [], "").success?).to eq(true)
+  	end
+
+  	it "returns false for response with a non-200 status" do
+  		expect(RestChain::RestResponse.new(500, [], "").success?).to eq(false)
+  	end
+  end
+
+  describe "#json()" do
+  	let(:body) {
+  		{"one" => 1, "two" => "TWO"}
+  	}
+  	subject {
+  		RestChain::RestResponse.new(200, [], body.to_json)
+  	}
+
+  	it "converts the response body from JSON to a Ruby object" do
+  		expect(subject.json).to eq(body)
+  	end
+
+    it "passes any specified options through to the JSON parse" do
+      output = subject.json(symbolize_names: true)
+      expect(output).to include(:one)
+      expect(output).to include(:two)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,101 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require "webmock/rspec"
+require "ostruct"
+require "rest_chain"
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: rest_chain
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Peter Wood
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: REST chain is a library that abstracts the path elements of making a
+  REST API call to appear as method calls in Ruby.
+email:
+- peter.wood@longboat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rest_chain.rb
+- lib/rest_chain/chain.rb
+- lib/rest_chain/exceptions.rb
+- lib/rest_chain/http_driver_class_factory.rb
+- lib/rest_chain/link.rb
+- lib/rest_chain/rest_client_driver.rb
+- lib/rest_chain/rest_response.rb
+- lib/rest_chain/version.rb
+- rest_chain.gemspec
+- spec/lib/rest_chain/chain_spec.rb
+- spec/lib/rest_chain/link_spec.rb
+- spec/lib/rest_chain/rest_client_driver_spec.rb
+- spec/lib/rest_chain/rest_response_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/free-beer/rest_chain
+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.4.6
+signing_key: 
+specification_version: 4
+summary: A library that abstracts the use of a REST interface.
+test_files:
+- spec/lib/rest_chain/chain_spec.rb
+- spec/lib/rest_chain/link_spec.rb
+- spec/lib/rest_chain/rest_client_driver_spec.rb
+- spec/lib/rest_chain/rest_response_spec.rb
+- spec/spec_helper.rb