RubyGems - fortitude - Versions diffs - 0.0.4-java - Mend

fortitude 0.0.4-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (355) hide show

data/spec/rails/erb_integration_system_spec.rb ADDED

@@ -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 ADDED

@@ -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 ADDED

@@ -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 ADDED

@@ -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 ADDED

@@ -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

data/spec/rails/localization_system_spec.rb ADDED

@@ -0,0 +1,38 @@
+describe "basic Rails support", :type => :rails do
+  uses_rails_with_template :localization_system_spec
+  it "should allow you to provide localized content methods" do
+    expect_match("content_method?locale=en", /wassup\? this is english/mi)
+    expect_match("content_method?locale=fr", /bienvenue, les mecs/mi)
+    expect_match("content_method?locale=pt", /i don&#(39|x27);t know that language/mi)
+  end
+  it "should let you translate strings with I18n.t" do
+    expect_match("i18n_t?locale=en", /a house is: house/)
+    expect_match("i18n_t?locale=fr", /a house is: maison/)
+  end
+  it "should let you translate strings with just t" do
+    expect_match("t?locale=en", /a house is: house/)
+    expect_match("t?locale=fr", /a house is: maison/)
+  end
+  it "should support dot-notation for I18n translation naming" do
+    expect_match("dot_notation?locale=en", /awesome is: awesome!/)
+    expect_match("dot_notation?locale=fr", /awesome is: formidable!/)
+  end
+  it "should let you translate strings with Fortitude translation support" do
+    expect_match("native_support?locale=en", /not translated; also awesome 127!; also not translated/i)
+    expect_match("native_support?locale=fr", /not translated; encore formidable 127!; also not translated/i)
+  end
+  it "should let you readjust the translation base" do
+    expect_match("readjust_base?locale=en", /SUPA-awesome 127!/)
+    expect_match("readjust_base?locale=fr", /TOUS formidable, 127!/)
+  end
+  it "should not escape explicitly-HTML translations" do
+    expect_match("explicit_html", /one: foo<bar>, two: bar<baz>, one again: foo<bar>, two again: bar<baz>/i)
+  end
+end

data/spec/rails/production_mode_system_spec.rb ADDED

@@ -0,0 +1,13 @@
+describe "Rails production-mode support", :type => :rails do
+  uses_rails_with_template :production_mode_system_spec
+  it "should not, by default, format output" do
+    expect_match("sample_output", %r{<section class="one"><p>hello, Jessica</p></section>}i)
+  end
+  it "should not, by default, output BEGIN/END debugging tags" do
+    data = get_success("sample_output")
+    expect(data).not_to match(%r{<!--\s*BEGIN}mi)
+    expect(data).not_to match(%r{<!--\s*END}mi)
+  end
+end

data/spec/rails/rendering_context_system_spec.rb ADDED

@@ -0,0 +1,64 @@
+describe "Rails RenderingContext support", :type => :rails do
+  uses_rails_with_template :rendering_context_system_spec
+  it "should use the context returned by create_fortitude_rendering_context in the view" do
+    expect_match("uses_specified_context_in_view", /context is: SimpleRc, value 12345/)
+  end
+  it "should still use that context even for partials invoked by ERb" do
+    expect_match("uses_specified_context_in_partials", /before partial.*context is: SimpleRc, value 23456.*after partial/mi)
+  end
+  it "should use that context for partials through multiple layers of nesting" do
+    text = get_success("uses_specified_context_through_nesting")
+    if text =~ /view rc: SimpleRc, 34567, (\d+).*partial.*inner partial rc: SimpleRc, 34567, (\d+)/mi
+      first_value, second_value = Integer($1), Integer($2)
+      expect(first_value).to eq(second_value)
+    else
+      raise "Text did not match: #{text.inspect}"
+    end
+  end
+  it "should use that context for widgets rendered with render :widget" do
+    expect_match("uses_specified_context_in_render_widget", /context is: SimpleRc, value 45678/)
+  end
+  it "should use that context for widgets rendered with render :inline" do
+    expect_match("uses_specified_context_in_render_inline", /context is: SimpleRc, value 56789/)
+  end
+  it "should use the context returned by just plain fortitude_rendering_context in the view" do
+    expect_match("uses_direct_context_in_view", /context is: SimpleRc, value 67890/)
+  end
+  it "should still call that method for all widgets" do
+    expect_match("uses_direct_context_for_all_widgets", /context is: SimpleRc, value 67890.*context is: SimpleRc, value 67891.*context is: SimpleRc, value 67890/mi)
+  end
+  it "should call start_widget! and end_widget! properly on widgets in Rails" do
+    text = get_success("start_end_widget_basic")
+    lines = text.split(/[\r\n]+/)
+    lines = lines.select { |l| l =~ /^\d:/ }.map { |l| l.strip }
+    expect(lines[0]).to eq("0: start Views::RenderingContextSystemSpec::StartEndWidgetBasic")
+    expect(lines[1]).to eq("1: start Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 1")
+    expect(lines[2]).to eq("2: end Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 1")
+    expect(lines[3]).to eq("3: start Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 2")
+    expect(lines[4]).to eq("4: start Views::RenderingContextSystemSpec::StartEndWidgetBasicInner")
+    expect(lines[5]).to eq("5: end Views::RenderingContextSystemSpec::StartEndWidgetBasicInner")
+    expect(lines[6]).to eq("6: end Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 2")
+    expect(lines.length).to eq(7)
+  end
+  it "should call start_widget! and end_widget! through ERb partials, passing them as hashes" do
+    text = get_success("start_end_widget_through_partials")
+    lines = text.split(/[\r\n]+/)
+    lines = lines.select { |l| l =~ /^\d:/ }.map { |l| l.strip }
+    expect(lines[0]).to eq("0: start Views::RenderingContextSystemSpec::StartEndWidgetThroughPartials")
+    expect(lines[1]).to eq("1: start [{:partial=>\"start_end_widget_through_partials_partial\"}]")
+    expect(lines[2]).to eq("2: start Views::RenderingContextSystemSpec::StartEndWidgetThroughPartialsPartialWidget 12345")
+    expect(lines[3]).to eq("3: end Views::RenderingContextSystemSpec::StartEndWidgetThroughPartialsPartialWidget 12345")
+    expect(lines[4]).to eq("4: end [{:partial=>\"start_end_widget_through_partials_partial\"}]")
+    expect(lines.length).to eq(5)
+  end
+end

data/spec/rails/rendering_system_spec.rb ADDED

@@ -0,0 +1,158 @@
+describe "Rails rendering support", :type => :rails do
+  uses_rails_with_template :rendering_system_spec
+  describe "rendering from a controller" do
+    it "should let you specify a widget with 'render :action =>'" do
+      expect_match("render_with_colon_action", /hello, world/)
+    end
+    it "should let you specify a widget with 'render :template =>'" do
+      expect_match("render_with_colon_template", /hello, world/)
+    end
+    it "should let you specify a widget with 'render :widget =>', which should use a layout by default" do
+      data = expect_match("render_widget", /hello from a widget named Fred/)
+      expect(data).to match(/rails_spec_application/)
+    end
+    it "should let you omit the layout with 'render :widget =>', if you ask for it" do
+      data = expect_match("render_widget_without_layout", /hello from a widget named Fred/, :no_layout => true)
+      expect(data).not_to match(/rails_spec_application/)
+    end
+    it "should let you render a widget with 'render \"foo\"'" do
+      expect_match("render_widget_via_file_path", /hello from a widget named Fred/)
+    end
+    it "should let you render a widget with 'render :file =>'" do
+      expect_match("render_widget_via_colon_file", /hello from a widget named Fred/)
+    end
+    it "should let you render a widget inline with 'render :inline =>'" do
+      expect_match("render_widget_via_inline", /this is an inline widget named Fred/)
+    end
+    it "should let you render a widget inline, and use all instance and local variables, with locals overriding instance variables" do
+      expect_match("render_widget_via_inline_with_var_access", /this is an inline widget named Fred, and it is 27 years old, and friends with Mary/)
+    end
+  end
+  describe "rendering in a widget" do
+    it "should let you render a partial in a widget" do
+      expect_match("render_partial_from_widget", /this is the widget.*this is the_partial.*this is the widget again/mi)
+    end
+    it "should let you render :text in a widget" do
+      expect_match("render_text_from_widget", /this is the widget.*this is render_text.*this is the widget again/mi)
+    end
+    it "should let you render :template in a widget" do
+      expect_match("render_template_from_widget", /this is the widget.*widget_with_name: Fred.*this is the widget again/mi)
+    end
+    it "should let you render :inline in a widget" do
+      expect_match("render_inline_from_widget", /this is the widget.*widget_with_name: Fred.*this is the widget again/mi)
+    end
+    it "should let you render :file in a widget" do
+      expect_match("render_file_from_widget", /this is the widget.*widget_with_name: Fred.*this is the widget again/mi)
+    end
+  end
+  describe "render options" do
+    it "should let you set the content-type" do
+      data = get_response("render_with_content_type")
+      expect(data.body.strip).to match(/hello, world/)
+      content_type = data.header['content-type']
+      expect(content_type).to match(%r{^boo/yeah(;.*)?$})
+    end
+    it "should let you set the location" do
+      data = get_response("render_with_location")
+      expect(data.body.strip).to match(/hello, world/)
+      location = data.header['location']
+      expect(location).to eq("http://somewhere/over/the/rainbow")
+    end
+    it "should let you set the status" do
+      data = get_response("render_with_status", :ignore_status_code => true)
+      expect(data.code.to_s).to eq("768")
+    end
+  end
+  describe "rendering partial invocation" do
+    it "should render a collection correctly if so invoked" do
+      expect_match("render_collection", /collection is:.*word: apple.*word: pie.*word: is.*word: nice.*and that's all!/mi)
+    end
+    it "should support :as for rendering" do
+      expect_match("render_collection_as", /collection is:.*widget_with_name: bonita.*widget_with_name: applebaum.*widget_with_name: the.*widget_with_name: dude.*and that's all!/mi)
+    end
+    it "should support :object for rendering" do
+      expect_match("render_object", /partial is:.*word: donkey.*and that's all!/mi)
+    end
+    it "should support ERb partial layouts" do
+      expect_match("render_partial_with_layout", /this is the partial:.*partial_layout before.*partial_with_layout.*partial_layout after.*done!/mi)
+    end
+    it "should support using a widget as an ERb partial layout" do
+      expect_match("render_partial_with_widget_layout", /this is the partial:.*widget_partial_layout before.*partial_with_layout.*widget_partial_layout after.*done!/mi)
+    end
+  end
+  describe "HTML escaping" do
+    it "should only escape strings that aren't raw() or html_safe(), and do the right thing with h()" do
+      expect_match("render_html_safe_strings", /a: foo&lt;bar, b: bar<baz, c: baz<quux, d: quux&lt;marph, e: marph>foo/)
+    end
+  end
+  describe "streaming support" do
+    # Actually trying to get streaming working completely is a VERY finicky business, and we don't want to fail
+    # our tests just because (e.g.) we can't get buffering 100% disabled on this platform. So, we:
+    #
+    # * Use Net::HTTP to collect the HTTP/1.1 transfer chunks of the response; there should be more than one if
+    #   we're actually streaming (and there ends up being just 1 if you don't tell it to stream, or if Rails
+    #   detects that your template engine doesn't support streaming);
+    # * Collect the rendering order server-side and output it; if streaming, we'll render the top of the layout,
+    #   then the widget, then the bottom of the layout, completely differently from Rails' default mechanism of
+    #   rendering the view first, then the layout.
+    def collect_chunks(path)
+      chunks = [ ]
+      uri = rails_server.uri_for(full_path(path))
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        request = Net::HTTP::Get.new uri.request_uri
+        http.request(request) do |response|
+          response.read_body do |chunk|
+            chunks << chunk
+          end
+        end
+      end
+      chunks
+    end
+    it "should let you stream a pure widget" do
+      skip "currently, we can't figure out a way to test this for certain -- we get just one chunk no matter what we do"
+      chunks = collect_chunks("stream_widget")
+      expect(chunks.length).to be > 1
+    end
+    it "should let you stream from a widget that's in an ERb layout" do
+      skip("Fortitude streaming test is not supported under Rails 3.0.x") if @rails_server.rails_version =~ /^3\.0\./
+      skip("Fortitude streaming test is not supported under Ruby 1.8") if RUBY_VERSION =~ /^1\.8\./
+      chunks = collect_chunks("stream_widget_with_layout")
+      expect(chunks.length).to be > 1
+      full_text = chunks.join("")
+      expect(full_text).to match(/start_of_layout order:\s+\[:layout_start\]/mi)
+      expect(full_text).to match(/end_of_widget order:\s+\[:layout_start, :widget\]/mi)
+      expect(full_text).to match(/end_of_layout order:\s+\[:layout_start, :widget, :layout_end\]/mi)
+    end
+  end
+end