erector-rails4 0.0.1

data/spec/dummy/spec/rails_spec_helper.rb

@@ -0,0 +1,10 @@
+ENV["RAILS_ENV"] ||= "test"
+ENV["BUNDLE_GEMFILE"] ||= "#{File.dirname(__FILE__)}/../Gemfile"
+
+here = File.expand_path(File.dirname(__FILE__))
+require File.expand_path("#{here}/../../spec_helper", __FILE__)
+require File.expand_path("#{here}/../config/environment", __FILE__)
+
+Bundler.require(:test)
+
+require "erector/rails"

data/spec/dummy/spec/rails_widget_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path("#{File.dirname(__FILE__)}/rails_spec_helper")
+
+describe Erector::Rails do
+  include Erector::Mixin
+
+  before(:each) do
+    @view = ActionView::Base.new
+  end
+
+  def test_render(&block)
+    Erector::Rails.render(Erector.inline(&block), @view)
+  end
+
+  it "should be set up with the same output buffer as rails" do
+    test_render { output.buffer.should === parent.output_buffer }
+  end
+
+  it "should get a new output buffer every time" do
+    one = test_render { text "foo" }
+    two = test_render { text "foo" }
+    one.should == "foo"
+    two.should == "foo"
+  end
+
+  describe "#capture" do
+    it "captures parent output" do
+      captured = nil
+      test_render do
+        captured = capture do
+          parent.concat "capture me!"
+        end
+      end.should == ""
+      captured.should == "capture me!"
+    end
+
+    it "captures with an erector block" do
+      captured = nil
+      test_render do
+        captured = capture do
+          text 'capture me!'
+        end
+      end.should == ""
+      captured.should == "capture me!"
+    end
+
+    it "captures erector output when called via parent" do
+      test_render do
+        text "A"
+        c = parent.capture do
+          text "C"
+        end
+        text "B"
+        text c
+      end.should == "ABC"
+    end
+
+    it "returns a safe string" do
+      captured = nil
+      test_render do
+        captured = capture {}
+      end.should == ""
+      captured.should be_html_safe
+    end
+  end
+
+  describe "escaping" do
+    it "escapes non-safe strings" do
+      test_render { text "<>&" }.should == "&lt;&gt;&amp;"
+    end
+
+    it "does not escape safe strings" do
+      test_render { text "<>&".html_safe }.should == "<>&"
+    end
+
+    it "returns safe strings from capture" do
+      captured = nil
+      test_render do
+        captured = capture {}
+      end
+      captured.should be_html_safe
+    end
+  end
+end

data/spec/dummy/spec/render_spec.rb

@@ -0,0 +1,369 @@
+require File.expand_path("#{File.dirname(__FILE__)}/rails_spec_helper")
+
+describe ActionController::Base do
+  class TestController < ActionController::Base
+    # Let exceptions propagate rather than generating the usual error page.
+    include ActionController::TestCase::RaiseActionExceptions
+
+    # We need this, because we reference Views::Test::Needs below, and it
+    # doesn't auto-load otherwise.
+    require 'views/test/needs.html.rb'
+
+    # replicate deprecated use for rails <3.2
+    if (Gem::Version.new(Rails.version) < Gem::Version.new('3.2.0') rescue false)
+      def render(*args, &block)
+        options = args.extract_options!
+        if options[:template]
+          handlers = options.delete(:handlers)
+          format = '.html' unless options.delete(:bare)
+          options[:template] += "#{format}.#{handlers.first}"
+        end
+        render(*(args << options), &block)
+      end
+    end
+
+    def render_widget_class
+      @foobar = "foobar"
+      render :widget => TestWidget
+    end
+
+    def render_widget_with_ignored_controller_variables
+      @foo = "foo"
+      @baz = "baz"
+      render :widget => NeedsWidget
+    end
+
+    def render_widget_with_extra_controller_variables
+      with_ignoring_extra_controller_assigns(NeedsWidget, false) do
+        @foo = "foo"
+        @baz = "baz"
+        render :widget => NeedsWidget
+      end
+    end
+
+    def render_widget_instance
+      render :widget => TestWidget.new(:foobar => "foobar")
+    end
+
+    def render_with_content_method
+      render :widget => TestWidget, :content_method_name => :content_method
+    end
+
+    def render_with_rails_options
+      render :widget => TestWidget, :status => 500, :content_type => "application/json"
+    end
+
+    def render_template_with_implicit_assigns
+      @foobar = "foobar"
+      render :template => "test/implicit_assigns", :handlers => [:rb]
+    end
+
+    def render_template_with_protected_instance_variable
+      render :template => "test/protected_instance_variable", :handlers => [:rb]
+    end
+
+    def render_template_with_excess_variables
+      with_ignoring_extra_controller_assigns(Views::Test::Needs, false) do
+        @foobar = "foobar"
+        @barfoo = "barfoo"
+        render :template => 'test/render_default', :handlers => [:rb]
+      end
+    end
+
+    def render_needs_template_with_excess_variables
+      with_ignoring_extra_controller_assigns(Views::Test::Needs, false) do
+        @foobar = "foobar"
+        @barfoo = "barfoo"
+        render :template => 'test/needs', :handlers => [:rb]
+      end
+    end
+
+    def with_ignoring_extra_controller_assigns(klass, value)
+      old_value = klass.ignore_extra_controller_assigns
+      begin
+        klass.ignore_extra_controller_assigns = value
+        yield
+      ensure
+        klass.ignore_extra_controller_assigns = old_value
+      end
+    end
+
+    def render_needs_template_with_excess_variables_and_ignoring_extras
+      @foobar = "foobar"
+      @barfoo = "barfoo"
+      render :template => 'test/needs', :handlers => [:rb]
+    end
+
+    def render_needs_subclass_template_with_excess_variables_and_ignoring_extras
+      @foobar = "foobar"
+      @barfoo = "barfoo"
+      render :template => 'test/needs_subclass', :handlers => [:rb]
+    end
+
+    def render_bare_rb
+      render :template => "test/bare", :handlers => [:rb], :bare => true
+    end
+
+    def render_default
+      @foobar = "foobar"
+    end
+
+    def render_template_with_partial
+      @foobar = "foobar"
+      render :template => "test/render_partial", :handlers => [:rb]
+    end
+
+    def render_erb_from_erector
+      @foobar = "foobar"
+      render :template => "test/erb_from_erector", :handlers => [:rb]
+    end
+
+    def render_erector_from_erb
+      @foobar = "foobar"
+      render :template => "test/erector_from_erb", :handlers => [:erb]
+    end
+
+    def render_erector_with_locals_from_erb
+      @local_foo = "hihi"
+      @local_bar = "byebye"
+      render :template => 'test/erector_with_locals_from_erb', :handlers => [:erb]
+    end
+
+    def render_erector_with_locals_from_erb_defaulted
+      @local_foo = "hihi"
+      render :template => 'test/erector_with_locals_from_erb', :handlers => [:erb]
+    end
+
+    def render_erector_with_locals_from_erb_override
+      @foo       = "globalfoo"
+      @local_foo = "localfoo"
+      render :template => 'test/erector_with_locals_from_erb', :handlers => [:erb]
+    end
+
+    def render_erector_with_locals_from_erb_not_needed
+      @local_foo = "localfoo"
+      @local_baz = "unneeded"
+      render :template => 'test/erector_with_locals_from_erb', :handlers => [:erb]
+    end
+
+    def render_erector_partial_with_unneeded_controller_variables
+      @local_foo = "localfoo"
+      @baz       = "unneeded"
+      render :template => 'test/erector_with_locals_from_erb', :handlers => [:erb]
+    end
+
+    def with_controller_assigns_propagate_to_partials(klass, value)
+      old_value = klass.controller_assigns_propagate_to_partials
+      begin
+        klass.controller_assigns_propagate_to_partials = value
+        yield
+      ensure
+        klass.controller_assigns_propagate_to_partials = old_value
+      end
+    end
+
+    def render_erector_partial_without_controller_variables
+      with_controller_assigns_propagate_to_partials(Views::Test::PartialWithLocals, false) do
+        @local_foo = "localfoo"
+        @bar       = "barbar"
+        render :template => 'test/erector_with_locals_from_erb', :handlers => [:erb]
+      end
+    end
+
+    def render_with_needs
+      @foo = "foo"
+      @bar = "bar"
+      render :widget => NeedsWidget
+    end
+
+    def render_with_widget_as_layout
+      render :layout => "layouts/widget_as_layout"
+    end
+
+    def render_default_widget_with_layout
+      @widget_content = "widget content"
+      @layout_content = "layout content"
+    end
+
+    def render_default_erb_with_layout
+      @erb_content    = "erb content"
+      @layout_content = "layout content"
+    end
+
+    def render_with_widget_as_layout_and_vars
+      @before = "Breakfast"
+      @during = "Lunch"
+      @after  = "Dinner"
+      render :template => "test/render_with_widget_as_layout", :layout => "layouts/widget_as_layout"
+    end
+
+    def render_with_widget_as_layout_using_content_for
+      render :template => "test/render_with_widget_as_layout_using_content_for", :layout => "layouts/widget_as_layout"
+    end
+  end
+
+  class TestWidget < Erector::Widget
+    def content
+      text @foobar
+    end
+
+    def content_method
+      text "content_method"
+    end
+  end
+
+  class TestFormWidget < Erector::Widget
+    def content
+      form_tag('/') do
+        h1 "Create a foo"
+        rawtext text_field_tag(:name)
+      end
+    end
+  end
+
+  class NeedsWidget < Erector::Widget
+    needs :foo, :bar => true
+
+    def content
+      text "foo #{@foo} bar #{@bar}"
+    end
+  end
+
+  def test_action(action)
+    @response = TestController.action(action).call(Rack::MockRequest.env_for("/path"))[2]
+    @response.body
+  end
+
+  describe "#render" do
+    it "should render a widget class with implicit assigns" do
+      test_action(:render_widget_class).should == "foobar"
+    end
+
+    it "should render a widget instance with explicit assigns" do
+      test_action(:render_widget_instance).should == "foobar"
+    end
+
+    it "should render a widget class with implicit assigns and ignoring extra variables" do
+      test_action(:render_widget_with_ignored_controller_variables).should == "foo foo bar true"
+    end
+
+    it "should raise when rendering a widget class with implicit assigns and too many variables" do
+      proc { test_action(:render_widget_with_extra_controller_variables) }.should raise_error(ArgumentError, /Excess parameters?.*: .*baz/)
+    end
+
+    it "should render a specific content method" do
+      test_action(:render_with_content_method).should == "content_method"
+    end
+
+    it "should pass rails options to base render method" do
+      test_action(:render_with_rails_options)
+      @response.response_code.should == 500
+      @response.content_type.should == "application/json"
+    end
+
+    it "should render a template with implicit assigns" do
+      test_action(:render_template_with_implicit_assigns).should == "foobar"
+    end
+
+    it "should not include protected instance variables in assigns" do
+      test_action(:render_template_with_protected_instance_variable).should == ""
+    end
+
+    it "should render a template without a .html format included" do
+      test_action(:render_bare_rb).should == "Bare"
+    end
+
+    it "should render a template with excess controller variables" do
+      test_action(:render_template_with_excess_variables).should == "Default foobar"
+    end
+
+    it "should raise if rendering a #needs template with excess controller variables" do
+      proc { test_action(:render_needs_template_with_excess_variables) }.should raise_error(ActionView::TemplateError, /Excess parameters?.*: .*barfoo/)
+    end
+
+    it "should render a #needs template with excess controller variables and ignore_extra_controller_assigns" do
+      test_action(:render_needs_template_with_excess_variables_and_ignoring_extras).should == "Needs foobar"
+    end
+
+    it "should respect ignore_extra_controller_assigns in subclasses" do
+      test_action(:render_needs_subclass_template_with_excess_variables_and_ignoring_extras).should == "NeedsSubclass foobar"
+    end
+
+    it "should render a template which uses partials" do
+      test_action(:render_template_with_partial).should == "Partial foobar"
+    end
+
+    it "should render an erector widget which uses an ERB partial'" do
+      test_action(:render_erb_from_erector).should == "Partial foobar"
+    end
+
+    it "should render an ERB template which uses an erector widget partial" do
+      test_action(:render_erector_from_erb).should == "Partial foobar"
+    end
+
+    it "should render an ERB template which uses an erector widget partial with locals" do
+      test_action(:render_erector_with_locals_from_erb).should == "Partial, foo hihi, bar byebye"
+    end
+
+    it "should render an ERB template which uses an erector widget partial with a defaulted local" do
+      test_action(:render_erector_with_locals_from_erb_defaulted).should == "Partial, foo hihi, bar 12345"
+    end
+
+    it "should override instance variables with local variables when rendering partials" do
+      test_action(:render_erector_with_locals_from_erb_override).should == "Partial, foo localfoo, bar 12345"
+    end
+
+    it "should raise if passing a local that's not needed" do
+      proc { test_action(:render_erector_with_locals_from_erb_not_needed) }.should raise_error(ActionView::TemplateError, /Excess parameters?.*: .*baz/)
+    end
+
+    it "should not pass unneeded controller variables to a partial" do
+      test_action(:render_erector_partial_with_unneeded_controller_variables).should == "Partial, foo localfoo, bar 12345"
+    end
+
+    it "should not pass controller variables to a partial at all, if requested" do
+      test_action(:render_erector_partial_without_controller_variables).should == "Partial, foo localfoo, bar 12345"
+    end
+
+    it "should render a default template" do
+      test_action(:render_default).should == "Default foobar"
+    end
+
+    it "should render a default erb template with default erb layout" do
+      TestController.layout 'erb_as_layout'
+      test_action(:render_default_erb_with_layout).should == "layout content\nerb content"
+    end
+
+    it "should render a default widget with default erb layout" do
+      TestController.layout 'erb_as_layout'
+      test_action(:render_default_widget_with_layout).should == "layout content\nwidget content"
+    end
+
+    it "should render a default erb template with default widget layout" do
+      TestController.layout 'widget_as_layout'
+      test_action(:render_default_erb_with_layout).should == "BEFOREerb contentAFTER"
+    end
+
+    it "should render a default widget with default widget layout" do
+      TestController.layout 'widget_as_layout'
+      test_action(:render_default_widget_with_layout).should == "BEFOREwidget contentAFTER"
+    end
+
+    it "should allow rendering widget with needs" do
+      proc { test_action(:render_with_needs) }.should_not raise_error
+    end
+
+    it "should allow using a widget as a layout" do
+      test_action(:render_with_widget_as_layout).should == "BEFOREDURINGAFTER"
+    end
+
+    it "should allow using a widget as a layout with instance vars" do
+      test_action(:render_with_widget_as_layout_and_vars).should == "BreakfastLunchDinner"
+    end
+
+    it "should allow using a widget as a layout using content_for" do
+      test_action(:render_with_widget_as_layout_using_content_for).should == "TOPBEFOREDURINGAFTER"
+    end
+
+  end
+end