extended_inherited_resources 0.1.0

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "extended_inherited_resources"
+    gem.summary = "Slightly extended version of josevalim inherited_resources - for rails 2.3"
+    gem.description = ""
+    gem.email = "b.kosmowski@selleo.com"
+    gem.homepage = "http://github.com/stevo/extended_inherited_resources"
+    gem.authors = ["josevalim", "stevo"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "extended_inherited_resources #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/extended_inherited_resources.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{extended_inherited_resources}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["josevalim", "stevo"]
+  s.date = %q{2010-04-22}
+  s.description = %q{}
+  s.email = %q{b.kosmowski@selleo.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "extended_inherited_resources.gemspec",
+     "init.rb",
+     "lib/inherited_resources.rb",
+     "lib/inherited_resources/actions.rb",
+     "lib/inherited_resources/base.rb",
+     "lib/inherited_resources/base_helpers.rb",
+     "lib/inherited_resources/belongs_to_helpers.rb",
+     "lib/inherited_resources/blank_slate.rb",
+     "lib/inherited_resources/class_methods.rb",
+     "lib/inherited_resources/dsl.rb",
+     "lib/inherited_resources/legacy/respond_to.rb",
+     "lib/inherited_resources/legacy/responder.rb",
+     "lib/inherited_resources/locales/en.yml",
+     "lib/inherited_resources/polymorphic_helpers.rb",
+     "lib/inherited_resources/responder.rb",
+     "lib/inherited_resources/singleton_helpers.rb",
+     "lib/inherited_resources/url_helpers.rb",
+     "lib/inherited_resources/version.rb",
+     "test/helper.rb",
+     "test/test_extended_inherited_resources.rb"
+  ]
+  s.homepage = %q{http://github.com/stevo/extended_inherited_resources}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Slightly extended version of josevalim inherited_resources - for rails 2.3}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_extended_inherited_resources.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+require 'inherited_resources'

data/lib/inherited_resources.rb

@@ -0,0 +1,43 @@
+# respond_to is the only file that should be loaded before hand. All others
+# are loaded on demand.
+#
+unless defined?(ActionController::Responder)
+  require 'inherited_resources/legacy/responder'
+  require 'inherited_resources/legacy/respond_to'
+end
+
+require 'responders'
+I18n.load_path.unshift File.expand_path(File.join(File.dirname(__FILE__), 'inherited_resources', 'locales', 'en.yml'))
+
+module InheritedResources
+  ACTIONS = [ :index, :show, :new, :edit, :create, :update, :destroy ] unless self.const_defined?(:ACTIONS)
+
+  autoload :Actions,            'inherited_resources/actions'
+  autoload :Base,               'inherited_resources/base'
+  autoload :BaseHelpers,        'inherited_resources/base_helpers'
+  autoload :BelongsToHelpers,   'inherited_resources/belongs_to_helpers'
+  autoload :ClassMethods,       'inherited_resources/class_methods'
+  autoload :DSL,                'inherited_resources/dsl'
+  autoload :PolymorphicHelpers, 'inherited_resources/polymorphic_helpers'
+  autoload :SingletonHelpers,   'inherited_resources/singleton_helpers'
+  autoload :UrlHelpers,         'inherited_resources/url_helpers'
+  autoload :VERSION,            'inherited_resources/version'
+
+  # Change the flash keys used by FlashResponder.
+  def self.flash_keys=(array)
+    Responders::FlashResponder.flash_keys = array
+  end
+end
+
+class ActionController::Base
+  public :flash, :render
+
+  # If you cannot inherit from InheritedResources::Base you can call
+  # inherit_resource in your controller to have all the required modules and
+  # funcionality included.
+  def self.inherit_resources
+    InheritedResources::Base.inherit_resources(self)
+    initialize_resources_class_accessors!
+    create_resources_url_helpers!
+  end
+end

data/lib/inherited_resources/actions.rb

@@ -0,0 +1,67 @@
+module InheritedResources
+  # Holds all default actions for InheritedResouces.
+  module Actions
+
+    # GET /resources
+    def index(&block)
+      respond_with(*with_chain(collection), &block)
+    end
+    alias :index! :index
+
+    # GET /resources/1
+    def show(&block)
+      respond_with(*with_chain(resource), &block)
+    end
+    alias :show! :show
+
+    # GET /resources/new
+    def new(&block)
+      respond_with(*with_chain(build_resource), &block)
+    end
+    alias :new! :new
+
+    # GET /resources/1/edit
+    def edit(&block)
+      respond_with(*with_chain(resource), &block)
+    end
+    alias :edit! :edit
+
+    # POST /resources
+    def create(options={}, &block)
+      object = build_resource
+
+      if create_resource(object)
+        options[:location] ||= (configured_redirects(:create) || resource_url)  rescue nil
+      end
+
+      respond_with_dual_blocks(object, options, &block)
+    end
+    alias :create! :create
+
+    # PUT /resources/1
+    def update(options={}, &block)
+      object = resource
+
+      if update_resource(object, params[resource_instance_name])
+        options[:location] ||= (configured_redirects(:update) || resource_url) rescue nil
+      end
+
+      respond_with_dual_blocks(object, options, &block)
+    end
+    alias :update! :update
+
+    # DELETE /resources/1
+    def destroy(options={}, &block)
+      object = resource
+      options[:location] ||= collection_url rescue nil
+
+      destroy_resource(object)
+      respond_with_dual_blocks(object, options, &block)
+    end
+    alias :destroy! :destroy
+
+    # Make aliases protected
+    protected :index!, :show!, :new!, :create!, :edit!, :update!, :destroy!
+  end
+end
+

data/lib/inherited_resources/base.rb

@@ -0,0 +1,47 @@
+require 'inherited_resources/blank_slate'
+require 'inherited_resources/responder'
+
+module InheritedResources
+  # = Base
+  #
+  # This is the base class that holds all actions. If you see the code for each
+  # action, they are quite similar to Rails default scaffold.
+  #
+  # To change your base behavior, you can overwrite your actions and call super,
+  # call <tt>default</tt> class method, call <<tt>actions</tt> class method
+  # or overwrite some helpers in the base_helpers.rb file.
+  #
+  class Base < ::ApplicationController
+    unloadable
+
+    # Overwrite inherit_resources to add specific InheritedResources behavior.
+    #
+    def self.inherit_resources(base)
+      base.class_eval do
+        include InheritedResources::Actions
+        include InheritedResources::BaseHelpers
+        extend  InheritedResources::ClassMethods
+        extend  InheritedResources::UrlHelpers
+
+        # Add at least :html mime type
+        respond_to :html
+        self.responder = InheritedResources::Responder
+
+        helper_method :collection_url, :collection_path, :resource_url, :resource_path,
+                      :new_resource_url, :new_resource_path, :edit_resource_url, :edit_resource_path,
+                      :parent_url, :parent_path, :resource, :collection, :resource_class, :association_chain,
+                      :resource_instance_name, :resource_collection_name
+
+        base.with_options :instance_writer => false do |c|
+          c.class_inheritable_accessor :resource_class, :redirects
+          c.class_inheritable_array :parents_symbols
+          c.class_inheritable_hash :resources_configuration
+        end
+
+        protected :resource_class, :parents_symbols, :resources_configuration
+      end
+    end
+
+    inherit_resources(self)
+  end
+end

data/lib/inherited_resources/base_helpers.rb

@@ -0,0 +1,284 @@
+# Whenever base is required load the dumb responder since it's used inside actions.
+require 'inherited_resources/blank_slate'
+
+module InheritedResources
+  # Base helpers for InheritedResource work. Some methods here can be overwriten
+  # and you will need to do that to customize your controllers from time to time.
+  #
+  module BaseHelpers
+
+    protected
+
+    def configured_redirects(for_action)
+
+      case self.class.redirects[for_action.to_sym]
+        when :index then
+          collection_url
+        when :edit then
+          edit_resource_url
+        when :show then
+          resource_url
+        when :root
+          root_url
+      end
+    end
+
+    # This is how the collection is loaded.
+    #
+    # You might want to overwrite this method if you want to add pagination
+    # for example. When you do that, don't forget to cache the result in an
+    # instance_variable:
+    #
+    #   def collection
+    #     @projects ||= end_of_association_chain.paginate(params[:page]).all
+    #   end
+    #
+    def collection
+      get_collection_ivar || set_collection_ivar(end_of_association_chain.find(:all))
+    end
+
+    # This is how the resource is loaded.
+    #
+    # You might want to overwrite this method when you are using permalink.
+    # When you do that, don't forget to cache the result in an
+    # instance_variable:
+    #
+    #   def resource
+    #     @project ||= end_of_association_chain.find_by_permalink!(params[:id])
+    #   end
+    #
+    # You also might want to add the exclamation mark at the end of the method
+    # because it will raise a 404 if nothing can be found. Otherwise it will
+    # probably render a 500 error message.
+    #
+    def resource
+      get_resource_ivar || set_resource_ivar(end_of_association_chain.find(params[:id]))
+    end
+
+    # This method is responsable for building the object on :new and :create
+    # methods. If you overwrite it, don't forget to cache the result in an
+    # instance variable.
+    #
+    def build_resource
+      get_resource_ivar || set_resource_ivar(end_of_association_chain.send(method_for_build, params[resource_instance_name] || {}))
+    end
+
+    # Responsible for saving the resource on :create method. Overwriting this
+    # allow you to control the way resource is saved. Let's say you have a
+    # PassworsController who is responsible for finding an user by email and
+    # sent password instructions for him. Instead of overwriting the entire
+    # :create method, you could do something:
+    #
+    #   def create_resource(object)
+    #     object.send_instructions_by_email
+    #   end
+    #
+    def create_resource(object)
+      object.save
+    end
+
+    # Responsible for updating the resource in :update method. This allow you
+    # to handle how the resource is gona be updated, let's say in a different
+    # way then the usual :update_attributes:
+    #
+    #   def update_resource(object, attributes)
+    #     object.reset_password!(attributes)
+    #   end
+    #
+    def update_resource(object, attributes)
+      object.update_attributes(attributes)
+    end
+
+    # Handle the :destroy method for the resource. Overwrite it to call your
+    # own method for destroing the resource, as:
+    #
+    #   def destroy_resource(object)
+    #     object.cancel
+    #   end
+    #
+    def destroy_resource(object)
+      object.destroy
+    end
+
+    # This class allows you to set a instance variable to begin your
+    # association chain. For example, usually your projects belongs to users
+    # and that means that they belong to the current logged in user. So you
+    # could do this:
+    #
+    #   def begin_of_association_chain
+    #     @current_user
+    #   end
+    #
+    # So every time we instantiate a project, we will do:
+    #
+    #   @current_user.projects.build(params[:project])
+    #   @current_user.projects.find(params[:id])
+    #
+    # The variable set in begin_of_association_chain is not sent when building
+    # urls, so this is never going to happen when calling resource_url:
+    #
+    #   project_url(@current_user, @project)
+    #
+    # If the user actually scopes the url, you should use belongs_to method
+    # and declare that projects belong to user.
+    #
+    def begin_of_association_chain
+      nil
+    end
+
+    # Returns if the controller has a parent. When only base helpers are loaded,
+    # it's always false and should not be overwriten.
+    #
+    def parent?
+      false
+    end
+
+    # Returns the association chain, with all parents (does not include the
+    # current resource).
+    #
+    def association_chain
+      @association_chain ||=
+              symbols_for_association_chain.inject([begin_of_association_chain]) do |chain, symbol|
+                chain << evaluate_parent(symbol, resources_configuration[symbol], chain.last)
+              end.compact.freeze
+    end
+
+    # Overwrite this method to provide other interpolation options when
+    # the flash message is going to be set.
+    #
+    # def interpolation_options
+    #    { }
+    # end
+
+    private
+
+    # Adds the given object to association chain.
+    def with_chain(object)
+      association_chain + [ object ]
+    end
+
+    # Fast accessor to resource_collection_name
+    #
+    def resource_collection_name #:nodoc:
+      self.resources_configuration[:self][:collection_name]
+    end
+
+    # Fast accessor to resource_instance_name
+    #
+    def resource_instance_name #:nodoc:
+      self.resources_configuration[:self][:instance_name]
+    end
+
+    # This methods gets your begin_of_association_chain, join it with your
+    # parents chain and returns the scoped association.
+    #
+    def end_of_association_chain #:nodoc:
+      if chain = association_chain.last
+        if method_for_association_chain
+          apply_scopes_if_available(chain.send(method_for_association_chain))
+        else
+          # This only happens when we specify begin_of_association_chain in
+          # a singletion controller without parents. In this case, the chain
+          # is exactly the begin_of_association_chain which is already an
+          # instance and then not scopable.
+          chain
+        end
+      else
+        apply_scopes_if_available(resource_class)
+      end
+    end
+
+    # Returns the appropriated method to build the resource.
+    #
+    def method_for_build #:nodoc:
+      (begin_of_association_chain || parent?) ? method_for_association_build : :new
+    end
+
+    # Returns the name of the method used for build the resource in cases
+    # where we have a parent. This is overwritten in singleton scenarios.
+    #
+    def method_for_association_build
+      :build
+    end
+
+    # Returns the name of the method to be called, before returning the end
+    # of the association chain. This is overwriten by singleton cases
+    # where no method for association chain is called.
+    #
+    def method_for_association_chain #:nodoc:
+      resource_collection_name
+    end
+
+    # Get resource ivar based on the current resource controller.
+    #
+    def get_resource_ivar #:nodoc:
+      instance_variable_get("@#{resource_instance_name}")
+    end
+
+    # Set resource ivar based on the current resource controller.
+    #
+    def set_resource_ivar(resource) #:nodoc:
+      instance_variable_set("@#{resource_instance_name}", resource)
+    end
+
+    # Get collection ivar based on the current resource controller.
+    #
+    def get_collection_ivar #:nodoc:
+      instance_variable_get("@#{resource_collection_name}")
+    end
+
+    # Set collection ivar based on the current resource controller.
+    #
+    def set_collection_ivar(collection) #:nodoc:
+      instance_variable_set("@#{resource_collection_name}", collection)
+    end
+
+    # Used to allow to specify success and failure within just one block:
+    #
+    #   def create
+    #     create! do |success, failure|
+    #       failure.html { redirect_to root_url }
+    #     end
+    #   end
+    #
+    # It also calculates the response url in case a block without arity is
+    # given and returns it. Otherwise returns nil.
+    #
+    def respond_with_dual_blocks(object, options, &block) #:nodoc:
+      args = (with_chain(object) << options)
+
+      case block.try(:arity)
+        when 2
+          respond_with(*args) do |responder|
+            blank_slate = InheritedResources::BlankSlate.new
+            if object.errors.empty?
+              block.call(responder, blank_slate)
+            else
+              block.call(blank_slate, responder)
+            end
+          end
+        when 1
+          respond_with(*args, &block)
+        else
+          options[:location] = block.call if block
+          respond_with(*args)
+      end
+    end
+
+    # Hook to apply scopes. By default returns only the target_object given.
+    # It's extend by HasScopeHelpers.
+    #
+    def apply_scopes_if_available(target_object) #:nodoc:
+      respond_to?(:apply_scopes) ? apply_scopes(target_object) : target_object
+    end
+
+    # Symbols chain in base helpers return nothing. This is later overwriten
+    # by belongs_to and can be complex in polymorphic cases.
+    #
+    def symbols_for_association_chain #:nodoc:
+      []
+    end
+
+  end
+end
+