first_responder 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d971be3ad0d3b952987a1f6786adb4594b0a595
+  data.tar.gz: af28852d98fc27fafcfd37ad1f0dcda83b37658f
+SHA512:
+  metadata.gz: b6fd3b459e9f1cb29c9543985ba88dadd1fb469fcd56f9f420ce8a8a53e58e1bb3be7adacac0c6dd12a1277559ad6dc64fd1b94550847c6dcbd9b43436cd8ea1
+  data.tar.gz: a3d2149ba0f5ca18a8f98e48988c7015ce959689a75e1f51e3d50fe9a0ae3b492595d141b315affd133d4f89a25b74935de9b029bb54724ae85c3dec07f5cd59

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/.rspec

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

data/.ruby-gemset

@@ -0,0 +1 @@
+sirius

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p195

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Curtis Ekstrom
+
+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,238 @@
+# FirstResponder
+
+A small library to coerce and validate API responses using PORO's.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'first_responder'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install first_responder
+
+## Usage
+
+FirstResponder includes the veritable [virtus](https://github.com/solnic/virtus) and ActiveModel::Validations
+libraries within classes to add attributes and validations to API response objects.
+
+This allows validation of API reponses at a "model" level, be they responses from real-world production services or Mock API's.
+
+Classes that include FirstResponder can be instantiated with either XML or JSON and can define the required attributes for that model.
+
+## Examples
+
+To use FirstResponder, simply include it in your class.  Then specify your required attributes, as in this fictitious example:
+
+```ruby
+class TwitterResponse
+  include FirstResponder
+  requires :tweet, String
+  requires :date, DateTime
+end
+```
+
+Then instantiate the class:
+
+```ruby
+response = TwitterResponse.new(:json, '{"tweet": "This is a tweet."}')
+
+response.valid?
+=> false
+
+response.date = "June 22nd, 2013"
+response.valid?
+=> true
+
+```
+As long as the response contains the required attributes, the instance will be considered valid.
+
+FirstResponder also supports attributes referencing an Array of objects, allowing Virtus to coerce those objects:
+
+```ruby
+class Foo
+  include Virtus
+  attribute :foo, String
+end
+
+class Biz
+  include FirstResponder
+  requires :foos, Array[Foo], at: ""
+end
+```
+
+We can pass an array of objects -- even at the root level in the case of JSON -- and our `Biz` class will have its collection of `Foos`:
+
+```ruby
+json_array = '[ {"foo": "bar" }, { "foo": "bar"} ]'
+biz = Biz.new(:json, json_array)
+
+biz.foos
+=> [#<Foo:0x007f876ac14be0 @foo="bar">, #<Foo:0x007f876ac1e938 @foo="bar">]
+```
+
+### Nested Keys
+
+FirstResponder assumes that the attribute you're defining is an unnested hash key.  The following example shows how to enable nested hash keys:
+```ruby
+class Magician
+  include FirstResponder
+  requires :surprise, String, at: "[:black][:hat]" # or using strings "['black']['hat']" 
+end
+```
+
+Then instantiate with JSON/XML as before:
+```ruby
+trick = '{"black": {"hat": "RABBIT!"}}'
+magician = Magician.new(:json, trick)
+```
+And, as one might have seen coming:
+```ruby
+magician.surprise
+=> "RABBIT!"
+```
+Were the black hat empty, the magician would, of course, not be valid ;)
+The previous example also highlights a second hidden feature in the `at` parameter: aliasing.
+If you want to refer to a JSON/XML node by a different name, simply require the attribute as you wish it to be called, pointing to its hash location.
+
+### The Root
+
+But what if all of your desired information is nested deeply within XML/JSON, always under the same outer node?
+Because we're all lazy and efficient, FirstResponder offers the ability to define a root element, which serves as the jumping off point for all other attributes using `at`:
+
+```ruby
+class Treasure
+  include Virtus
+  attribute :type, String
+  attribute :weight, Integer
+  attribute :unit, String
+end
+
+class TreasureHunt
+  include FirstResponder
+  root "[:ocean][:sea_floor][:treasure_chest][:hidden_compartment]"
+  requires :treasure, Treasure
+end
+```
+So when we get back our sunken treasure response, and it contains multiple attributes we don't really care about, the code above allows us to skip straight to the good stuff!
+
+```ruby
+response = '{"ocean": 
+              { "sea_floor": 
+                {"treasure_chest": 
+                  {"hidden_compartment": 
+                    { "treasure": { "type": "Gold", "weight": 1, "unit": "Ton" }}}}}}'
+
+treasure_hunt = TreasureHunt.new(:json, response)
+treasure_hunt.treasure
+=> #<Treasure:0x007fe50c98c990 @type="Gold", @weight=1, @unit="Ton">
+``` 
+
+Treasure that.
+
+### Nested Validations
+FirstResponder will also detect problems lurking beneath the surface by automatically searching for and validating nested attributes.
+Take the previous example of a `TreasureHunt` and `Treasure` classes, this time including FirstResponder and requiring the presence of certain attributes.
+A `TreasureHunt`, after all, is only valid if the `Treasure` it finds is:
+
+```ruby
+class TreasureHunt
+  include FirstResponder
+  root "[:ocean][:sea_floor][:treasure_chest][:hidden_compartment]"
+  requires :treasure, Treasure
+end
+
+class Treasure
+  include FirstResponder
+  requires :type, String
+  requires :weight, Integer
+  requires :unit, String
+end
+```
+We instantiate our `TreasureHunt` this time, however, with what appears to be a `Treasure`, but isn't:
+
+```ruby
+response = '{"ocean": 
+              { "sea_floor": 
+                {"treasure_chest": 
+                  {"hidden_compartment": 
+                    { "treasure": { "type": null, "weight": null, "unit": null}}}}}}'
+
+treasure_hunt = TreasureHunt.new(:json, response)
+treasure_hunt.treasure
+```
+Coercion still works, but the `Treasure` object that's been created is devoid of all value.  It is itself, of course, invalid:
+
+```ruby
+treasure_hunt.treasure.valid?
+=> false
+```
+
+But since FirstResponder knows that our `TreasureHunt` requires a `Treasure`, our `TreasureHunt` is also rendered invalid:
+
+```ruby
+treasure_hunt.valid?
+=> false
+```
+
+### The Invalid Callback
+FirstResponder also allows an object to execute arbitrary code when the object isn't valid.  It is defined on the class and triggered when `#invalid?` is true or `#valid?` is false:
+
+```ruby
+class InvalidWithCallback
+  include FirstResponder
+  requires :important_attr, String
+  requires :another, String
+  when_invalid { |data, errors| puts data }
+end
+
+with_callback = InvalidWithCallback.new(:json, '{"foo":"bar"}')
+with_callback.valid?
+{"foo"=>"bar"}
+=> false
+```
+
+As you can tell from the example above, the code will be executed by default whenever `valid?` is called before the boolean value is returned.  Should you desire a return value without executing the callback in a specific intsance, you can supply `false` to the `valid?` and `invalid?` methods:
+
+```ruby
+with_callback.valid?(false)
+=> false
+
+with_callback.invalid?(false)
+=> true
+```
+
+### ActiveModel::Validations
+Because FirstResponder uses ActiveModel::Validations under the covers, you can use most of the API you already know to validate individual attributes.
+Of course, this excludes those checks relying on persistence (i.e. uniqueness) or attempts to validate an object using Virtus coercion.
+
+```ruby
+class Baz
+  include FirstResponder
+  requires :foo, String, format: { with: /bar/ }
+end
+```
+
+This should play nicely with the options one normally passes to Virtus attributes, but be advised that collisions are theoretically possible.
+Should you run into an issue here, please don't hesitate to open up an issue.
+
+For further validation examples, please see the Rails [Guides](http://guides.rubyonrails.org/active_record_validations.html) or ActiveModel::Validations API docs.
+
+## TODO
+
+1. Pinpoint errors in JSON/XML in exception (helps to debug API problems)
+2. Raise when attribute not present in data on instantiation.
+3. Clearly separate ActiveModel::Validation options from those passed to Virtus 
+
+## Contributing
+
+1. Fork it
+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,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/first_responder.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'first_responder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "first_responder"
+  spec.version       = FirstResponder::VERSION
+  spec.authors       = ["Curtis Ekstrom"]
+  spec.email         = ["curtis@wellmatchhealth.com"]
+  spec.description   = %q{A small library to coerce and validate API responses using PORO's.}
+  spec.summary       = %q{FirstResponder classes wrap API responses and define the attributes required of those responses.}
+  spec.homepage      = "https://github.com/clekstro/first_responder"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "virtus"
+  spec.add_dependency "activemodel"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+
+end

data/lib/first_responder.rb

@@ -0,0 +1,148 @@
+require "first_responder/version"
+require "virtus"
+require "active_model"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/inflector"
+require "json"
+
+module FirstResponder
+  VALID_FORMATS = [:json, :xml]
+
+  module InstanceMethods
+
+    # Every instance must instantiate itself with a format and corresponding
+    # data. Given that information, formats are validated, data is parsed using
+    # that format, after which the attributes defined on the class are set to
+    # the hash value at the defined location.
+
+    def initialize(fmt=nil, data)
+      @format = ensure_format(fmt) if fmt
+      @data = data.is_a?(Hash) ? data : deserialize(data, fmt)
+      map_attrs
+    end
+
+    def valid?(execute=true)
+      return true if all_attributes_valid?
+      proc_on_invalid.call(@data, errors) if execute
+      return no_nesting? ? super : false
+    end
+
+    def invalid?(execute=true)
+      !valid?(execute)
+    end
+
+    private
+
+    def no_nesting?
+      nested_validations.empty?
+    end
+
+    def map_attrs
+      required_attributes.each do |attr_hash|
+        attr = attr_hash.keys.first
+        value = extract_attribute_value(attr_hash, attr)
+        send("#{attr}=", value)
+      end
+    end
+
+    def ensure_format(fmt)
+      raise UnknownFormatError unless VALID_FORMATS.include?(fmt)
+    end
+
+    def all_attributes_valid?
+      nested_validations.any? &&
+        nested_validations.all? { |attr| eval("#{attr}.valid?") }
+    end
+
+    def required_attributes
+      self.class.required_attributes
+    end
+
+    def nested_validations
+      self.class.nested_validations
+    end
+
+    def proc_on_invalid
+      self.class.proc_on_invalid || Proc.new {}
+    end
+
+    def deserialize(data, format)
+      raise MissingDataError if data == ''
+      return JSON.parse(data) if format == :json
+      Hash.from_xml(data) if format == :xml
+    end
+
+    # Currently have to use eval to access @data at nested array object
+    # attr_hash[attr] is String at this point:
+    # "['foo']['bar']['baz']"
+
+    def extract_attribute_value(attr_hash, attr)
+      return @data if @data.is_a?(Array)
+      attr_location = (attr_hash[attr] || "['#{attr.to_s}']")
+      hash_location = self.class.first_responder_root + attr_location
+      eval("@data.with_indifferent_access#{hash_location}")
+    end
+  end
+
+  module ClassMethods
+    def required_attributes
+      @required_attributes ||= []
+    end
+
+    def nested_validations
+      @nested_validations ||= []
+    end
+
+    def first_responder_root
+      @first_responder_root ||= ""
+    end
+
+    def root(node)
+      @first_responder_root = node
+    end
+
+    def proc_on_invalid
+      @proc_on_invalid
+    end
+
+    def when_invalid(&blk)
+      @proc_on_invalid = blk
+    end
+
+    def default_validations
+      { presence: true }
+    end
+
+    def requires(attr, type, opts={})
+      add_to_required(attr, opts)
+      add_to_nested(attr, type)
+      validates attr, default_validations.merge(opts)
+      attribute attr, type, opts
+    end
+
+    def add_to_required(attr, opts)
+      first_responder_opts = opts.extract!(:at)[:at]
+      required_attributes << Hash[attr, first_responder_opts]
+    end
+
+    def add_to_nested(attr, type)
+      return if type.is_a? Array
+      nested_validations << attr if type.ancestors.include?(FirstResponder)
+    end
+
+  end
+
+  module Exceptions
+    class UnknownFormatError < Exception; end
+    class MissingDataError < Exception; end
+  end
+
+  def self.included(base)
+    base.send(:include, Virtus)
+    base.send(:include, ActiveModel::Validations)
+    base.send(:include, InstanceMethods)
+    base.extend(ClassMethods)
+    base.extend(Exceptions)
+  end
+end

data/lib/first_responder/version.rb

@@ -0,0 +1,3 @@
+module FirstResponder
+  VERSION = "0.2"
+end

data/spec/dependencies_spec.rb

@@ -0,0 +1,12 @@
+require 'first_responder'
+
+describe FirstResponder do
+  context "dependencies" do
+    it 'requires virtus' do
+      Virtus.should be
+    end
+    it 'requires active_model' do
+      ActiveModel.should be
+    end
+  end
+end

data/spec/first_responder_spec.rb

@@ -0,0 +1,290 @@
+require 'first_responder'
+require 'json'
+
+describe FirstResponder do
+  let(:valid_json) { '{"foo":"bar"}' }
+  let(:incomplete_json) { '{"foo": null}' }
+  let(:valid_xml) { "<foo>bar</foo>" }
+  let(:incomplete_xml) { "<foo></foo>" }
+  let(:nested_json) { '{"foo":{"bar":{"baz": "boo"}}}' }
+  let(:nested_xml) { '<foo><bar><baz>boo</baz></bar></foo>' }
+
+  describe ".initialize" do
+    let(:klass) { Class.new { include FirstResponder } }
+
+    context "with unknown format" do
+      it "raises UnknownSerializationFormat error" do
+        expect{ klass.new(:wrong, '') }.to raise_error
+      end
+    end
+
+    context "valid formats" do
+      context "json" do
+        context "and valid data" do
+          it "initializes successfully" do
+            expect{ klass.new(:json, valid_json) }.not_to raise_error
+          end
+        end
+        context "and blank data" do
+          it "blows up" do
+            expect{ klass.new(:json, '') }.to raise_error
+          end
+        end
+      end
+      context "xml" do
+        context "and valid data" do
+          it "initializes successfully" do
+            expect{ klass.new(:xml, valid_xml) }.not_to raise_error
+          end
+        end
+        context "and blank data" do
+          it "blows up" do
+            expect{ klass.new(:xml, '') }.to raise_error
+          end
+        end
+      end
+    end
+  end
+
+  describe "#requires" do
+    let(:klass) {
+      Class.new do
+        include FirstResponder
+        requires :foo, String
+        def self.model_name; ActiveModel::Name.new(self, nil, "temp"); end
+      end
+    }
+
+    context "json attribute" do
+      context "with data" do
+        subject { klass.new(:json, valid_json) }
+        it{ should respond_to(:foo) }
+        its(:foo) { should == "bar" }
+        it{ should be_valid }
+      end
+      context "without data" do
+        subject { klass.new(:json, incomplete_json) }
+        it{ should_not be_valid }
+      end
+    end
+
+    context "xml attribute" do
+      context "with data" do
+        subject { klass.new(:xml, valid_xml) }
+        it{ should respond_to(:foo) }
+        its(:foo) { should == "bar" }
+        it{ should be_valid }
+      end
+      context "without data" do
+        subject { klass.new(:xml, incomplete_xml) }
+        it{ should_not be_valid }
+      end
+    end
+
+    describe "extracts passed options" do
+      context "with string attrs" do
+        let(:klass) {
+          Class.new do
+            include FirstResponder
+            requires :foo, String, at: "['foo']['bar']['baz']"
+          end
+        }
+
+        context "(json)" do
+          subject { klass.new(:json, nested_json) }
+          its(:foo) { should == "boo" }
+        end
+        context "(xml)" do
+          subject { klass.new(:xml, nested_xml) }
+          its(:foo) { should == "boo" }
+        end
+      end
+      context "with symbol attrs" do
+        let(:klass) {
+          Class.new do
+            include FirstResponder
+            requires :foo, String, at: "[:foo][:bar][:baz]"
+          end
+        }
+
+        context "(json)" do
+          subject { klass.new(:json, nested_json) }
+          its(:foo) { should == "boo" }
+        end
+        context "(xml)" do
+          subject { klass.new(:xml, nested_xml) }
+          its(:foo) { should == "boo" }
+        end
+      end
+    end
+  end
+
+  describe ".root" do
+    let(:klass) {
+      Class.new do
+        include FirstResponder
+        root "['foo']['bar']"
+        requires :foo, String, at: "['baz']"
+      end
+    }
+
+    context "correctly filters beginning at defined root node" do
+      context "(json)" do
+        subject { klass.new(:json, nested_json) }
+        its(:foo) { should == 'boo' }
+      end
+      context "(xml)" do
+        subject { klass.new(:xml, nested_xml) }
+        its(:foo) { should == 'boo' }
+      end
+    end
+  end
+
+  describe "nested first_responder objects" do
+    let(:klass) {
+      Class.new do
+        include FirstResponder
+        root "['ocean']['sea_floor']['treasure_chest']['hidden_compartment']"
+        requires :treasure, Treasure
+      end
+    }
+    let(:with_treasure) { '{"ocean": { "sea_floor": {"treasure_chest": {"hidden_compartment": { "treasure": { "type": "Gold", "weight": 1, "unit": "Ton" }}}}}}' }
+
+    let(:without_treasure) { '{"ocean": { "sea_floor": {"treasure_chest": {"hidden_compartment": { "treasure": { "type": null, "weight": null, "unit": null}}}}}}' }
+
+    describe "maintains Virtus coercion abilities" do
+
+      before do
+        class Treasure
+          include Virtus
+          attribute :type, String
+          attribute :weight, Integer
+          attribute :unit, String
+        end
+      end
+
+      subject { klass.new(:json, with_treasure).treasure }
+      it{ should be_a(Treasure) }
+    end
+
+    describe "validates nested first_responder objects" do
+      before do
+        class Treasure
+          include FirstResponder
+          requires :type, String
+          requires :weight, Integer
+          requires :unit, String
+
+          when_invalid {}
+        end
+      end
+
+      describe ".nested_validations" do
+        it "returns required attributes that must themselves be validated" do
+          klass.nested_validations.should == [:treasure]
+        end
+      end
+
+      describe "#valid?" do
+        context "with invalid nested object" do
+          subject { klass.new(:json, without_treasure).valid? }
+          it{ should be_false }
+
+          context "with proc_on_invalid defined" do
+            subject { klass.new(:json, without_treasure) }
+
+            context "by default" do
+              it "calls the proc" do
+                new_proc = stub(:proc)
+                subject.stub(:proc_on_invalid).and_return(new_proc)
+                new_proc.should_receive(:call)
+                subject.valid?
+              end
+            end
+            context "with false passed" do
+              it "does not call the proc" do
+                new_proc = stub(:proc)
+                subject.stub(:proc_on_invalid).and_return(new_proc)
+                new_proc.should_not_receive(:call)
+                subject.valid?(false)
+              end
+            end
+          end
+
+          context "with proc_on_invalid absent" do
+            before do
+              class Treasure
+                include FirstResponder
+                requires :type, String
+                requires :weight, String
+                requires :unit, String
+              end
+            end
+
+            subject { klass.new(:json, with_treasure) }
+            it "does nothing" do
+              new_proc = stub(:proc)
+              subject.stub(:proc_on_invalid).and_return(new_proc)
+              new_proc.should_not_receive(:call)
+              subject.invalid?
+            end
+          end
+        end
+
+        context "with valid nested object" do
+          subject { klass.new(:json, with_treasure).valid? }
+          it{ should be_true }
+        end
+      end
+
+      describe "#invalid?" do
+        subject { klass.new(:json, with_treasure) }
+        its(:invalid?) { should be_false }
+      end
+    end
+
+    describe "supports ActiveModel::Validation parameters" do
+      context "format" do
+
+        let(:valid) {
+          class Valid
+            include FirstResponder
+            requires :foo, String, format: { with: /bar/ }
+          end
+        }
+
+        let(:invalid) {
+          class Invalid
+            include FirstResponder
+            requires :foo, String, format: { with: /baz/ }
+          end
+        }
+
+        it "is invalid with non-matching format" do
+          valid.new(:json, valid_json).should be_valid
+          invalid.new(:json, valid_json).should_not be_valid
+        end
+      end
+    end
+  end
+
+  describe "edge cases" do
+    let(:json_array) { '[ { "foo": "bar" }, { "foo": "baz"} ]' }
+    before do
+      class Foo
+        include Virtus
+        attribute :foo, String
+      end
+
+      class JsonArrayTest
+        include FirstResponder
+        requires :foos, Array[Foo], at: ""
+      end
+    end
+    subject { JsonArrayTest.new(:json, json_array).foos }
+    it { should be_a_kind_of Array }
+    it "coerces to Foo" do
+      subject.first.should be_a Foo
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'first_responder'
+
+RSpec.configure do |config|
+  config.fail_fast = true 
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: first_responder
+version: !ruby/object:Gem::Version
+  version: '0.2'
+platform: ruby
+authors:
+- Curtis Ekstrom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  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: activemodel
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: pry
+  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'
+description: A small library to coerce and validate API responses using PORO's.
+email:
+- curtis@wellmatchhealth.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- first_responder.gemspec
+- lib/first_responder.rb
+- lib/first_responder/version.rb
+- spec/dependencies_spec.rb
+- spec/first_responder_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/clekstro/first_responder
+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.0.3
+signing_key: 
+specification_version: 4
+summary: FirstResponder classes wrap API responses and define the attributes required
+  of those responses.
+test_files:
+- spec/dependencies_spec.rb
+- spec/first_responder_spec.rb
+- spec/spec_helper.rb