test_track_rails_client 0.9.7 → 0.9.8

data/vendor/gems/her/lib/her/model/relation.rb

@@ -0,0 +1,251 @@
+module Her
+  module Model
+    class Relation
+      # @private
+      attr_accessor :params, :request_headers, :request_options
+
+      # @private
+      def initialize(parent)
+        @parent = parent
+        @params = {}
+        @request_headers = {}
+        @request_options = {}
+      end
+
+      # @private
+      def apply_to(attributes)
+        @params.merge(attributes)
+      end
+
+      # Build a new resource
+      def build(attributes = {})
+        @parent.build(@params.merge(attributes))
+      end
+
+      def with_request_headers(headers = {})
+        return self if headers.blank?
+        self.clone.tap do |r|
+          r.request_headers = r.request_headers.merge!(headers)
+          r.clear_fetch_cache!
+        end
+      end
+
+      def with_request_options(options = {})
+        return self if options.blank?
+        self.clone.tap do |r|
+          r.request_options = r.request_options.merge!(options)
+          r.clear_fetch_cache!
+        end
+      end
+
+      # Add a query string parameter
+      #
+      # @example
+      #   @users = User.all
+      #   # Fetched via GET "/users"
+      #
+      # @example
+      #   @users = User.where(:approved => 1).all
+      #   # Fetched via GET "/users?approved=1"
+      def where(params = {})
+        return self if params.blank? && !@_fetch.nil?
+        self.clone.tap do |r|
+          r.params = r.params.merge(params)
+          r.clear_fetch_cache!
+        end
+      end
+      alias all where
+
+      # Bubble all methods to the fetched collection
+      #
+      # @private
+      def method_missing(method, *args, &blk)
+        fetch.send(method, *args, &blk)
+      end
+
+      # @private
+      def respond_to?(method, *args)
+        super || fetch.respond_to?(method, *args)
+      end
+
+      # @private
+      def nil?
+        fetch.nil?
+      end
+
+      # @private
+      def kind_of?(thing)
+        fetch.kind_of?(thing)
+      end
+
+      # Fetch a collection of resources
+      #
+      # @private
+      def fetch
+        @_fetch ||= begin
+          path = @parent.build_request_path(@params)
+          method = @parent.method_for(:find)
+          @parent.request(@params.merge(:_method => method, :_path => path, :_headers => request_headers, :_options => request_options)) do |parsed_data, response|
+            @parent.new_collection(parsed_data)
+          end
+        end
+      end
+
+      # Fetch specific resource by some of its attributes
+      #
+      # @example
+      #   @user = User.find_by(id: 1)
+      #   # Fetched via GET "/users/1"
+      #
+      # @example
+      #   @users = User.find_by(id: 1, age: 25)
+      #   # Fetched via GET "/users/1?age=25"
+      #
+      # @example
+      #   @users = User.find_by(age: 25)
+      #   # Fetched via GET "/users?age=25"
+      #   # locally limit to single result
+      def find_by(params = {})
+        where(params).first
+      end
+
+      # Fetch first result
+      #
+      # @example
+      #   @user = User.where(id: 1).first
+      #   # Fetched via GET "/users/1"
+      #
+      # @example
+      #   @users = User.where(id: 1, age: 25)
+      #   # Fetched via GET "/users/1?age=25"
+      #
+      # @example
+      #   @users = User.where(age: 25)
+      #   # Fetched via GET "/users?age=25"
+      #   # locally limit to single result
+      #
+      # @example
+      #   @users = User.where(id: [1, 2])
+      #   # Fetched via GET "/users?id[]=1&id[]=2"
+      #   # locally limit to single result
+      def first
+        id_param = self.params[@parent.primary_key]
+
+        if id_param && !id_param.is_a?(Array)
+          self.params.delete(@parent.primary_key)
+          request_params = self.params.merge(
+            :_method => @parent.method_for(:find),
+            :_path => @parent.build_request_path(self.params.merge(@parent.primary_key => id_param)),
+            :_headers => request_headers,
+            :_options => request_options
+          )
+          @parent.request(request_params) do |parsed_data, response|
+            if response.success?
+              resource = @parent.new_from_parsed_data(parsed_data)
+              resource.instance_variable_set(:@changed_attributes, {})
+              resource.run_callbacks :find
+              resource
+            elsif [404, 410].include? response.status
+              nil
+            else
+              raise Her::Errors::ResponseError.for(response.status).new("Request against #{@parent.name} returned a #{response.status}")
+            end
+          end
+        else
+          fetch.first
+        end
+      end
+
+      # Fetch specific resource(s) by their ID
+      #
+      # @example
+      #   @user = User.find(1)
+      #   # Fetched via GET "/users/1"
+      #
+      # @example
+      #   @users = User.find([1, 2])
+      #   # Fetched via GET "/users/1" and GET "/users/2"
+      def find(*ids)
+        params = @params.merge(ids.last.is_a?(Hash) ? ids.pop : {})
+        ids = Array(params[@parent.primary_key]) if params.key?(@parent.primary_key)
+
+        results = ids.flatten.compact.uniq.map do |id|
+          resource = nil
+          request_params = params.merge(
+            :_method => @parent.method_for(:find),
+            :_path => @parent.build_request_path(params.merge(@parent.primary_key => id)),
+            :_headers => request_headers,
+            :_options => request_options
+          )
+
+          @parent.request(request_params) do |parsed_data, response|
+            if response.success?
+              resource = @parent.new_from_parsed_data(parsed_data)
+              resource.instance_variable_set(:@changed_attributes, {})
+              resource.run_callbacks :find
+            else
+              raise Her::Errors::ResponseError.for(response.status).new("Request against #{@parent.name} returned a #{response.status}")
+            end
+          end
+
+          resource
+        end
+
+        ids.length > 1 || ids.first.kind_of?(Array) ? results : results.first
+      end
+
+      # Create a resource and return it
+      #
+      # @example
+      #   @user = User.create(:fullname => "Tobias Fünke")
+      #   # Called via POST "/users/1" with `&fullname=Tobias+Fünke`
+      #
+      # @example
+      #   @user = User.where(:email => "tobias@bluth.com").create(:fullname => "Tobias Fünke")
+      #   # Called via POST "/users/1" with `&email=tobias@bluth.com&fullname=Tobias+Fünke`
+      def create(attributes = {})
+        attributes ||= {}
+        resource = @parent.new(@params.merge(attributes))
+        resource.request_headers = request_headers
+        resource.request_options = request_options
+        resource.save
+
+        resource
+      end
+
+      # Fetch a resource and create it if it's not found
+      #
+      # @example
+      #   @user = User.where(:email => "remi@example.com").find_or_create
+      #
+      #   # Returns the first item of the collection if present:
+      #   # GET "/users?email=remi@example.com"
+      #
+      #   # If collection is empty:
+      #   # POST /users with `email=remi@example.com`
+      def first_or_create(attributes = {})
+        fetch.first || create(attributes)
+      end
+
+      # Fetch a resource and build it if it's not found
+      #
+      # @example
+      #   @user = User.where(:email => "remi@example.com").find_or_initialize
+      #
+      #   # Returns the first item of the collection if present:
+      #   # GET "/users?email=remi@example.com"
+      #
+      #   # If collection is empty:
+      #   @user.email # => "remi@example.com"
+      #   @user.new? # => true
+      def first_or_initialize(attributes = {})
+        fetch.first || build(attributes)
+      end
+
+      # @private
+      def clear_fetch_cache!
+        instance_variable_set(:@_fetch, nil)
+      end
+    end
+  end
+end

data/vendor/gems/her/lib/her/model.rb

@@ -0,0 +1,81 @@
+require "her/model/base"
+require "her/model/deprecated_methods"
+require "her/model/http"
+require "her/model/attributes"
+require "her/model/relation"
+require "her/model/orm"
+require "her/model/parse"
+require "her/model/associations"
+require "her/model/introspection"
+require "her/model/paths"
+require "her/model/nested_attributes"
+require "her/model/active_model_overrides"
+require "active_model"
+
+module Her
+  # This module is the main element of Her. After creating a Her::API object,
+  # include this module in your models to get a few magic methods defined in them.
+  #
+  # @example
+  #   class User
+  #     include Her::Model
+  #   end
+  #
+  #   @user = User.new(:name => "Rémi")
+  #   @user.save
+  module Model
+    extend ActiveSupport::Concern
+
+    # Her modules
+    include Her::Model::Base
+    include Her::Model::DeprecatedMethods
+    include Her::Model::Attributes
+    include Her::Model::ORM
+    include Her::Model::HTTP
+    include Her::Model::Parse
+    include Her::Model::Introspection
+    include Her::Model::Paths
+    include Her::Model::Associations
+    include Her::Model::NestedAttributes
+
+    # Supported ActiveModel modules
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+    include ActiveModel::Conversion
+    include ActiveModel::Dirty
+
+    include Her::Model::ActiveModelOverrides
+
+    # Class methods
+    included do
+      # Assign the default API
+      use_api Her::API.default_api
+      method_for :create, :post
+      method_for :update, :put
+      method_for :find, :get
+      method_for :destroy, :delete
+      method_for :new, :get
+
+      # Define the default primary key
+      primary_key :id
+
+      # Define default storage accessors for errors and metadata
+      store_response_errors :response_errors
+      store_metadata :metadata
+
+      # provide a place to store headers and options to be added to requests
+      attr_accessor :request_headers, :request_options
+
+      # Include ActiveModel naming methods
+      extend ActiveModel::Translation
+
+      # Configure ActiveModel callbacks
+      extend ActiveModel::Callbacks
+      define_model_callbacks :create, :update, :save, :find, :destroy, :initialize
+
+      # Define matchers for attr? and attr= methods
+      define_attribute_method_matchers
+    end
+  end
+end

data/vendor/gems/her/lib/her/version.rb

@@ -0,0 +1,3 @@
+module Her
+  VERSION = "0.8.1"
+end

data/vendor/gems/her/lib/her.rb

@@ -0,0 +1,20 @@
+require "her/version"
+
+require "multi_json"
+require "faraday"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext/hash"
+
+require "her/model"
+require "her/api"
+require "her/middleware"
+require "her/errors"
+require "her/collection"
+require "her/error_collection"
+
+module Her
+  module JsonApi
+    autoload :Model, 'her/json_api/model'
+  end
+end

data/vendor/gems/her/spec/api_spec.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe Her::API do
+  subject { Her::API.new }
+
+  context "initialization" do
+    describe "#setup" do
+      context "when setting custom middleware" do
+        before do
+          class Foo; end;
+          class Bar; end;
+
+          subject.setup :url => "https://api.example.com" do |connection|
+            connection.use Foo
+            connection.use Bar
+          end
+        end
+
+        specify { subject.connection.builder.handlers.should == [Foo, Bar] }
+      end
+
+      context "when setting custom options" do
+        before { subject.setup :foo => { :bar => "baz" }, :url => "https://api.example.com" }
+        its(:options) { should == { :foo => { :bar => "baz" }, :url => "https://api.example.com" } }
+      end
+    end
+
+    describe "#request" do
+      before do
+        class SimpleParser < Faraday::Response::Middleware
+          def on_complete(env)
+            env[:body] = { :data => env[:body] }
+          end
+        end
+      end
+
+      context "making HTTP requests" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "/foo")[:parsed_data] }
+        before do
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use SimpleParser
+            builder.adapter(:test) { |stub| stub.get("/foo") { |env| [200, {}, "Foo, it is."] } }
+          end
+        end
+
+        specify { parsed_data[:data].should == "Foo, it is." }
+      end
+
+      context "making HTTP requests while specifying custom HTTP headers" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "/foo", :_headers => { "X-Page" => 2 })[:parsed_data] }
+
+        before do
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use SimpleParser
+            builder.adapter(:test) { |stub| stub.get("/foo") { |env| [200, {}, "Foo, it is page #{env[:request_headers]["X-Page"]}."] } }
+          end
+        end
+
+        specify { parsed_data[:data].should == "Foo, it is page 2." }
+      end
+
+      context "parsing a request with the default parser" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "users/1")[:parsed_data] }
+        before do
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use Her::Middleware::FirstLevelParseJSON
+            builder.adapter :test do |stub|
+              stub.get("/users/1") { |env| [200, {}, MultiJson.dump({ :id => 1, :name => "George Michael Bluth", :errors => ["This is a single error"], :metadata => { :page => 1, :per_page => 10 } })] }
+            end
+          end
+        end
+
+        specify do
+          parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
+          parsed_data[:errors].should == ["This is a single error"]
+          parsed_data[:metadata].should == { :page => 1, :per_page => 10 }
+        end
+      end
+
+      context "parsing a request with a custom parser" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "users/1")[:parsed_data] }
+        before do
+          class CustomParser < Faraday::Response::Middleware
+            def on_complete(env)
+              json = MultiJson.load(env[:body], :symbolize_keys => true)
+              errors = json.delete(:errors) || []
+              metadata = json.delete(:metadata) || {}
+              env[:body] = {
+                :data => json,
+                :errors => errors,
+                :metadata => metadata,
+              }
+            end
+          end
+
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use CustomParser
+            builder.use Faraday::Request::UrlEncoded
+            builder.adapter :test do |stub|
+              stub.get("/users/1") { |env| [200, {}, MultiJson.dump(:id => 1, :name => "George Michael Bluth")] }
+            end
+          end
+        end
+
+        specify do
+          parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
+          parsed_data[:errors].should == []
+          parsed_data[:metadata].should == {}
+        end
+      end
+    end
+  end
+end

data/vendor/gems/her/spec/collection_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Her::Collection do
+
+  let(:items) { [1, 2, 3, 4] }
+  let(:metadata) { { :name => 'Testname' } }
+  let(:errors) { { :name => ['not_present'] } }
+
+  describe "#new" do
+    context "without parameters" do
+      subject { Her::Collection.new }
+
+      it { should eq([]) }
+      its(:metadata) { should eq({}) }
+      its(:errors) { should eq({}) }
+    end
+
+    context "with parameters" do
+      subject { Her::Collection.new(items, metadata, errors) }
+
+      it { should eq([1,2,3,4]) }
+      its(:metadata) { should eq({ :name => 'Testname' }) }
+      its(:errors) { should eq({ :name => ['not_present'] }) }
+    end
+  end
+end

data/vendor/gems/her/spec/error_collection_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Her::ErrorCollection do
+
+  let(:metadata) { { :name => 'Testname' } }
+  let(:errors) { { :name => ['not_present'] } }
+
+  describe "#new" do
+    context "without parameters" do
+      subject { Her::ErrorCollection.new }
+
+      it "raises upon access" do
+        expect { subject[0] }.to raise_error(Her::Errors::ResponseError, "Cannot access collection, Request returned an error")
+        expect { subject.last }.to raise_error(Her::Errors::ResponseError, "Cannot access collection, Request returned an error")
+      end
+
+      its(:metadata) { should eq({}) }
+      its(:errors) { should eq({}) }
+    end
+
+    context "with parameters" do
+      subject { Her::ErrorCollection.new(metadata, errors) }
+
+      it "raises upon access" do
+        expect { subject[0] }.to raise_error(Her::Errors::ResponseError, "Cannot access collection, Request returned an error")
+        expect { subject.last }.to raise_error(Her::Errors::ResponseError, "Cannot access collection, Request returned an error")
+      end
+
+      its(:metadata) { should eq({ :name => 'Testname' }) }
+      its(:errors) { should eq({ :name => ['not_present'] }) }
+    end
+  end
+end

data/vendor/gems/her/spec/json_api/model_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Her::JsonApi::Model do
+  before do
+    Her::API.setup :url => "https://api.example.com" do |connection|
+      connection.use Her::Middleware::JsonApiParser
+      connection.adapter :test do |stub|
+        stub.get("/users/1") do |env| 
+          [ 
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: 'users',
+                attributes: {
+                  name: "Roger Federer",
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.get("/users") do |env| 
+          [ 
+            200,
+            {},
+            {
+              data: [
+                {
+                  id:    1,
+                  type: 'users',
+                  attributes: {
+                    name: "Roger Federer",
+                  },
+                }, 
+                {
+                  id:    2,
+                  type: 'users',
+                  attributes: {
+                    name: "Kei Nishikori",
+                  },
+                }
+              ]
+            }.to_json
+          ] 
+        end
+
+        stub.post("/users", data: {
+          type: 'users',
+          attributes: {
+            name: "Jeremy Lin",
+          },
+        }) do |env|
+          [ 
+            201,
+            {},
+            {
+              data: {
+                id:    3,
+                type: 'users',
+                attributes: {
+                  name: 'Jeremy Lin',
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.patch("/users/1", data: {
+          type: 'users',
+          id: 1,
+          attributes: {
+            name: "Fed GOAT",
+          },
+        }) do |env|
+          [ 
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: 'users',
+                attributes: {
+                  name: 'Fed GOAT',
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.delete("/users/1") { |env|
+          [ 204, {}, {}, ] 
+        }
+      end
+
+    end
+
+    spawn_model("Foo::User", type: Her::JsonApi::Model)
+  end
+
+  it 'allows configuration of type' do
+    spawn_model("Foo::Bar", type: Her::JsonApi::Model) do
+      type :foobars
+    end
+
+    expect(Foo::Bar.instance_variable_get('@type')).to eql('foobars')
+  end
+
+  it 'finds models by id' do
+    user = Foo::User.find(1)
+    expect(user.attributes).to eql(
+      'id' => 1,
+      'name' => 'Roger Federer',
+    )
+  end
+
+  it 'finds a collection of models' do
+    users = Foo::User.all
+    expect(users.map(&:attributes)).to match_array([
+      {
+        'id' => 1,
+        'name' => 'Roger Federer',
+      },
+      {
+        'id' => 2,
+        'name' => 'Kei Nishikori',
+      }
+    ])
+  end
+
+  it 'creates a Foo::User' do
+    user = Foo::User.new(name: 'Jeremy Lin')
+    user.save
+    expect(user.attributes).to eql(
+      'id' => 3,
+      'name' => 'Jeremy Lin',
+      'status_code' => 201
+    )
+  end
+
+  it 'updates a Foo::User' do
+    user = Foo::User.find(1)
+    user.name = 'Fed GOAT'
+    user.save
+    expect(user.attributes).to eql(
+      'id' => 1,
+      'name' => 'Fed GOAT',
+      'status_code' => 200
+    )
+  end
+
+  it 'destroys a Foo::User' do
+    user = Foo::User.find(1)
+    expect(user.destroy).to be_destroyed
+  end
+
+  context 'undefined methods' do
+    it 'removes methods that are not compatible with json api' do
+      [:parse_root_in_json, :include_root_in_json, :root_element, :primary_key].each do |method|
+        expect { Foo::User.new.send(method, :foo) }.to raise_error NoMethodError, "Her::JsonApi::Model does not support the #{method} configuration option"
+      end
+    end
+  end
+end