controll 0.2.0

data/spec/rspec_controller_class.rb

@@ -0,0 +1,15 @@
+module FocusedController
+  module RSpecControllerClass
+    def controller_class
+      metadata = self.metadata[:example_group]
+      klass    = nil
+
+      until metadata.nil? || klass.respond_to?(:new)
+        klass    = metadata[:description_args].first
+        metadata = metadata[:example_group]
+      end
+
+      klass.respond_to?(:new) ? klass : super
+    end
+  end
+end

data/spec/rspec_functional_helper.rb

@@ -0,0 +1,25 @@
+require 'action_controller'
+require 'action_view'
+require 'action_dispatch'
+require 'rspec/rails'
+require 'focused_controller/functional_test_helper'
+require 'focused_controller/rspec_controller_class'
+
+module FocusedController
+  module RSpecFunctionalHelper
+    def self.append_features(base)
+      base.class_eval do
+        # This must be included first
+        include RSpec::Rails::ControllerExampleGroup
+        extend ClassMethods
+        include FocusedController::FunctionalTestHelper
+      end
+
+      super
+    end
+
+    module ClassMethods
+      include FocusedController::RSpecControllerClass
+    end
+  end
+end

data/spec/rspec_helper.rb

@@ -0,0 +1,42 @@
+require 'focused_controller/test_helper'
+require 'focused_controller/rspec_controller_class'
+
+begin
+  # Requiring specific files rather than just 'rspec/rails' because I don't
+  # want to force the configuration that 'rspec/rails' adds on people if they
+  # haven't specifically chosen to receive it.
+  require 'rspec/rails/matchers'
+  require 'rspec/rails/adapters'
+  require 'rspec/rails/example/rails_example_group'
+rescue LoadError
+end
+
+module FocusedController
+  module RSpecHelper
+    def self.append_features(base)
+      base.class_eval do
+        # This must get included higher in the ancestor chain than
+        # this module so that inheritance works as desired
+        include FocusedController::TestHelper
+        extend ClassMethods
+        subject { controller }
+      end
+
+      super
+    end
+
+    if defined?(RSpec::Rails)
+      include RSpec::Rails::RailsExampleGroup
+      include RSpec::Rails::Matchers::RedirectTo
+      include RSpec::Rails::Matchers::RenderTemplate
+    end
+
+    module ClassMethods
+      include FocusedController::RSpecControllerClass
+
+      def stub_url(*helper_names)
+        before { stub_url(*helper_names) }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rspec'
+require 'rails'
+require 'controll'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/test_helper.rb

@@ -0,0 +1,183 @@
+require 'action_dispatch'
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/hash_with_indifferent_access'
+
+module FocusedController
+  module TestHooks
+    attr_reader :_render_options
+
+    def render_to_body(options = {})
+      _process_options(options)
+      @_render_options = options
+    end
+
+    def url_for(options = nil)
+      if options.is_a?(StubbedURL)
+        options
+      else
+        super
+      end
+    end
+  end
+
+  class TestRequest < ActionDispatch::TestRequest
+    def initialize(env = {})
+      super
+      self.session = HashWithIndifferentAccess.new
+    end
+
+    def cookie_jar
+      @cookie_jar ||= ActionDispatch::Cookies::CookieJar.new
+    end
+
+    def flash
+      session['flash'] ||= ActionDispatch::Flash::FlashHash.new
+    end
+  end
+
+  class TestResponse < ActionDispatch::TestResponse
+  end
+
+  class StubbedURL
+    attr_reader :helper_name, :args
+
+    def initialize(helper_name, args)
+      @helper_name = helper_name.to_s
+      @args        = args
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        helper_name == other.helper_name &&
+        args        == other.args
+    end
+
+    # Deals with _compute_redirect_to_location in action_controller/metal/redirecting
+    # (I don't feel proud about this...)
+    def gsub(*)
+      self
+    end
+
+    def to_s
+      "#{helper_name}(#{args.each(&:to_s).join(', ')})"
+    end
+  end
+
+  module TestHelper
+    extend ActiveSupport::Concern
+    include ActionDispatch::Assertions::ResponseAssertions
+
+    included do
+      class_attribute :_controller_class, :instance_reader => false, :instance_writer => false
+    end
+
+    module ClassMethods
+      def controller_class=(klass)
+        self._controller_class = klass
+      end
+
+      def controller_class
+        _controller_class || name.sub(/Test$/, '').constantize
+      end
+
+      def include_routes
+        if controller_class.respond_to?(:_routes) && controller_class._routes
+          include controller_class._routes.named_routes.module
+        end
+      end
+
+      def stub_url(*names)
+        setup { stub_url(*names) }
+      end
+    end
+
+    def controller
+      @controller ||= begin
+        controller = self.class.controller_class.new
+        controller.singleton_class.send :include, TestHooks
+        controller.request  = request
+        controller.response = response
+        controller
+      end
+    end
+
+    def request
+      @request ||= TestRequest.new
+    end
+
+    def response
+      @response ||= TestResponse.new
+    end
+
+    def req(params = nil, session = nil, flash = nil)
+      controller.params = params        if params
+      controller.session.update session if session
+      controller.flash.update flash     if flash
+      controller.run
+    end
+
+    def session
+      controller.session
+    end
+
+    def flash
+      controller.flash
+    end
+
+    def cookies
+      request.cookie_jar
+    end
+
+    def assert_template(template, message = nil)
+      assert_equal template.to_s, controller._render_options[:template], message
+    end
+
+    def assert_response(type, message = nil)
+      controller # make sure controller is initialized
+      super
+    end
+
+    def assert_redirected_to(location, message = nil)
+      controller # make sure controller is initialized
+      super
+    end
+
+    def url_for(*args)
+      controller.url_for(*args)
+    end
+
+    def respond_to?(*args)
+      unless defined?(@_routes_included) && @_routes_included
+        self.class.include_routes
+        @_routes_included = true
+      end
+
+      super
+    end
+
+    def method_missing(method_name, *args, &block)
+      if respond_to?(method_name)
+        send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def stub_url(*names)
+      [self, controller].each do |host|
+        host.singleton_class.class_eval do
+          names.each do |name|
+            define_method("#{name}_url") do |*args|
+              StubbedURL.new("#{name}_url", args)
+            end
+
+            define_method("#{name}_path") do |*args|
+              StubbedURL.new("#{name}_path", args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/functional_test_helper_test.rb

@@ -0,0 +1,65 @@
+require 'helper'
+require 'focused_controller/functional_test_helper'
+require 'action_controller'
+
+module FocusedController
+  module FunctionalTestHelper
+    class FakePostsController
+      class Action < ActionController::Base; end
+      class Index < Action; end
+      class Show < Action; end
+
+      class TestCase < ActionController::TestCase
+        include FocusedController::FunctionalTestHelper
+
+        def initialize(method_name = :foo)
+          super
+        end
+
+        def foo; end
+      end
+
+      class IndexTest < TestCase
+      end
+
+      class ShowTest < TestCase
+      end
+    end
+
+    describe FunctionalTestHelper do
+      subject { FakePostsController::IndexTest.new }
+
+      it 'automatically determines the controller class' do
+        FakePostsController::IndexTest.controller_class.
+          must_equal FakePostsController::Index
+        FakePostsController::ShowTest.controller_class.
+          must_equal FakePostsController::Show
+      end
+
+      it "doesn't require using the action name to dispatch the action" do
+        subject.singleton_class.class_eval do
+          attr_reader :last_process
+
+          def process(*args)
+            @last_process = args
+          end
+        end
+
+        subject.get :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'GET']
+
+        subject.post :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'POST']
+
+        subject.put :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'PUT']
+
+        subject.delete :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'DELETE']
+
+        subject.head :foo, :bar, :baz
+        subject.last_process.must_equal ['run', :foo, :bar, :baz, 'HEAD']
+      end
+    end
+  end
+end

data/spec/unit/macros_test.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+class ApplicationController
+end
+
+require 'focused_controller/macros'
+
+class MyBaseAction < ::FocusedAction
+end
+
+module FocusedController
+  describe Macros do
+    describe ".focused_action" do
+      let(:klass) do
+        klass = Class.new(FocusedController::Test::MixinTestController)
+        klass.name = "PostsController"
+        klass.use_focused_macros
+        klass.action_parent MyBaseAction
+        klass
+      end
+
+      subject { klass }
+
+      describe 'create an Action class with a #run method' do
+        before do
+          subject.focused_action(:show) do
+            def run
+              "running"
+            end
+          end
+        end
+
+        it 'should have the superclass MyBaseAction' do
+          subject::Show.superclass.should == MyBaseAction
+        end
+
+        it 'should have a run method' do
+          subject::Show.new.run.should == "running"
+        end        
+      end
+    end
+  end
+end

data/spec/unit/mixin_test.rb

@@ -0,0 +1,147 @@
+require 'helper'
+require 'action_controller'
+
+module FocusedController
+  module Test
+    class MixinTestBaseController
+      def view_assigns
+        {'some' => 'var'}
+      end
+    end
+
+    class MixinTestController < ActionController::Base
+      include FocusedController::Mixin
+
+      class << self
+        attr_accessor :name
+      end
+    end
+  end
+end
+
+module FocusedController
+  describe Mixin do
+    describe "with a PostsController::Show class" do
+      let(:klass) do
+        klass = Class.new(FocusedController::Test::MixinTestController)
+        klass.name = "PostsController::Show"
+        klass
+      end
+
+      subject { klass.new }
+
+      it "has a .controller_path of 'posts'" do
+        klass.controller_path.must_equal 'posts'
+      end
+
+      it "has a .call which dispatches the #run action" do
+        def klass.action(name)
+          if name.to_s == 'run'
+            proc { |env| "omg" }
+          end
+        end
+
+        klass.call(nil).must_equal "omg"
+      end
+
+      it "has an #action_name of 'show'" do
+        subject.action_name.must_equal 'show'
+      end
+
+      it "uses the run method for the action" do
+        subject.method_for_action('whatever').must_equal 'run'
+      end
+
+      it "removes all view assigns by default" do
+        subject.view_assigns.must_equal({})
+      end
+
+      it "can be configured to allow view assigns" do
+        subject.class.allow_view_assigns = true
+        subject.instance_variable_set('@foo', 'bar')
+        subject.view_assigns['foo'].must_equal('bar')
+      end
+
+      it "has a #run method by default" do
+        subject.run.must_equal nil
+      end
+    end
+
+    describe '.run' do
+      subject do
+        @klass = Class.new do
+          include FocusedController::Mixin
+        end
+      end
+
+      it 'defines a #run method' do
+        subject.run { 'running' }
+        subject.new.run.must_equal 'running'
+      end      
+    end
+
+    describe '.expose' do
+      subject do
+        @klass = Class.new do
+          include FocusedController::Mixin
+
+          @helper_methods = []
+
+          class << self
+            attr_reader :helper_methods
+
+            def helper_method(name)
+              @helper_methods << name
+            end
+          end
+        end
+      end
+
+      it 'defines a #foo method' do
+        subject.expose(:foo) { 'bar' }
+        subject.new.foo.must_equal 'bar'
+      end
+
+      it 'declares the method a helper method' do
+        subject.expose(:foo) { 'bar' }
+        subject.helper_methods.must_equal [:foo]
+      end
+
+      it 'memoizes the result' do
+        count = 0
+        counter = proc { count += 1 }
+        subject.expose(:foo) { counter.call }
+
+        obj = subject.new
+        obj.foo.must_equal 1
+        obj.foo.must_equal 1
+      end
+
+      it 'it memoizes falsey values' do
+        val = true
+        meth = proc { val = !val }
+        subject.expose(:foo) { meth.call }
+
+        obj = subject.new
+        obj.foo.must_equal false
+        obj.foo.must_equal false
+      end
+
+      it 'instance evals the block' do
+        subject.expose(:foo) { @bar }
+        obj = subject.new
+        obj.instance_variable_set('@bar', 'bar')
+        obj.foo.must_equal 'bar'
+      end
+
+      it 'declares an attr_reader when called without a block' do
+        subject.expose :foo
+        subject.helper_methods.must_equal [:foo]
+
+        obj = subject.new
+        obj.instance_variable_set('@foo', 'bar')
+        obj.foo.must_equal 'bar'
+      end
+    end
+  end
+end