fortitude 0.0.1

data/spec/helpers/system_helpers.rb

@@ -0,0 +1,117 @@
+require 'active_support'
+require 'fortitude'
+
+module SystemHelpers
+  extend ActiveSupport::Concern
+
+  class IvarAccessible
+    def [](x)
+      instance_variable_get("@#{x}")
+    end
+
+    def []=(x, y)
+      instance_variable_set("@#{x}", y)
+    end
+  end
+
+  attr_reader :ivars
+
+  def rc(options = { })
+    options[:instance_variables_object] = ivars unless options.has_key?(:instance_variables_object)
+    ::Fortitude::RenderingContext.new(options)
+  end
+
+  def html_from(rendering_context)
+    rendering_context.output_buffer_holder.output_buffer.to_s
+  end
+
+  def define_helper(name, &block)
+    @helpers_class.send(:define_method, name, &block)
+  end
+
+  class TestDoctype < Fortitude::Doctypes::Base
+    def initialize
+      super(:test_doctype, "FORTITUDE TEST")
+    end
+
+    def close_void_tags?
+      true
+    end
+
+    def default_javascript_tag_attributes
+      { }
+    end
+
+    def needs_cdata_in_javascript_tag?
+      false
+    end
+
+    tag :p, :newline_before => true, :valid_attributes => %w{class}, :can_enclose => %w{a span br b _text}, :spec => 'THE_SPEC_FOR_P'
+    tag :div, :newline_before => true, :valid_attributes => %w{aaaaaaaaaaaaaa}, :can_enclose => %w{div p hr}
+    tag :span
+    tag :hr, :content_allowed => false
+    tag :br, :content_allowed => false, :spec => 'THE_SPEC_FOR_BR'
+    tag :a
+    tag :b
+    tag :nav, :newline_before => true
+    tag :h1, :newline_before => true
+    tag :img
+    tag :script, :newline_before => true, :escape_direct_content => false
+    tag :head, :newline_before => true
+    tag :style, :newline_before => true, :escape_direct_content => false
+  end
+
+  class TestWidgetClass < Fortitude::Widget
+    doctype TestDoctype.new
+  end
+
+  def widget_class(options = { }, &block)
+    klass = Class.new(options[:superclass] || TestWidgetClass, &block)
+    $spec_widget_seq ||= 0
+    $spec_widget_seq += 1
+    ::Object.const_set("SpecWidget#{$spec_widget_seq}", klass)
+    klass
+  end
+
+  def widget_class_with_content(options = { }, &block)
+    wc = widget_class(options)
+    wc.send(:define_method, :content, &block)
+    wc
+  end
+
+  def render(widget_or_class, options = { })
+    widget = if widget_or_class.kind_of?(Class)
+      widget_or_class.new(options[:assigns] || { })
+    else
+      widget_or_class
+    end
+    rendering_context = options[:rendering_context] || rc
+    widget.to_html(rendering_context)
+    html_from(rendering_context)
+  end
+
+  def capture_exception(klass = StandardError, &block)
+    out = nil
+    begin
+      block.call
+    rescue klass => e
+      out = e
+    end
+    raise "Exception of class #{klass.inspect} was expected, but none was raised" unless out
+    out
+  end
+
+  def render_content(options = { }, &block)
+    widget_class = widget_class_with_content(options, &block)
+    render(widget_class, options)
+  end
+
+  included do
+    before :each do
+      @helpers_class = Class.new
+      @helpers = @helpers_class.new
+      @ivars = IvarAccessible.new
+      @yield_block = double("yield_block")
+    end
+  end
+end

data/spec/rails/basic_rails_system_spec.rb

@@ -0,0 +1,7 @@
+describe "basic Rails support", :type => :rails do
+  uses_rails_with_template :basic_rails_system_spec
+
+  it "should be able to render a trivial widget" do
+    expect_match("trivial_widget", /layout_default/, /hello, world/)
+  end
+end

data/spec/rails/capture_system_spec.rb

@@ -0,0 +1,75 @@
+describe "Rails capture support", :type => :rails do
+  uses_rails_with_template :capture_system_spec
+
+  it "should successfully capture a widget partial with capture { } in an ERb view" do
+    expect_match('capture_widget_from_erb', %r{Widget text is:\s+<h3>\s*this is some_widget</h3>\s*END}mi)
+  end
+
+  it "should successfully capture an ERb partial with capture { } in a widget" do
+    expect_match('capture_erb_from_widget', %r{Widget text is:\s+<h3>\s*this is some_erb_partial</h3>\s*END}mi)
+  end
+
+  it "should successfully capture a widget with capture { } in a widget" do
+    expect_match('capture_widget_from_widget', %r{Rendered with widget:\s*<h3>\s*this is another_widget rendered_with_widget</h3>.*Rendered with render_partial:\s*<h3>\s*this is another_widget rendered_with_render_partial\s*</h3>\s*END}mi)
+  end
+
+  it "should be able to provide content in a widget with content_for" do
+    expect_match('widget_content_for',
+      %r{erb_layout_needing_content}i,
+      %r{Foo content is: <h5>this is content for foo!</h5>\s*<h5>this is more content for foo!</h5>}mi,
+      %r{Main content is: <h4>this is main_content!</h4>}mi,
+      %r{Bar content is: <h3>this is content for bar!</h3>\s*<h3>this is more content for bar!</h3>}mi,
+      :no_layout => true)
+  end
+
+  it "should be able to provide content in a widget with provide" do
+    skip "Rails 3.0.x doesn't support :provide" if @rails_server.rails_version =~ /^3\.0\./
+
+    expect_match('widget_provide',
+      %r{erb_layout_needing_content}i,
+      %r{Foo content is: <h5>this is content for foo!</h5>}mi,
+      %r{Main content is: <h4>this is main_content!</h4>}mi,
+      %r{Bar content is: <h3>this is content for bar!</h3>}mi,
+      :no_layout => true)
+  end
+
+  describe "should be able to retrieve stored content in a widget with yield :name" do
+    it "when provided by ERb" do
+      expect_match('widget_layout_needing_content_yield_with_erb',
+        %r{widget_layout_needing_content}mi,
+        %r{Foo content is: <h5>this is content for foo!</h5>\s*<h5>this is more content for foo!</h5>}mi,
+        %r{Main content is: <h4>this is main_content!</h4>}mi,
+        %r{Bar content is: <h3>this is content for bar!</h3>\s*<h3>this is more content for bar!</h3>}mi,
+        :no_layout => true)
+    end
+
+    it "when provided by a widget" do
+      expect_match('widget_layout_needing_content_yield_with_widget',
+        %r{widget_layout_needing_content}mi,
+        %r{Foo content is: <h5>this is content for foo!</h5>\s*<h5>this is more content for foo!</h5>}mi,
+        %r{Main content is: <h4>this is main_content!</h4>}mi,
+        %r{Bar content is: <h3>this is content for bar!</h3>\s*<h3>this is more content for bar!</h3>}mi,
+        :no_layout => true)
+    end
+  end
+
+  describe "should be able to retrieve stored content in a widget with content_for :name" do
+    it "when provided by ERb" do
+      expect_match('widget_layout_needing_content_content_for_with_erb',
+        %r{widget_layout_needing_content}mi,
+        %r{Foo content is: <h5>this is content for foo!</h5>\s*<h5>this is more content for foo!</h5>}mi,
+        %r{Main content is: <h4>this is main_content!</h4>}mi,
+        %r{Bar content is: <h3>this is content for bar!</h3>\s*<h3>this is more content for bar!</h3>}mi,
+        :no_layout => true)
+    end
+
+    it "when provided by a widget" do
+      expect_match('widget_layout_needing_content_content_for_with_widget',
+        %r{widget_layout_needing_content}mi,
+        %r{Foo content is: <h5>this is content for foo!</h5>\s*<h5>this is more content for foo!</h5>}mi,
+        %r{Main content is: <h4>this is main_content!</h4>}mi,
+        %r{Bar content is: <h3>this is content for bar!</h3>\s*<h3>this is more content for bar!</h3>}mi,
+        :no_layout => true)
+    end
+  end
+end

data/spec/rails/class_loading_system_spec.rb

@@ -0,0 +1,63 @@
+describe "Rails class-loading support", :type => :rails do
+  uses_rails_with_template :class_loading_system_spec
+
+  it "should not load classes under app/views without the Views:: prefix" do
+    expect_exception('the_class_should_not_load', 'NameError',
+      /uninitialized constant ClassLoadingSystemSpec::ClassShouldNotLoad/i)
+  end
+
+  it "should allow me to define classes under Views:: outside of app/views, like in lib/views" do
+    expect_match('lib_views', /hello: i am lib\/views/)
+  end
+
+  it "should allow me to define classes under Views:: outside of app/views, but in some other autoloaded place, like app/models" do
+    expect_match('app_models', /hello: i am app\/models/)
+  end
+
+  it "should not create anonymous modules without the Views:: namespace for directories under app/views/" do
+    expect_exception('some_namespace', 'NameError', /uninitialized constant SomeNamespace/)
+    expect_exception('some_other_namespace', 'NameError', /uninitialized constant SomeNamespace/)
+    expect_match('views_some_namespace', /Views::SomeNamespace/, :no_layout => true)
+    expect_match('views_some_other_namespace', /Views::SomeNamespace::SomeOtherNamespace/, :no_layout => true)
+  end
+
+  it "should autoload widgets under app/views/" do
+    expect_match('autoload_widget', /autoload_widget is here!/, :no_layout => true)
+  end
+
+  it "should autoload one widget from another" do
+    expect_match('autoload_one_widget_from_another', /about to run the sub widget.*this is the sub widget.*ran the sub widget/)
+  end
+
+  it "should allow use of a widget defined in lib/ from a view widget" do
+    expect_match('use_lib_widget_from_view_widget', /about to run the lib widget.*this is the lib widget.*ran the lib widget/)
+  end
+
+  it "should allow use of a widget defined on another autoload path from a view widget" do
+    expect_match('use_models_widget_from_view_widget', /about to run the models widget.*this is the models widget.*ran the models widget/)
+  end
+
+  it "should not allow me to define widgets outside of app/views/" do
+    expect_exception('widget_defined_outside_app_views', 'ActionView::MissingTemplate', /class_loading_system_spec\/widget_defined_outside_app_views/)
+  end
+
+  it "should not let me define a widget in a file starting with an underscore, and use it for a view" do
+    expect_exception('underscore_view', 'ActionView::MissingTemplate', /class_loading_system_spec\/underscore_view/)
+  end
+
+  it "should not let me define a widget in a file starting with an underscore, and autoload it" do
+    expect_exception('underscore_widget', 'NameError', /uninitialized constant Views::ClassLoadingSystemSpec::UnderscoreWidget/)
+  end
+
+  it "should not let me 'require' files in app/views without a views/ prefix" do
+    expect_exception('require_loaded_underscore_widget_without_views', 'LoadError', /(cannot load such file|no such file to load)/)
+  end
+
+  it "should not let me 'require' files in app/views with a views/ prefix" do
+    expect_exception('require_loaded_underscore_widget_with_views', 'LoadError', /(cannot load such file|no such file to load)/)
+  end
+
+  it "should let me render a widget defined outside of app/views/ if I use render :widget" do
+    expect_match('render_widget_outside_app_views', /arbitrary_name_some_widget/)
+  end
+end

data/spec/rails/complex_helpers_system_spec.rb

@@ -0,0 +1,33 @@
+describe "Rails complex helper support", :type => :rails do
+  uses_rails_with_template :complex_helpers_system_spec
+
+  it "should render form_for correctly" do
+    expect_match("form_for_test",
+      %r{OUTSIDE_BEFORE\s*<form.*action=\"/complex_helpers_system_spec/form_for_test\".*
+        INSIDE_BEFORE\s*
+        FIRST:\s*<input.*person_first_name.*/>\s*
+        LAST:\s*<input.*person_last_name.*/>\s*
+        INSIDE_AFTER\s*
+        </form>\s*
+        OUTSIDE_AFTER}mix)
+  end
+
+  it "should render fields_for correctly" do
+    expect_match("fields_for_test",
+      %r{OUTSIDE_BEFORE\s*
+        INSIDE_BEFORE\s*
+        FIRST:\s*<input.*person_first_name.*/>\s*
+        LAST:\s*<input.*person_last_name.*/>\s*
+        INSIDE_AFTER\s*
+        OUTSIDE_AFTER}mix)
+  end
+
+  it "should cache based on a name properly" do
+    expect_match("cache_test?a=a1&b=b1",
+      /before_cache\(a1,b1\).*inside_cache\(a1,b1\).*after_cache\(a1,b1\)/mi)
+    expect_match("cache_test?a=a1&b=b2",
+      /before_cache\(a1,b2\).*inside_cache\(a1,b1\).*after_cache\(a1,b2\)/mi)
+    expect_match("cache_test?a=a2&b=b2",
+      /before_cache\(a2,b2\).*inside_cache\(a2,b2\).*after_cache\(a2,b2\)/mi)
+  end
+end

data/spec/rails/data_passing_system_spec.rb

@@ -0,0 +1,96 @@
+describe "Rails data-passing support", :type => :rails do
+  uses_rails_with_template :data_passing_system_spec
+
+  it "should allow passing data to the widget through controller variables" do
+    expect_match("passing_data_widget", /foo is: the_foo/, /bar is: and_bar/)
+  end
+
+  it "should not fail if the controller provides more data than it needs" do
+    expect_match("extra_data_widget", /foo is: the_foo/, /bar is: and_bar/)
+  end
+
+  it "should allow passing data to the widget through :locals => { ... }" do
+    expect_match("passing_locals_widget", /foo is: local_foo/, /bar is: local_bar/)
+  end
+
+  it "should merge locals and controller variables, with locals winning" do
+    expect_match("passing_locals_and_controller_variables_widget", /foo is: controller_foo/, /bar is: local_bar/, /baz is: local_baz/)
+  end
+
+  it "should give you a reasonable error if you omit a variable" do
+    expect_exception('omitted_variable', 'Fortitude::Errors::MissingNeed', /bar/)
+  end
+
+  it "should not propagate un-needed variables" do
+    expect_match("extra_variables", /foo method call: the_foo/, /foo instance var: nil/,
+      /bar method call: NoMethodError/, /bar instance var: nil/,
+      /baz method call: NoMethodError/, /baz instance var: nil/)
+  end
+
+  it "should propagate un-needed variables, if asked" do
+    expect_match("extra_variables_requested", /foo method call: the_foo/, /foo instance var: nil/,
+      /bar method call: the_bar/, /bar instance var: nil/,
+      /baz method call: the_baz/, /baz instance var: nil/)
+  end
+
+  it "should not propagate a controller variable through a view to a child widget without being explicitly passed" do
+    expect_exception('parent_to_child_passing', 'Fortitude::Errors::MissingNeed', /foo/)
+  end
+
+  it "should propagate a controller variable through a view to a child widget without being explicitly passed, if invoked using render :partial" do
+    expect_match('parent_to_child_passing_partial', /parent before.*foo: the_foo.*parent after/)
+  end
+
+  it "should let a widget read a controller variable explicitly, as a Symbol or a String" do
+    expect_match("explicit_controller_variable_read", /explicit foo as symbol: the_foo/)
+    expect_match("explicit_controller_variable_read", /explicit foo as string: the_foo/)
+  end
+
+  it "should let a widget read a controller variable set by an earlier ERb view" do
+    expect_match("erb_to_parallel_widget_handoff", /widget foo: foo_from_erb/)
+  end
+
+  it "should let a widget write a controller variable that a later ERb view can read" do
+    expect_match("widget_to_parallel_erb_handoff", /erb foo: foo_from_widget/)
+  end
+
+  it "should let both controller variables and locals get picked up by the layout, as well as the view" do
+    expect_match("variables_to_layout", /widget_default_layout: foo = the_foo, bar = the_bar.*widget foo: the_foo, widget bar: the_bar/, :no_layout => true)
+  end
+
+  describe "backwards-compatible instance-variable mode" do
+    it "should let a widget read a controller variable implicitly" do
+      expect_match("implicit_variable_read", /inner widget foo: foo_from_controller/)
+    end
+
+    it "should let a widget write a controller variable implicitly" do
+      expect_match("implicit_variable_write", /erb foo: foo_from_widget/)
+    end
+
+    it "should let a widget read a controller variable set by an earlier ERb view" do
+      expect_match("implicit_erb_to_widget_handoff", /widget foo: foo_from_erb/)
+    end
+
+    it "should not enable access to local variables via @foo directly" do
+      expect_match("implicit_shared_variable_access", /foo: nil/)
+    end
+
+    it "should inherit the setting for implicit_shared_variable_access properly" do
+      expect_match("implicit_shared_variable_access_inheritance", /C1: foo is , bar is .*C2: foo is the_foo, bar is the_bar/mi)
+    end
+
+    it "should have the same set of copied variables for ERb and a widget" do
+      widget_copied_variables = JSON.parse(get('widget_copied_variables'))['widget_copied_variables'].sort
+      erb_copied_variables = JSON.parse(get('erb_copied_variables'))['erb_copied_variables'].sort
+
+      common = widget_copied_variables & erb_copied_variables
+      extra_widget = widget_copied_variables - erb_copied_variables
+      missing_widget = erb_copied_variables - widget_copied_variables
+
+      extra_widget = extra_widget.reject { |v| v =~ /^@_fortitude_/i }
+
+      expect(extra_widget).to eq([ ])
+      expect(missing_widget).to eq([ ])
+    end
+  end
+end

data/spec/rails/default_layout_system_spec.rb

@@ -0,0 +1,15 @@
+describe "Rails default layout support", :type => :rails do
+  uses_rails_with_template :default_layout_system_spec
+
+  it "should let you use a default layout that's a widget, and render ERb inside it" do
+    data = get("erb_with_widget_default_layout")
+    data.should match(/widget_default_layout/i)
+    data.should match(/erb_with_widget_default_layout/i)
+  end
+
+  it "should let you use a default layout that's a widget, and render a widget inside it" do
+    data = get("widget_with_widget_default_layout")
+    data.should match(/widget_default_layout/i)
+    data.should match(/widget_with_widget_default_layout/i)
+  end
+end

data/spec/rails/development_mode_system_spec.rb

@@ -0,0 +1,67 @@
+describe "Rails development-mode support", :type => :rails do
+  uses_rails_with_template :development_mode_system_spec, :rails_env => :development
+
+  it "should automatically reload widgets if they change on disk" do
+    expect_match("reload_widget", /before_reload/)
+    # The sleep is unfortunate, but required: without it, Rails will not necessarily pick up our change,
+    # especially if we run multiple tests back-to-back. (There's a maximum frequency at which Rails can
+    # detect distinct file changes on disk, which on the order of 1 Hz -- i.e., once a second; any more
+    # than this and it fails. This is irrelevant for human-centered development, but important for
+    # tests like this.)
+    sleep 1
+    splat_new_widget!
+    expect_match("reload_widget", /after_reload/)
+  end
+
+  it "should let you change the controller, and that should work fine, too" do
+    expect_match("reload_widget", /datum\s+one\s+datum/)
+    sleep 1
+    splat_new_controller!
+    expect_match("reload_widget", /datum\s+two\s+datum/)
+  end
+
+  it "should, by default, format output" do
+    expect_match("sample_output", %r{<section class="one">
+  <p>hello, Jessica</p>
+</section>}mi)
+  end
+
+  it "should, by default, output BEGIN/END debugging tags" do
+    expect_match("sample_output", %r{<!-- BEGIN Views::DevelopmentModeSystemSpec::SampleOutput depth 0: :name => "Jessica" -->
+.*
+<!-- END Views::DevelopmentModeSystemSpec::SampleOutput depth 0 -->}mi)
+  end
+
+  private
+  def splat_new_widget!
+    reload_file = File.join(rails_server.rails_root, 'app/views/development_mode_system_spec/reload_widget.rb')
+    File.open(reload_file, 'w') do |f|
+      f.puts <<-EOS
+class Views::DevelopmentModeSystemSpec::ReloadWidget < Fortitude::Widgets::Html5
+  needs :datum
+
+  def content
+    p "after_reload: datum \#{datum} datum"
+  end
+end
+EOS
+    end
+  end
+
+  def splat_new_controller!
+    controller_file = File.join(rails_server.rails_root, 'app/controllers/development_mode_system_spec_controller.rb')
+    File.open(controller_file, 'w') do |f|
+      f.puts <<-EOS
+class DevelopmentModeSystemSpecController < ApplicationController
+  def reload_widget
+    @datum = "two"
+  end
+
+  def sample_output
+    @name = "Jessica"
+  end
+end
+EOS
+    end
+  end
+end

data/spec/rails/erb_integration_system_spec.rb

@@ -0,0 +1,23 @@
+describe "Rails ERb integration support", :type => :rails do
+  uses_rails_with_template :erb_integration_system_spec
+
+  it "should let you call a widget from an ERb file with render :partial" do
+    expect_match("erb_to_widget_with_render_partial", /erb to widget with render partial widget/,
+      /erb_start/, /erb_end/, /erb_start.*erb to widget with render partial widget.*erb_end/m)
+  end
+
+  it "should prefer ERb partials to Fortitude partials" do
+    expect_match("prefers_erb_partial", /erb partial/,
+      /erb_start.*erb partial.*erb_end/m)
+  end
+
+  it "should allow you to define a Fortitude partial in a file with an underscore" do
+    expect_match('fortitude_partial_with_underscore', /fortitude partial with underscore partial/,
+      /erb_start.*fortitude partial with underscore partial.*erb_end/m)
+  end
+
+  it "should let you call an ERb partial from a widget with render :partial" do
+    expect_match('erb_partial_from_widget',
+      /this is the widget.*this is the partial.*this is the widget again/mi)
+  end
+end

data/spec/rails/helpers_include_all_off_system_spec.rb

@@ -0,0 +1,7 @@
+describe "Fortitude helpers with config.action_controller.include_all_helpers = false", :type => :rails do
+  uses_rails_with_template :helpers_include_all_off_system_spec
+
+  it "should not include all helpers" do
+    expect_match("include_all_off", /excitedly: awesome!!!; uncertainly: NoMethodError/mi)
+  end
+end

data/spec/rails/helpers_system_spec.rb

@@ -0,0 +1,79 @@
+describe "Rails helper support", :type => :rails do
+  uses_rails_with_template :helpers_system_spec
+
+  it "should support the built-in Rails helpers by default" do
+    expect_match("basic_helpers",
+      /Three months ago: 3 months/mi,
+      /A million dollars: \$1,000,000\.00/mi,
+      %r{Select datetime:\s*<select.*name="date.*>.*<option.*value="2014".*</option>}mi)
+  end
+
+  it "should refine the built-in Rails helpers by default" do
+    expect_match("helpers_that_output_when_refined",
+      %r{START.*<img.*src="http://example.com/foo".*/><a href="mailto:test@example.com">test@example.com</a><link.*href="http://example.com/bar".*/>END}mi)
+  end
+
+  it "should support helpers that use blocks" do
+    expect_match("block_helpers",
+      %r{<body>\s*<form.*action="/form_dest".*>.*<input.*authenticity_token.*/>.*<p>inside the form</p>.*</form>}mi,
+      %r{})
+  end
+
+  it "should support built-in Rails helpers that output, rather than return, properly" do
+    expect_match("built_in_outputting_helpers",
+      %r{<div class=.concat_container.>.*this is concatted.*</div>.*<div class=.safe_concat_container.>.*this is safe_concatted.*</div>}mi)
+  end
+
+  it "should support custom-defined helpers" do
+    expect_match("custom_helpers_basic", %r{excited: awesome!!!})
+  end
+
+  it "should support custom-defined helpers that output, rather than return, properly" do
+    expect_match("custom_helper_outputs", %r{how awesome: super awesome!})
+  end
+
+  it "should support custom-defined helpers that take a block" do
+    expect_match("custom_helpers_with_a_block", %r{fedxxcbayyabcxxdef})
+  end
+
+  it "should allow changing a built-in Rails helper from outputting to returning" do
+    expect_match("built_in_outputting_to_returning", %r{<body>\s*<p>\s*text is: this is the_text\s*</p>\s*</body>}mi)
+  end
+
+  it "should allow changing a built-in Rails helper from returning to outputting" do
+    expect_match("built_in_returning_to_outputting", %r{<body>\s*it was 3 months, yo\s*</body>}mi)
+  end
+
+  it "should allow changing a custom-defined helper from outputting to returning" do
+    expect_match("custom_outputting_to_returning", %r{and super awesome!, yo}mi)
+  end
+
+  it "should allow changing a custom-defined helper from returning to outputting" do
+    expect_match("custom_returning_to_outputting", %r{and awesome!!!, yo}mi)
+  end
+
+  it "should inherit helper settings, but also let them be overridden" do
+    expect_match("helper_settings_inheritance", %r{it is really awesome!!!, yo\s*and super awesome!, too}mi)
+  end
+
+  it "should allow access to controller methods declared as helpers" do
+    expect_match("controller_helper_method", %r{it is \*\~\* Fred \*\~\*\!}mi)
+  end
+
+  it "should allow access to methods explicitly imported as helpers" do
+    expect_match("controller_helper_module", %r{and &gt;=== June ===&gt;}mi)
+  end
+
+  it "should allow turning off automatic helper access" do
+    expect_match("automatic_helpers_disabled", %r{excitedly: NoMethodError; time_ago_in_words: NoMethodError; number_to_currency: \$1,000,000.00})
+  end
+
+  it "should inherit automatic helper access properly" do
+    expect_match("automatic_helpers_inheritance", %r{C1: excitedly: NoMethodError; time_ago_in_words: NoMethodError; number_to_currency: \$1,000,000.00.*C2: excitedly: awesome!!!; time_ago_in_words: 3 months; number_to_currency: \$1,000,000.00})
+  end
+
+  it "should allow access to private helpers in exactly the same way as ERb" do
+    expect_match("private_helper_erb", %r{a private helper: private!})
+    expect_match("private_helper_fortitude", %r{a private helper: private!})
+  end
+end

data/spec/rails/helpers_unrefined_system_spec.rb

@@ -0,0 +1,7 @@
+describe "Fortitude unrefined Rails helper support", :type => :rails do
+  uses_rails_with_template :helpers_unrefined_system_spec
+
+  it "should not output when refined-outputting helpers are called" do
+    expect_match("helpers_that_output_when_refined", /STARTEND/)
+  end
+end

data/spec/rails/layouts_system_spec.rb

@@ -0,0 +1,60 @@
+describe "Rails layout support", :type => :rails do
+  uses_rails_with_template :layouts_system_spec
+
+  it "should let you use a widget in an ERb layout, and render in the right order" do
+    data = get("widget_inside_erb_layout")
+    data.should match(/default_layout_erb/i)
+    data.should match(/this is widget_inside_erb_layout/i)
+    data.should match(/pre_layout order: \[:widget_inside_erb_layout, :layout_pre\]/i)
+    data.should match(/post_layout order: \[:widget_inside_erb_layout, :layout_pre, :layout_post\]/i)
+    data.should match(/order inside widget: \[:widget_inside_erb_layout\]/i)
+    data.should match(/pre_layout foo: foo_from_widget_inside_erb_layout/i)
+    data.should match(/post_layout foo: foo_from_widget_inside_erb_layout/i)
+  end
+
+  it "should let you use a widget as a layout with an ERb view, and render in the right order" do
+    data = get("erb_inside_widget_layout")
+    data.should match(/widget_layout/i)
+    data.should match(/this is erb_inside_widget_layout/i)
+    data.should match(/pre_layout order: \[:erb_inside_widget_layout, :widget_layout_pre\]/i)
+    data.should match(/post_layout order: \[:erb_inside_widget_layout, :widget_layout_pre, :widget_layout_post\]/i)
+    data.should match(/order inside erb: \[:erb_inside_widget_layout\]/i)
+    data.should match(/pre_layout foo: foo_from_erb_inside_widget_layout/i)
+    data.should match(/post_layout foo: foo_from_erb_inside_widget_layout/i)
+  end
+
+  it "should let you use a widget as a layout with a widget view, and render in the right order" do
+    data = get("widget_inside_widget_layout")
+    data.should match(/widget_layout/i)
+    data.should match(/this is widget_inside_widget_layout/i)
+    data.should match(/pre_layout order: \[:widget_inside_widget_layout, :widget_layout_pre\]/i)
+    data.should match(/post_layout order: \[:widget_inside_widget_layout, :widget_layout_pre, :widget_layout_post\]/i)
+    data.should match(/order inside widget: \[:widget_inside_widget_layout\]/i)
+    data.should match(/pre_layout foo: foo_from_widget_inside_widget_layout/i)
+    data.should match(/post_layout foo: foo_from_widget_inside_widget_layout/i)
+  end
+
+  it "should use a layout with render :widget by default" do
+    data = get("render_widget")
+    data.should match(/default_layout_erb/i)
+    data.should match(/this is the_render_widget/i)
+  end
+
+  it "should let you turn off the layout with render :widget" do
+    data = get("render_widget_without_layout")
+    data.should_not match(/default_layout_erb/i)
+    data.should match(/this is the_render_widget/i)
+  end
+
+  it "should let you pick an alternate layout for render :widget" do
+    data = get("render_widget_with_alt_layout")
+    data.should match(/alternate_layout_erb/i)
+    data.should match(/this is the_render_widget/i)
+  end
+
+  it "should let you explicitly yield to the view" do
+    data = get("yield_from_widget_explicitly")
+    data.should match(/explicit_yield_layout/i)
+    data.should match(/this is yield_from_widget_explicitly/i)
+  end
+end