remote_association 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+*swp
+spec/config/database.yml

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p194@remote_association"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.14.3 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in remote_association.gemspec
+gemspec
+
+gem "debugger"

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    remote_association (0.0.1)
+      activerecord (~> 3.2)
+      activeresource (~> 3.2)
+      activesupport (~> 3.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    columnize (0.3.6)
+    database_cleaner (0.8.0)
+    debugger (1.2.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.3)
+    debugger-linecache (1.1.2)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.3)
+    diff-lcs (1.1.3)
+    fakeweb (1.3.0)
+    i18n (0.6.0)
+    multi_json (1.3.6)
+    pg (0.14.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  database_cleaner (~> 0.8)
+  debugger
+  fakeweb
+  pg (~> 0.14)
+  remote_association!
+  rspec (~> 2.11)

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Denis Yagofarov
+
+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,48 @@
+# Remote Association
+
+  Add ```has_``` and ```belongs_``` associations to models inherited from ActiveResource::Base
+
+  Say, you have Author and a service with Profiles. You can access profile of author as easy as `author.profile`.
+
+  Also, if you have 10K profiles and you need 3 of them, it won't load all profiles and won't do 3 requests to API.
+  Instead, just use ```Author.scoped.includes_remote(:profile)``` and it will do a get request like this one:
+
+  ```GET http://example.com/profiles?author_id[]=1&author_id[]=2&author_id[]=3```
+
+  Don't want to use default ```author_id```? You can alter class of ```profile``` association and ```author_id``` key by options.
+  Just like in ActiveRecord.
+
+  Notice, that for now, associations work in read-only mode.
+
+## Example
+
+```ruby
+  class Profile < ActiveResource::Base
+    self.site = REMOTE_HOST
+  end
+  class User < ActiveRecord::Base
+    include RemoteAssociation::Base
+    has_one_remote :profile
+  end
+
+  User.first.profile
+
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'remote_association'
+
+## TODO
+
+Implement 'has_many_remote' analogie of 'AR.has_many'
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+
+Dir["#{File.dirname(__FILE__)}/spec/tasks/*.rake"].sort.each { |f| load f }

data/lib/remote_association/active_record/relation.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  class Relation
+    # Loads relations to ActiveModel models of models, selected by current relation.
+    # The analogy is <tt>includes(*args)</tt> of ActiveRecord.
+    #
+    # May raise <tt>RemoteAssociation::SettingsNotFoundError</tt> if one of args can't be found among
+    # Class.activeresource_relations settings
+    #
+    # Returns all the records matched by the options of the relation, same as <tt>all(*args)</tt>
+    #
+    # === Examples
+    #
+    # Author.scoped.includes_remote(:profile, :avatar)
+    def includes_remote(*args)
+      keys = self.uniq.pluck(:id)
+
+      args.each do |r|
+        settings = klass.activeresource_relations[r.to_sym]
+        raise RemoteAssociation::SettingsNotFoundError, "Can't find settings for #{r} association" if settings.blank?
+
+        ar_accessor = r.to_sym
+        foregin_key = settings[:foreign_key]
+        ar_class    = settings[:class_name ].constantize
+
+        remote_objects = ar_class.find(:all, :params => { foregin_key => keys })
+
+        self.each do |u|
+          u.send("#{ar_accessor}=", remote_objects.select {|s| s.send(foregin_key) == u.id })
+          u.instance_variable_set(:@remote_resources_prefetched, true)
+        end
+      end
+
+      self.all
+    end
+  end
+end

data/lib/remote_association/version.rb

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

data/lib/remote_association.rb

@@ -0,0 +1,120 @@
+require "active_record"
+require "active_support"
+
+require "remote_association/version"
+require "remote_association/active_record/relation"
+
+module RemoteAssociation
+  # Include this class to hav associations to ActiveResource models
+  #
+  # It will add methods to your class:
+  # * <tt>has_one_remote(name, *oprions)</tt>
+  # * <tt>activeresource_relations</tt>
+  # * <tt>add_activeresource_relation(name, options)</tt>
+  module Base
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+
+      base.class_eval do
+      end
+    end
+
+    module ClassMethods
+      # Specifies a one-to-one association with another class. This method should only be used
+      # if this class is a kind of ActiveResource::Base and service for this resource can
+      # return some kind of foreign key.
+      #
+      # Methods will be added for retrieval and query for a single associated object, for which
+      # this object holds an id:
+      #
+      # [association()]
+      #   Returns the associated object. +nil+ is returned if none is found.
+      # [association=(associate)]
+      #   Just setter, no saves.
+      #
+      # (+association+ is replaced with the symbol passed as the first argument, so
+      # <tt>has_one_remote :author</tt> would add among others <tt>author.nil?</tt>.)
+      #
+      # === Example
+      #
+      # A Author class declares <tt>has_one_remote :profile</tt>, which will add:
+      # * <tt>Authort#profile</tt> (similar to <tt>Profile.find(:first, params: { author_id: [author.id]})</tt>)
+      # * <tt>Author#profile=(profile)</tt> (will set @profile instance variable of Author# to profile value)
+      # The declaration can also include an options hash to specialize the behavior of the association.
+      #
+      # === Options
+      #
+      # [:class_name]
+      #   Specify the class name of the association. Use it only if that name can't be inferred
+      #   from the association name. So <tt>has_one_remote :profile</tt> will by default be linked to the Profile class, but
+      #   if the real class name is SocialProfile, you'll have to specify it with this option.
+      # [:foreign_key]
+      #   Specify the foreign key used for searching association on remote service. By default this is guessed to be the name
+      #   of the current class with an "_id" suffix. So a class Author that defines a <tt>has_one_remote :profile</tt>
+      #   association will use "author_id" as the default <tt>:foreign_key</tt>.
+      #   This key will be used in :get request. Example: <tt>GET http://example.com/profiles?author_id[]=1</tt>
+      #
+      # Option examples:
+      #   has_one_remote :firm, :foreign_key => "client_of"
+      #   has_one_remote :author, :class_name => "Person", :foreign_key => "author_id"
+      def has_one_remote(remote_rel, options ={})
+        rel_options = {
+                       class_name: remote_rel.to_s.classify,
+                       foreign_key: self.model_name.to_s.foreign_key
+                      }.merge(options.symbolize_keys)
+
+        add_activeresource_relation(remote_rel.to_sym, rel_options)
+
+        class_eval <<-RUBY, __FILE__, __LINE__+1
+
+          attr_accessor :#{remote_rel}
+
+          def #{remote_rel}
+            if remote_resources_prefetched?
+              @#{remote_rel} ? @#{remote_rel}.first : nil
+            else
+              @#{remote_rel} ||= #{rel_options[:class_name]}.find(:first, params: { #{rel_options[:foreign_key]}: [self.id]})
+            end
+          end
+
+        RUBY
+
+      end
+
+      # Adds settings of relation to ActiveResource model.
+      #
+      # === Parameters
+      # * <tt>name</tt> a Symbol, representing name of association
+      # * <tt>options</tt> a Hash, contains :class_name and :foreign_key settings
+      #
+      # === Examples
+      #
+      # Author.add_activeresource_relation(:profile, {class_name: "Profile", foreign_key: "author_id"})
+      def add_activeresource_relation(name, options)
+        existing_relations = activeresource_relations
+        existing_relations[name] = options
+        @activeresource_relations = existing_relations
+      end
+
+      # Returns settings for relations to ActiveResource models.
+      #
+      # === Examples
+      #
+      # Author.activeresource_relations #=> [{profile: {class_name: "Profile", foreign_key: "author_id"}}]
+      def activeresource_relations
+        @activeresource_relations ||= {}
+      end
+    end
+
+    module InstanceMethods
+
+      # Returns <tt>true</tt> if associations to remote relations already loaded and set
+      def remote_resources_prefetched?
+        @remote_resources_prefetched
+      end
+    end
+  end
+
+  class SettingsNotFoundError < StandardError; end
+end

data/remote_association.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/remote_association/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Denis Yagofarov"]
+  gem.email         = ["denyago@gmail.com"]
+  gem.description   = %q{Your model has_one_remote ActiveResource instance}
+  gem.summary       = %q{Adds relations to ActiveResource models}
+  gem.homepage      = "https://github.com/denyago/remote_association"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.name          = "remote_association"
+  gem.require_paths = ["lib"]
+  gem.version       = RemoteAssociation::VERSION
+
+  rails_version = "~> 3.2"
+
+  gem.add_dependency  'activesupport',  rails_version
+  gem.add_dependency  'activerecord',   rails_version
+  gem.add_dependency  'activeresource', rails_version
+
+  gem.add_development_dependency 'rspec',             '~> 2.11'
+  gem.add_development_dependency 'pg',                '~> 0.14'
+  gem.add_development_dependency 'database_cleaner',  '~> 0.8'
+  gem.add_development_dependency 'fakeweb'
+
+end

data/spec/config/database.example.yml

@@ -0,0 +1,5 @@
+adapter:  postgresql
+database: remote_association
+host:     localhost
+port:     5432
+username: rails

data/spec/remote_association/remote_association_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe RemoteAssociation do
+  before(:all) do
+    REMOTE_HOST = "http://127.0.0.1:3000"
+    PROFILES_JSON = [
+      {profile: {id: 1, user_id: 1, like: "letter A"}},
+      {profile: {id: 2, user_id: 2, like: "letter B"}}
+    ]
+  end
+
+  before(:each) do
+    class Profile < ActiveResource::Base
+      self.site = REMOTE_HOST
+    end
+    class User < ActiveRecord::Base
+      include RemoteAssociation::Base
+      has_one_remote :profile
+    end
+
+    add_user(1,"User A")
+    add_user(2,"User B")
+  end
+
+  it 'should prefetch remote associations of models with defaults (single request)' do
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1&user_id%5B%5D=2", body: PROFILES_JSON.to_json)
+
+    users = User.scoped.includes_remote(:profile)
+    users.first.profile.like.should eq('letter A')
+    users.last.profile.like.should eq('letter B')
+  end
+
+  it 'should raise error if can\'t find settings for included remote' do
+    lambda{ User.scoped.includes_remote(:whatever) }.should raise_error(RemoteAssociation::SettingsNotFoundError, "Can't find settings for whatever association")
+  end
+
+  it 'should prefetch remote associations of models, passed as args of includes_remote' do
+    class OtherProfile < ActiveResource::Base
+      self.site = REMOTE_HOST
+      self.element_name = "profile"
+    end
+    class User < ActiveRecord::Base
+      include RemoteAssociation::Base
+      has_one_remote :profile
+      has_one_remote :other_profile
+    end
+
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/other_profiles.json?user_id%5B%5D=1&user_id%5B%5D=2", body: PROFILES_JSON.to_json)
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1&user_id%5B%5D=2", body: PROFILES_JSON.to_json)
+
+    users = User.scoped.includes_remote(:profile, :other_profile)
+    users.first.profile.like.should eq('letter A')
+    users.last.profile.like.should eq('letter B')
+    users.first.other_profile.like.should eq('letter A')
+    users.last.other_profile.like.should eq('letter B')
+  end
+
+  it 'should autoload remote associations of each models without prefetching (1+N requiests)' do
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1", body: [PROFILES_JSON.first].to_json)
+    FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=2", body: [PROFILES_JSON.last].to_json)
+
+    users = User.scoped
+    users.first.profile.like.should eq('letter A')
+    users.last.profile.like.should eq('letter B')
+  end
+
+  describe "method :has_one_remote with options:" do
+    before(:each) do
+      @body = [PROFILES_JSON.first].to_json
+    end
+    it ":class_name - able to choose custom class of association" do
+      class CustomProfile < ActiveResource::Base
+        self.site = REMOTE_HOST
+        self.element_name = "profile"
+      end
+      class User < ActiveRecord::Base
+        include RemoteAssociation::Base
+        has_one_remote :profile, class_name: "CustomProfile"
+      end
+      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?user_id%5B%5D=1", body: @body )
+    end
+    it ":foreign_key - can set uri param for search" do
+       class CustomProfile < ActiveResource::Base
+        self.site = REMOTE_HOST
+        self.element_name = "profile"
+      end
+      class User < ActiveRecord::Base
+        include RemoteAssociation::Base
+        has_one_remote :profile, foreign_key: :login_id
+      end
+      FakeWeb.register_uri(:get, "#{REMOTE_HOST}/profiles.json?login_id%5B%5D=1", body: @body)
+    end
+    after(:each) do
+      User.first.profile.like.should eq('letter A')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require 'rspec'
+require "database_cleaner"
+require 'fake_web'
+
+require 'remote_association'
+
+require 'yaml'
+require 'active_resource'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    FakeWeb.allow_net_connect = false
+  end
+
+  config.after(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end
+
+root      = File.dirname(__FILE__)
+db_config = YAML.load_file("#{root}/config/database.yml")
+ActiveRecord::Base.establish_connection(db_config)
+
+def add_user(id, name)
+  ActiveRecord::Base.connection.execute("insert into \"public\".\"users\" (\"id\", \"name\") values ( #{id}, '#{name}');")
+end

data/spec/tasks/db_setup.rake

@@ -0,0 +1,57 @@
+require 'active_record'
+
+namespace :spec do
+  namespace :db do
+    desc "Setup DB for tests"
+    task :setup do
+      puts "Create database\n"
+      Rake::Task["spec:db:create"].invoke
+      puts "Migrate database\n"
+      Rake::Task["spec:db:migrate"].invoke
+    end
+
+    desc "Add tables required for tests"
+    task :migrate do
+      ActiveRecord::Base.establish_connection(db_config)
+
+      ActiveRecord::Base.connection.execute(<<SQL
+DROP TABLE IF EXISTS "public"."users";
+
+CREATE TABLE "public"."users" (
+	"id" int4 NOT NULL,
+	"name" varchar(255) NOT NULL,
+	CONSTRAINT "users_pkey" PRIMARY KEY ("id") NOT DEFERRABLE INITIALLY IMMEDIATE
+)
+WITH (OIDS=FALSE);
+ALTER TABLE "public"."users" OWNER TO "rails";
+SQL
+                                     )
+    end
+
+    desc "Create DB for tests"
+    task :create do
+      encoding = db_config[:encoding] || ENV['CHARSET'] || 'utf8'
+      begin
+        ActiveRecord::Base.establish_connection(db_config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+        ActiveRecord::Base.connection.drop_database(db_config['database']) and puts "previously dropping DB..." if db_present?
+        ActiveRecord::Base.connection.create_database(db_config['database'], db_config.merge('encoding' => encoding))
+        ActiveRecord::Base.establish_connection(db_config)
+      rescue
+        $stderr.puts $!, *($!.backtrace)
+        $stderr.puts "Couldn't create database for #{db_config.inspect}"
+      end
+    end
+
+    def db_config
+      root    = File.expand_path('../../', __FILE__)
+      @db_conf ||= YAML.load_file("#{root}/config/database.yml")
+    end
+
+    def db_present?
+      ActiveRecord::Base.connection.execute("SELECT count(*) FROM pg_database where datname = '#{db_config['database']}'").values.flatten.first.to_i == 1
+    end
+  end
+end
+
+
+

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: remote_association
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Denis Yagofarov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activeresource
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Your model has_one_remote ActiveResource instance
+email:
+- denyago@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/remote_association.rb
+- lib/remote_association/active_record/relation.rb
+- lib/remote_association/version.rb
+- remote_association.gemspec
+- spec/config/database.example.yml
+- spec/remote_association/remote_association_spec.rb
+- spec/spec_helper.rb
+- spec/tasks/db_setup.rake
+homepage: https://github.com/denyago/remote_association
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Adds relations to ActiveResource models
+test_files:
+- spec/config/database.example.yml
+- spec/remote_association/remote_association_spec.rb
+- spec/spec_helper.rb
+- spec/tasks/db_setup.rake