galetahub-active_presenter 0.1.0

data/README.rdoc

@@ -0,0 +1,86 @@
+= ActivePresenter
+
+ActivePresenter is the presenter library you already know! (...if you know ActiveRecord)
+
+By acting nearly identically to ActiveRecord models, ActivePresenter makes presenters highly approachable to anybody who is already familiar with ActiveRecord.
+
+== Get It
+
+As a gem (Gemfile):
+
+  gem 'active_presenter', :git => 'git://github.com/galetahub/active_presenter.git'
+
+As a rails plugin:
+
+  rails install plugin git://github.com/galetahub/active_presenter.git
+  
+Or get the source from github:
+  
+  $ git clone git://github.com/galetahub/active_presenter.git
+    
+== Usage
+
+Creating a presenter is as simple as subclassing ActivePresenter::Base. Use the presents method to indicate which models the presenter should present.
+
+  class SignupPresenter < ActivePresenter::Base
+    presents :user, :account
+  end
+ 
+In the above example, :user will (predictably) become User. If you want to override this behaviour, specify the desired types in a hash, as so:
+
+  class PresenterWithTwoAddresses < ActivePresenter::Base
+    presents :primary_address => Address, :secondary_address => Address
+  end
+
+=== Instantiation
+
+Then, you can instantiate the presenter using either, or both of two forms. 
+
+For example, if you had a SignupPresenter that presented User, and Account, you could specify arguments in the following two forms:
+  
+  1. SignupPresenter.new(:user_login => 'james', :user_password => 'swordfish', :user_password_confirmation => 'swordfish', :account_subdomain => 'giraffesoft')
+
+    - This form is useful for initializing a new presenter from the params hash: i.e. SignupPresenter.new(params[:signup_presenter])
+    
+  2. SignupPresenter.new(:user => User.find(1), :account => Account.find(2))
+
+    - This form is useful if you have instances that you'd like to edit using the presenter. You can subsequently call presenter.update_attributes(params[:signup_presenter]) just like with a regular AR instance.
+
+Both forms can also be mixed together: SignupPresenter.new(:user => User.find(1), :user_login => 'james'). 
+
+In this case, the login attribute will be updated on the user instance provided.
+ 
+If you don't specify an instance, one will be created by calling Model.new
+
+=== Validation
+  
+The #valid? method will return true or false based on the validity of the presented objects. 
+
+This is calculated by calling #valid? on them.
+
+You can retrieve the errors in two ways. 
+  
+  1. By calling #errors on the presenter, which returns an instance of ActiveRecord::Errors where all the attributes are in type_name_attribute_name form (i.e. You'd retrieve an error on User#login, by calling @presenter.errors.on(:user_login)).
+  
+  2. By calling @presenter.user_errors, or @presenter.user.errors to retrieve the errors from one presentable.
+  
+Both of these methods are compatible with error_messages_for. It just depends whether you'd like to show all the errors in one block, or whether you'd prefer to break them up.
+
+=== Saving
+
+You can save your presenter the same way you'd save an ActiveRecord object. Both #save, and #save! behave the same way they do on a normal AR model.
+
+=== Callbacks
+
+Callbacks work exactly like ActiveRecord callbacks. before_save, and after_save are available.
+
+Note that if any of your after_save callbacks return false, the rest of them will not be run. This is consistent with AR behavior.
+
+== Credits
+
+ActivePresenter was created, and is maintained by {Daniel Haran}[http://danielharan.com] and {James Golick}[http://jamesgolick.com] on the train ride to {RubyFringe}[http://rubyfringe.com] from Montreal.
+
+== License
+
+ActivePresenter is available under the {MIT License}[http://en.wikipedia.org/wiki/MIT_License]
+

data/Rakefile

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the active_presenter plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the active_presenter plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActivePresenter'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/active_presenter.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'active_record'
+
+module ActivePresenter
+  autoload :Base,    'active_presenter/base'
+  autoload :Version, 'active_presenter/version'
+end

data/lib/active_presenter/base.rb

@@ -0,0 +1,282 @@
+module ActivePresenter
+  # Base class for presenters. See README for usage.
+  #
+  class Base
+    extend  ActiveModel::Callbacks
+    extend  ActiveModel::Naming
+    extend  ActiveModel::Translation
+    
+    include ActiveModel::Conversion
+    include ActiveModel::MassAssignmentSecurity
+
+    attr_reader :errors
+    
+    define_model_callbacks :validation, :save
+    
+    class_inheritable_accessor :presented
+    self.presented = {}
+    
+    # Indicates which models are to be presented by this presenter.
+    # i.e.
+    #
+    #   class SignupPresenter < ActivePresenter::Base
+    #     presents :user, :account
+    #   end
+    #  
+    # In the above example, :user will (predictably) become User. If you want to override this behaviour, specify the desired types in a hash, as so:
+    #
+    #   class PresenterWithTwoAddresses < ActivePresenter::Base
+    #     presents :primary_address => Address, :secondary_address => Address
+    #   end
+    #
+    class << self
+      def presents(*types)
+        types_and_classes = types.extract_options!
+        types.each { |t| types_and_classes[t] = t.to_s.tableize.classify.constantize }
+
+        attr_accessor *types_and_classes.keys
+        
+        types_and_classes.keys.each do |t|
+          define_method("#{t}_errors") do
+            send(t).errors
+          end
+          
+          presented[t] = types_and_classes[t]
+        end
+      end
+      
+      def human_attribute_name(attribute_key_name, options = {})
+        presentable_type = presented.keys.detect do |type|
+          attribute_key_name.to_s.starts_with?("#{type}_") || attribute_key_name.to_s == type.to_s
+        end
+        attribute_key_name_without_class = attribute_key_name.to_s.gsub("#{presentable_type}_", "")
+        
+        if presented[presentable_type] and attribute_key_name_without_class != presentable_type.to_s
+          presented[presentable_type].human_attribute_name(attribute_key_name_without_class, options)
+        else
+          I18n.translate(presentable_type, options.merge(:default => presentable_type.to_s.humanize, :scope => [:activerecord, :models]))
+        end
+      end
+      
+      # Since ActivePresenter does not descend from ActiveRecord, we need to
+      # mimic some ActiveRecord behavior in order for the ActiveRecord::Errors
+      # object we're using to work properly.
+      #
+      # This problem was introduced with Rails 2.3.4.
+      # Fix courtesy http://gist.github.com/191263
+      def self_and_descendants_from_active_record # :nodoc:
+        [self]
+      end
+      
+      def human_name(options = {}) # :nodoc:
+        defaults = self_and_descendants_from_active_record.map do |klass|
+          :"#{klass.name.underscore}"
+        end 
+        defaults << self.name.humanize
+        I18n.translate(defaults.shift, {:scope => [:activerecord, :models], :count => 1, :default => defaults}.merge(options))
+      end
+    end
+    
+    # Accepts arguments in two forms. For example, if you had a SignupPresenter that presented User, and Account, you could specify arguments in the following two forms:
+    #
+    #   1. SignupPresenter.new(:user_login => 'james', :user_password => 'swordfish', :user_password_confirmation => 'swordfish', :account_subdomain => 'giraffesoft')
+    #     - This form is useful for initializing a new presenter from the params hash: i.e. SignupPresenter.new(params[:signup_presenter])
+    #   2. SignupPresenter.new(:user => User.find(1), :account => Account.find(2))
+    #     - This form is useful if you have instances that you'd like to edit using the presenter. You can subsequently call presenter.update_attributes(params[:signup_presenter]) just like with a regular AR instance.
+    #
+    # Both forms can also be mixed together: SignupPresenter.new(:user => User.find(1), :user_login => 'james')
+    #   In this case, the login attribute will be updated on the user instance provided.
+    # 
+    # If you don't specify an instance, one will be created by calling Model.new
+    #
+    def initialize(args = {})
+      @errors = ActiveModel::Errors.new(self)
+      return self unless args
+      presented.each do |type, klass|
+        value = args.delete(type)
+        send("#{type}=", value.is_a?(klass) ? value : klass.new)
+      end
+      self.attributes = args
+    end
+
+    # Set the attributes of the presentable instances using
+    # the type_attribute form (i.e. user_login => 'james'), or
+    # the multiparameter attribute form (i.e. {user_birthday(1i) => "1980", user_birthday(2i) => "3"})
+    #
+    def attributes=(attrs)
+      return if attrs.nil?
+
+      attrs = attrs.stringify_keys      
+      multi_parameter_attributes = {}
+      
+      sanitize_for_mass_assignment(attrs).each do |k,v|
+        if (base_attribute = k.to_s.split("(").first) != k.to_s
+          presentable = presentable_for(base_attribute)
+          multi_parameter_attributes[presentable] ||= {}
+          multi_parameter_attributes[presentable].merge!(flatten_attribute_name(k,presentable).to_sym => v)
+        else
+          send("#{k}=", v) unless attribute_protected?(k)
+        end
+      end
+      
+      multi_parameter_attributes.each do |presentable,multi_attrs|
+        send(presentable).send(:attributes=, multi_attrs)
+      end
+    end
+    
+    # Makes sure that the presenter is accurate about responding to presentable's attributes, even though they are handled by method_missing.
+    #
+    def respond_to?(method, include_private = false)
+      presented_attribute?(method) || super
+    end
+    
+    # Handles the decision about whether to delegate getters and setters to presentable instances.
+    #
+    def method_missing(method_name, *args, &block)
+      presented_attribute?(method_name) ? delegate_message(method_name, *args, &block) : super
+    end
+    
+    # Returns boolean based on the validity of the presentables by calling valid? on each of them.
+    #
+    def valid?
+      validated = false
+      errors.clear
+      result = _run_validation_callbacks do
+        presented.each do |type, klass|
+          presented_inst = (send(type) || klass.new)
+          next unless save?(type, presented_inst)
+          merge_errors(presented_inst, type) unless presented_inst.valid?
+        end
+        validated = true
+      end
+      errors.empty? && validated
+    end
+    
+    # Do any of the attributes have unsaved changes?
+    def changed?
+      presented_instances.map(&:changed?).any?
+    end
+    
+    # Save all of the presentables, wrapped in a transaction.
+    # 
+    # Returns true or false based on success.
+    #
+    def save(options={})
+      saved = false
+      ActiveRecord::Base.transaction do
+        if !perform_validations?(options) || (perform_validations?(options) && valid?)
+          _run_save_callbacks do
+            saved = presented.keys.select {|key| save?(key, send(key))}.all? {|key| send(key).save}
+            raise ActiveRecord::Rollback unless saved
+          end
+        end
+      end
+      saved
+    end
+    
+    # Save all of the presentables wrapped in a transaction.
+    #
+    # Returns true on success, will raise otherwise.
+    # 
+    def save!(options={})
+      saved = false
+      ActiveRecord::Base.transaction do
+        raise ActiveRecord::RecordInvalid.new(self) if perform_validations?(options) && !valid?
+        _run_save_callbacks do
+          presented.keys.select {|key| save?(key, send(key))}.all? {|key| send(key).save!}
+          saved = true
+        end
+      raise ActiveRecord::RecordNotSaved.new(self) unless saved
+      end
+      saved
+    end
+    
+    # Update attributes, and save the presentables
+    #
+    # Returns true or false based on success.
+    #
+    def update_attributes(attrs)
+      self.attributes = attrs
+      save
+    end
+    
+    # Should this presented instance be saved?  By default, this returns true
+    # Called from #save and #save!
+    #
+    # For
+    #  class SignupPresenter < ActivePresenter::Base
+    #    presents :account, :user
+    #  end
+    #
+    # #save? will be called twice:
+    #  save?(:account, #<Account:0x1234dead>)
+    #  save?(:user, #<User:0xdeadbeef>)
+    def save?(presented_key, presented_instance)
+      true
+    end
+
+    # We define #id and #new_record? to play nice with form_for(@presenter) in Rails
+    def id # :nodoc:
+      nil
+    end
+
+    def new_record?
+      presented_instances.map(&:new_record?).all?
+    end
+    
+    def persisted?
+      presented_instances.map(&:persisted?).all?
+    end
+
+    protected
+      def presented_instances
+        presented.keys.map { |key| send(key) }
+      end
+      
+      def delegate_message(method_name, *args, &block)
+        presentable = presentable_for(method_name)
+        send(presentable).send(flatten_attribute_name(method_name, presentable), *args, &block)
+      end
+      
+      def presentable_for(method_name)
+        presented.keys.sort_by { |k| k.to_s.size }.reverse.detect do |type|
+          method_name.to_s.starts_with?(attribute_prefix(type))
+        end
+      end
+    
+      def presented_attribute?(method_name)
+        p = presentable_for(method_name)
+        !p.nil? && send(p).respond_to?(flatten_attribute_name(method_name,p))
+      end
+      
+      def flatten_attribute_name(name, type)
+        name.to_s.gsub(/^#{attribute_prefix(type)}/, '')
+      end
+      
+      def attribute_prefix(type)
+        "#{type}_"
+      end
+      
+      def merge_errors(presented_inst, type)
+        presented_inst.errors.each do |att,msg|
+          if att == :base
+            errors.add(type, msg)
+          else
+            errors.add(attribute_prefix(type)+att.to_s, msg)
+          end
+        end
+      end
+      
+      def attribute_protected?(name)
+        presentable    = presentable_for(name)
+        return false unless presentable
+        #remove_att... normally takes a hash, so we use a ''
+        flat_attribute = {flatten_attribute_name(name, presentable) => ''}
+        presented[presentable].new.send(:sanitize_for_mass_assignment, flat_attribute).empty?
+      end
+      
+      def perform_validations?(options={})
+        options[:validate] != false
+      end
+  end
+end

data/lib/active_presenter/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module ActivePresenter
+  VERSION = "0.1.0".freeze
+end

data/test/base_test.rb

@@ -0,0 +1,362 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+Expectations do
+  expect nil do
+    SignupPresenter.new.id
+  end
+
+  expect true do
+    SignupPresenter.new.new_record?
+  end
+
+  expect :user => User, :account => Account do
+    SignupPresenter.presented
+  end
+
+  expect User.create!(hash_for_user) do |u|
+    SignupPresenter.new(:user => u.expected).user
+  end
+
+  expect true do
+    SignupPresenter.new(:user => nil).user.new_record?
+  end
+
+  expect User do
+    SignupPresenter.new.user
+  end
+
+  expect User.any_instance.to.receive(:login=).with('james') do
+    SignupPresenter.new(:user_login => 'james')
+  end
+
+  # admin= should be protected from mass assignment
+  expect SignupPresenter.new.to.be.attribute_protected?(:user_admin)
+  expect SignupPresenter.new(:user_admin => true).user.not.to.be.admin?
+
+  expect 'mymockvalue' do
+    User.any_instance.stubs(:login).returns('mymockvalue')
+    SignupPresenter.new.user_login
+  end
+
+  expect User.any_instance.to.receive(:login=).with('mymockvalue') do
+    SignupPresenter.new.user_login = 'mymockvalue'
+  end
+
+  expect SignupPresenter.new.not.to.be.valid?
+  expect SignupPresenter.new(:user => User.new(hash_for_user)).to.be.valid?
+
+  expect ActiveRecord::Errors do
+    s = SignupPresenter.new
+    s.valid?
+    s.errors
+  end
+
+  expect ActiveRecord::Errors do
+    s = SignupPresenter.new
+    s.valid?
+    s.user_errors
+  end
+
+  expect ActiveRecord::Errors do
+    s = SignupPresenter.new
+    s.valid?
+    s.account_errors
+  end
+
+  expect String do
+    s = SignupPresenter.new
+    s.valid?
+    s.errors.on(:user_login)
+  end
+
+  expect "can't be blank" do
+    s = SignupPresenter.new
+    s.valid?
+    s.errors.on(:user_login)
+  end
+
+  expect ["User Password can't be blank"] do
+    s = SignupPresenter.new(:user_login => 'login')
+    s.valid?
+    s.errors.full_messages
+  end
+
+  expect 'c4N n07 83 8L4nK' do
+    old_locale = I18n.locale
+    I18n.locale = '1337'
+    
+    s = SignupPresenter.new(:user_login => nil)
+    s.valid?
+    message = s.errors.on(:user_login)
+    
+    I18n.locale = old_locale
+    
+    message
+  end
+
+  expect ['U53R pa22w0rD c4N n07 83 8L4nK'] do
+    old_locale = I18n.locale
+    I18n.locale = '1337'
+    
+    s = SignupPresenter.new(:user_login => 'login')
+    s.valid?
+    message = s.errors.full_messages
+    
+    I18n.locale = old_locale
+    
+    message
+  end
+
+  expect ActiveRecord::Base.to.receive(:transaction) do
+    s = SignupPresenter.new
+    s.save
+  end
+
+  expect User.any_instance.to.receive(:save) do
+    s = SignupPresenter.new :user => User.new(hash_for_user)
+    s.save
+  end
+
+  expect Account.any_instance.to.receive(:save) do
+    s = SignupPresenter.new :user => User.new(hash_for_user)
+    s.save
+  end
+
+  expect SignupPresenter.new.not.to.be.save
+
+  expect ActiveRecord::Rollback do
+    ActiveRecord::Base.stubs(:transaction).yields
+    User.any_instance.stubs(:save).returns(false)
+    Account.any_instance.stubs(:save).returns(false)
+    s = SignupPresenter.new :user => User.new(hash_for_user)
+    s.save
+  end
+
+  expect ActiveRecord::Base.to.receive(:transaction) do
+    s = SignupPresenter.new(:user_login => "da", :user_password => "seekrit")
+    s.save!
+  end
+
+  expect User.any_instance.to.receive(:save!) do
+    s = SignupPresenter.new(:user_login => "da", :user_password => "seekrit")
+    s.save!
+  end
+
+  expect Account.any_instance.to.receive(:save!) do
+    User.any_instance.stubs(:save!)
+    s = SignupPresenter.new(:user_login => "da", :user_password => "seekrit")
+    s.save!
+  end
+
+  expect ActiveRecord::RecordInvalid do
+    SignupPresenter.new.save!
+  end
+
+  expect SignupPresenter.new(:user => User.new(hash_for_user)).to.be.save!
+
+  expect SignupPresenter.new.to.be.respond_to?(:user_login)
+  expect SignupPresenter.new.to.be.respond_to?(:user_password_confirmation)
+  expect SignupPresenter.new.to.be.respond_to?(:valid?) # just making sure i didn't break everything :)
+  expect SignupPresenter.new.to.be.respond_to?(:nil?, false) # making sure it's possible to pass 2 arguments
+
+  expect User.create!(hash_for_user).not.to.be.login_changed? do |user|
+    s = SignupPresenter.new(:user => user)
+    s.update_attributes :user_login => 'Something Totally Different'
+  end
+
+  expect SignupPresenter.new(:user => User.create!(hash_for_user)).to.receive(:save) do |s|
+    s.update_attributes :user_login => 'Something'
+  end
+
+  expect 'Something Different' do
+    s = SignupPresenter.new
+    s.update_attributes :user_login => 'Something Different'
+    s.user_login
+  end
+  
+  # Multiparameter assignment
+  expect Time.parse('March 27 1980 9:30:59 am') do
+    s = SignupPresenter.new
+    s.update_attributes({
+      :"user_birthday(1i)" => '1980',
+      :"user_birthday(2i)" => '3',
+      :"user_birthday(3i)" => '27',
+      :"user_birthday(4i)" => '9',
+      :"user_birthday(5i)" => '30',
+      :"user_birthday(6i)" => '59'
+    })
+    s.user_birthday
+  end
+
+  expect nil do
+    s = SignupPresenter.new
+    s.attributes = nil
+  end
+  
+  # this is a regression test to make sure that _title is working. we had a weird conflict with using String#delete
+  expect 'something' do
+    s = SignupPresenter.new :account_title => 'something'
+    s.account_title
+  end
+
+  expect String do
+    s = SignupPresenter.new
+    s.save
+    s.errors.on(:user_login)
+  end
+
+  expect String do
+    s = SignupPresenter.new
+    s.save! rescue
+    s.errors.on(:user_login)
+  end
+
+  expect 'Login' do
+    SignupPresenter.human_attribute_name(:user_login)
+  end
+
+  # it was raising with nil
+  expect SignupPresenter do
+    SignupPresenter.new(nil)
+  end
+  
+  expect EndingWithSPresenter.new.address.not.to.be.nil?
+
+  # this should act as ActiveRecord models do
+  expect NoMethodError do
+    SignupPresenter.new({:i_dont_exist=>"blah"})
+  end
+
+  # ActiveRecord::Base uses nil id to signify an unsaved model
+  expect nil do
+    SignupPresenter.new.id
+  end
+
+  expect nil do
+    returning(SignupPresenter.new(:user => User.new(hash_for_user))) do |presenter|
+      presenter.save!
+    end.id
+  end
+  
+  expect CantSavePresenter.new.not.to.be.save # it won't save because the filter chain will halt
+  
+  expect ActiveRecord::RecordNotSaved do
+    CantSavePresenter.new.save!
+  end
+  
+  expect 'Some Street' do
+    p = AfterSavePresenter.new
+    p.save
+    p.address.street
+  end
+  
+  expect 'Some Street' do
+    p = AfterSavePresenter.new
+    p.save!
+    p.address.street
+  end
+  
+  expect SamePrefixPresenter.new.to.be.respond_to?(:account_title)
+  expect SamePrefixPresenter.new.to.be.respond_to?(:account_info_info)
+
+  expect [:before_validation, :before_save, :after_save] do
+    returning(CallbackOrderingPresenter.new) do |presenter|
+      presenter.save!
+    end.steps
+  end
+
+  expect [:before_validation, :before_save] do
+    returning(CallbackCantSavePresenter.new) do |presenter|
+      presenter.save
+    end.steps
+  end
+
+  expect [:before_validation, :before_save] do
+    returning(CallbackCantSavePresenter.new) do |presenter|
+      begin
+        presenter.save!
+      rescue ActiveRecord::RecordNotSaved
+        # NOP
+      end
+    end.steps
+  end
+
+  expect ActiveRecord::RecordNotSaved do
+    CallbackCantSavePresenter.new.save!
+  end
+
+  expect ActiveRecord::RecordInvalid do
+    CallbackCantValidatePresenter.new.save!
+  end
+
+  expect [:before_validation] do
+    returning(CallbackCantValidatePresenter.new) do |presenter|
+      begin
+        presenter.save!
+      rescue ActiveRecord::RecordInvalid
+        # NOP
+      end
+    end.steps
+  end
+
+  expect [:before_validation] do
+    returning(CallbackCantValidatePresenter.new) do |presenter|
+      presenter.save
+    end.steps
+  end
+
+  expect ActiveRecord::Errors.any_instance.to.receive(:clear).twice do
+    CallbackCantValidatePresenter.new.valid?
+  end
+
+  # this should act as ActiveRecord models do
+  expect NoMethodError do
+    SignupPresenter.new({:i_dont_exist=>"blah"})
+  end
+
+  expect false do
+    SignupNoAccountPresenter.new.save
+  end
+
+  expect true do
+    SignupNoAccountPresenter.new(:user => User.new(hash_for_user), :account => nil).save
+  end
+
+  expect true do
+    SignupNoAccountPresenter.new(:user => User.new(hash_for_user), :account => nil).save!
+  end
+
+  expect Address do
+    PresenterWithTwoAddresses.new.secondary_address
+  end
+  
+  expect "123 awesome st" do
+    p = PresenterWithTwoAddresses.new(:secondary_address_street => "123 awesome st")
+    p.save
+    p.secondary_address_street
+  end
+  
+  # attr_protected
+  expect "" do
+    p = SignupPresenter.new(:account_secret => 'swordfish')
+    p.account.secret
+  end
+  
+  expect "comment" do
+    p = HistoricalPresenter.new(:history_comment => 'comment', :user => User.new(hash_for_user))
+    p.save
+    p.history_comment
+  end
+  
+  expect false do
+    SignupPresenter.new.changed?
+  end
+  
+  expect true do
+    p = SignupPresenter.new(:user => User.new(hash_for_user))
+    p.save
+    p.user_login = 'something_else'
+    p.changed?
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,218 @@
+require File.dirname(__FILE__)+'/../lib/active_presenter' unless defined?(ActivePresenter)
+require 'expectations'
+require 'logger'
+
+ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('sqlite3')
+
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.logger.level = Logger::WARN
+
+I18n.backend.store_translations '1337',
+  :activerecord => {
+    :models => {
+      :user => 'U53R'
+    },
+    :attributes => {
+      :user => {:password => 'pa22w0rD'}
+    },
+    :errors => {
+      :messages => {
+        :blank => 'c4N n07 83 8L4nK'
+      }
+    }
+  }
+  
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users do |t|
+    t.boolean  :admin,    :default => false
+    t.string   :login,    :default => ''
+    t.string   :password, :default => ''
+    t.datetime :birthday
+  end
+  
+  create_table :accounts do |t|
+    t.string :subdomain, :default => ''
+    t.string :title,     :default => ''
+    t.string :secret,    :default => ''
+  end
+  
+  create_table :addresses do |t|
+    t.string :street
+  end
+
+  create_table :account_infos do |t|
+    t.string :info
+  end
+  
+  create_table :histories do |t|
+    t.integer  :user_id
+    t.string   :comment,   :default => ''
+    t.string   :action,    :default => ''
+    t.datetime :created_at
+  end
+  
+end
+
+class User < ActiveRecord::Base
+  validates_presence_of :login
+  validate :presence_of_password
+  attr_accessible :login, :password, :birthday
+  attr_accessor   :password_confirmation
+
+  def presence_of_password
+    if password.blank?
+      attribute_name = I18n.t(:password, {:default => "Password", :scope => [:activerecord, :attributes, :user]})
+      error_message = I18n.t(:blank, {:default => "can't be blank", :scope => [:activerecord, :errors, :messages]})
+      errors.add_to_base("#{attribute_name} #{error_message}")
+    end
+  end
+end
+class Account < ActiveRecord::Base; end
+class History < ActiveRecord::Base; end
+class Address < ActiveRecord::Base; end
+class AccountInfo < ActiveRecord::Base; end
+
+class PresenterWithTwoAddresses < ActivePresenter::Base
+  presents :address, :secondary_address => Address
+end
+
+class SignupPresenter < ActivePresenter::Base
+  presents :account, :user
+  attr_protected :account_secret
+end
+
+class EndingWithSPresenter < ActivePresenter::Base
+  presents :address
+end
+
+class HistoricalPresenter < ActivePresenter::Base
+  presents :user, :history  
+  attr_accessible :history_comment
+end
+
+class CantSavePresenter < ActivePresenter::Base
+  presents :address
+  
+  before_save :halt
+  
+  def halt; false; end
+end
+
+class SignupNoAccountPresenter < ActivePresenter::Base
+  presents :account, :user
+
+  def save?(key, instance)
+    key != :account
+  end
+end
+
+class AfterSavePresenter < ActivePresenter::Base
+  presents :address
+  
+  after_save :set_street
+  
+  def set_street
+    address.street = 'Some Street'
+  end
+end
+
+class SamePrefixPresenter < ActivePresenter::Base
+  presents :account, :account_info
+end
+
+class CallbackOrderingPresenter < ActivePresenter::Base
+  presents :account
+  
+  before_validation :do_before_validation
+  before_save :do_before_save
+  after_save :do_after_save
+  
+  attr_reader :steps
+  
+  def initialize(params={})
+    super
+    @steps = []
+  end
+  
+  def do_before_validation
+    @steps << :before_validation
+  end
+  
+  def do_before_save
+    @steps << :before_save
+  end
+  
+  def do_after_save
+    @steps << :after_save
+  end
+end
+
+class CallbackCantSavePresenter < ActivePresenter::Base
+  presents :account
+  
+  before_validation :do_before_validation
+  before_save :do_before_save
+  before_save :halt
+  after_save :do_after_save
+  
+  attr_reader :steps
+  
+  def initialize(params={})
+    super
+    @steps = []
+  end
+  
+  def do_before_validation
+    @steps << :before_validation
+  end
+  
+  def do_before_save
+    @steps << :before_save
+  end
+  
+  def do_after_save
+    @steps << :after_save
+  end
+
+  def halt
+    false
+  end
+end
+
+class CallbackCantValidatePresenter < ActivePresenter::Base
+  presents :account
+  
+  before_validation :do_before_validation
+  before_validation :halt
+  before_save :do_before_save
+  after_save :do_after_save
+  
+  attr_reader :steps
+  
+  def initialize(params={})
+    super
+    @steps = []
+  end
+  
+  def do_before_validation
+    @steps << :before_validation
+  end
+  
+  def do_before_save
+    @steps << :before_save
+  end
+  
+  def do_after_save
+    @steps << :after_save
+  end
+
+  def halt
+    false
+  end
+end
+
+def hash_for_user(opts = {})
+  {:login => 'jane', :password => 'seekrit' }.merge(opts)
+end
+

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: galetahub-active_presenter
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- James Golick
+- Daniel Haran
+- Igor Galeta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: ActivePresenter is the presenter library you already know! (...if you know ActiveRecord)
+email: galeta.igor@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/active_presenter/base.rb
+- lib/active_presenter/version.rb
+- lib/active_presenter.rb
+- Rakefile
+- README.rdoc
+- test/base_test.rb
+- test/test_helper.rb
+homepage: https://github.com/galetahub/active_presenter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: active_presenter
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: ActivePresenter is the presenter library
+test_files: 
+- test/base_test.rb
+- test/test_helper.rb