active_presenter 1.4.0 → 2.0.0a

data/README

@@ -28,7 +28,7 @@ Creating a presenter is as simple as subclassing ActivePresenter::Base. Use the
     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:
+In the above example, :user will (predictably) become User. If you want to override this behavior, specify the desired types in a hash, as so:
 
   class PresenterWithTwoAddresses < ActivePresenter::Base
     presents :primary_address => Address, :secondary_address => Address
@@ -68,6 +68,15 @@ You can retrieve the errors in two ways.
   
 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.
 
+=== Protected and Accessible Attributes
+
+ActivePresenter supports +attr_protected+ and +attr_accessible+ just like an ActiveRecord object to avoid mass assignment. This can be leveraged to provide an additional layer of protection at the presenter level.
+
+  class AccountPresenter < ActivePresenter::Base
+    presents :user, :profile
+    attr_accessible :user_email, :profile_birthday
+  end
+
 === 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.

data/Rakefile

@@ -1,10 +1,10 @@
 require 'rake'
-require 'rake/rdoctask'
+require 'rdoc/task'
 require File.dirname(__FILE__)+'/lib/active_presenter'
 Dir.glob(File.dirname(__FILE__)+'/lib/tasks/**/*.rake').each { |l| load l }
 
 task :default => :test
 
 task :test do
-  Dir['test/**/*_test.rb'].each { |l| require l }
+  Dir['test/**/*_test.rb'].each { |l| require File.join(File.dirname(__FILE__),l)}
 end

data/lib/active_presenter/base.rb

@@ -2,13 +2,19 @@ module ActivePresenter
   # Base class for presenters. See README for usage.
   #
   class Base
-    include ActiveSupport::Callbacks
-    define_callbacks :before_validation, :before_save, :after_save
-    
+    extend  ActiveModel::Callbacks
+    extend  ActiveModel::Naming
+    extend  ActiveModel::Translation
+    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Conversion
+
+    attr_reader :errors
+
+    define_model_callbacks :validation, :save
+
     class_inheritable_accessor :presented
-    class_inheritable_accessor :attr_protected, :attr_accessible
     self.presented = {}
-    
+
     # Indicates which models are to be presented by this presenter.
     # i.e.
     #
@@ -27,29 +33,29 @@ module ActivePresenter
       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 self.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.
@@ -59,7 +65,7 @@ module ActivePresenter
     def self.self_and_descendants_from_active_record # :nodoc:
       [self]
     end
-    
+
     def self.human_name(options = {}) # :nodoc:
       defaults = self_and_descendants_from_active_record.map do |klass|
         :"#{klass.name.underscore}"
@@ -67,31 +73,7 @@ module ActivePresenter
       defaults << self.name.humanize
       I18n.translate(defaults.shift, {:scope => [:activerecord, :models], :count => 1, :default => defaults}.merge(options))
     end
-    
-    # Note that +attr_protected+ is still applied to the received hash. Thus,
-    # with this technique you can at most _extend_ the list of protected
-    # attributes for a particular mass-assignment call.
-    def self.attr_protected(*attributes)
-      write_inheritable_attribute(:attr_protected, Set.new(attributes.map {|a| a.to_s}) + (protected_attributes || []))
-    end
-    
-    # Returns an array of all the attributes that have been protected from mass-assignment.
-    def self.protected_attributes # :nodoc:
-      read_inheritable_attribute(:attr_protected)
-    end
-    
-    # Note that +attr_accessible+ is still applied to the received hash. Thus,
-    # with this technique you can at most _narrow_ the list of accessible
-    # attributes for a particular mass-assignment call.
-    def self.attr_accessible(*attributes)
-      write_inheritable_attribute(:attr_accessible, Set.new(attributes.map(&:to_s)) + (accessible_attributes || []))
-    end
-    
-    # Returns an array of all the attributes that have been made accessible to mass-assignment.
-    def self.accessible_attributes # :nodoc:
-      read_inheritable_attribute(:attr_accessible)
-    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')
@@ -105,13 +87,12 @@ module ActivePresenter
     # If you don't specify an instance, one will be created by calling Model.new
     #
     def initialize(args = {})
-      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
 
@@ -121,11 +102,11 @@ module ActivePresenter
     #
     def attributes=(attrs)
       return if attrs.nil?
-      
-      attrs = attrs.stringify_keys
+
+      attrs = attrs.stringify_keys      
       multi_parameter_attributes = {}
-      attrs = remove_attributes_protected_from_mass_assignment(attrs)
-      
+      attrs = sanitize_for_mass_assignment(attrs)
+
       attrs.each do |k,v|
         if (base_attribute = k.to_s.split("(").first) != k.to_s
           presentable = presentable_for(base_attribute)
@@ -135,87 +116,79 @@ module ActivePresenter
           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 an instance of ActiveRecord::Errors with all the errors from the presentables merged in using the type_attribute form (i.e. user_login).
-    #
-    def errors
-      @errors ||= ActiveRecord::Errors.new(self)
-    end
-    
+
     # Returns boolean based on the validity of the presentables by calling valid? on each of them.
     #
     def valid?
+      validated = false
       errors.clear
-      if run_callbacks_with_halt(:before_validation)
+      result = _run_validation_callbacks do
         presented.keys.each do |type|
           presented_inst = send(type)
-
           next unless save?(type, presented_inst)
           merge_errors(presented_inst, type) unless presented_inst.valid?
         end
-
-        errors.empty?
+        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
       saved = false
-      
       ActiveRecord::Base.transaction do
-        if valid? && run_callbacks_with_halt(:before_save)
-          saved = presented.keys.select {|key| save?(key, send(key))}.all? {|key| send(key).save}
-          raise ActiveRecord::Rollback unless saved # TODO: Does this happen implicitly?
+        if 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
-
-        run_callbacks_with_halt(:after_save) if saved
       end
-      
       saved
     end
-    
+
     # Save all of the presentables wrapped in a transaction.
     #
     # Returns true on success, will raise otherwise.
     # 
     def save!
-      raise ActiveRecord::RecordInvalid.new(self) unless valid?
-      raise ActiveRecord::RecordNotSaved unless run_callbacks_with_halt(:before_save)
-      
+      saved = false
       ActiveRecord::Base.transaction do
-        presented.keys.select {|key| save?(key, send(key))}.each {|key| send(key).save!}
-
-        run_callbacks_with_halt(:after_save)
+        raise ActiveRecord::RecordInvalid.new(self) unless 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
-
-      true
+      saved
     end
-    
+
     # Update attributes, and save the presentables
     #
     # Returns true or false based on success.
@@ -224,7 +197,7 @@ module ActivePresenter
       self.attributes = attrs
       save
     end
-    
+
     # Should this presented instance be saved?  By default, this returns true
     # Called from #save and #save!
     #
@@ -244,72 +217,61 @@ module ActivePresenter
     def id # :nodoc:
       nil
     end
-    
+
     def new_record?
-      true
+      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, msg)
-          end
-        end
-      end
-      
-      def attribute_protected?(name)
-        presentable    = presentable_for(name)
-        return false unless presentable
-        flat_attribute = {flatten_attribute_name(name, presentable) => ''} #remove_att... normally takes a hash, so we use a ''
-        presented[presentable].new.send(:remove_attributes_protected_from_mass_assignment, flat_attribute).empty?
-      end
-      
-      def run_callbacks_with_halt(callback)
-        run_callbacks(callback) { |result, object| result == false }
+
+    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
-      
-      def remove_attributes_protected_from_mass_assignment(attributes)
-        if self.class.accessible_attributes.nil? && self.class.protected_attributes.nil?
-          attributes
-        elsif self.class.protected_attributes.nil?
-          attributes.reject { |key, value| !self.class.accessible_attributes.include?(key.gsub(/\(.+/, ""))}
-        elsif self.class.accessible_attributes.nil?
-          attributes.reject { |key, value| self.class.protected_attributes.include?(key.gsub(/\(.+/,""))}
+    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
-          raise "Declare either attr_protected or attr_accessible for #{self.class}, but not both."
+          errors.add(attribute_prefix(type)+att.to_s, msg)
         end
       end
-      
+    end
+
+    def attribute_protected?(name)
+      presentable = presentable_for(name)
+      return false unless presentable
+      flat_attribute = {flatten_attribute_name(name, presentable) => ''} #remove_att... normally takes a hash, so we use a ''
+      presented[presentable].new.send(:sanitize_for_mass_assignment, flat_attribute).empty?
+    end
+
   end
 end

data/lib/active_presenter/version.rb

@@ -1,9 +1,10 @@
 module ActivePresenter
   module VERSION
-    MAJOR    = 1
-    MINOR    = 4
+    MAJOR    = 2
+    MINOR    = 0
     TINY     = 0
-    
-    STRING   = [MAJOR, MINOR, TINY].join('.')
+    EXTRA    = "a"
+
+    STRING   = [MAJOR, MINOR, TINY].join('.') + EXTRA
   end
 end

data/lib/tasks/gem.rake

@@ -1,4 +1,4 @@
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
 
 task :clean => :clobber_package
 
@@ -21,7 +21,7 @@ spec = Gem::Specification.new do |s|
   s.require_path          = "lib"
 end
 
-Rake::GemPackageTask.new(spec) do |p|
+Gem::PackageTask.new(spec) do |p|
   p.gem_spec = spec
 end
 

data/test/base_test.rb

@@ -45,34 +45,34 @@ Expectations do
   expect SignupPresenter.new.not.to.be.valid?
   expect SignupPresenter.new(:user => User.new(hash_for_user)).to.be.valid?
 
-  expect ActiveRecord::Errors do
+  expect ActiveModel::Errors do
     s = SignupPresenter.new
     s.valid?
     s.errors
   end
 
-  expect ActiveRecord::Errors do
+  expect ActiveModel::Errors do
     s = SignupPresenter.new
     s.valid?
     s.user_errors
   end
 
-  expect ActiveRecord::Errors do
+  expect ActiveModel::Errors do
     s = SignupPresenter.new
     s.valid?
     s.account_errors
   end
 
-  expect String do
+  expect ["can't be blank"] do
     s = SignupPresenter.new
     s.valid?
-    s.errors.on(:user_login)
+    s.errors[:user_login]
   end
 
-  expect "can't be blank" do
+  expect ["can't be blank"] do
     s = SignupPresenter.new
     s.valid?
-    s.errors.on(:user_login)
+    s.errors[:user_login]
   end
 
   expect ["User Password can't be blank"] do
@@ -81,13 +81,13 @@ Expectations do
     s.errors.full_messages
   end
 
-  expect 'c4N n07 83 8L4nK' do
+  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)
+    message = s.errors[:user_login]
     
     I18n.locale = old_locale
     
@@ -143,7 +143,7 @@ Expectations do
   end
 
   expect Account.any_instance.to.receive(:save!) do
-    User.any_instance.stubs(:save!)
+    User.any_instance.stubs(:save!).returns(true)
     s = SignupPresenter.new(:user_login => "da", :user_password => "seekrit")
     s.save!
   end
@@ -173,7 +173,7 @@ Expectations do
     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
@@ -192,23 +192,23 @@ Expectations 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
+  expect ["can't be blank"] do
     s = SignupPresenter.new
     s.save
-    s.errors.on(:user_login)
+    s.errors[:user_login]
   end
 
-  expect String do
+  expect ["can't be blank"] do
     s = SignupPresenter.new
     s.save! rescue
-    s.errors.on(:user_login)
+    s.errors[:user_login]
   end
 
   expect 'Login' do
@@ -219,7 +219,7 @@ Expectations do
   expect SignupPresenter do
     SignupPresenter.new(nil)
   end
-  
+
   expect EndingWithSPresenter.new.address.not.to.be.nil?
 
   # this should act as ActiveRecord models do
@@ -237,25 +237,25 @@ Expectations do
       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)
 
@@ -305,7 +305,7 @@ Expectations do
     end.steps
   end
 
-  expect ActiveRecord::Errors.any_instance.to.receive(:clear).twice do
+  expect ActiveModel::Errors.any_instance.to.receive(:clear) do
     CallbackCantValidatePresenter.new.valid?
   end
 
@@ -329,34 +329,33 @@ Expectations do
   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/lint_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__)+'/test_helper'
+require 'test/unit'
+
+class LintTest < ActiveModel::TestCase
+  include ActiveModel::Lint::Tests
+ 
+  def setup
+    @model = SignupPresenter.new
+  end
+end

data/test/test_helper.rb

@@ -1,4 +1,3 @@
-require File.dirname(__FILE__)+'/../lib/active_presenter' unless defined?(ActivePresenter)
 require 'expectations'
 require 'logger'
 
@@ -51,7 +50,6 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string   :action,    :default => ''
     t.datetime :created_at
   end
-  
 end
 
 class User < ActiveRecord::Base
@@ -64,12 +62,12 @@ class User < ActiveRecord::Base
     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}")
+      errors[:base] << ("#{attribute_name} #{error_message}")
     end
   end
 end
-class Account < ActiveRecord::Base; end
-class History < ActiveRecord::Base; end
+class Account < ActiveRecord::Base ;end
+class History < ActiveRecord::Base ;end
 class Address < ActiveRecord::Base; end
 class AccountInfo < ActiveRecord::Base; end
 
@@ -86,11 +84,6 @@ 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
   
@@ -103,7 +96,7 @@ class SignupNoAccountPresenter < ActivePresenter::Base
   presents :account, :user
 
   def save?(key, instance)
-    key != :account
+    key.to_sym != :account
   end
 end
 
@@ -212,7 +205,16 @@ class CallbackCantValidatePresenter < ActivePresenter::Base
   end
 end
 
+class HistoricalPresenter < ActivePresenter::Base
+  presents :user, :history  
+  attr_accessible :history_comment
+end
+
 def hash_for_user(opts = {})
   {:login => 'jane', :password => 'seekrit' }.merge(opts)
 end
 
+def returning(value)
+  yield(value)
+  value
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: active_presenter
 version: !ruby/object:Gem::Version 
-  hash: 7
-  prerelease: 
+  hash: 10
+  prerelease: 5
   segments: 
-  - 1
-  - 4
+  - 2
   - 0
-  version: 1.4.0
+  - 0
+  - a
+  version: 2.0.0a
 platform: ruby
 authors: 
 - James Golick & Daniel Haran
@@ -15,7 +16,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-23 00:00:00 Z
+date: 2011-09-26 00:00:00 -07:00
+default_executable: 
 dependencies: []
 
 description: ActivePresenter is the presenter library you already know! (...if you know ActiveRecord)
@@ -36,7 +38,9 @@ files:
 - lib/tasks/doc.rake
 - lib/tasks/gem.rake
 - test/base_test.rb
+- test/lint_test.rb
 - test/test_helper.rb
+has_rdoc: true
 homepage: http://jamesgolick.com/active_presenter
 licenses: []
 
@@ -59,16 +63,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: active_presenter
-rubygems_version: 1.8.10
+rubygems_version: 1.3.9.3
 signing_key: 
 specification_version: 3
 summary: ActivePresenter is the presenter library you already know! (...if you know ActiveRecord)