remotable 0.0.1 → 0.1.1

data/Rakefile

@@ -1,5 +1,4 @@
 require 'bundler/gem_tasks'
-
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|

data/lib/remotable.rb

@@ -1,7 +1,4 @@
 require "remotable/version"
-require "remotable/core_ext"
-require "remotable/active_resource_fixes"
-require "active_support/concern"
 
 
 # Remotable keeps a locally-stored ActiveRecord
@@ -31,268 +28,23 @@ require "active_support/concern"
 #
 #
 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
+  def remote_model(*args)
+    if args.any?
+      @remote_model = args.first
       
-      # This line is especially crucial if the primary key
-      # of the remote resource needs to be stored locally.
-      merge_remote_data(@remote_resource)
+      require "remotable/active_record_extender"
+      include Remotable::ActiveRecordExtender
     else
-      
-      merge_remote_errors(remote_resource.errors)
-      raise ActiveRecord::RecordInvalid.new(self)
+      @remote_model
     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
+
+
+ActiveRecord::Base.extend(Remotable) if defined?(ActiveRecord::Base)

data/lib/remotable/active_record_extender.rb

@@ -0,0 +1,343 @@
+require "remotable/core_ext"
+require "active_support/concern"
+
+
+module Remotable
+  module ActiveRecordExtender
+    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 - %w{id created_at updated_at expires_at}
+      @remote_attribute_map = default_remote_attributes.map_to_self
+      @remote_attribute_routes = {}
+      @expires_after = 1.day
+      
+      extend_remote_model
+    end
+    
+    
+    
+    module ClassMethods
+      
+      def remote_key(*args)
+        if args.any?
+          remote_key = args.first
+          raise("#{remote_key} is not the name of a remote attribute") unless remote_attribute_names.member?(remote_key)
+          @remote_key = remote_key
+          fetch_with(remote_key)
+          remote_key
+        else
+          @remote_key || generate_default_remote_key
+        end
+      end
+      
+      def expires_after(*args)
+        if args.any?
+          @expires_after = args.first
+        else
+          @expires_after
+        end
+      end
+      
+      def attr_remote(*attrs)
+        map = attrs.extract_options!
+        map = attrs.map_to_self(map)
+        @remote_attribute_map = map
+      end
+      
+      def fetch_with(*args)
+        keys_and_routes = extract_keys_and_routes(*args)
+        @remote_attribute_routes.merge!(keys_and_routes)
+      end
+      alias :find_by :fetch_with
+      
+      
+      
+      attr_reader :remote_attribute_map,
+                  :remote_attribute_routes
+      
+      def local_key
+        local_attribute_name(remote_key)
+      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
+      
+      def route_for(local_key)
+        remote_key = remote_attribute_name(local_key)
+        remote_attribute_routes[remote_key] || default_route_for(local_key, remote_key)
+      end
+      
+      def default_route_for(local_key, remote_key=nil)
+        remote_key ||= remote_attribute_name(local_key)
+        "by_#{remote_key}/:#{local_key}.json"
+      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
+      
+      
+      
+      def method_missing(method_sym, *args, &block)
+        method_name = method_sym.to_s
+        
+        if method_name =~ /find_by_(.*)(!?)/
+          local_attr, bang, value = $1.to_sym, !$2.blank?, args.first
+          remote_attr = remote_attribute_name(local_attr)
+          
+          remote_key # Make sure we've figured out the remote
+                     # primary key if we're evaluating a finder
+          
+          if remote_attribute_routes.key?(remote_attr)
+            local_resource = where(local_attr => value).first
+            unless local_resource
+              remote_resource = remote_model.find_by(remote_attr, value)
+              local_resource = new_from_remote(remote_resource) if remote_resource
+            end
+            
+            raise ActiveRecord::RecordNotFound if local_resource.nil? && bang
+            return local_resource
+          end
+        end
+        
+        super(method_sym, *args, &block)
+      end
+      
+      
+      
+    private
+      
+      
+      
+      def extend_remote_model
+        if remote_model < ActiveResource::Base
+          require "remotable/adapters/active_resource"
+          remote_model.send(:include, Remotable::Adapters::ActiveResource)
+          remote_model.local_model = self
+        
+        # !todo
+        # Adapters for other API consumers can be implemented here
+        #
+        
+        else
+          raise("#{remote_model} is not a recognized remote resource")
+        end
+      end
+      
+      
+      def extract_keys_and_routes(*local_keys)
+        keys_and_routes = local_keys.extract_options!
+        {}.tap do |hash|
+          local_keys.each {|local_key| hash[remote_attribute_name(local_key)] = nil}
+          keys_and_routes.each {|local_key, value| hash[remote_attribute_name(local_key)] = value}
+        end
+      end
+      
+      
+      def generate_default_remote_key
+        raise("No remote key supplied and :id is not a remote attribute") unless remote_attribute_names.member?(:id)
+        remote_key(:id)
+      end
+      
+      
+      def new_from_remote(remote_resource)
+        record = self.new
+        record.instance_variable_set(:@remote_resource, remote_resource)
+        record.pull_remote_data!
+      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]
+      remote_model.find_by(remote_key, fetch_value)
+    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
+    
+    
+    
+    def local_attribute_changed?(name)
+      changed.member?(name.to_s)
+    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 || local_attribute_changed?(local_attr)
+          remote_resource.send("#{remote_attr}=", send(local_attr))
+        end
+      end
+      self
+    end
+    
+    
+    
+  end
+end

data/lib/remotable/active_resource_fixes.rb

@@ -1,4 +1,4 @@
-require 'active_resource'
+require "active_resource"
 
 
 module ActiveResourceFixes

data/lib/remotable/adapters/active_resource.rb

@@ -0,0 +1,68 @@
+require "remotable/active_resource_fixes"
+require "active_support/concern"
+
+
+module Remotable
+  module Adapters
+    module ActiveResource
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        
+        
+        attr_accessor :local_model
+        
+        delegate :local_attribute_name,
+                 :route_for,
+                 :to => :local_model
+        
+        
+        
+        def find_by!(key, value)
+          if key == :id
+            find(value)
+          else
+            find(:one, :from => path_for(key, value))
+          end
+        end
+        
+        def find_by(key, value)
+          find_by!(key, value)
+        rescue ::ActiveResource::ResourceNotFound
+          nil
+        end
+        
+        
+        
+        def path_for(remote_key, value)
+          local_key = local_attribute_name(remote_key)
+          route = route_for(local_key)
+          path = route.gsub(/:#{local_key}/, value.to_s)
+          if relative_path?(path)
+            path
+          else
+            join_url_segments(prefix, collection_name, path)
+          end
+        end
+        
+        
+        
+      private
+        
+        
+        
+        def relative_path?(path)
+          path.start_with?("/") || path["://"]
+        end
+        
+        def join_url_segments(*segments)
+          segments.flatten.join("/").gsub(/\/+/, "/")
+        end
+        
+        
+        
+      end
+      
+    end
+  end
+end

data/lib/remotable/version.rb

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

data/test/factories/tenants.rb

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

data/test/remotable_test.rb

@@ -1,29 +1,88 @@
-require 'test_helper'
-require 'remotable'
-require 'support/active_resource'
-require 'active_resource_simulator'
+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
+  
+  test "should consider :id to be the remote key if none is specified" do
+    assert_equal :id,         RemoteWithoutKey.remote_key
+    assert_equal :remote_id,  RemoteWithoutKey.local_key
+  end
+  
+  test "should use a different remote_key if one is supplied" do
+    assert_equal :slug, RemoteWithKey.remote_key
+    assert_equal :slug, RemoteWithKey.local_key
+  end
+  
+  test "should be able to generate paths for with different attributes" do
+    assert_equal "/api/accounts/by_slug/value.json",   RemoteTenant.path_for(:slug, "value")
+    assert_equal "/api/accounts/by_nombre/value.json", RemoteTenant.path_for(:name, "value")
+  end
+  
+  
+  
+  test "should be able to find resources by different attributes" 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}."
+      "There's not supposed to be a Tenant with the slug #{new_tenant_slug}."
     
     assert_difference "Tenant.count", +1 do
-      Tenant::RemoteTenant.run_simulation do |s|
-        attrs = {
-          :id => 1,
-          :slug => "not_found",
+      RemoteTenant.run_simulation do |s|
+        s.show(nil, {
+          :id => 46,
+          :slug => new_tenant_slug,
           :church_name => "Not Found"
-        }
+        }, :path => "/api/accounts/by_slug/#{new_tenant_slug}.json")
         
-        s.show(nil, attrs, :path => "/api/accounts/by_slug/#{attrs[:slug]}.json")
+        new_tenant = Tenant.find_by_slug(new_tenant_slug)
+        assert_not_nil new_tenant, "A remote tenant was not found with the slug #{new_tenant_slug.inspect}"
+      end
+    end
+  end
+  
+  test "should be able to find resources by different attributes and specify a path" do
+    new_tenant_name = "JohnnyG"
+    
+    assert_equal 0, Tenant.where(:name => new_tenant_name).count,
+      "There's not supposed to be a Tenant with the name #{new_tenant_name}."
+    
+    assert_difference "Tenant.count", +1 do
+      RemoteTenant.run_simulation do |s|
+        s.show(nil, {
+          :id => 46,
+          :slug => "not_found",
+          :church_name => new_tenant_name
+        }, :path => "/api/accounts/by_nombre/#{new_tenant_name}.json")
+        
+        new_tenant = Tenant.find_by_name(new_tenant_name)
+        assert_not_nil new_tenant, "A remote tenant was not found with the name #{new_tenant_name.inspect}"
+      end
+    end
+  end
+  
+  
+  
+  test "should create a record locally when fetching a new remote resource" do
+    new_tenant_id = 17
+    
+    assert_equal 0, Tenant.where(:remote_id => new_tenant_id).count,
+      "There's not supposed to be a Tenant with the id #{new_tenant_id}."
+    
+    assert_difference "Tenant.count", +1 do
+      RemoteTenant.run_simulation do |s|
+        s.show(new_tenant_id, {
+          :id => new_tenant_id,
+          :slug => "not_found",
+          :church_name => "Not Found"
+        })
         
-        Tenant.find_by_slug(new_tenant_slug)
+        new_tenant = Tenant.find_by_remote_id(new_tenant_id)
+        assert_not_nil new_tenant, "A remote tenant was not found with the id #{new_tenant_id.inspect}"
       end
     end
   end
@@ -34,16 +93,14 @@ class RemotableTest < ActiveSupport::TestCase
     tenant = Factory(:tenant, :expires_at => 100.years.from_now)
     unexpected_name = "Totally Wonky"
     
-    Tenant::RemoteTenant.run_simulation do |s|
-      attrs = {
-        :id => tenant.id,
+    RemoteTenant.run_simulation do |s|
+      s.show(tenant.remote_id, {
+        :id => tenant.remote_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)
+      tenant = Tenant.find_by_remote_id(tenant.remote_id)
       assert_not_equal unexpected_name, tenant.name
     end
   end
@@ -54,16 +111,14 @@ class RemotableTest < ActiveSupport::TestCase
     tenant = Factory(:tenant, :expires_at => 1.year.ago)
     unexpected_name = "Totally Wonky"
     
-    Tenant::RemoteTenant.run_simulation do |s|
-      attrs = {
-        :id => tenant.id,
+    RemoteTenant.run_simulation do |s|
+      s.show(tenant.remote_id, {
+        :id => tenant.remote_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)
+      tenant = Tenant.find_by_remote_id(tenant.remote_id)
       assert_equal unexpected_name, tenant.name
     end
   end
@@ -74,11 +129,10 @@ class RemotableTest < ActiveSupport::TestCase
     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)
+      RemoteTenant.run_simulation do |s|
+        s.show(tenant.remote_id, nil, :status => 404)
         
-        tenant = Tenant.find_by_slug(tenant.slug)
+        tenant = Tenant.find_by_remote_id(tenant.remote_id)
         assert_equal nil, tenant
       end
     end
@@ -90,14 +144,13 @@ class RemotableTest < ActiveSupport::TestCase
     tenant = Factory(:tenant)
     new_name = "Totally Wonky"
     
-    Tenant::RemoteTenant.run_simulation do |s|
-      s.show(nil, {
-        :id => tenant.id,
+    RemoteTenant.run_simulation do |s|
+      s.show(tenant.remote_id, {
+        :id => tenant.remote_id,
         :slug => tenant.slug,
         :church_name => tenant.name
-        }, :path => "/api/accounts/by_slug/#{tenant.slug}.json")
-      
-      s.update(tenant.id)
+      })
+      s.update(tenant.remote_id)
       
       tenant.nosync = false
       tenant.name = "Totally Wonky"
@@ -113,14 +166,13 @@ class RemotableTest < ActiveSupport::TestCase
     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 => {
+    RemoteTenant.run_simulation do |s|
+      s.show(tenant.remote_id, {
+        :id => tenant.remote_id,
+        :slug => tenant.slug,
+        :church_name => tenant.name
+      })
+      s.update(tenant.remote_id, :status => 422, :body => {
         :errors => {:church_name => ["is already taken"]}
       })
       
@@ -141,7 +193,7 @@ class RemotableTest < ActiveSupport::TestCase
       :name => "Brand New"
     })
     
-    Tenant::RemoteTenant.run_simulation do |s|
+    RemoteTenant.run_simulation do |s|
       s.create({
         :id => 143,
         :slug => tenant.slug,
@@ -160,7 +212,7 @@ class RemotableTest < ActiveSupport::TestCase
       :name => "Brand New"
     })
     
-    Tenant::RemoteTenant.run_simulation do |s|
+    RemoteTenant.run_simulation do |s|
       s.create({
         :errors => {
           :what => ["ever"],
@@ -180,14 +232,13 @@ class RemotableTest < ActiveSupport::TestCase
   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)
+    RemoteTenant.run_simulation do |s|
+      s.show(tenant.remote_id, {
+        :id => tenant.remote_id,
+        :slug => tenant.slug,
+        :church_name => tenant.name
+      })
+      s.destroy(tenant.remote_id)
       
       tenant.nosync = false
       tenant.destroy
@@ -199,14 +250,14 @@ class RemotableTest < ActiveSupport::TestCase
   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")
+    RemoteTenant.run_simulation do |s|
+      s.show(tenant.remote_id, {
+        :id => tenant.remote_id,
+        :slug => tenant.slug,
+        :church_name => tenant.name
+      })
       
-      s.destroy(tenant.id, :status => 500)
+      s.destroy(tenant.remote_id, :status => 500)
       
       tenant.nosync = false
       assert_raises(ActiveResource::ServerError) do

data/test/support/active_resource.rb

@@ -1,32 +1,43 @@
-require 'active_record'
-require 'active_resource'
+require "active_record"
+require "active_resource"
+
+
+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"
+end
 
 class Tenant < ActiveRecord::Base
-  include Remotable
+  remote_model RemoteTenant
+  attr_remote :slug, :church_name => :name, :id => :remote_id
+  find_by :slug
+  find_by :name => "by_nombre/:name.json"
+end
+
+
+
+class RemoteTenant2 < ActiveResource::Base
+end
+
+class RemoteWithoutKey < ActiveRecord::Base
+  set_table_name "tenants"
   
-  attr_remote :slug, :church_name => :name, :active_unite_account => :active
-  fetch_with :slug
+  remote_model RemoteTenant2
+  attr_remote :id => :remote_id
+end
+
+
+class RemoteTenant3 < ActiveResource::Base
+end
+
+class RemoteWithKey < ActiveRecord::Base
+  set_table_name "tenants"
   
-  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
+  remote_model RemoteTenant3
+  attr_remote :slug
+  remote_key :slug
 end

data/test/support/schema.rb

@@ -13,12 +13,12 @@
 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.string   "slug"
+    t.string   "name"
+    t.integer  "remote_id"
     t.datetime "created_at"
     t.datetime "updated_at"
-    t.datetime "expires_at"
+    t.datetime "expires_at", :null => false
   end
 
 end

metadata

@@ -2,7 +2,7 @@
 name: remotable
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Robert Lail
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-18 00:00:00 -05:00
+date: 2011-08-26 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -115,7 +115,9 @@ files:
 - Gemfile
 - Rakefile
 - lib/remotable.rb
+- lib/remotable/active_record_extender.rb
 - lib/remotable/active_resource_fixes.rb
+- lib/remotable/adapters/active_resource.rb
 - lib/remotable/core_ext.rb
 - lib/remotable/core_ext/enumerable.rb
 - lib/remotable/version.rb