class-action 0.0.1

data/spec/class_action/action_spec.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+
+describe ClassAction::Action do
+
+  let(:controller) { double(:controller, :view_assigns => {}, :response_body => nil) }
+  let(:action_class) { Class.new(ClassAction::Action) }
+  let(:action) { action_class.new(controller) }
+
+  it "should by default be available" do
+    expect(action).to be_available
+  end
+
+  describe '.helpers && .helper_method' do
+    it "should create an empty module upon inheritance" do
+      expect(action_class.helpers).to be_a(Module)
+    end
+
+    it "should define the helper method in the action's helpers module, which should call the method on the controller action" do
+      action_class.class_eval do
+        def helper1
+          'HELPER RESULT'
+        end
+        helper_method :helper1
+      end
+
+      helpers = action_class.helpers
+      klass = Class.new do
+        include helpers
+        attr_reader :controller
+        def initialize(controller)
+          @controller = controller
+        end
+      end
+
+      obj = klass.new(controller)
+
+      expect(obj).to respond_to(:helper1)
+      expect(controller).to receive(:class_action).and_return(action)
+      expect(obj.helper1).to eql('HELPER RESULT')
+    end
+  end
+
+  describe '.controller_method' do
+    before { allow(controller).to receive(:load_post) }
+    before { action_class.class_eval { controller_method :load_post } }
+
+    it "should create a protected method :load_post" do
+      expect(action.protected_methods).to include(:load_post)
+    end
+
+    it "should create a proxy to the controller" do
+      result = double(:result)
+      expect(controller).to receive(:load_post).and_return(result)
+      expect(action.send(:load_post)).to be(result)
+    end
+
+    it "should copy assigns to the controller before executing the controller method, and copy them back afterwards" do
+      # Simulate an instance variable.
+      var = 1
+      allow(controller).to receive(:view_assigns) do
+        {'var' => var}
+      end
+      allow(controller).to receive(:instance_variable_set).with(:@var, an_instance_of(Fixnum)) do |_, num|
+        var = num
+      end
+      expect(controller).to receive(:increase_var) do
+        var += 1
+      end
+
+      action_class.class_eval do
+        controller_method :increase_var
+        def execute
+          @var = 2
+          increase_var
+        end
+      end
+
+      # Even though it's set to 1 initially, it is set to 2 by copying
+      # the assigns to the controller, and subsequently increased by 1
+      # to end up as 3 - both the controller and the action's versions.
+
+      action._execute
+      expect(var).to eql(3)
+      expect(action.instance_variable_get('@var')).to eql(3)
+    end
+  end
+
+  describe '.action_methods' do
+    it "should include (in order) - only the public defined action methods in the action class" do
+      action_class.class_eval do
+        def method1; end
+        def method2; end
+
+        protected
+        def method3; end
+
+        private
+        def method4; end
+      end
+
+      expect(action_class.action_methods).to eql([ :method1, :method2 ])
+    end
+  end
+
+  describe '#_execute' do
+    it "should raise an exception if the action is not available" do
+      expect(action).to receive(:available?).and_return(false)
+      expect{ action._execute }.to raise_error(ClassAction::ActionNotAvailable)
+    end
+
+    it "should execute all action methods in the action, and call #copy_assigns_to_controller finally" do
+      called = []
+
+      expect(action_class).to receive(:action_methods).and_return([:method1, :method2])
+      expect(action).to receive(:method1) { called << :method1 }
+      expect(action).to receive(:method2) { called << :method2 }
+
+      action._execute
+      expect(called).to eql([:method1, :method2])
+    end
+
+    it "should stop executing when a response body is set" do
+      called = []; response_body = nil
+
+      allow(controller).to receive(:response_body) { response_body }
+      expect(action_class).to receive(:action_methods).and_return([:method1, :method2])
+      expect(action).to receive(:method1) { called << :method1; response_body = '<html></html>' }
+      expect(action).not_to receive(:method2)
+
+      action._execute
+      expect(called).to eql([:method1])
+    end
+
+    it "should call _respond at the end" do
+      called = []
+
+      expect(action_class).to receive(:action_methods).and_return([:method1, :method2])
+      expect(action).to receive(:method1) { called << :method1 }
+      expect(action).to receive(:method2) { called << :method2 }
+      expect(action).to receive(:_respond) { called << :_respond }
+
+      action._execute
+      expect(called).to eql([:method1, :method2, :_respond])
+    end
+
+    it "should not call _respond if a response body is set" do
+      allow(controller).to receive(:response_body).and_return('<html></html>')
+      expect(action).not_to receive(:_respond)
+      action._execute
+    end
+
+  end
+
+  describe '#_respond' do
+
+    # Note - as _respond is a private method, we will call _execute to test
+    # this method. _execute does not perform other actions if no public methods
+    # are defined.
+
+    it "should always copy assignment variables back to the controller" do
+      action_class.class_eval do
+        def set_ivar
+          @my_var = :test
+        end
+      end
+
+      expect(controller).to receive(:instance_variable_set).with(:@my_var, :test)
+      action._execute
+    end
+
+    context "with no respond with or responders" do
+      it "should not call a respond method, but copy all instance variables into the controller at the end" do
+        expect(controller).not_to receive(:respond_with)
+        expect(controller).not_to receive(:respond_to)
+        action._execute
+      end
+    end
+
+    context "having set a respond_with" do
+      let(:response) { double(:response) }
+      before do
+        action_class.class_eval do
+          respond_with :response
+        end
+        expect(action).to receive(:response).and_return(response)
+      end
+
+      it "should call the respond_with method and use it in the response" do
+        expect(controller).to receive(:respond_with).with(response) do |&blk|
+          expect(blk).to be_nil
+        end
+
+        action._execute
+      end
+
+      it "should use the _respond_block if it is set" do
+        block = proc{}
+        allow(action).to receive(:_respond_block).and_return(block)
+
+        expect(controller).to receive(:respond_with).with(response) do |&blk|
+          expect(blk).to be(block)
+        end
+
+        action._execute
+      end
+
+    end
+
+    context "having set _respond_block" do
+
+      it "should use the _respond_block" do
+        block = proc{}
+        allow(action).to receive(:_respond_block).and_return(block)
+
+        expect(controller).to receive(:respond_to) do |&blk|
+          expect(blk).to be(block)
+        end
+
+        action._execute
+      end
+
+    end
+
+  end
+
+  describe 'responders & _respond_block' do
+
+    # Private method, but specced individually to make spec terser.
+
+    let(:respond_block) { action.send(:_respond_block) }
+
+    it "should create a block using the given responders, which is executed on the action" do
+      called = nil; receiver = nil
+      json_block = proc { receiver = self; called = :json }
+      html_block = proc { receiver = self; called = :html }
+      any_block = proc { receiver = self; called = :any }
+
+      action_class.class_eval do
+        respond_to :json, &json_block
+        respond_to :html, &html_block
+        respond_to_any &any_block
+      end
+
+      # Simulate ActionController's format collector.
+      collector = Class.new{ attr_reader :json_block, :html_block, :any_block }.new
+      def collector.json(&block) @json_block = block end
+      def collector.html(&block) @html_block = block end
+      def collector.any(&block) @any_block = block end
+
+      respond_block.call collector
+
+      collector.json_block.call
+      expect(receiver).to be(action); expect(called).to be(:json)
+
+      collector.html_block.call
+      expect(receiver).to be(action); expect(called).to be(:html)
+
+      collector.any_block.call
+      expect(receiver).to be(action); expect(called).to be(:any)
+    end
+
+  end
+
+end

data/spec/class_action_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe ClassAction do
+
+  let(:controller) { ClassActionTestController.new }
+
+  before do
+    Object.send :remove_const, :ClassActionTestController if defined?(ClassActionTestController)
+
+    class ::ClassActionTestController < ActionController::Base
+      include ClassAction
+
+      def self.logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      class Show < ClassAction::Action
+      end
+
+      class OtherShow < ClassAction::Action
+      end
+    end
+  end
+
+  context "adding a class action :show" do
+
+    before { ClassActionTestController.class_eval { class_action :show } }
+
+    it "should respond to method :show" do
+      expect(controller).to respond_to(:show)
+    end
+
+    it "should add helper methods from the action class to the view context class" do
+      helpers = Module.new do
+        def method_added_by_class_action
+        end
+      end
+
+      action_class = double(:helpers => helpers)
+      allow(controller).to receive(:class_action).and_return(double(:class => action_class))
+      expect(controller.view_context).to respond_to(:method_added_by_class_action)
+    end
+
+    context "when executing the action" do
+      let(:action) { action = double(:action, :_execute => nil) }
+      before { expect(ClassActionTestController::Show).to receive(:new).with(controller).and_return(action) }
+
+      it "should try to instantiate TestController::Show and execute it" do
+        expect(action).to receive(:_execute)
+        controller.show
+      end
+
+      it "should store the created action in the controller" do
+        controller.show
+        expect(controller.class_action).to be(action)
+      end
+
+      it "should not appear in the view assigns" do
+        controller.show
+        expect(controller.view_assigns).not_to have_key('_class_action')
+      end
+    end
+
+    context "giving another action class" do
+      before do
+        ClassActionTestController.class_eval do
+          class_action :show, klass: ClassActionTestController::OtherShow
+        end
+      end
+
+      it "should try to instantiate the given action class when executed" do
+        action = ClassActionTestController::OtherShow.new(controller)
+        expect(ClassActionTestController::OtherShow).to receive(:new).with(controller).and_return(action)
+        controller.show
+
+        expect(controller.class_action).to be(action)
+      end
+    end
+
+  end
+
+  describe "respond mime injection" do
+
+    before do
+      ClassActionTestController::Show.class_eval do
+        respond_to :html
+      end
+    end
+
+    it "should create mimes with :only => 'show' for nonexisting mimes" do
+      ClassActionTestController.class_eval { class_action :show }
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :html => {:only => %w[show]}
+      )
+    end
+
+    it "should append the action 'show' to existing mimes with an :only restriction" do
+      ClassActionTestController.class_eval do
+        respond_to :html, :only => [ :index ]
+        class_action :show
+      end
+
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :html => {:only => %w[index show]}
+      )
+    end
+
+    it "should not append the action 'show' to existing mimes with no :only restriction" do
+      ClassActionTestController.class_eval do
+        respond_to :html
+        class_action :show
+      end
+
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :html => {}
+      )
+    end
+
+    it "should not append the action 'show' if it was already targeted" do
+      ClassActionTestController.class_eval do
+        respond_to :html, :only => [ :show ]
+        class_action :show
+      end
+
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :html => { :only => %w[show] }
+      )
+    end
+
+    it "should not append the action 'show' if it was also already to the :except list (but log a warning)" do
+      expect(ClassActionTestController.logger).to receive(:warn).with("Warning: action show (ClassAction) responds to `html` but it does not accept this mime type")
+
+      ClassActionTestController.class_eval do
+        respond_to :html, :except => [ :show ]
+        class_action :show
+      end
+
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :html => { :except => %w[show] }
+      )
+    end
+
+    it "should exclude the action from any other mime types that may be defined" do
+      ClassActionTestController.class_eval do
+        respond_to :json
+        class_action :show
+      end
+
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :html => { :only => %w[show] },
+        :json => { :except => %w[show] }
+      )
+    end
+
+    it "should leave everything alone if the class action has no responders" do
+      allow(ClassActionTestController::Show).to receive(:responders).and_return({})
+
+      ClassActionTestController.class_eval do
+        respond_to :json
+        class_action :show
+      end
+
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :json => {}
+      )
+    end
+
+    it "should leave everything alone if the class action has an 'any' responder" do
+      ClassActionTestController::Show.class_eval do
+        respond_to_any
+      end
+
+      ClassActionTestController.class_eval do
+        respond_to :json
+        class_action :show
+      end
+
+      ClassActionTestController.mimes_for_respond_to.should eql(
+        :json => {}
+      )
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'action_controller'
+require 'class-action'
+require 'rspec/autorun'
+
+RSpec.configure do |config|
+
+  config.mock_with :rspec do |config|
+    config.syntax = :expect
+  end
+
+end
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: class-action
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joost Lubach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Allows you to write controller actions as classes, rather than methods.
+email:
+- joost@yoazt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- ClassAction.sublime-project
+- ClassAction.sublime-workspace
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- class-action.gemspec
+- lib/class-action.rb
+- lib/class_action.rb
+- lib/class_action/action.rb
+- lib/class_action/version.rb
+- spec/class_action/action_spec.rb
+- spec/class_action_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Allows you to write controller actions as classes, rather than methods.
+test_files:
+- spec/class_action/action_spec.rb
+- spec/class_action_spec.rb
+- spec/spec_helper.rb
+has_rdoc: