signaling 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8784fb8e4727801f77797c4e4ebabf9fe826f079
+  data.tar.gz: dc9aa50680a5bc469f12c00bc03a86faddfef1b6
+SHA512:
+  metadata.gz: 5eedfa6faf94e6514bdf7f2111d8c232f0b7ca75c4afc58fb70246bd77191fb6ce025d3e585ba73ec9f350a42da132ad753b72631b7fc9c3ddf6520a7c59131f
+  data.tar.gz: 00adad312a2ad7716ee5fe8da03c3ef17c6f355e1898235f98121019d6524e45503af5e6e0724f267ca1ec6433cd49283dd6050815daa1802a670d9656a2ab8c

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Neer Friedman
+
+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,160 @@
+# Signaling
+
+Signaling is a Ruby library that provides a 
+[simple](http://www.infoq.com/presentations/Simple-Made-Easy)
+API to work with remote objects exposed through HTTP services.
+
+Main goals for this project are:
+
+1. expose a simple API that will feel native in rails controllers (read
+   ActiveRecord like)
+1. have as least lines of code as possible
+1. To **NEVER** implement auto-loading associations
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'signaling'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install signaling
+
+## Usage
+
+1. Define a namespace and remote API:
+    ```ruby
+    # app/models/example_com.rb
+    module ExampleCom
+      Api = Signaling::Api.new(url: "http://example.com/api")
+
+      def self.use_relative_model_naming?
+        true
+      end
+    end
+    ```
+
+    The `use_relative_model_naming?` tells `ActiveModel::Naming` to build the
+    names of classes without the namespace.
+    [read more](https://coderwall.com/p/heed_q)
+
+1. Define a model:
+    ```ruby
+    # app/models/example_com/item_list.rb
+    class ExampleCom::ItemList < Signaling::Base
+      use_api ExampleCom::Api
+
+      attribute :name, String
+    end
+    ```
+
+## Features
+
+### Attributes
+
+Attribute definition is implemented by [virtus](https://github.com/solnic/virtus).
+
+To change the key used to send the attribute to the remote server use the
+`:param_name` option.
+
+    attribute :name, String, param_name: :title
+
+  This will send the attribute to the server as `:title`. this will **not**
+  parse it as `:title` from the remote response.
+
+
+### Nested models
+
+Virtus provides an API for typed arrays, these can contain other Signaling models.
+
+```ruby
+# app/models/example_com/item.rb
+module ExampleCom
+  class Item < Signaling::Base
+    attribtue :name, String
+  end
+end
+```
+
+```
+# app/models/example_com/item_list.rb
+module ExampleCom
+  class ItemList < Signaling::Base
+    use_api ExampleCom::Api
+
+    attribute :name
+    attribute :items, Array[ExampleCom::Item]
+  end
+end
+```
+
+**Tip!**&trade; Use this in combination with `:param_name` when using rails's
+`accepts_nested_attributes_for`.
+
+    module ExampleCom
+      class ItemList < Signaling::Base
+        use_api ExampleCom::Api
+
+        attribute :items, Array[ExampleCom::Item], param_name: :items_attributes
+      end
+    end
+
+
+### Api Setup
+
+`Signaling::Api.new` accepts the following options:
+
+  * `:url` - The base URL for the remote API
+  * `:logger` - A `Logger`-compatible object to use for logging
+
+It also accepts a block that yields with the faraday connection to allow adding
+custom middleware.
+
+    Api = Signaling::Api.new(url: api_base_url) do |faraday|
+      faraday.use SomeCustomFaradayMiddleware
+    end
+
+
+### Errors
+
+Signaling handles errors returned from the remote service in the `errors` json
+field. It uses `ActiveModel::Errors` for this so all the rails tricks should
+work here.
+
+    > list = ExampleCom::ItemList.new(name: 'My list')
+    > list.save
+
+If the remote service will respond with HTTP status code 422 (Unprocessable Entity)
+and the following json body:
+
+    {
+      "name": "My list",
+      "errors": {
+        "items": ["can not be empty"]
+      }
+    }
+
+Then signaling will load these errors to the `ItemList` models
+
+    > list.errors.full_messages
+    => ["Items can not be empty"]
+
+### Usage in controllers
+
+[Here's a typical rails controller for a Signaling model](spec/support/integration/item_lists_controller.rb)
+
+This file serves as a reference implementation for a controller and as a guide
+to make sure Signaling follows it's main goal.
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/signaling/api.rb

@@ -0,0 +1,26 @@
+require 'faraday_middleware'
+require_relative 'faraday_middleware/raise_error'
+
+class Signaling::Api
+  attr_reader :connection
+
+  def initialize(options, &block)
+    @connection = Faraday.new(url: options[:url]) do |conn|
+      block.call(conn) if block_given?
+
+      conn.request :multipart
+      conn.request :url_encoded
+
+      conn.use Signaling::FaradayMiddleware::RaiseError
+
+      if options[:logger]
+        conn.response :logger, options[:logger]
+      end
+
+      conn.response :mashify, mash_class: (options[:mash_class])
+      conn.response :json, content_type: /\bjson$/
+
+      conn.adapter options[:adapter] || Faraday.default_adapter
+    end
+  end
+end

data/lib/signaling/base/errors.rb

@@ -0,0 +1,19 @@
+module Signaling::Base::Errors
+  extend ActiveSupport::Concern
+
+  included do
+    attr_reader :errors
+  end
+
+  def initialize(*args)
+    self.errors = {}
+    super
+  end
+
+  def errors=(error_hash)
+    @errors = ActiveModel::Errors.new(self)
+    error_hash.each do |attr, errors|
+      errors.each {|error| self.errors.add(attr, error) }
+    end if error_hash
+  end
+end

data/lib/signaling/base/finders.rb

@@ -0,0 +1,24 @@
+module Signaling::Base::Finders
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def find(id)
+      from_response(request(:show, id: id))
+    end
+
+    def all(params = {})
+      from_response(request(:index, params))
+    end
+
+    def from_response(response)
+      case response
+      when Hash, Hashie::Mash
+        self.new(response)
+      when Array
+        response.map {|i| from_response(i) }
+      else
+        response
+      end
+    end
+  end
+end

data/lib/signaling/base/http.rb

@@ -0,0 +1,97 @@
+module Signaling::Base::Http
+  extend ActiveSupport::Concern
+
+  class UndefinedAction < StandardError
+    def initialize(action)
+      super("Undefined action: #{action.inspect}")
+    end
+  end
+
+  included do
+    class_attribute :_defined_actions
+  end
+
+  module ClassMethods
+    def request(action, params = {}, &block)
+      http_method = http_method_for(action)
+      path = path_for(action, id: params[:id])
+      scoped_params = scope_params(params.except(:id))
+
+      response = connection.send(http_method, path, scoped_params)
+
+      block ? block.call(response.body) : response.body
+    end
+
+    def define_action(action_name, options)
+      self._defined_actions ||= {}
+      unless options[:method] && options[:path]
+        raise ArgumentError, ':method and :path options are required'
+      end
+      self._defined_actions[action_name.to_sym] = options
+    end
+
+    # convert value to params-friendly hash/array
+    # this also sets parameter names for Signaling models
+    def to_params(value, set_param_names_first = false)
+      case value
+      when Signaling::Base
+        value.class.set_param_names(value.to_params)
+      when Array
+        value.map {|e| to_params(e, set_param_names_first) }
+      when Hash
+        value = set_param_names(value) if set_param_names_first
+        Hash[value.map {|k,v| [k, to_params(v)]}]
+      else
+        value
+      end
+    end
+
+    protected
+
+    def path_for(action, options = nil)
+      path = _defined_actions.try(:[], action).try(:[], :path)
+
+      raise(UndefinedAction, action) unless path
+
+      path.gsub(":route_key", route_key)
+        .gsub(":id") { options[:id] || raise('missing :id parameter for route') }
+    end
+
+    def http_method_for(action)
+      method = _defined_actions.try(:[], action).try(:[], :method)
+
+      method || raise(UndefinedAction, action)
+    end
+
+    def scope_params(params)
+      key = params.is_a?(Array) ? param_key.pluralize : param_key
+
+      { key => to_params(params, true) }
+    end
+
+    def route_key
+      ActiveModel::Naming.route_key(self).pluralize
+    end
+
+    def param_key
+      ActiveModel::Naming.param_key(self)
+    end
+
+    # changes attribtue names to param names (defined by ":param_name")
+    def set_param_names(params)
+      HashWithIndifferentAccess.new.tap do |result|
+        params.each do |k, v|
+          attribute = attribute_set[k.to_sym]
+          name = attribute.try(:options).try(:[], :param_name) || k
+          result[name] = v
+        end
+      end
+    end
+  end
+
+  def to_params
+    clean_attributes = persisted? ? attributes : attributes.except(:id)
+    self.class.to_params(clean_attributes, true)
+  end
+
+end

data/lib/signaling/base/persistence.rb

@@ -0,0 +1,59 @@
+module Signaling::Base::Persistence
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def create(params)
+      from_response(request(:create, params))
+    rescue Signaling::Error::UnprocessableEntity => e
+      from_response(e.response[:body])
+    end
+
+    def destroy(id)
+      from_response(request(:destroy, id: id))
+    end
+
+  end
+
+  def new?
+    self.id.blank?
+  end
+
+  def persisted?
+    !new?
+  end
+
+  def save
+    new? ? create : update
+    true
+  rescue Signaling::Error::UnprocessableEntity => e
+    self.errors = e.response[:body][:errors]
+    false
+  end
+
+  def save!
+    save || raise(ResourceInvalid.new(self))
+  end
+
+  def update_attributes(params)
+    update(params)
+  rescue Signaling::Error::UnprocessableEntity => e
+    self.attributes = e.response[:body]
+    false
+  end
+
+
+  private
+
+  def update(params = attributes)
+    self.class.request(:update, params.merge(id: self.id)) do |response|
+      self.attributes = response
+    end
+  end
+
+  def create
+    self.class.request(:create, attributes.except(:id)) do |response|
+      self.attributes = response
+    end
+  end
+
+end

data/lib/signaling/base/use_api.rb

@@ -0,0 +1,17 @@
+module Signaling::Base::UseApi
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def use_api(api)
+      @api = api
+    end
+
+    def api
+      @api or raise "API is not set for #{self.name}"
+    end
+
+    def connection
+      api.connection
+    end
+  end
+end

data/lib/signaling/base.rb

@@ -0,0 +1,32 @@
+module Signaling
+  class Base
+    include Virtus.model
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+
+    autoload :Errors,       'signaling/base/errors'
+    autoload :Finders,      'signaling/base/finders'
+    autoload :Http,         'signaling/base/http'
+    autoload :Persistence,  'signaling/base/persistence'
+    autoload :UseApi,       'signaling/base/use_api'
+
+    include Base::Errors
+    include Base::Finders
+    include Base::Http
+    include Base::Persistence
+    include Base::UseApi
+
+    attribute :id, String
+
+    define_action :index,   method: :get,    path: ":route_key.json"
+    define_action :create,  method: :post,   path: ":route_key.json"
+    define_action :show,    method: :get,    path: ":route_key/:id.json"
+    define_action :update,  method: :put,    path: ":route_key/:id.json"
+    define_action :destroy, method: :delete, path: ":route_key/:id.json"
+
+    def to_param
+      id
+    end
+
+  end
+end

data/lib/signaling/error.rb

@@ -0,0 +1,8 @@
+require 'faraday'
+
+module Signaling
+  module Error
+    class UnprocessableEntity < Faraday::Error::ClientError; end
+    class Forbidden < Faraday::Error::ClientError; end
+  end
+end

data/lib/signaling/faraday_middleware/raise_error.rb

@@ -0,0 +1,18 @@
+require 'faraday/response/raise_error'
+
+module Signaling
+  module FaradayMiddleware
+    class RaiseError < ::Faraday::Response::RaiseError
+      def on_complete(env)
+        case env[:status]
+        when 422
+          raise Signaling::Error::UnprocessableEntity, response_values(env)
+        when 403
+          raise Signaling::Error::Forbidden, response_values(env)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/signaling/resource_invalid.rb

@@ -0,0 +1,10 @@
+module Signaling
+  class ResourceInvalid < StandardError
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+      super()
+    end
+  end
+end

data/lib/signaling/version.rb

@@ -0,0 +1,3 @@
+module Signaling
+  VERSION = "1.0.0"
+end

data/lib/signaling.rb

@@ -0,0 +1,10 @@
+require 'active_support/all'
+require 'faraday'
+require 'virtus'
+require 'active_model'
+
+module Signaling
+  autoload :Api,        'signaling/api'
+  autoload :Base,       'signaling/base'
+  autoload :Error,      'signaling/error'
+end

data/signaling.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'signaling/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "signaling"
+  spec.version       = Signaling::VERSION
+  spec.authors       = ["Neer Friedman"]
+  spec.email         = ["neerfri@gmail.com"]
+  spec.description   = %q{Signaling maps REST-like APIs to ruby objects}
+  spec.summary       = %q{Signaling maps REST-like APIs to ruby objects}
+  spec.homepage      = ""
+  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 "activemodel", ">= 3.1.0"
+  spec.add_dependency "activesupport", ">= 3.1.0"
+  spec.add_dependency "virtus", ">= 1.0.0"
+  spec.add_dependency "faraday"
+  spec.add_dependency "faraday_middleware"
+  spec.add_dependency "hashie"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "rack"
+  spec.add_development_dependency "addressable"
+end

data/spec/integration/readme_features/api_setup_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "README features" do
+  describe 'Api setup' do
+    let(:api_base_url) { "http://example.com/api" }
+    let(:logger) { double("logger", info: nil, debug: nil) }
+
+    it "sets base url" do
+      expect(new_api.connection.url_prefix.to_s).to eq(api_base_url)
+    end
+
+    it "allows setting a logger" do
+      stub_request(:get, api_base_url)
+
+      logger.should_receive(:info)
+      new_api(logger: logger).connection.get('')
+    end
+
+    it "yields block with faraday builder" do
+      expect {|b| new_api(&b) }.to yield_with_args(Faraday::Connection)
+    end
+
+    def new_api(options = {}, &block)
+      Signaling::Api.new({url: api_base_url}.merge(options), &block)
+    end
+  end
+end

data/spec/integration/readme_features/attributes_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "README features" do
+  describe "attribtues" do
+    describe ":param_name option" do
+      let(:item_list) { ExampleCom::ItemList.new(tags: ['tag1']) }
+
+      before do
+        stub_request(*create_item_list_request).to_return(successful_response)
+        stub_request(*update_item_list_request).to_return(successful_response)
+      end
+
+      it "changes remote attribute name on #save" do
+        item_list.save
+
+        expected_body = { item_list: { name: nil, list_tags: ["tag1"]}}
+        expect_request(:post, path: item_lists_path, body: expected_body)
+      end
+
+      it "changes remote attribute name on #update_attributes" do
+        item_list.save
+        item_list.update_attributes(tags: ['tag2'])
+
+        expected_body = { item_list: { list_tags: ["tag2"]}}
+        expect_request(:put, path: item_list_path, body: expected_body)
+      end
+
+      def successful_response
+        { status: 200, body: { id: '1' } }
+      end
+
+    end
+  end
+end
+

data/spec/integration/readme_features/controller_usage_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe "README Features" do
+  describe "Usage in rails controllers" do
+    let(:controller) { ItemListsController.new }
+
+    describe "#index" do
+      it "finds all item lists" do
+        stub_request(*index_item_list_request).to_return(successful_response)
+
+        get :index
+        expect(assigns(:item_lists).count).to eq(2)
+      end
+
+      def successful_response
+        { status: 200, body: [{}, {}] }
+      end
+    end
+
+    describe "#new" do
+      it "assigns a new item list" do
+        get :new
+        expect(assigns(:item_list)).to be_kind_of(ExampleCom::ItemList)
+      end
+    end
+
+    describe "#create" do
+      let(:item_list_param) { { name: "my list" } }
+
+      before do
+        stub_request(*create_item_list_request).to_return(successful_response)
+      end
+
+      it "creates a new item list on remote service" do
+        post :create, item_list: item_list_param
+        expect_request(:post, path: item_lists_path, body: expected_body)
+      end
+
+      def expected_body
+        { item_list: item_list_param }
+      end
+    end
+
+    describe "#show / #edit" do
+      it "finds the item list" do
+        stub_request(*get_item_list_request).to_return(successful_response)
+
+        get :show, { id: '1' }
+        expect_request(:get, path: item_list_path)
+      end
+    end
+
+    describe "#update" do
+      let(:item_list_param) { { name: 'my list' } }
+
+      before do
+        stub_request(*update_item_list_request).to_return(successful_response)
+      end
+
+      it "does NOT fetch the item list from remote" do
+        put :update, { id: '1', item_list: {} }
+        expect_no_request(:get, path: item_list_path)
+      end
+
+      it "updates record on remote service" do
+        put :update, { id: '1', item_list: item_list_param }
+
+        expected_body = { item_list: item_list_param }
+        expect_request(:put, path: item_list_path, body: expected_body)
+      end
+    end
+
+    describe "#destroy" do
+      it "destroys record on remote" do
+        stub_request(*destroy_item_list_request).to_return(successful_response)
+        delete :destroy, { id: '1' }
+
+        expect_request(:delete, path: item_list_path)
+      end
+    end
+
+    def successful_response
+      { status: 200, body: { id: '1' } }
+    end
+
+    %w(get post put delete).each do |http_method|
+      define_method(http_method) do |action, params = {}|
+        controller.process(action, params)
+      end
+    end
+
+    def assigns(name)
+      controller.instance_variable_get("@#{name}")
+    end
+  end
+end

data/spec/integration/readme_features/errors_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "README Features" do
+  describe "Errors" do
+    let(:item_list) { ExampleCom::ItemList.new(name: 'My list') }
+
+    it "exposes ActiveModel::Errors object" do
+      expect(item_list.errors).to be_kind_of(ActiveModel::Errors)
+    end
+
+    it "loads errors from remote response" do
+      stub_request(*create_item_list_request).to_return(response_with_errors)
+      item_list.save
+
+      expect(item_list.errors[:items]).to eq(["can not be empty"])
+    end
+
+    def response_with_errors
+      {
+        status: 422,
+        body: { 
+          name: "My list",
+          errors: {
+            items: ["can not be empty"]
+          },
+        }
+      }
+    end
+  end
+end

data/spec/integration/readme_features/nested_models_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "README features" do
+  describe "Nested models" do
+    let(:item_hash) { {name: 'item 1'} }
+    let(:item_list) { ExampleCom::ItemList.new(items: [item_hash]) }
+
+    context "with a new record" do
+      before do
+        stub_request(*create_item_list_request).to_return(successful_response)
+      end
+
+      it "converts items" do
+        expect(item_list.items.first).to be_kind_of(ExampleCom::Item)
+      end
+
+      it "sends items as hashes to the remote service" do
+        item_list.save
+        expect_request(:post, path: item_lists_path, body: expected_body)
+      end
+
+      def expected_body
+        {item_list: { name: nil, items: [item_hash]}}
+      end
+    end
+
+    context "with a record from the remote service" do
+      let(:item_list) { ExampleCom::ItemList.find(1) }
+
+      before do
+        stub_request(*get_item_list_request).to_return(successful_response)
+        stub_request(*update_item_list_request).to_return(successful_response)
+      end
+
+      it "converts items" do
+        expect(item_list.items.first).to be_kind_of(ExampleCom::Item)
+      end
+
+      it "sends items as hashes to the remote service" do
+        new_items_array = [item_hash, {name: 'item 2'}]
+        item_list.update_attributes(items: new_items_array)
+
+        expected_body = {item_list: { items: new_items_array}}
+        expect_request(:put, path: item_list_path, body: expected_body)
+      end
+    end
+
+    def successful_response
+      { status: 200, body: { id: '1', items: [item_hash] } }
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'signaling'
+require 'pathname'
+require 'webmock/rspec'
+require 'pry'
+require 'rack'
+require 'addressable/uri'
+
+project_root = Pathname.new(__FILE__).join('../..').expand_path
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[project_root.join("spec/support/**/*.rb").to_s].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # 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'
+end

data/spec/support/example_com/item.rb

@@ -0,0 +1,5 @@
+require_relative '../example_com'
+
+class ExampleCom::Item < Signaling::Base
+  attribute :name, String
+end

data/spec/support/example_com/item_list.rb

@@ -0,0 +1,10 @@
+require_relative '../example_com'
+require_relative 'item'
+
+class ExampleCom::ItemList < Signaling::Base
+  use_api ExampleCom::Api
+
+  attribute :name, String
+  attribute :items, Array[ExampleCom::Item]
+  attribute :tags, Array, param_name: :list_tags
+end

data/spec/support/example_com.rb

@@ -0,0 +1,9 @@
+require 'faraday'
+
+module ExampleCom
+  Api = Signaling::Api.new(url: "http://example.com/api/")
+
+  def self.use_relative_model_naming?
+    true
+  end
+end

data/spec/support/integration/application_controller.rb

@@ -0,0 +1,22 @@
+class ApplicationController
+  attr_accessor :params
+
+  def process(action, params)
+    self.params = params.with_indifferent_access
+    send(action)
+  end
+
+  def redirect_to(path)
+  end
+
+  def render(template, options = {})
+  end
+
+  def item_list_path(item_list)
+    "/item_lists/#{item_list.id}"
+  end
+
+  def item_lists_path
+    "/item_lists"
+  end
+end

data/spec/support/integration/item_lists_controller.rb

@@ -0,0 +1,55 @@
+require_relative 'application_controller'
+
+class ItemListsController < ApplicationController
+  def index
+    @item_lists = ExampleCom::ItemList.all
+  end
+
+  def new
+    @item_list = ExampleCom::ItemList.new
+  end
+
+  def create
+    @item_list = ExampleCom::ItemList.new(item_list_params)
+
+    if @item_list.save
+      redirect_to(item_list_path(@item_list))
+    else
+      render 'new'
+    end
+  end
+
+  def show
+    @item_list = find_item_list
+  end
+
+  def edit
+    @item_list = find_item_list
+  end
+
+  def update
+    @item_list = ExampleCom::ItemList.new(id: params[:id])
+
+    if @item_list.update_attributes(item_list_params)
+      redirect_to item_list_path(@item_list)
+    else
+      render 'edit'
+    end
+  end
+
+
+  def destroy
+    ExampleCom::ItemList.destroy(params[:id])
+
+    redirect_to item_lists_path
+  end
+
+  protected
+  def find_item_list
+    ExampleCom::ItemList.find(params[:id])
+  end
+
+  def item_list_params
+    params[:item_list]
+  end
+end

data/spec/support/integration/spec_helpers.rb

@@ -0,0 +1,59 @@
+module IntegrationSpecHelpers
+  extend ActiveSupport::Concern
+
+  included do
+    let(:item_lists_path) { example_com_build_url("item_lists.json") }
+    let(:item_list_path)  { example_com_build_url("item_lists/1.json") }
+
+    let(:index_item_list_request)   { [:get,    item_lists_path] }
+    let(:create_item_list_request)  { [:post,   item_lists_path] }
+    let(:get_item_list_request)     { [:get,    item_list_path ] }
+    let(:update_item_list_request)  { [:put,    item_list_path ] }
+    let(:destroy_item_list_request) { [:delete, item_list_path ] }
+  end
+
+  class BodyPattern < Struct.new(:expected)
+    def ===(body)
+      normalize!(expected) == Rack::Utils.parse_nested_query(body)
+    end
+
+    def normalize!(hash)
+      Hash[stringify!(hash).sort]
+    end
+
+    def stringify!(hash)
+      WebMock::Util::HashKeysStringifier.stringify_keys!(hash)
+    end
+
+    def inspect
+      expected.inspect
+    end
+  end
+
+  def expect_request(method, options)
+    matcher = have_requested(method, options[:path])
+    if options[:body]
+      matcher.with(body: body_matcher(options[:body]))
+    end
+
+    to_or_to_not = options[:not] ? :to_not : :to
+    expect(WebMock).send(to_or_to_not, matcher)
+  end
+
+  def expect_no_request(method, options)
+    expect_request(method, options.merge(not: true))
+  end
+
+  def body_matcher(expected)
+    BodyPattern.new(expected)
+  end
+
+  def example_com_build_url(path = '')
+    ExampleCom::Api.connection.build_url(path).to_s
+  end
+
+  RSpec.configure do |config|
+    config.include self, type: :integration,
+                         example_group: { :file_path => %r(spec/integration) }
+  end
+end

metadata

@@ -0,0 +1,255 @@
+--- !ruby/object:Gem::Specification
+name: signaling
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Neer Friedman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.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: faraday_middleware
+  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: hashie
+  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: webmock
+  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: rack
+  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: addressable
+  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: Signaling maps REST-like APIs to ruby objects
+email:
+- neerfri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/signaling.rb
+- lib/signaling/api.rb
+- lib/signaling/base.rb
+- lib/signaling/base/errors.rb
+- lib/signaling/base/finders.rb
+- lib/signaling/base/http.rb
+- lib/signaling/base/persistence.rb
+- lib/signaling/base/use_api.rb
+- lib/signaling/error.rb
+- lib/signaling/faraday_middleware/raise_error.rb
+- lib/signaling/resource_invalid.rb
+- lib/signaling/version.rb
+- signaling.gemspec
+- spec/integration/readme_features/api_setup_spec.rb
+- spec/integration/readme_features/attributes_spec.rb
+- spec/integration/readme_features/controller_usage_spec.rb
+- spec/integration/readme_features/errors_spec.rb
+- spec/integration/readme_features/nested_models_spec.rb
+- spec/spec_helper.rb
+- spec/support/example_com.rb
+- spec/support/example_com/item.rb
+- spec/support/example_com/item_list.rb
+- spec/support/integration/application_controller.rb
+- spec/support/integration/item_lists_controller.rb
+- spec/support/integration/spec_helpers.rb
+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.0.2
+signing_key: 
+specification_version: 4
+summary: Signaling maps REST-like APIs to ruby objects
+test_files:
+- spec/integration/readme_features/api_setup_spec.rb
+- spec/integration/readme_features/attributes_spec.rb
+- spec/integration/readme_features/controller_usage_spec.rb
+- spec/integration/readme_features/errors_spec.rb
+- spec/integration/readme_features/nested_models_spec.rb
+- spec/spec_helper.rb
+- spec/support/example_com.rb
+- spec/support/example_com/item.rb
+- spec/support/example_com/item_list.rb
+- spec/support/integration/application_controller.rb
+- spec/support/integration/item_lists_controller.rb
+- spec/support/integration/spec_helpers.rb