active_presenter 0.0.1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Daniel Haran, James Golick, GiraffeSoft, Inc.
+
+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

@@ -0,0 +1,75 @@
+= 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:
+
+  $ sudo gem install active_presenter
+
+As a rails gem dependency:
+
+  config.gem 'active_presenter'
+  
+Or get the source from github:
+  
+  $ git clone git://github.com/giraffesoft/active_presenter.git
+  
+(or fork it at http://github.com/giraffesoft/active_presenter)
+    
+== 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
+
+=== 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.
+
+== 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,19 @@
+require 'rake'
+require 'rake/rdoctask'
+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 }
+end
+
+desc 'Generate documentation for the ResourceController 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 'activerecord'
+Dir.glob(File.dirname(__FILE__)+'/active_presenter/**/*.rb').each { |l| require l }
+
+module ActivePresenter
+  NAME = 'active_presenter'
+end

data/lib/active_presenter/base.rb

@@ -0,0 +1,165 @@
+module ActivePresenter
+  # Base class for presenters. See README for usage.
+  #
+  class Base
+    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
+    #
+    #
+    def self.presents(*types)
+      attr_accessor *types
+      
+      types.each do |t|
+        define_method("#{t}_errors") do
+          send(t).errors
+        end
+        
+        presented[t] = t.to_s.classify.constantize
+      end
+    end
+    
+    def self.human_attribute_name(attribute_name)
+      presentable_type = presented.keys.detect do |type|
+        attribute_name.to_s.starts_with?("#{type}_")
+      end
+      
+      attribute_name.to_s.gsub("#{presentable_type}_", "").humanize
+    end
+    
+    attr_accessor :errors
+    
+    # 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 = {})
+      presented.each do |type, klass|
+        send("#{type}=", args[type].is_a?(klass) ? args.delete(type) : klass.new)
+      end
+      
+      self.attributes = args
+    end
+    
+    # Set the attributes of the presentable instances using the type_attribute form (i.e. user_login => 'james')
+    #
+    def attributes=(attrs)
+      attrs.each { |k,v| send("#{k}=", v) }
+    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)
+      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?
+      presented.keys.each do |type|
+        presented_inst = send(type)
+        
+        merge_errors(presented_inst, type) unless presented_inst.valid?
+      end
+      
+      errors.empty?
+    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?
+          saved = presented_instances.map { |i| i.save(false) }.all?
+          raise ActiveRecord::Rollback unless saved # TODO: Does this happen implicitly?
+        end
+      end
+      
+      saved
+    end
+    
+    # Save all of the presentables, by calling each of their save! methods, wrapped in a transaction.
+    #
+    # Returns true on success, will raise otherwise.
+    # 
+    def save!
+      ActiveRecord::Base.transaction do
+        valid? # collect errors before potential exception raise
+        presented_instances.each { |i| i.save! }
+      end
+    end
+    
+    # Update attributes, and save the presentables
+    #
+    # Returns true or false based on success.
+    #
+    def update_attributes(attrs)
+      self.attributes = attrs
+      save
+    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.detect do |type|
+          method_name.to_s.starts_with?(attribute_prefix(type))
+        end
+      end
+    
+      def presented_attribute?(method_name)
+        !presentable_for(method_name).nil?
+      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|
+          errors.add(attribute_prefix(type)+att, msg)
+        end
+      end
+  end
+end

data/lib/active_presenter/version.rb

@@ -0,0 +1,9 @@
+module ActivePresenter
+  module VERSION
+    MAJOR    = 0
+    MINOR    = 0
+    TINY     = 1
+    
+    STRING   = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/tasks/gem.rake

@@ -0,0 +1,62 @@
+require 'rake/gempackagetask'
+
+task :clean => :clobber_package
+
+spec = Gem::Specification.new do |s|
+  s.name                  = ActivePresenter::NAME
+  s.version               = ActivePresenter::VERSION::STRING
+  s.summary               = 
+  s.description           = "ActivePresenter is the presenter library you already know! (...if you know ActiveRecord)"
+  s.author                = "James Golick & Daniel Haran"
+  s.email                 = 'james@giraffesoft.ca'
+  s.homepage              = 'http://jamesgolick.com/active_presenter'
+  s.rubyforge_project     = 'active_presenter'
+  s.has_rdoc              = true
+
+  s.required_ruby_version = '>= 1.8.5'
+
+  s.files                 = %w(README LICENSE Rakefile) +
+                            Dir.glob("{lib,test}/**/*")
+  
+  s.require_path          = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+task :tag_warn do
+  puts "*" * 40
+  puts "Don't forget to tag the release:"
+  puts
+  puts "  git tag -a v#{ActivePresenter::VERSION::STRING}"
+  puts
+  puts "or run rake tag"
+  puts "*" * 40
+end
+
+task :tag do
+  sh "git tag -a v#{ActivePresenter::VERSION::STRING}"
+end
+task :gem => :tag_warn
+
+namespace :gem do  
+  namespace :upload do
+
+    desc 'Upload gems (ruby & win32) to rubyforge.org'
+    task :rubyforge => :gem do
+      sh 'rubyforge login'
+      sh "rubyforge add_release giraffesoft active_presenter #{ActivePresenter::VERSION::STRING} pkg/#{spec.full_name}.gem"
+      sh "rubyforge add_file    giraffesoft active_presenter #{ActivePresenter::VERSION::STRING} pkg/#{spec.full_name}.gem"
+    end
+    
+  end
+end
+
+task :install => [:clobber, :package] do
+  sh "sudo gem install pkg/#{spec.full_name}.gem"
+end
+
+task :uninstall => :clean do
+  sh "sudo gem uninstall -v #{ActivePresenter::VERSION::STRING} -x #{ActivePresenter::NAME}"
+end

data/test/base_test.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+Expectations do
+  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 User do
+    SignupPresenter.new.user
+  end
+  
+  expect User.any_instance.to.receive(:login=).with('james') do
+    SignupPresenter.new(:user_login => 'james')
+  end
+  
+  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 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
+    s.save!
+  end
+  
+  expect User.any_instance.to.receive(:save!) do
+    s = SignupPresenter.new
+    s.save!
+  end
+  
+  expect Account.any_instance.to.receive(:save!) do
+    User.any_instance.stubs(:save!)
+    s = SignupPresenter.new
+    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?(:valid?) # just making sure i didn't break everything :)
+  
+  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
+  
+  # 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
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__)+'/../lib/active_presenter'
+require 'expectations'
+
+ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('sqlite3')
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users do |t|
+    t.boolean :admin,    :default => false
+    t.string  :login,    :default => ''
+    t.string  :password, :default => ''
+  end
+  
+  create_table :accounts do |t|
+    t.string :subdomain, :default => ''
+    t.string :title,     :default => ''
+  end
+end
+
+class User < ActiveRecord::Base
+  validates_presence_of :login, :password
+end
+class Account < ActiveRecord::Base; end
+
+class SignupPresenter < ActivePresenter::Base
+  presents :account, :user
+end
+
+def hash_for_user(opts = {})
+  {:login => 'jane', :password => 'seekrit' }.merge(opts)
+end
+

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: active_presenter
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Golick & Daniel Haran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-27 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: ActivePresenter is the presenter library you already know! (...if you know ActiveRecord)
+email: james@giraffesoft.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- LICENSE
+- Rakefile
+- lib/active_presenter
+- lib/active_presenter/base.rb
+- lib/active_presenter/version.rb
+- lib/active_presenter.rb
+- lib/tasks
+- lib/tasks/gem.rake
+- test/base_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://jamesgolick.com/active_presenter
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.5
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: active_presenter
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: ActivePresenter is the presenter library you already know! (...if you know ActiveRecord)
+test_files: []
+