class-action 0.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15d11311c878ea8b12e8814df141799f8f848650
-  data.tar.gz: 13b865f9ded36ccff087faaaab5e910fad45515e
+  metadata.gz: 2d7c4f6566ad04e2d10d0cfcc3e107302afb367d
+  data.tar.gz: 1fc331ef010a59d7723ca3faa206dd72b4322b17
 SHA512:
-  metadata.gz: 95a7f24f41a2e6b14db13d23ecd5b776a6de2d65cb7f1fcece692ab79ae53a48a70e65c0a754736aad44596ba7e616f0365b1f14005a550edacfa57f4dcb2509
-  data.tar.gz: 39e2c284daa56bb1d33f573abe483cc661ec5b6e89108031bfbea315695db13c6da8f9cee3b0e19102023a8dd7060f21befd71467de1ac2e9f06f9d7e002251e
+  metadata.gz: 2ae15f473e25cdf638d5aaa51daf9239f61d4ee157544ce55d5184019405795584a8538eb693d0377730117dca662de16fcfdd96e3cbb96e3b3ebcc7c434f83b
+  data.tar.gz: 16c0a85b1a3798f913171cecc68830cb5f046d6689a33ddeb316458b85d9168ea019d174fcc2049c6a6358ff3684b722f2c398824d6b4391d59cd9014e6af00b

data/.gitignore

@@ -1,17 +1,34 @@
-*.gem
-*.rbc
-.bundle
-.config
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore .DS_Store
+.DS_Store
+
+# Ignore the output files.
+/pkg
+
+# Ignore bundler and database config and precompiled assets
+/.bundle
+/.env
+
+# RVM files
+.rvmrc
+.ruby-version
+.ruby-gemset
+
+# Ignore all logfiles and tempfiles.
+/tmp
+
+# Ignore TextMate projects
+*.tmproj
+*.sublime-project
+*.sublime-workspace
+
+# Documentation files and other stuff
 .yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
+/doc
+/nbproject
+/coverage

data/.travis.yml

@@ -0,0 +1,6 @@
+script: bundle exec rake
+rvm:
+  - 2.0.0
+branches:
+  only:
+    - master

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+## 1.1.0 ##
+
+*   Early class action resolution
+
+    - Allow access to `class_action` method from before-filters.
+
+*   Add helper methods onto controller instance as well
+
+## 1.0.0.rc1 ##
+
+*   Automatic controller method inferral
+
+    - No need to write `controller_method`
+
+*   Instance variable references allowed in `respond_with`
+
+## 0.0.2 ##
+
+*   Extension of responses
+
+    - Differentiation of responses for XHR requests
+    - Differentiation of responses based on state
+
+## 0.0.1 ##
+
+*   Initial development
+
+    - Support for execution
+    - Rudimentary response support
+
+    *Joost Lubach*

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    class-action (1.1.0)
+      activesupport (~> 3.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (3.2.14)
+      activemodel (= 3.2.14)
+      activesupport (= 3.2.14)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.5)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.14)
+      activesupport (= 3.2.14)
+      builder (~> 3.0.0)
+    activesupport (3.2.14)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    builder (3.0.4)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.9)
+    journey (1.0.4)
+    multi_json (1.8.2)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  actionpack (~> 3.2)
+  bundler (~> 1.3)
+  class-action!
+  rake
+  rspec (~> 2.14)

data/README.md

@@ -39,16 +39,11 @@ In your controller, make sure you have included `ClassAction`, and declare which
 
 Then, create your `show` action class (the default is to name this class `PostsController::Show`, but you may customize this).
 
-All *public* methods are executed in order when the action is run. Any support methods you need, you will need to make protected. You may also declare that you need some controller methods.
-
-Some default controller methods (`params`, `request`, `render`, `redirect_to`, `respond_to` and `respond_with`) are available at all times.
+All *public* methods are executed in order when the action is run. Any support methods you need, you will need to make protected. Also, all controller methods are available in the action.
 
     class PostController
       class Show < ClassAction::Action
 
-        # We need this method from the controller.
-        controller_method :current_user
-
         def prepare
           load_post
         end
@@ -124,9 +119,7 @@ This employs the use of `ActionController#respond_to`. Additionally, there is su
 
     class Show < ClassAction::Action
 
-      controller_method :post
-
-      respond_with :post
+      respond_with :@post
       respond_to :html, :json
 
       respond_to :text do
@@ -142,7 +135,7 @@ is roughly equivalent to:
       respond_to :html, :json, :text, :only => [ :show ]
 
       def show
-        respond_with post do |format|
+        respond_with @post do |format|
           format.text do
             render :text => @post.to_yaml
           end
@@ -151,14 +144,52 @@ is roughly equivalent to:
 
     end
 
+Note that the value you pass to `respond_with` may be a simple symbol (e.g. `:post`) for a method or a reference to an instance variable (e.g. `:@post`).
+
 In other words, using `respond_with` in conjunction with `respond_to` allows you to:
 
-1. Specify which method to use to obtain the response object (the first argument to `ActionController#respond_with`). Note that this method must exist on the action, or must be exposed using `controller_method`.
+1. Specify which method to use to obtain the response object (the first argument to `ActionController#respond_with`). Note that this method must exist on the action or controller.
 2. Specify the formats that this action responds to. `ClassAction` will make sure that the controller mime types are modified accordingly.
 3. Create a custom responder block in one breath.
 
 The only caveat is that you have to specify all your controller-level `respond_to` declarations *before* defining your actions using `class_action`, or you might override the `respond_to` array of your controller.
 
+### State based responses
+
+In some cases you may want a certain response method (`respond_with`) or responder block (`respond_to`) to be only available in a certain case. For example, in some update action, you may want a different response based on whether the object was saved successfully.
+
+Limiting a response method or reponder block this way is possible through the `on:` option in the methods `respond_with` and `respond_to`. The value of this option should correspond to a question-mark method on your action (or controller).
+
+For example:
+
+    class Update < ClassAction::Action
+
+      respond_with :@post
+      respond_to :html, on: :failure do
+        render :edit, :status => :unprocessable_entity
+      end
+
+      protected
+
+        def success?
+          @post.errors.blank?
+        end
+        def failure?
+          @post.errors.present?
+        end
+
+    end
+
+This will effectively perform the following response logic on the controller:
+
+    if @post.errors.blank?
+      respond_with @post
+    elsif @post.errors.present?
+      respond_with @post do |format|
+        format.html { render :edit, :status => :unprocessable_entity }
+      end
+    end
+
 ## Contributing
 
 1. Fork it

data/class-action.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "simplecov", "~> 2.14"
   spec.add_development_dependency "actionpack", "~> 3.2"
 end

data/lib/class-action/rspec.rb

@@ -0,0 +1,2 @@
+# File provided as the gem is called 'class-action'.
+require 'class_action/rspec'

data/lib/class_action/action.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/try'
+
 module ClassAction
 
   # Base class for controller actions.
@@ -8,12 +10,15 @@ module ClassAction
 
       def initialize(controller)
         @_controller = controller
+        @_controller.singleton_class.send :include, self.class.helpers
       end
 
     ######
     # Attributes
 
-      attr_internal_reader :controller
+      def controller
+        @_controller
+      end
 
       def available?
         true
@@ -26,68 +31,55 @@ module ClassAction
       class << self
 
         # Exposes the given controller methods into the action.
-        def controller_method(*methods, sync_assigns: true)
-          if sync_assigns
-            assigns_copy_to   = "copy_assigns_to_controller"
-            assigns_copy_from = "copy_assigns_from_controller"
-          end
-
-          methods.each do |method|
-            class_eval <<-RUBY, __FILE__, __LINE__+1
-              def #{method}(*args, &block)
-                #{assigns_copy_to}
-                controller.send :#{method}, *args, &block
-              ensure
-                #{assigns_copy_from}
-              end
-              protected :#{method}
-            RUBY
-          end
+        def _controller_method(method)
+          class_eval <<-RUBY, __FILE__, __LINE__+1
+            def #{method}(*args, &block)
+              copy_assigns_to_controller
+              controller.send :#{method}, *args, &block
+            ensure
+              copy_assigns_from_controller
+            end
+            protected :#{method}
+          RUBY
         end
 
-        def action_methods
-          methods  = public_instance_methods
-          methods -= [ :_execute ]
-          methods -= Object.public_instance_methods
-          methods
-        end
+      end
 
+      def respond_to?(method, include_private = false)
+        super || (include_private && controller.respond_to?(method, true))
       end
 
-      controller_method :params, :request, :format, sync_assigns: false
-      controller_method :render, :redirect_to, :respond_to, :respond_with
+      def method_missing(method, *args, &block)
+        if controller.respond_to?(method, true)
+          self.class._controller_method method
+          send method, *args, &block
+        else
+          super
+        end
+      end
+      private :method_missing
 
     ######
-    # Helper methods
+    # Execution
 
       class << self
 
-        attr_accessor :helpers
-
-        def inherited(klass)
-          klass.helpers = Module.new
-        end
-
-        def helper_method(*methods)
-          methods.each do |method|
-            helpers.class_eval <<-RUBY, __FILE__, __LINE__+1
-              def #{method}(*args, &block)
-                controller.class_action.send(:#{method}, *args, &block)
-              end
-            RUBY
-          end
+        def _action_methods
+          methods  = public_instance_methods
+          methods -= [ :_execute ]
+          methods -= Object.public_instance_methods
+          methods
         end
 
       end
 
-    ######
-    # Execution
-
       def _execute
         raise ActionNotAvailable unless available?
 
         # Execute the action by running all public methods in order.
-        self.class.action_methods.each do |method|
+        self.class._action_methods.each do |method|
+          next if self.method(method).arity != 0
+
           send method
 
           # Break execution of the action when some response body is set.
@@ -104,8 +96,17 @@ module ClassAction
       def _respond
         copy_assigns_to_controller
 
-        if self.class.respond_with_method
-          response_object = send(self.class.respond_with_method)
+        response = self.class._responses.find do |on, response|
+          !on || send(:"#{on}?")
+        end.try(:last)
+
+        if response
+          response_object = if response =~ /^@/
+            instance_variable_get(response)
+          else
+            send(response)
+          end
+
           controller.respond_with response_object, &_respond_block
         elsif _respond_block
           controller.respond_to &_respond_block
@@ -113,46 +114,95 @@ module ClassAction
       end
 
       def _respond_block
-        responders = self.class.responders
-        return if responders.none? { |format, block| !!block }
+        responders = {}
+        self.class._responders.each do |(format, on), block|
+          # Select only those responders that have a block, and for which no precondition is set, or
+          # one that matches the current action state.
+          responders[format] ||= block if block && (!on || send(:"#{on}?"))
+        end
+        return if responders.empty?
 
         action = self
         proc do |collector|
           responders.each do |format, block|
-            next unless block
             collector.send(format) do
               action.instance_exec &block
+              copy_assigns_to_controller
             end
           end
         end
       end
 
+    class << self
 
-    ######
-    # Responding
+      ######
+      # Helpers
 
-      class << self
+        attr_accessor :helpers
+        def helpers
+          @helpers ||= Module.new.tap do |helpers|
+            helpers.send :include, superclass.helpers if superclass.respond_to?(:helpers)
+          end
+        end
 
-        attr_accessor :respond_with_method
-        def responders
-          @reponders ||= {}
+        def helper_method(*methods)
+          methods.each do |method|
+            helpers.class_eval <<-RUBY, __FILE__, __LINE__+1
+              def #{method}(*args, &block)
+                controller = if respond_to?(:class_action)
+                  self
+                else
+                  self.controller
+                end
+                controller.class_action.send(:#{method}, *args, &block)
+              end
+            RUBY
+          end
+        end
+
+      ######
+      # Responders
+
+        attr_reader :_responders, :_responses
+
+        def _responses
+          @_responses ||= {}.tap do |responses|
+            responses.reverse_merge! superclass._responses if superclass.respond_to?(:_responses)
+          end
+
+          # Keep the hash in such an order that the 'nil' condition is always *last*.
+          # { :ok => 1, nil => 2, :invalid => 3 } => { :ok => 1, :invalid => 3, nil => 2 }
+          @_responses = Hash[ *@_responses.sort_by { |on, _method| on.nil? ? 1 : 0 }.flatten ]
+        end
+
+        def _responders
+          @_responders ||= {}.tap do |responders|
+            responders.reverse_merge! superclass._responders if superclass.respond_to?(:_responders)
+          end
+
+          # Keep the hash in such an order that the 'nil' conditions are always *last*.
+          # { [ (:html, nil) => 1, (:json, nil) => 2, (:html, :ok) => 3 } => { (:html, :ok) => 3, (:html, nil) => 1, (:json, nil) => 2 }
+          @_responders = Hash[ *@_responders.sort_by { |(format, on), _method| on.nil? ? 1 : 0 }.inject([]) { |arr, (key, value)| arr << key << value } ]
         end
 
-        def respond_with(method)
-          self.respond_with_method = method
+        # Defines a method that returns the response. Specify an optional precondition in the `on` parameter.
+        def respond_with(method, on: nil)
+          _responses[on.try(:to_sym)] = method
         end
 
-        def respond_to(*formats, &block)
+        # Defines a response block for the given format(s). Specify an optional precondition in the `on` parameter.
+        def respond_to(*formats, on: nil, &block)
           formats.each do |format|
-            responders[format.to_sym] = block
+            _responders[ [format.to_sym, on.try(:to_sym)] ] = block
           end
         end
 
-        def respond_to_any(&block)
-          respond_to :any, &block
+        # Defines a response block for any remaining format. Specify an optional precondition in the `on` parameter.
+        def respond_to_any(on: nil, &block)
+          respond_to :any, on: on, &block
         end
 
-      end
+    end
 
     ######
     # Assigns

data/lib/class_action/rspec/class_action_example_group.rb

@@ -0,0 +1,57 @@
+module ClassAction
+  module RSpec
+
+    # Adds support for speccing Class Actions. Sets up the example as
+    module ClassActionExampleGroup
+      def self.included(target)
+        target.send :include, ::RSpec::Rails::ControllerExampleGroup
+        target.extend ClassMethods
+        target.send :include, InstanceMethods
+
+        target.class_eval do
+          # I don't know why ControllerExampleGroup overrides this.
+          metadata[:type] = :class_action
+
+          subject { action }
+          before do
+            # This is required for response testing, as we won't use
+            # ActionController::TestCase#process
+            @controller.instance_variable_set '@_response', @response
+          end
+        end
+      end
+
+      module ClassMethods
+        def action_class
+          described_class
+        end
+        def controller_class
+          # Controller::Action => Controller
+          described_class.name.sub(/(.*)::.*$/, '\1').constantize
+        end
+      end
+
+      module InstanceMethods
+        def action
+          @action ||= self.class.action_class.new(@controller)
+        end
+
+        def assigns(*)
+          action.send :copy_assigns_to_controller
+          super
+        end
+      end
+
+      def assigns
+        @action.send :copy_assigns_to_controller
+        super
+      end
+
+    end
+
+  end
+end
+
+RSpec.configure do |c|
+  c.include ClassAction::RSpec::ClassActionExampleGroup, type: :class_action
+end

data/lib/class_action/rspec/have_class_action_matcher.rb

@@ -0,0 +1,67 @@
+module ClassAction
+  module RSpec
+
+    class HaveClassActionMatcher
+
+      def initialize(action_name)
+        @action_name = action_name.to_s
+      end
+
+      def using_class(klass)
+        @klass = klass
+        self
+      end
+
+      def matches?(controller)
+        @controller = controller
+        @reason = :unsupported and return false unless controller.respond_to?(:_class_action, true)
+        @reason = :not_an_action and return false unless controller.respond_to?(@action_name)
+        @reason = :not_a_class_action and return false unless controller.respond_to?(:"_#{@action_name}_action_class", true)
+
+        if @klass
+          @found_class = controller.send(:"_#{@action_name}_action_class").class
+          @reason = :incorrect_class and return false if @found_class != @klass
+        end
+
+        true
+      end
+
+      def description
+        if @klass
+          "have class action :#{@action_name} using class #{@klass}"
+        else
+          "have class action :#{@action_name}"
+        end
+      end
+
+      def failure_message_for_should
+        case @reason
+        when :unsupported
+          "expected controller of class #{@controller.class} to have class action :#{@action_name}, but it does not support class actions"
+        when :incorrect_class
+          "expected action #{@controller.class}##{@action_name} to use class #{@klass}, but it used #{@found_class}"
+        when :not_a_class_action
+          "expected action #{@controller.class}##{@action_name} to be a class action"
+        else
+          "expected controller of class #{@controller.class} to have class action :#{@action_name}"
+        end
+      end
+
+      def failure_message_for_should_not
+        if @klass
+          "expected #{@controller.class}##{@action_name} not to be a class action using class #{@klass}"
+        else
+          "expected #{@controller.class}##{@action_name} not to be a class action"
+        end
+      end
+
+    end
+
+  end
+end
+
+RSpec::Matchers.module_eval do
+  def have_class_action(action_name)
+    ClassAction::RSpec::HaveClassActionMatcher.new(action_name)
+  end
+end