remotable 0.3.0 → 0.4.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55fd48684b48f738a160bce22e85c08a8bf206be
-  data.tar.gz: 8b157f2ee0ea3e3baf10de49391a22ceebe3459e
+  metadata.gz: 50bbb2463866bea7de985bdc5375aaac0b7c715b
+  data.tar.gz: ee16e4675c4c3c8a7cd4420e9180a0d532575a80
 SHA512:
-  metadata.gz: 08d450f3c0efde8b23c84a75135576293715df063657d608730ad6ad3f175082f1edf8c116ff8a92f9e5c50ee6693bee9fcf72b6854a6f3d4db63d6dabcb1ead
-  data.tar.gz: 5c89a432fa32638f8e28fc1e08e784dd059fb7d506bed8dec03d104be0c166f3b26df528804023f278f3d1550c1437d200f0864fa04904663b9a1cd6cdfeecb9
+  metadata.gz: 32767f6332fe922693bf2265c7dff1b73b916c491800e792b44e4d4104050335fcf562a5c729bf1ba9f1306d3bf14d2a0590e4211c98de7bf22a0f4a7865d26f
+  data.tar.gz: 46c8039a5195b3a629761798b359c228ce8448caa72b59686402182f17ea70773fe8191ee5c80fcd13a3cd8af9ebbf73947ae4c53317ceef78fa4fa9ae730d46

data/.gitignore

@@ -2,4 +2,5 @@
 .bundle
 pkg/*
 coverage
+tmp/*
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    remotable (0.3.0)
+    remotable (0.4.0.beta2)
       activerecord
       activeresource
       activesupport
@@ -123,3 +123,6 @@ DEPENDENCIES
   simplecov
   sqlite3
   turn
+
+BUNDLED WITH
+   1.10.6

data/README.mdown

@@ -71,15 +71,15 @@ If you must look up a remote model with more than one attribute, you can express
 
 For `:id` or whatever you chose to be the remote key, Remotable will create a finder method on the ActiveRecord model. These finders will _first_ look in the local database for the requested record and, if it isn't found, look for the resource remotely. If a finder finds the resource remotely, it creates a local copy and returns that.
 
-You can create additional finder with the `find_by` method:
+You can create additional finder with the `fetch_with` method:
 
     class Tenant < ActiveRecord::Base
       remote_model RemoteTenant
       attr_remote :slug,
                   :customer_name => :name,
                   :id => :remote_id
-      find_by :slug
-      find_by :name
+      fetch_with :slug
+      fetch_with :name
     end
 
 Remotable will create the following methods and assume the URI for the custom finders from the attribute. The example above will create the following methods:
@@ -90,18 +90,18 @@ Remotable will create the following methods and assume the URI for the custom fi
 
 Note that the finder methods are named with the _local_ attributes.
 
-You can specify a custom path with the `find_by` method:
+You can specify a custom path with the `fetch_with` method:
 
     class Tenant < ActiveRecord::Base
       remote_model RemoteTenant
       attr_remote :slug,
                   :customer_name => :name,
                   :id => :remote_id
-      find_by :name, :path => "by_nombre/:name"
+      fetch_with :name, :path => "by_nombre/:name"
     end
 
 
-When you use `find_by`, give the name of the _local_ attribute not the remote one (if they differ). Also, the name of the symbolic part of the path should match the local attribute name as well.
+When you use `fetch_with`, give the name of the _local_ attribute not the remote one (if they differ). Also, the name of the symbolic part of the path should match the local attribute name as well.
 
 ### Expiration
 

data/lib/remotable.rb

@@ -36,27 +36,27 @@ require "remotable/logger_wrapper"
 module Remotable
   extend Nosync
   extend ValidateModels
-  
+
   # By default, Remotable will validate the models you
   # supply it via +remote_model+. You can set validate_models
   # to false to skip this validation. It is recommended that
   # you keep validation on in development and test environments,
   # but turn it off in production.
   self.validate_models = true
-  
+
   # Logger
   def self.logger; @logger ||= LoggerWrapper.new(FakeLogger.new); end
   def self.logger=(logger); @logger = LoggerWrapper.new(logger); end
-  
+
   class << self
     attr_accessor :log_level
     Remotable.log_level = :debug
   end
-  
-  
-  
+
+
+
   # == remote_model( model [optional] )
-  # 
+  #
   # When called without arguments, this method returns
   # the remote model connected to this local ActiveRecord
   # model.
@@ -68,7 +68,7 @@ module Remotable
   # of these API consumers:
   #
   #  * ActiveResource
-  # 
+  #
   # <tt>model</tt> can be any object that responds
   # to these two methods for getting a resource:
   #
@@ -78,7 +78,7 @@ module Remotable
   #      If it takes one argument, it will be passed path.
   #      If it takes two, it will be passed remote_attr and value.
   #  * (Optional) +find_by_for_local(local_record, remote_key, fetch_value)+
-  # 
+  #
   # Resources must respond to:
   #
   #  * +save+ (return true on success and false on failure)
@@ -89,20 +89,20 @@ module Remotable
   def remote_model(*args)
     if args.length >= 1
       @remote_model = args.first
-      
+
       @__remotable_included ||= begin
         require "remotable/active_record_extender"
         include Remotable::ActiveRecordExtender
         true
       end
-      
+
       extend_remote_model(@remote_model) if @remote_model
     end
     @remote_model
   end
-  
-  
-  
+
+
+
   def with_remote_model(model)
     if block_given?
       begin
@@ -116,50 +116,51 @@ module Remotable
       WithRemoteModelProxy.new(self, model)
     end
   end
-  
-  
-  
+
+
+
   REQUIRED_CLASS_METHODS = [:find_by, :new_resource]
   REQUIRED_INSTANCE_METHODS = [:save, :errors, :destroy]
-  
+
   class InvalidRemoteModel < ArgumentError; end
-  
+
   class FakeLogger
-    
+
     def write(s)
       puts s
     end
-    
+
     alias :debug :write
     alias :info :write
     alias :warn :write
     alias :error :write
-    
+
   end
-  
-  
+
+
   def self.http_format_time(time)
+    return "" unless time
     time.utc.strftime("%a, %e %b %Y %H:%M:%S %Z")
   end
-  
-  
-  
+
+
+
 private
-  
+
   def extend_remote_model(remote_model)
     if remote_model.is_a?(Class) and (remote_model < ActiveResource::Base)
       require "remotable/adapters/active_resource"
       remote_model.send(:include, Remotable::Adapters::ActiveResource)
-    
+
     #
     # Adapters for other API consumers can be implemented here
     #
-    
+
     else
       assert_that_remote_model_meets_api_requirements!(remote_model) if Remotable.validate_models?
     end
   end
-  
+
   def assert_that_remote_model_meets_api_requirements!(model)
     unless model.respond_to_all?(REQUIRED_CLASS_METHODS)
       raise InvalidRemoteModel,
@@ -173,7 +174,7 @@ private
         "because it does not define these methods: #{instance.does_not_respond_to(REQUIRED_INSTANCE_METHODS).join(", ")}."
     end
   end
-  
+
 end
 
 

data/lib/remotable/active_record_extender.rb

@@ -8,23 +8,23 @@ module Remotable
   module ActiveRecordExtender
     extend ActiveSupport::Concern
     include Nosync
-    
+
     def nosync?
       return super if nosync_value?
       self.class.nosync?
     end
-    
-    
-    
+
+
+
     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 :initialize_expiration_date, :on => :create
-      
+
       validates_presence_of :expires_at
-      
+
       @remote_attribute_map ||= default_remote_attributes.map_to_self
       @local_attribute_routes ||= {}
       @expires_after ||= 1.day
@@ -37,18 +37,18 @@ module Remotable
         :destroy => 2  # when we're destroying a remote resource
       }
     end
-    
-    
-    
+
+
+
     module ClassMethods
       include Nosync
-      
+
       def nosync?
         return true if remote_model.nil?
         return super if nosync_value?
         Remotable.nosync?
       end
-      
+
       # Sets the key with which a resource is identified remotely.
       # If no remote key is set, the remote key is assumed to be :id.
       # Which could be explicitly set like this:
@@ -68,34 +68,34 @@ module Remotable
         if args.any?
           remote_key = args.shift
           options = args.shift || {}
-          
+
           # remote_key may be a composite of several attributes
           # ensure that all of the attributs have been defined
           Array.wrap(remote_key).each do |attribute|
             raise(":#{attribute} is not the name of a remote attribute") unless remote_attribute_names.member?(attribute)
           end
-          
+
           # Set up a finder method for the remote_key
           fetch_with(local_key(remote_key), options)
-          
+
           @remote_key = remote_key
         else
           @remote_key || generate_default_remote_key
         end
       end
-      
+
       def expires_after(*args)
         @expires_after = args.first if args.any?
         @expires_after
       end
-      
+
       def attr_remote(*attrs)
         map = attrs.extract_options!
         map = attrs.map_to_self.merge(map)
         @remote_attribute_map = map
         @local_attribute_routes = {} # reset routes
       end
-      
+
       def remote_timeout(*args)
         if args.any?
           @remote_timeout = n = args.first
@@ -103,17 +103,16 @@ module Remotable
         end
         @remote_timeout
       end
-      
+
       def fetch_with(local_key, options={})
         @local_attribute_routes.merge!(local_key => options[:path])
       end
-      alias :find_by :fetch_with
-      
-      
-      
+
+
+
       attr_reader :remote_attribute_map,
                   :local_attribute_routes
-      
+
       def local_key(remote_key=nil)
         remote_key ||= self.remote_key
         if remote_key.is_a?(Array)
@@ -122,28 +121,28 @@ module Remotable
           local_attribute_name(remote_key)
         end
       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(remote_key)
         local_key = self.local_key(remote_key)
         local_attribute_routes[local_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)
         if remote_key.to_s == primary_key
@@ -152,9 +151,9 @@ module Remotable
           "by_#{local_key}/:#{local_key}"
         end
       end
-      
-      
-      
+
+
+
       # !nb: this method is called when associations are loaded
       # so you can use the remoted record in associations.
       def instantiate(*args)
@@ -163,87 +162,101 @@ module Remotable
           begin
             Remotable.logger.debug "[remotable:#{name.underscore}:instantiate](#{record.fetch_value.inspect}) expired #{record.expires_at}"
             record.pull_remote_data!
-            record = nil if record.destroyed?
           rescue Remotable::TimeoutError
             report_ignored_timeout_error($!)
+          rescue Remotable::NetworkError
+            report_ignored_network_error($!)
           rescue Remotable::ServiceUnavailableError
             report_ignored_503_error($!)
           end
         end
         record
       end
-      
+
       def report_ignored_timeout_error(error)
         Remotable.logger.error "[remotable:#{name.underscore}:instantiate] #{error.message}"
       end
-      
+
+      def report_ignored_network_error(error)
+        Remotable.logger.error "[remotable:#{name.underscore}:instantiate] #{error.message}"
+      end
+
       def report_ignored_503_error(error)
         Remotable.logger.error "[remotable:#{name.underscore}:instantiate] #{error.message}"
       end
-      
-      
-      
+
+
+
       # !todo: create these methods on an anonymous module and mix it in
-      
+
       def respond_to?(method_sym, include_private=false)
         return true if recognize_remote_finder_method(method_sym)
         super(method_sym, include_private)
       end
-      
-      def method_missing(method_sym, *args, &block)
+
+      def method_missing(method_sym, *values, &block)
         method_details = recognize_remote_finder_method(method_sym)
-        if method_details
-          local_attributes = method_details[:local_attributes]
-          values = args
-          
-          unless values.length == local_attributes.length
-            raise ArgumentError, "#{method_sym} was called with #{values.length} but #{local_attributes.length} was expected"
-          end
-          
-          local_resource = ((0...local_attributes.length).inject(self) do |scope, i|
-            scope.where(local_attributes[i] => values[i])
-          end).first || fetch_by(method_details[:remote_key], *values)
-          
-          raise ActiveRecord::RecordNotFound if local_resource.nil? && (method_sym =~ /!$/)
-          local_resource
-        else
-          super(method_sym, *args, &block)
-        end
+        return super(method_sym, *values, &block) unless method_details
+
+        local_attributes = method_details[:local_attributes]
+        raise ArgumentError, "#{method_sym} was called with #{values.length} but #{local_attributes.length} was expected" unless values.length == local_attributes.length
+
+        local_resource = __remotable_lookup(method_details[:remote_key], local_attributes, values)
+        local_resource = nil if local_resource && local_resource.destroyed?
+        raise ActiveRecord::RecordNotFound if local_resource.nil? && (method_sym =~ /!$/)
+        local_resource
+      end
+
+      def __remotable_lookup(key, local_attributes, values)
+        __remotable_local_lookup(local_attributes, values) || fetch_by(key, *values)
+      rescue ActiveRecord::RecordNotUnique
+        __remotable_local_lookup(local_attributes, values)
+      end
+
+      def __remotable_local_lookup(local_attributes, values)
+        (0...local_attributes.length)
+          .inject(self) { |scope, i| scope.where(local_attributes[i] => values[i]) }
+          .limit(1).first
       end
-      
+
       # If the missing method IS a Remotable finder method,
       # returns the remote key (may be a composite key).
       # Otherwise, returns false.
       def recognize_remote_finder_method(method_sym)
         method_name = method_sym.to_s
         return false unless method_name =~ /find_by_([^!]*)(!?)/
-        
+
         local_attributes = $1.split("_and_").map(&:to_sym)
         remote_attributes = local_attributes.map(&method(:remote_attribute_name))
-        
+
         local_key, remote_key = if local_attributes.length == 1
           [local_attributes[0], remote_attributes[0]]
         else
           [local_attributes, remote_attributes]
         end
-        
+
         generate_default_remote_key # <- Make sure we've figured out the remote
                                     #    primary key if we're evaluating a finder
-        
+
         return false unless local_attribute_routes.key?(local_key)
-        
+
         { :local_attributes => local_attributes,
           :remote_key => remote_key }
       end
-      
-      
-      
+
+
+
       def expire_all!
-        update_all(["expires_at=?", 1.day.ago])
+        update_all(expires_at: 1.day.ago)
       end
-      
-      
-      
+
+      def sync_all!
+        expire_all!
+        all.to_a
+      end
+
+
+
       # Looks the resource up remotely, by the given attribute
       # If the resource is found, wraps it in a new local resource
       # and returns that.
@@ -251,11 +264,11 @@ module Remotable
         remote_resource = find_remote_resource_by(remote_attr, *values)
         remote_resource && new_from_remote(remote_resource)
       end
-      
+
       def find_remote_resource_by(remote_attr, *values)
         invoke_remote_model_find_by(remote_attr, *values)
       end
-      
+
       def find_remote_resource_for_local_by(local_resource, remote_attr, *values)
         if remote_model.respond_to?(:find_by_for_local)
           invoke_remote_model_find_by_for_local(local_resource, remote_attr, *values)
@@ -263,10 +276,10 @@ module Remotable
           invoke_remote_model_find_by(remote_attr, *values)
         end
       end
-      
+
       def invoke_remote_model_find_by(remote_attr, *values)
         remote_set_timeout :fetch
-        
+
         find_by = remote_model.method(:find_by)
         case find_by.arity
         when 1; find_by.call(remote_path_for(remote_attr, *values))
@@ -275,10 +288,10 @@ module Remotable
           raise InvalidRemoteModel, "#{remote_model}.find_by should take either 1 or 2 parameters"
         end
       end
-      
+
       def invoke_remote_model_find_by_for_local(local_resource, remote_attr, *values)
         remote_set_timeout :pull
-        
+
         find_by_for_local = remote_model.method(:find_by_for_local)
         case find_by_for_local.arity
         when 2; find_by_for_local.call(local_resource, remote_path_for(remote_attr, *values))
@@ -287,57 +300,57 @@ module Remotable
           raise InvalidRemoteModel, "#{remote_model}.find_by_for_local should take either 2 or 3 parameters"
         end
       end
-      
-      
-      
+
+
+
       def remote_path_for(remote_key, *values)
         route = route_for(remote_key)
         local_key = self.local_key(remote_key)
-        
+
         if remote_key.is_a?(Array)
           remote_path_for_composite_key(route, local_key, values)
         else
           remote_path_for_simple_key(route, local_key, values.first)
         end
       end
-      
+
       def remote_path_for_simple_key(route, local_key, value)
-        route.gsub(/:#{local_key}/, value.to_s)
+        route.gsub(/:#{local_key}/, URI.escape(value.to_s))
       end
-      
+
       def remote_path_for_composite_key(route, local_key, values)
         values.flatten!
         unless values.length == local_key.length
           raise ArgumentError, "local_key has #{local_key.length} attributes but values has #{values.length}"
         end
-        
+
         (0...values.length).inject(route) do |route, i|
-          route.gsub(/:#{local_key[i]}/, values[i].to_s)
+          route.gsub(/:#{local_key[i]}/, URI.escape(values[i].to_s))
         end
       end
-      
-      
-      
+
+
+
       def all_by_remote
         find_by_remote_query(:all)
       end
-      
+
       def find_by_remote_query(remote_method_name, *args)
         remote_set_timeout :list
         remote_resources = Array.wrap(remote_model.send(remote_method_name, *args))
         map_remote_resources_to_local(remote_resources)
       end
-      
+
       def map_remote_resources_to_local(remote_resources)
         return [] if remote_resources.nil? || remote_resources.empty?
-        
+
         local_resources = nosync { fetch_corresponding_local_resources(remote_resources).to_a }
-        
+
         # Ensure a corresponding local resource for
         # each remote resource; return the set of
         # local resources.
         remote_resources.map do |remote_resource|
-          
+
           # Get the specific local resource that
           # corresponds to this remote one.
           local_resource = local_resources.detect { |local_resource|
@@ -346,7 +359,7 @@ module Remotable
               local_resource.send(local_attr) == remote_resource[remote_attr]
             }
           }
-          
+
           # If a local counterpart to this remote value
           # exists, update the local resource and return it.
           # If not, create a local counterpart and return it.
@@ -358,47 +371,47 @@ module Remotable
           end
         end
       end
-      
+
       def fetch_corresponding_local_resources(remote_resources)
         conditions = Array.wrap(remote_key).each_with_object({}) do |remote_attr, query|
           local_attr = local_attribute_name(remote_attr)
           query[local_attr] = remote_resources.map { |resource| resource[remote_attr] }
         end
-        
+
         where(conditions)
       end
-      
-      
-      
+
+
+
     private
-      
+
       def remote_set_timeout(mode)
         remote_model.timeout = remote_timeout[mode] if remote_model.respond_to?(:timeout=)
       end
-      
-      
+
+
       def default_remote_attributes
         column_names - %w{id created_at updated_at expires_at}
       end
-      
-      
+
+
       def generate_default_remote_key
         return @remote_key if @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,
@@ -409,23 +422,23 @@ module Remotable
              :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 accepts_not_modified?
-      respond_to?(:updated_at)
+      respond_to?(:remote_updated_at)
     end
-    
-    
-    
+
+
+
     def pull_remote_data!
       if remote_resource
         merge_remote_data!(remote_resource)
@@ -433,19 +446,19 @@ module Remotable
         remote_model_has_been_destroyed!
       end
     end
-    
-    
-    
+
+
+
     def remote_resource
       @remote_resource ||= fetch_remote_resource
     end
-    
+
     def any_remote_changes?
       (changed.map(&:to_sym) & local_attribute_names).any?
     end
-    
-    
-    
+
+
+
     def fetch_value
       if local_key.is_a?(Array)
         local_key.map(&method(:send))
@@ -453,42 +466,42 @@ module Remotable
         send(local_key)
       end
     end
-    
-    
-    
+
+
+
   private
-    
+
     def fetch_remote_resource
       fetch_value && find_remote_resource_by(remote_key, fetch_value)
     end
-    
+
     def find_remote_resource_by(remote_key, fetch_value)
       result = nil
       ms = Benchmark.ms do
         result = self.class.find_remote_resource_for_local_by(self, remote_key, fetch_value)
       end
-      Remotable.logger.info "[remotable:#{self.class.name.underscore}:find_remote_resource_by](#{fetch_value.inspect}) %.1fms" % [ ms ]
+      Remotable.logger.info "[remotable:#{self.class.name.underscore}:find_remote_resource_by](#{fetch_value.inspect})" << " %.1fms" % [ ms ]
       result
     end
-    
+
     def merge_remote_data!(remote_resource)
       merge_remote_data(remote_resource)
       reset_expiration_date
       nosync { save! }
       self
     end
-    
+
     def remote_model_has_been_destroyed!
       Remotable.logger.info "[remotable:#{self.class.name.underscore}:remote_model_has_been_destroyed!](#{fetch_value.inspect})"
       nosync { destroy }
     end
-    
-    
-    
+
+
+
     def update_remote_resource
       if any_remote_changes? && remote_resource
         merge_local_data(remote_resource, true)
-        
+
         remote_set_timeout :update
         if remote_resource.save
           merge_remote_data!(remote_resource)
@@ -498,27 +511,27 @@ module Remotable
         end
       end
     end
-    
+
     def create_remote_resource
       @remote_resource = remote_model.new_resource
       merge_local_data(@remote_resource)
-      
+
       remote_set_timeout :create
       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
       return nil unless remote_resource
-      
+
       remote_set_timeout :destroy
       if remote_resource.destroy
         true
@@ -526,30 +539,36 @@ module Remotable
         merge_remote_errors(remote_resource.errors)
         false
       end
+    rescue Remotable::NotFound
+      report_ignored_404_on_destroy $!
     end
-    
-    
-    
+
+
+
     def initialize_expiration_date
       reset_expiration_date unless self.expires_at
     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 report_ignored_404_on_destroy(error)
+      Remotable.logger.error "[remotable:#{self.class.name.underscore}:destroy] #{error.message}"
+    end
+
     def merge_remote_errors(errors)
       Remotable.logger.debug "[remotable:#{self.class.name.underscore}:merge_remote_errors](#{fetch_value.inspect}) #{errors.inspect}"
       errors.each do |attribute, messages|
@@ -559,7 +578,7 @@ module Remotable
       end
       self
     end
-    
+
     def merge_remote_data(remote_resource)
       remote_attribute_map.each do |remote_attr, local_attr|
         if remote_resource.key?(remote_attr)
@@ -568,9 +587,10 @@ module Remotable
           send("#{local_attr}=", remote_value)
         end
       end
+      self.remote_updated_at = Time.now if respond_to?(:remote_updated_at=)
       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)
@@ -581,14 +601,14 @@ module Remotable
       end
       self
     end
-    
-    
-    
+
+
+
   private
-    
+
     def remote_set_timeout(mode)
       self.class.send :remote_set_timeout, mode
     end
-    
+
   end
 end