remotable 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end

data/lib/remotable/active_resource_fixes.rb

@@ -0,0 +1,60 @@
+require 'active_resource'
+
+
+module ActiveResourceFixes
+end
+
+
+module ActiveResourceFixes30
+  include ActiveResourceFixes
+  
+  # ! in this method, don't check the Content-Type header: rack doesn't always return it
+  def load_attributes_from_response(response)
+    if !response.body.nil? && response.body.strip.size > 0
+      load(self.class.format.decode(response.body))
+    end
+  end
+  
+end
+
+
+module ActiveResourceFixes31
+  include ActiveResourceFixes
+  
+  # ! in this method, don't check the Content-Type header: rack doesn't always return it
+  def load_attributes_from_response(response)
+    if !response.body.nil? && response.body.strip.size > 0
+      load(self.class.format.decode(response.body), true)
+      @persisted = true
+    end
+  end
+  
+end
+
+
+if Rails.version < '3.1'
+  ActiveResource::Base.send(:include, ActiveResourceFixes30)
+else
+  ActiveResource::Base.send(:include, ActiveResourceFixes31)
+end
+
+
+# ActiveResource expects that errors will be an array of string
+# However, this is not what Rails Responders are inclined to return.
+
+class ActiveResource::Errors
+  
+  # Grabs errors from an array of messages (like ActiveRecord::Validations).
+  # The second parameter directs the errors cache to be cleared (default)
+  # or not (by passing true).
+  def from_array(array, save_cache=false)
+    clear unless save_cache
+    hash = array[0] || {}
+    hash.each do |key, value|
+      Array.wrap(value).each do |message|
+        self[key] = message
+      end
+    end
+  end
+  
+end

data/lib/remotable/core_ext/enumerable.rb

@@ -0,0 +1,7 @@
+module Enumerable
+  
+  def map_to_self(result={})
+    inject(result) {|hash, value| hash.merge(value => value)}
+  end
+  
+end

data/lib/remotable/core_ext.rb

@@ -0,0 +1 @@
+require "remotable/core_ext/enumerable"

data/lib/remotable/version.rb

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

data/lib/remotable.rb

@@ -0,0 +1,298 @@
+require "remotable/version"
+require "remotable/core_ext"
+require "remotable/active_resource_fixes"
+require "active_support/concern"
+
+
+# Remotable keeps a locally-stored ActiveRecord
+# synchronized with a remote resource.
+#
+# == Requirements ==
+# Remotable expects there to be an <tt>expires_at</tt>
+# field on the record.
+#
+# == New resources ==
+# When a resource isn't found locally, Remotable
+# fetches it from the remote API and creates a local
+# copy of the resource.
+#
+# == Expired resources ==
+# When a resource is found locally, Remotable checks
+# the value of <tt>expires_at</tt> and re-fetches the
+# remote resource if need be.
+#
+# == Deleted resources ==
+# When a remote resources has been deleted, the local
+# resource should be removed when it is expired.
+#
+# == Creating, Updating, and Destroying local resources ==
+# Before a local record is saved, Remotable tries
+# to apply the changes remotely.
+#
+#
+module Remotable
+  extend ActiveSupport::Concern
+  
+  
+  
+  included do
+    before_update   :update_remote_resource,  :unless => :nosync?
+    before_create   :create_remote_resource,  :unless => :nosync?
+    before_destroy  :destroy_remote_resource, :unless => :nosync?
+    
+    before_validation :reset_expiration_date, :on => :create, :unless => :nosync?
+    
+    validates_presence_of :expires_at
+    
+    default_remote_attributes = column_names - ["id", "created_at", "updated_at", "expires_at"]
+    @remote_model_name = "#{self.name}::Remote#{self.name}"
+    @remote_attribute_map = default_remote_attributes.map_to_self
+    @expires_after = 1.day
+  end
+  
+  
+  
+  module ClassMethods
+    
+    def remote_model_name(name)
+      @remote_model = nil
+      @remote_model_name = name
+    end
+    
+    def attr_remote(*attrs)
+      map = attrs.extract_options!
+      map = attrs.map_to_self(map)
+      @remote_attribute_map = map
+    end
+    
+    def fetch_with(local_key)
+      @local_key = local_key
+      @remote_key = remote_attribute_name(local_key)
+      
+      class_eval <<-RUBY
+        def self.find_by_#{local_key}(value)
+          local_resource = where(:#{local_key} => value).first
+          local_resource || fetch_new_from_remote(value)
+        end
+        
+        def self.find_by_#{local_key}!(value)
+          find_by_#{local_key}(value) || raise(ActiveRecord::RecordNotFound)
+        end
+      RUBY
+    end
+    
+    def expires_after(val)
+      @expires_after = val
+    end
+    
+    
+    
+    attr_reader :local_key,
+                :remote_key,
+                :expires_after,
+                :remote_attribute_map
+    
+    def remote_model
+      @remote_model ||= @remote_model_name.constantize
+    end
+    
+    def remote_attribute_names
+      remote_attribute_map.keys
+    end
+    
+    def local_attribute_names
+      remote_attribute_map.values
+    end
+    
+    def remote_attribute_name(local_attr)
+      remote_attribute_map.key(local_attr) || local_attr
+    end
+    
+    def local_attribute_name(remote_attr)
+      remote_attribute_map[remote_attr] || remote_attr
+    end
+    
+    
+    
+    # !nb: this method is called when associations are loaded
+    # so you can use the remoted record in associations.
+    def instantiate(*args)
+      record = super
+      record.pull_remote_data! if record.expired?
+      record = nil if record.destroyed?
+      record
+    end
+    
+    
+    
+  private
+    
+    
+    
+    def fetch_new_from_remote(value)
+      record = self.new
+      record.send("#{local_key}=", value) # {local_key => value} not passed to :new so local_key can be protected
+      if record.remote_resource
+        record.pull_remote_data!
+      else
+        nil
+      end
+    end
+    
+  end
+  
+  
+  
+  delegate :local_key,
+           :remote_key,
+           :remote_model,
+           :remote_attribute_map,
+           :remote_attribute_names,
+           :remote_attribute_name,
+           :local_attribute_names,
+           :local_attribute_name,
+           :expires_after,
+           :to => "self.class"
+  
+  def expired?
+    expires_at.nil? || expires_at < Time.now
+  end
+  
+  def expired!
+    update_attribute(:expires_at, 1.day.ago)
+  end
+  
+  
+  
+  def pull_remote_data!
+    merge_remote_data!(remote_resource)
+  end
+  
+  
+  
+  def remote_resource
+    @remote_resource ||= fetch_remote_resource
+  end
+  
+  def any_remote_changes?
+    (changed.map(&:to_sym) & local_attribute_names).any?
+  end
+  
+  
+  
+  def nosync!
+    @nosync = true
+  end
+  
+  def nosync
+    value = @nosync
+    @nosync = true
+    yield
+  ensure
+    @nosync = value
+  end
+  
+  def nosync=(val)
+    @nosync = (val == true)
+  end
+  
+  def nosync?
+    @nosync == true
+  end
+  
+  
+  
+private
+  
+  def fetch_remote_resource
+    fetch_value = self[local_key]
+    if remote_key == :id
+      remote_model.find(fetch_value)
+    else
+      remote_model.send("find_by_#{remote_key}", fetch_value)
+    end
+  end
+  
+  def merge_remote_data!(remote_resource)
+    if remote_resource.nil?
+      nosync { destroy }
+    
+    else
+      merge_remote_data(remote_resource)
+      reset_expiration_date
+      nosync { save! }
+    end
+    
+    self
+  end
+  
+  
+  
+  def update_remote_resource
+    if any_remote_changes?
+      merge_local_data(remote_resource, true)
+      unless remote_resource.save
+        merge_remote_errors(remote_resource.errors)
+        raise ActiveRecord::RecordInvalid.new(self)
+      end
+    end
+  end
+  
+  def create_remote_resource
+    @remote_resource = remote_model.new
+    merge_local_data(@remote_resource)
+    
+    if @remote_resource.save
+      
+      # This line is especially crucial if the primary key
+      # of the remote resource needs to be stored locally.
+      merge_remote_data(@remote_resource)
+    else
+      
+      merge_remote_errors(remote_resource.errors)
+      raise ActiveRecord::RecordInvalid.new(self)
+    end
+  end
+  
+  def destroy_remote_resource
+    remote_resource && remote_resource.destroy
+  end
+  
+  
+  
+  def reset_expiration_date
+    self.expires_at = expires_after.from_now
+  end
+  
+  
+  
+protected
+  
+  def merge_remote_errors(errors)
+    errors.each do |attribute, message|
+      self.errors[local_attribute_name(attribute)] = message
+    end
+    self
+  end
+  
+  def merge_remote_data(remote_resource)
+    remote_attribute_map.each do |remote_attr, local_attr|
+      if remote_resource.respond_to?(remote_attr)
+        send("#{local_attr}=", remote_resource.send(remote_attr))
+      end
+    end
+    self
+  end
+  
+  def merge_local_data(remote_resource, changes_only=false)
+    remote_attribute_map.each do |remote_attr, local_attr|
+      if !changes_only || changed.member?(local_attr.to_s)
+        remote_resource.send("#{remote_attr}=", send(local_attr))
+      end
+    end
+    self
+  end
+  
+  
+  
+end

data/remotable.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "remotable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "remotable"
+  s.version     = Remotable::VERSION
+  s.authors     = ["Robert Lail"]
+  s.email       = ["robert.lail@cph.org"]
+  s.homepage    = ""
+  s.summary     = %q{Binds an ActiveRecord model to a remote resource and keeps the two synchronized}
+  s.description = %q{Remotable keeps a locally-stored ActiveRecord synchronized with a remote resource.}
+  
+  s.rubyforge_project = "remotable"
+  
+  s.add_dependency "activeresource"
+  s.add_dependency "activerecord"
+  s.add_dependency "activesupport"
+  
+  s.add_development_dependency "rails"
+  s.add_development_dependency "turn"
+  s.add_development_dependency "factory_girl"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "active_resource_simulator"
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/factories/tenants.rb

@@ -0,0 +1,8 @@
+Factory.define :tenant do |f|
+  f.sequence(:slug) { |n| "test#{n}" }
+  f.name "Test"
+  
+  f.active true
+  f.expires_at 100.years.from_now
+  f.nosync true
+end

data/test/remotable_test.rb

@@ -0,0 +1,220 @@
+require 'test_helper'
+require 'remotable'
+require 'support/active_resource'
+require 'active_resource_simulator'
+
+
+class RemotableTest < ActiveSupport::TestCase
+  
+  
+  test "should create a record locally when fetching a new remote resource" do
+    new_tenant_slug = "not_found"
+    
+    assert_equal 0, Tenant.where(:slug => new_tenant_slug).count,
+      "There's not supposed to be a Tenant with the subdomain #{new_tenant_slug}."
+    
+    assert_difference "Tenant.count", +1 do
+      Tenant::RemoteTenant.run_simulation do |s|
+        attrs = {
+          :id => 1,
+          :slug => "not_found",
+          :church_name => "Not Found"
+        }
+        
+        s.show(nil, attrs, :path => "/api/accounts/by_slug/#{attrs[:slug]}.json")
+        
+        Tenant.find_by_slug(new_tenant_slug)
+      end
+    end
+  end
+  
+  
+  
+  test "should not fetch a remote record when a local record is not expired" do
+    tenant = Factory(:tenant, :expires_at => 100.years.from_now)
+    unexpected_name = "Totally Wonky"
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      attrs = {
+        :id => tenant.id,
+        :slug => tenant.slug,
+        :church_name => unexpected_name
+      }
+      
+      s.show(nil, attrs, :path => "/api/accounts/by_slug/#{attrs[:slug]}.json")
+      
+      tenant = Tenant.find_by_slug(tenant.slug)
+      assert_not_equal unexpected_name, tenant.name
+    end
+  end
+  
+  
+  
+  test "should fetch a remote record when a local record is expired" do
+    tenant = Factory(:tenant, :expires_at => 1.year.ago)
+    unexpected_name = "Totally Wonky"
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      attrs = {
+        :id => tenant.id,
+        :slug => tenant.slug,
+        :church_name => unexpected_name
+      }
+      
+      s.show(nil, attrs, :path => "/api/accounts/by_slug/#{attrs[:slug]}.json")
+      
+      tenant = Tenant.find_by_slug(tenant.slug)
+      assert_equal unexpected_name, tenant.name
+    end
+  end
+  
+  
+  
+  test "should delete a local record when a remote record has been deleted" do
+    tenant = Factory(:tenant, :expires_at => 1.year.ago)
+    
+    assert_difference "Tenant.count", -1 do
+      Tenant::RemoteTenant.run_simulation do |s|
+        
+        s.show(nil, nil, :path => "/api/accounts/by_slug/#{tenant.slug}.json", :status => 404)
+        
+        tenant = Tenant.find_by_slug(tenant.slug)
+        assert_equal nil, tenant
+      end
+    end
+  end
+  
+  
+  
+  test "should update a record remotely when updating one locally" do
+    tenant = Factory(:tenant)
+    new_name = "Totally Wonky"
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      s.show(nil, {
+        :id => tenant.id,
+        :slug => tenant.slug,
+        :church_name => tenant.name
+        }, :path => "/api/accounts/by_slug/#{tenant.slug}.json")
+      
+      s.update(tenant.id)
+      
+      tenant.nosync = false
+      tenant.name = "Totally Wonky"
+      assert_equal true, tenant.any_remote_changes?
+      
+      tenant.save!
+      
+      pending "Not sure how to test that an update happened"
+    end
+  end
+  
+  test "should fail to update a record locally when failing to update one remotely" do
+    tenant = Factory(:tenant)
+    new_name = "Totally Wonky"
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      s.show(nil, {
+          :id => tenant.id,
+          :slug => tenant.slug,
+          :church_name => tenant.name
+        }, :path => "/api/accounts/by_slug/#{tenant.slug}.json")
+      
+      s.update(tenant.id, :status => 422, :body => {
+        :errors => {:church_name => ["is already taken"]}
+      })
+      
+      tenant.nosync = false
+      tenant.name = new_name
+      assert_raises(ActiveRecord::RecordInvalid) do
+        tenant.save!
+      end
+      assert_equal ["is already taken"], tenant.errors[:name]
+    end
+  end
+  
+  
+  
+  test "should create a record remotely when creating one locally" do
+    tenant = Tenant.new({
+      :slug => "brand_new",
+      :name => "Brand New"
+    })
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      s.create({
+        :id => 143,
+        :slug => tenant.slug,
+        :church_name => tenant.name
+      })
+      
+      tenant.save!
+      
+      assert_equal true, tenant.remote_resource.persisted?
+    end
+  end
+  
+  test "should fail to create a record locally when failing to create one remotely" do
+    tenant = Tenant.new({
+      :slug => "brand_new",
+      :name => "Brand New"
+    })
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      s.create({
+        :errors => {
+          :what => ["ever"],
+          :church_name => ["is already taken"]}
+      }, :status => 422)
+      
+      assert_raises(ActiveRecord::RecordInvalid) do
+        tenant.save!
+      end
+      
+      assert_equal ["is already taken"], tenant.errors[:name]
+    end
+  end
+  
+  
+  
+  test "should destroy a record remotely when destroying one locally" do
+    tenant = Factory(:tenant)
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      s.show(nil, {
+          :id => tenant.id,
+          :slug => tenant.slug,
+          :church_name => tenant.name
+        }, :path => "/api/accounts/by_slug/#{tenant.slug}.json")
+      
+      s.destroy(tenant.id)
+      
+      tenant.nosync = false
+      tenant.destroy
+      
+      pending # how do I check for this?
+    end
+  end
+  
+  test "should fail to destroy a record locally when failing to destroy one remotely" do
+    tenant = Factory(:tenant)
+    
+    Tenant::RemoteTenant.run_simulation do |s|
+      s.show(nil, {
+          :id => tenant.id,
+          :slug => tenant.slug,
+          :church_name => tenant.name
+        }, :path => "/api/accounts/by_slug/#{tenant.slug}.json")
+      
+      s.destroy(tenant.id, :status => 500)
+      
+      tenant.nosync = false
+      assert_raises(ActiveResource::ServerError) do
+        tenant.destroy
+      end
+    end
+  end
+  
+  
+  
+end

data/test/support/active_resource.rb

@@ -0,0 +1,32 @@
+require 'active_record'
+require 'active_resource'
+
+class Tenant < ActiveRecord::Base
+  include Remotable
+  
+  attr_remote :slug, :church_name => :name, :active_unite_account => :active
+  fetch_with :slug
+  
+  class RemoteTenant < ActiveResource::Base
+    
+    self.site                 = "http://example.com/api/"
+    self.element_name         = "account"
+    self.format               = :json
+    self.include_root_in_json = false
+    self.user                 = "username"
+    self.password             = "password"
+    
+    class << self
+      def find_by_slug!(slug)
+        find(:one, :from => "/api/accounts/by_slug/#{slug}.json")
+      end
+      
+      def find_by_slug(slug)
+        find_by_slug!(slug)
+      rescue ActiveResource::ResourceNotFound
+        nil
+      end
+    end
+    
+  end
+end

data/test/support/schema.rb

@@ -0,0 +1,24 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(:version => 20110507152635) do
+
+  create_table "tenants", :force => true do |t|
+    t.string   "slug",       :null => false
+    t.string   "name",       :null => false
+    t.boolean  "active"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+    t.datetime "expires_at"
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'rails'
+require 'rails/test_help'
+require 'active_support/core_ext'
+require 'factory_girl'
+require 'turn'
+
+
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => ":memory:",
+  :verbosity => "quiet")
+
+load File.join(File.dirname(__FILE__), "support", "schema.rb")
+
+
+require 'factories/tenants'

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: remotable
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Robert Lail
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-18 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: turn
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: factory_girl
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: active_resource_simulator
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: Remotable keeps a locally-stored ActiveRecord synchronized with a remote resource.
+email: 
+- robert.lail@cph.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/remotable.rb
+- lib/remotable/active_resource_fixes.rb
+- lib/remotable/core_ext.rb
+- lib/remotable/core_ext/enumerable.rb
+- lib/remotable/version.rb
+- remotable.gemspec
+- test/factories/tenants.rb
+- test/remotable_test.rb
+- test/support/active_resource.rb
+- test/support/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ""
+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: remotable
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Binds an ActiveRecord model to a remote resource and keeps the two synchronized
+test_files: 
+- test/factories/tenants.rb
+- test/remotable_test.rb
+- test/support/active_resource.rb
+- test/support/schema.rb
+- test/test_helper.rb