attr_remote 0.0.7

data/LICENSE

@@ -0,0 +1,7 @@
+(The 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.rdoc

@@ -0,0 +1,69 @@
+= attr_remote - Painlessly integrate ActiveResource into ActiveRecord.
+
+== Why?
+
+ActiveResource is cool, but it's is a pain to integrate with ActiveRecord. Want to have_many :my_active_resource? Nope. Also, you can't front any ActiveResource classes with a form. Want to use form_for? Sorry. Want validations? No dice.
+
+== How does attr_remote help?
+
+It allows you to hide an ActiveResource behind ActiveRecord, which means you can (sort of) have all the things you want, but can't with vanilla ActiveResource. Essentially, ActiveRecord becomes a proxy for ActiveResource.
+
+== Okay, show me some code.
+
+    # attr_remote requires an integer attribute remote_<class>_id for 
+    # the local ActiveRecord to store the ActiveResource ID
+    #
+    # For instance,
+    #
+    # create_table :users do |t|
+    #   t.integer :remote_user_id
+    #   t.integer :group_id
+    # end
+    class User
+      attr_remote :first_name, :last_name, :email, :password
+    
+      belongs_to :group
+      has_many :posts
+  
+  
+      validates_length_of :first_name, :within => 1..30
+      validates_length_of :last_name, :within => 1..30
+      validates_presence_of :email
+      validates_presence_of :password, :on => :create
+    end
+  
+    # The configuration behind the scenes:
+    #
+    # attr_remote assumes that there is an ActiveResource class 
+    # with a Remote prefix
+    class RemoteUser < ActiveResource::Base
+      self.site = "https://myservice.com/"
+      self.element_name = "user"
+    end
+
+With the above code, you can now CRUD (well, not delete yet) a User, and it will do all the right stuff behind the scenes with the remote resource. It even caches the remote instance the first time a remote attribute is read.
+
+Want to use form_for? No problem. It works since you're really interacting with ActiveRecord and _not_ ActiveResource. Cool. Validations? Yep. Just don't do validates_uniqueness_of. :)
+
+== Install
+    
+    $ gem sources -a http://gems.github.com
+    $ sudo gem install codebrulee-attr_remote
+
+== Any issues/TODOs?
+
+* Delete isn't implemented yet.
+* No support for validates_uniqueness_of.
+* attr_remote declarations create a reader and writer. There isn't support for just reading or writing.
+* Not all of the ActiveRecord methods do what you might expect. For instance, ActiveRecord::Base#reload doesn't delegate to ActiveResource yet, which means the locally cached instance isn't reloaded.
+* Hook the caching into something like ActiveSupport::Cache::Store
+
+== License
+
+(The 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/attr_remote.gemspec

@@ -0,0 +1,31 @@
+Gem::Specification.new do |s|
+  s.name     = "attr_remote"
+  s.version  = "0.0.7"
+  s.date     = "2008-01-06"
+  s.summary  = "Painlessly integrate ActiveResource into ActiveRecord."
+  s.email    = "smithk14@gmail.com"
+  s.homepage = "http://github.com/codebrulee/attr_remote"
+  s.description = "Painlessly integrate ActiveResource into ActiveRecord."
+  s.has_rdoc = true
+  s.authors  = ["Kevin Smith"]
+  s.files    = [
+  	"README.rdoc",
+  	"attr_remote.gemspec",
+    "LICENSE",
+    "lib/attr_remote.rb"
+  ]
+  
+  s.test_files = [
+    "test/test_attr_remote.rb",
+    "test/helper.rb",
+    "test/factories.rb",
+    "test/db/test.db",
+    "test/models/bob.rb",
+    "test/models/remote_bob.rb",
+    "test/models/user.rb",
+    "test/models/remote_user.rb",
+  ]
+
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.extra_rdoc_files = ["README.rdoc"]
+end

data/lib/attr_remote.rb

@@ -0,0 +1,191 @@
+require 'active_record'
+require 'active_support'
+require 'active_resource'
+
+module AttrRemote
+  module ClassMethods
+    
+    def remote_attributes
+      @remote_attributes ||= []
+    end
+    
+    def attr_remote(*remote_attrs)
+      remote_class = "Remote#{self.to_s}"
+      remote_instance_meth = remote_class.underscore
+      remote_instance_id = remote_class.foreign_key
+      
+      remote_attributes.concat(remote_attrs).uniq!
+    
+      class_eval <<-remote_access, __FILE__, __LINE__+1
+  # def remote_user
+  #   if @remote_user
+  #     @remote_user
+  #   elsif self.remote_user_id
+  #     @remote_user = RemoteUser.find(self.remote_user_id) rescue nil
+  #   else
+  #     nil
+  #   end
+  # end
+    def #{remote_instance_meth}
+      if @#{remote_instance_meth}
+        @#{remote_instance_meth}
+      elsif self.#{remote_instance_id}
+        @#{remote_instance_meth} = #{remote_class}.find(self.#{remote_instance_id}) rescue nil
+      else
+        nil
+      end
+    end
+  
+  # before_create :create_remote_user
+    before_create :create_#{remote_instance_meth}
+  
+  # def create_remote_user
+  #   unless self.remote_user_id
+  #     remote_hash = {}
+  #     self.class.remote_attributes.each do |attr|
+  #       remote_hash[attr.to_sym] = self.send(attr.to_sym)
+  #     end
+  #     remote_hash[:validate_only] = true if validate_only
+  #     @remote_user = RemoteUser.create(remote_hash)
+  #     
+  #     unless @remote_user.valid?
+  #       @remote_user.errors.each do |attr, err|
+  #         errors.add(attr, err)
+  #       end
+  #       return false
+  #     else
+  #       self.remote_user_id = @remote_user.id
+  #     end
+  #   end
+  # end
+    def create_#{remote_instance_meth}
+      unless self.#{remote_instance_id}
+        remote_hash = {}
+        self.class.remote_attributes.each do |attr|
+          remote_hash[attr.to_sym] = self.send(attr.to_sym)
+        end
+        @#{remote_instance_meth} = #{remote_class}.create(remote_hash)
+        
+        unless @#{remote_instance_meth}.valid?
+          @#{remote_instance_meth}.errors.each do |attr, err|
+            errors.add(attr, err)
+          end
+          return false
+        else
+          self.#{remote_instance_id} = @#{remote_instance_meth}.id
+        end
+      end
+    end
+    private :create_#{remote_instance_meth}
+    
+  # validate_on_create :validate_remote_user_on_create
+    validate_on_create :validate_#{remote_instance_meth}_on_create
+    
+  # def validate_remote_user_on_create; end  
+    def validate_#{remote_instance_meth}_on_create; end
+    
+  # before_update :update_remote_user  
+    before_update :update_#{remote_instance_meth}
+    
+  # def update_remote_user
+  #   if self.remote_user_id and self.remote_attributes_changed?
+  #     remote_hash = {}
+  #     self.class.remote_attributes.each do |attr|
+  #       remote_hash[attr.to_sym] = self.send(attr.to_sym)
+  #     end
+  #     remote_user.load(remote_hash)
+  #     remote_user.save
+  #     
+  #     unless @#{remote_instance_meth}.valid?
+  #       remote_user.errors.each do |attr, err|
+  #         errors.add(attr, err)
+  #       end
+  #       return false
+  #     else
+  #       @remote_attributes_changed = false
+  #       return true
+  #     end
+  #   end
+  # end
+    def update_#{remote_instance_meth}
+      if self.#{remote_instance_id} and self.remote_attributes_changed?
+        remote_hash = {}
+        self.class.remote_attributes.each do |attr|
+          remote_hash[attr.to_sym] = self.send(attr.to_sym)
+        end
+        #{remote_instance_meth}.load(remote_hash)
+        #{remote_instance_meth}.save
+        
+        unless @#{remote_instance_meth}.valid?
+          #{remote_instance_meth}.errors.each do |attr, err|
+            errors.add(attr, err)
+          end
+          return false
+        else
+          @remote_attributes_changed = false
+          return true
+        end
+      end
+    end
+    private :update_#{remote_instance_meth}
+    
+  # validate_on_update :validate_remote_user_on_update
+    validate_on_update :validate_#{remote_instance_meth}_on_update
+    
+  # def validate_remote_user_on_update; end  
+    def validate_#{remote_instance_meth}_on_update; end
+remote_access
+
+      remote_attributes.each do |attr|      
+        class_eval <<-remote_attribute, __FILE__, __LINE__+1
+  def #{attr}                             # def username
+    remote_#{attr} || ''                  #   remote_username || ''
+  end                                     # end
+
+  def remote_#{attr}                      # def remote_username
+    if @#{attr}                           #   if @username
+      @#{attr}                            #     @username
+    elsif self.#{remote_instance_meth}    #   elsif self.remote_user
+      @#{attr} = self.                    #     @username = self.
+                 #{remote_instance_meth}. #                 remote_user.
+                 #{attr} rescue nil       #                 username rescue nil
+    else                                  #   else
+      nil                                 #     nil
+    end                                   #   end
+  end                                     # end
+
+  def #{attr}=(attr_value)                # def username=(attr_value)
+    @#{attr} = attr_value                 #   @username = attr_value
+    @remote_attributes_changed = true     #   @remote_attributes_changed = true
+  end                                     # end
+remote_attribute
+      end
+    end
+  end
+  
+  module InstanceMethods
+    def self.included(base)
+      base.alias_method_chain :save, :dirty_remote
+      base.alias_method_chain :save!, :dirty_remote
+    end
+    
+    def remote_attributes_changed?
+      @remote_attributes_changed == true
+    end
+    
+    def save_with_dirty_remote(*args) #:nodoc:
+      if status = save_without_dirty_remote(*args)
+        @remote_attributes_changed = false
+      end
+      status
+    end
+    def save_with_dirty_remote!(*args) #:nodoc:
+      status = save_without_dirty_remote!(*args)
+      @remote_attributes_changed = false
+      status
+    end
+  end
+end
+
+ActiveRecord::Base.extend AttrRemote::ClassMethods
+ActiveRecord::Base.send(:include, AttrRemote::InstanceMethods)

data/test/factories.rb

@@ -0,0 +1,8 @@
+Factory.sequence :remote_user_id do |n|
+  n
+end
+
+Factory.define :user do |u|
+  u.name "Kevin"
+  u.remote_user_id { Factory.next(:remote_user_id) }
+end

data/test/helper.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'rubygems'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'attr_remote')
+require 'active_resource/http_mock'
+
+Dir['**/models/*.rb'].each do |model|
+  require model
+end
+
+require 'redgreen'
+require 'context'
+require 'factory_girl'
+
+ActiveRecord::Base.establish_connection({
+  :adapter => 'sqlite3', 
+  :dbfile => File.dirname(__FILE__) + '/db/test.db'
+})
+
+class Test::Unit::TestCase
+  def mock_user(user)
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get "/users/#{user.remote_user_id}.xml", {}, {
+        :id => user.remote_user_id,
+        :name => user.name
+      }.to_xml(:root => "user")
+      mock.put "/users/#{user.remote_user_id}.xml", {}, '', 200, {}
+    end
+  end
+  
+  
+  def teardown
+    # cleanup all our test data
+    User.delete_all
+    Bob.delete_all
+  end
+end

data/test/models/bob.rb

@@ -0,0 +1,9 @@
+class Bob < ActiveRecord::Base
+  validates_presence_of :title
+  
+  attr_remote :email, :foo
+  
+  def validate_remote_bob_on_create
+    errors.add(:foo, "has already been taken") if foo == "taken"
+  end
+end

data/test/models/remote_bob.rb

@@ -0,0 +1,4 @@
+class RemoteBob < ActiveResource::Base
+  self.site = "http://0.0.0.0:3000/"
+  self.element_name = "bob"
+end

data/test/models/remote_user.rb

@@ -0,0 +1,4 @@
+class RemoteUser < ActiveResource::Base
+  self.site = "http://0.0.0.0:3000/"
+  self.element_name = "user"
+end

data/test/models/user.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  attr_remote :name
+  attr_remote :not_here
+end

data/test/test_attr_remote.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestAttrRemote < Test::Unit::TestCase
+  context "general specs" do
+    test "that attributes can be added multiple times" do
+      assert_equal User.remote_attributes, [:name, :not_here]
+    end
+    
+    test "that a remote hit isn't attempted if the local remote id is nil" do
+      user = User.new
+      assert_nil user.remote_user_id
+      assert_nil user.remote_user
+      assert_equal "", user.name
+    end
+  end
+  
+  context "remote object access" do
+    before do
+      mock_user(@user = Factory(:user, :name => "Kevin"))
+    end
+    test "that an instance should have a method for the remote object" do
+      assert @user.respond_to?(:remote_user)
+    end
+    test "that the remote object should be looked up based on the id" do
+      assert_equal "Kevin", @user.remote_user.name
+    end
+  end
+  
+  context "reading" do
+    test "that an instance should have a read method for the attribute" do
+      user = Factory(:user)
+      assert user.respond_to?(:name)
+    end
+    
+    test "that the read method returns the correct value" do
+      user = Factory(:user)
+      assert_equal "Kevin", user.name
+    end
+    
+    test "that after first read, an instance variable contains the value" do
+      mock_user(user = Factory(:user))
+      expected_name = user.name
+      
+      user = User.find(user.id)
+      assert_nil user.instance_variable_get('@name')
+      user.name
+      assert_equal "Kevin", user.instance_variable_get('@name')
+    end
+    
+    test "that an attribute will be empty if the remote side does not exist" do
+      user = Factory.build(:user, :remote_user_id => 666, :name => nil)
+      assert_equal '', user.name
+    end
+    
+    test "that an attribute that is not readable returns an empty string" do
+      user = Factory(:user)
+      user = User.find(user.id)
+      assert_equal '', user.not_here
+    end
+  end
+  
+  context "creation" do
+    test "that an instance should have a writer method for the attribute" do
+      user = Factory(:user)
+      assert user.respond_to?(:name=)
+    end
+    test "that an instance reads correctly after writing" do
+      user = Factory.build(:user, :name => "test")
+      assert_equal "test", user.name
+    end
+    test "that the remote object id is set after creation" do
+      user = Factory.build(:user, :remote_user_id => nil)
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.post "/users.xml", {}, {
+          :name => user.name
+        }.to_xml(:root => "user"), 200, {
+          'Location' => 'http://0.0.0.0:3000/users/1'
+        }
+      end
+      assert user.save
+      assert_not_nil user.remote_user_id
+    end
+    
+    test "that remote errors halt save process" do
+      bob = Bob.new(:title => "title")
+      assert !bob.save
+      assert_not_nil bob.errors.on(:email)
+    end
+    
+    test "that failure of local validations halts remote creation and therefore remote errors do not show up" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.post "/bobs.xml", 
+                  {}, 
+                  returning(ActiveRecord::Errors.new(Bob.new)) { |errors|
+                    errors.add(:email, "can't be blank")
+                  }.to_xml, 422
+      end
+      bob = Bob.create(:title => nil)
+      assert !bob.save
+      assert_not_nil bob.errors.on(:title)
+      assert_nil bob.errors.on(:email)
+    end
+    
+    test "that after a successful creation an instance is marked as not having any remote changes" do
+      user = Factory(:user, :remote_user_id => 2)
+      assert !user.remote_attributes_changed?
+    end
+  end
+  
+  context "updates" do
+    test "that a remote attribute change is propogated" do
+      mock_user(user = Factory(:user))
+      user.name = "boo"
+      assert user.save
+      mock_user(user)
+      user = User.find(user.id)
+      assert_equal "boo", user.name
+    end
+    
+    test "that after a successful update an instance is marked as not having any remote changes" do
+      user = Factory(:user)
+      mock_user(user)
+      user.name = "new name"
+      assert user.save
+      assert !user.remote_attributes_changed?
+    end
+    
+    test "that save doesn't cause a remote hit if a remote attribute has not been changed" do
+      user = Factory(:user, :remote_user_id => 2)
+      # purposely not mocking the ARes call to "prove" 
+      # that it isn't invoked on save
+      assert user.save
+    end
+    
+    test "that changing a local attribute does not trigger a remote save" do
+      bob = Bob.new(:remote_bob_id => 3)
+      bob.title = "test"
+      assert bob.save
+    end
+  end
+  
+  context "deletes" do
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: attr_remote
+version: !ruby/object:Gem::Version 
+  version: 0.0.7
+platform: ruby
+authors: 
+- Kevin Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-06 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Painlessly integrate ActiveResource into ActiveRecord.
+email: smithk14@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- attr_remote.gemspec
+- LICENSE
+- lib/attr_remote.rb
+has_rdoc: true
+homepage: http://github.com/codebrulee/attr_remote
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Painlessly integrate ActiveResource into ActiveRecord.
+test_files: 
+- test/test_attr_remote.rb
+- test/helper.rb
+- test/factories.rb
+- test/db/test.db
+- test/models/bob.rb
+- test/models/remote_bob.rb
+- test/models/user.rb
+- test/models/remote_user.rb