erector 0.8.2 → 0.8.3

data/spec/rails2/rails_app/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/spec/rails2/rails_app/script/about

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+$LOAD_PATH.unshift "#{RAILTIES_PATH}/builtin/rails_info"
+require 'commands/about'

data/spec/rails2/rails_app/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/console'

data/spec/rails2/rails_app/script/dbconsole

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/dbconsole'

data/spec/rails2/rails_app/script/destroy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/destroy'

data/spec/rails2/rails_app/script/generate

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/generate'

data/spec/rails2/rails_app/script/performance/benchmarker

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../../config/boot',  __FILE__)
+require 'commands/performance/benchmarker'

data/spec/rails2/rails_app/script/performance/profiler

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../../config/boot',  __FILE__)
+require 'commands/performance/profiler'

data/spec/rails2/rails_app/script/plugin

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/plugin'

data/spec/rails2/rails_app/script/runner

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/runner'

data/spec/rails2/rails_app/script/server

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/server'

data/spec/rails2/rails_app/spec/rails_helpers_spec.rb

@@ -0,0 +1,255 @@
+require File.expand_path("#{File.dirname(__FILE__)}/rails_spec_helper")
+
+describe Erector::Rails::Helpers do
+  class RailsHelpersSpecController < ActionController::Base
+  end
+
+  before do
+    @controller = RailsHelpersSpecController.new
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @controller.send(:initialize_template_class, @response)
+    @controller.send(:assign_shortcuts, @request, @response)
+    @controller.send(:initialize_current_url)
+
+    @view = ActionView::Base.new
+    @view.output_buffer = ""
+    @view.controller = @controller
+
+    def @view.protect_against_forgery?
+      false
+    end
+
+    class << @controller
+      public :render
+
+      attr_accessor :user # dummy instance variable for assigns testing
+    end
+  end
+
+  def test_render(&block)
+    Erector::Rails.render(Erector.inline(&block), @view)
+  end
+
+  describe "#link_to" do
+    it "renders a link" do
+      test_render do
+        link_to 'Test', '/foo'
+      end.should == %{<a href="/foo">Test</a>}
+    end
+
+    it "supports blocks" do
+      test_render do
+        link_to '/foo' do
+          strong "Test"
+        end
+      end.should == %{<a href="/foo"><strong>Test</strong></a>}
+    end
+
+    it "escapes input" do
+      test_render do
+        link_to 'This&that', '/foo?this=1&amp;that=1'
+      end.should == %{<a href="/foo?this=1&amp;that=1">This&amp;that</a>}
+    end
+
+    it "isn't double rendered when 'text link_to' is used by mistake" do
+      test_render do
+        text link_to('Test', '/foo')
+      end.should == %{<a href="/foo">Test</a>}
+    end
+  end
+
+  describe "a regular helper" do
+    it "can be called directly" do
+      test_render do
+        text truncate("foo")
+      end.should == "foo"
+    end
+
+    it "can be called via capture" do
+      test_render do
+        text capture { text truncate("foo") }
+      end.should == "foo"
+    end
+
+    it "can be called via sub-widget" do
+      test_render do
+        widget Erector.inline { text truncate("foo") }
+      end.should == "foo"
+    end
+  end
+
+  describe "a named route helper" do
+    before do
+      ActionController::Routing::Routes.draw do |map|
+        map.root :controller => "rails_helpers_spec"
+      end
+    end
+
+    it "can be called directly" do
+      test_render do
+        text root_path
+      end.should == "/"
+    end
+
+    it "can be called via parent" do
+      test_render do
+        text parent.root_path
+      end.should == "/"
+    end
+
+    it "respects default_url_options defined by the controller" do
+      def @controller.default_url_options(options = nil)
+        { :host => "www.override.com" }
+      end
+
+      test_render do
+        text root_url
+      end.should == "http://www.override.com/"
+    end
+  end
+
+  describe "#auto_discovery_link_tag" do
+    it "renders tag" do
+      test_render do
+        auto_discovery_link_tag(:rss, "rails")
+      end.should == %{<link href="rails" rel="alternate" title="RSS" type="application/rss+xml" />}
+    end
+  end
+
+  describe "#javascript_include_tag" do
+    it "renders tag" do
+      test_render do
+        javascript_include_tag("rails")
+      end.should == %{<script src="/javascripts/rails.js" type="text/javascript"></script>}
+    end
+  end
+
+  describe "#stylesheet_link_tag" do
+    it "renders tag" do
+      test_render do
+        stylesheet_link_tag("rails")
+      end.should == %{<link href="/stylesheets/rails.css" media="screen" rel="stylesheet" type="text/css" />}
+    end
+  end
+
+  describe "#image_tag" do
+    it "renders tag" do
+      test_render do
+        image_tag("/foo")
+      end.should == %{<img alt="Foo" src="/foo" />}
+    end
+  end
+
+  describe "#javascript_tag" do
+    it "renders tag" do
+      test_render do
+        javascript_tag "alert('All is good')"
+      end.should == %{<script type="text/javascript">\n//<![CDATA[\nalert('All is good')\n//]]>\n</script>}
+    end
+
+    it "supports block syntax" do
+      test_render do
+        javascript_tag do
+          text! "alert('All is good')"
+        end
+      end.should == %{<script type="text/javascript">\n//<![CDATA[\nalert('All is good')\n//]]>\n</script>}
+    end
+  end
+
+  [:sortable_element,
+   :draggable_element,
+   :drop_receiving_element].each do |helper|
+    describe "##{helper}" do
+      it "renders helper js" do
+        test_render do
+           send(helper, "rails", :url => "/foo")
+        end.should =~ %r{<script type="text/javascript">.*</script>}m
+      end
+    end
+  end
+
+  describe "#link_to_function" do
+    context "when passed a string for the js function" do
+      it "renders a link with the name as the content and the onclick handler" do
+        test_render do
+          link_to_function("hi", "alert('hi')")
+        end.should == "<a href=\"#\" onclick=\"alert('hi'); return false;\">hi</a>"
+      end
+    end
+
+    context "when passed a block for the js function" do
+      it "renders the name and the block rjs contents onto onclick" do
+        test_render do
+          link_to_function("Show me more", nil, :id => "more_link") do |page|
+            page[:details].visual_effect  :toggle_blind
+            page[:more_link].replace_html "Show me less"
+          end
+        end.should == "<a href=\"#\" id=\"more_link\" onclick=\"$(&quot;details&quot;).visualEffect(&quot;toggle_blind&quot;);\n$(&quot;more_link&quot;).update(&quot;Show me less&quot;);; return false;\">Show me more</a>"
+      end
+    end
+  end
+
+  describe "#render" do
+    it "renders text" do
+      test_render do
+        render :text => "Test"
+      end.should == "Test"
+    end
+  end
+
+  describe "#error_messages_for" do
+    it "renders the error message" do
+      pending "RR problem with Ruby 1.9" if RUBY_VERSION >= "1.9.0"
+
+      user_class = BaseDummyModel
+      stub(user_class).human_attribute_name {'User'}
+      user = user_class.new
+      stub(user).name {'bob'}
+      errors = ActiveRecord::Errors.new(user)
+      errors.add("name", "must be unpronounceable")
+      stub(user).errors {errors}
+
+      @controller.user = user
+
+      test_render do
+        error_messages_for('user')
+      end.should == "<div class=\"errorExplanation\" id=\"errorExplanation\"><h2>1 error prohibited this user from being saved</h2><p>There were problems with the following fields:</p><ul><li>User must be unpronounceable</li></ul></div>"
+    end
+  end
+
+  describe "#form_tag" do
+    it "works without a block" do
+      test_render do
+        form_tag("/posts")
+      end.should == %{<form action="/posts" method="post">}
+    end
+
+    it "can be mixed with erector and rails helpers" do
+      test_render do
+        form_tag("/posts") do
+          div { submit_tag 'Save' }
+        end
+      end.should == %{<form action="/posts" method="post"><div><input name="commit" type="submit" value="Save" /></div></form>}
+    end
+  end
+
+  describe "#form_for" do
+    it "produces expected output" do
+      test_render do
+        form_for(:something, :url => "/test") do |form|
+          form.label :my_input, "My input"
+          form.text_field :my_input
+        end
+      end.should == %{<form action="/test" method="post"><label for="something_my_input">My input</label><input id="something_my_input" name="something[my_input]" size="30" type="text" /></form>}
+    end
+
+    it "doesn't double render if 'text form.label' is used by mistake" do
+      test_render do
+        form_for(:something, :url => "/test") do |form|
+          text form.label(:my_input, "My input")
+        end
+      end.should == %{<form action="/test" method="post"><label for="something_my_input">My input</label></form>}
+    end
+  end
+end

data/spec/rails2/rails_app/spec/rails_spec_helper.rb

@@ -0,0 +1,34 @@
+ENV["RAILS_ENV"] ||= "test"
+ENV["BUNDLE_GEMFILE"] ||= "#{File.dirname(__FILE__)}/../Gemfile"
+
+here = File.expand_path(File.dirname(__FILE__))
+require File.expand_path("#{here}/../config/environment", __FILE__)
+require File.expand_path("#{here}/../../../spec_helper", __FILE__)
+
+Bundler.require(:test)
+
+class BaseDummyModel
+  # see http://gist.github.com/191263
+  def self.self_and_descendants_from_active_record
+    [self]
+  end
+
+  def self.human_attribute_name(attribute_key_name, options = {})
+    defaults = self_and_descendants_from_active_record.map do |klass|
+      "#{klass.name.underscore}.#{attribute_key_name}""#{klass.name.underscore}.#{attribute_key_name}"
+    end
+    defaults << options[:default] if options[:default]
+    defaults.flatten!
+    defaults << attribute_key_name.humanize
+    options[:count] ||= 1
+    I18n.translate(defaults.shift, options.merge(:default => defaults, :scope => [:activerecord, :attributes]))
+  end
+
+  def self.human_name(options = {})
+    defaults = self_and_descendants_from_active_record.map do |klass|
+      "#{klass.name.underscore}""#{klass.name.underscore}"
+    end
+    defaults << self.name.humanize
+    I18n.translate(defaults.shift, {:scope => [:activerecord, :models], :count => 1, :default => defaults}.merge(options))
+  end
+end

data/spec/rails2/rails_app/spec/rails_widget_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path("#{File.dirname(__FILE__)}/rails_spec_helper")
+
+describe Erector::Rails::WidgetExtensions 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
+      erector { text "<>&" }.should == "&lt;&gt;&amp;"
+    end
+
+    it "does not escape safe strings" do
+      erector { text "<>&".html_safe }.should == "<>&"
+    end
+
+    it "returns safe strings from capture" do
+      captured = nil
+      erector do
+        captured = capture {}
+      end
+      captured.should be_html_safe
+    end
+  end
+end

data/spec/rails2/rails_app/spec/render_spec.rb

@@ -0,0 +1,324 @@
+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'
+
+    def render_widget_with_implicit_assigns
+      @foobar = "foobar"
+      render_widget TestWidget
+    end
+
+    def render_widget_with_explicit_assigns
+      render_widget TestWidget, :foobar => "foobar"
+    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.html.rb"
+    end
+
+    def render_template_with_protected_instance_variable
+      render :template => "test/protected_instance_variable.html.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.html.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.html.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.html.rb'
+    end
+
+    def render_needs_subclass_template_with_excess_variables_and_ignoring_extras
+      @foobar = "foobar"
+      @barfoo = "barfoo"
+      render :template => 'test/needs_subclass.html.rb'
+    end
+
+    def render_bare_rb
+      render :template => "test/bare.rb"
+    end
+
+    def render_default
+      @foobar = "foobar"
+    end
+
+    def render_template_with_partial
+      @foobar = "foobar"
+      render :template => "test/render_partial.html.rb"
+    end
+
+    def render_erb_from_erector
+      @foobar = "foobar"
+      render :template => "test/erb_from_erector.html.rb"
+    end
+
+    def render_erector_from_erb
+      @foobar = "foobar"
+      render :template => "test/erector_from_erb.html.erb"
+    end
+
+    def render_erector_with_locals_from_erb
+      @local_foo = "hihi"
+      @local_bar = "byebye"
+      render :template => 'test/erector_with_locals_from_erb.html.erb'
+    end
+
+    def render_erector_with_locals_from_erb_defaulted
+      @local_foo = "hihi"
+      render :template => 'test/erector_with_locals_from_erb.html.erb'
+    end
+
+    def render_erector_with_locals_from_erb_override
+      @foo = "globalfoo"
+      @local_foo = "localfoo"
+      render :template => 'test/erector_with_locals_from_erb.html.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.html.erb'
+    end
+
+    def render_erector_partial_with_unneeded_controller_variables
+      @local_foo = "localfoo"
+      @baz = "unneeded"
+      render :template => 'test/erector_with_locals_from_erb.html.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.html.erb'
+      end
+    end
+
+    def render_with_needs
+      @foo = "foo"
+      @bar = "bar"
+      render :widget => NeedsWidget
+    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
+
+  before do
+    @controller = TestController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_action(action)
+    @request.action = action.to_s
+    @controller.process(@request, @response)
+    @response.body
+  end
+
+  describe "#render_widget" do
+    it "should render a widget with implicit assigns" do
+      test_action(:render_widget_with_implicit_assigns).should == "foobar"
+    end
+
+    it "should render a widget with explicit assigns" do
+      test_action(:render_widget_with_explicit_assigns).should == "foobar"
+    end
+  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(RuntimeError, /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 allow rendering widget with needs" do
+      proc { test_action(:render_with_needs) }.should_not raise_error
+    end
+  end
+end