fortitude 0.9.1 → 0.9.2

data/lib/fortitude/rails/helpers.rb

@@ -59,9 +59,9 @@ module Fortitude
       # form_helper
       FORM_FOR_YIELDED_METHODS_TO_OUTPUT =
         # Directly from form_helper
-        %w{check_box color_field date_field datetime_field datetime_local_field} +
+        %w{button check_box color_field date_field datetime_field datetime_local_field} +
         %w{email_field file_field hidden_field label month_field number_field password_field phone_field} +
-        %w{radio_button range_field search_field telephone_field text_area text_field time_field url_field} +
+        %w{radio_button range_field search_field submit telephone_field text_area text_field time_field url_field} +
         %w{week_field} +
 
         # From form_options_helper

data/lib/fortitude/rendering_context.rb

@@ -140,6 +140,15 @@ module Fortitude
       @newline_needed = true
     end
 
+    def suppress_formatting!
+      @suppress_formatting_level ||= 0
+      @suppress_formatting_level += 1
+    end
+
+    def desuppress_formatting!
+      @suppress_formatting_level -= 1
+    end
+
     def current_indent
       ("  " * @indent).freeze
     end
@@ -155,7 +164,7 @@ module Fortitude
     end
 
     def about_to_output_non_whitespace!
-      if @newline_needed
+      if @newline_needed && ((@suppress_formatting_level ||= 0) == 0)
         if @have_output
           o = @output_buffer_holder.output_buffer
           o.original_concat(NEWLINE)

data/lib/fortitude/tags/tag.rb

@@ -31,7 +31,7 @@ module Fortitude
 
       def initialize(name, options = { })
         options.assert_valid_keys(:valid_attributes, :newline_before, :content_allowed, :can_enclose,
-          :allow_data_attributes, :allow_aria_attributes, :spec, :escape_direct_content)
+          :allow_data_attributes, :allow_aria_attributes, :spec, :escape_direct_content, :suppress_formatting_inside)
 
         @name = self.class.normalize_tag_name(name)
 
@@ -42,6 +42,7 @@ module Fortitude
         @allow_data_attributes = true unless options.has_key?(:allow_data_attributes) && (! options[:allow_data_attributes])
         @allow_aria_attributes = true unless options.has_key?(:allow_aria_attributes) && (! options[:allow_aria_attributes])
         @escape_direct_content = true unless options.has_key?(:escape_direct_content) && (! options[:escape_direct_content])
+        @suppress_formatting_inside = !! options[:suppress_formatting_inside]
         @spec = options[:spec]
       end
 
@@ -141,7 +142,7 @@ module Fortitude
         needs_formatting = !! options[:enable_formatting]
 
         if needs_formatting && @newline_before
-          yield_call = "_fortitude_formatted_output_tag_yield(:#{name}) { yield }"
+          yield_call = "_fortitude_formatted_output_tag_yield(:#{name}, #{@suppress_formatting_inside.inspect}) { yield }"
         elsif needs_formatting
           yield_call = "yield; rc.about_to_output_non_whitespace!"
         else

data/lib/fortitude/tags/tag_support.rb

@@ -18,17 +18,22 @@ module Fortitude
 
       FORTITUDE_TAG_PARTIAL_OPEN_END = ">".freeze
 
-      def _fortitude_formatted_output_tag_yield(tag_name)
+      def _fortitude_formatted_output_tag_yield(tag_name, suppress_formatting_inside)
         rc = @_fortitude_rendering_context
         if rc.format_output?
           rc.needs_newline!
           rc.increase_indent!
           begin
+            rc.suppress_formatting! if suppress_formatting_inside
             yield
           ensure
             rc.decrease_indent!
-            rc.needs_newline!
-            rc.about_to_output_non_whitespace!
+            if suppress_formatting_inside
+              rc.desuppress_formatting!
+            else
+              rc.needs_newline!
+              rc.about_to_output_non_whitespace!
+            end
           end
         else
           yield

data/lib/fortitude/tilt/fortitude_template.rb

@@ -7,7 +7,11 @@ module Fortitude
   module Tilt
     class FortitudeTemplate < ::Tilt::Template
       def prepare
-        ::Object.class_eval(data)
+        if file && line
+          ::Object.class_eval(data, file, line)
+        else
+          ::Object.class_eval(data)
+        end
 
         # 2014-06-19 ageweke -- Earlier versions of Tilt try to instantiate the engine with an empty tempate as a way
         # of making sure it can be created, so we have to support this case.
@@ -26,7 +30,7 @@ module Fortitude
           :yield_block => block, :render_yield_result => false,
           :helpers_object => scope, :instance_variables_object => scope })
 
-        widget_assigns = { }.with_indifferent_access
+        widget_assigns = { }
 
         scope.instance_variables.each do |instance_variable_name|
           if instance_variable_name.to_s =~ /^\@(.*)$/

data/lib/fortitude/version.rb

@@ -1,3 +1,3 @@
 module Fortitude
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
 end

data/lib/fortitude/widget.rb

@@ -15,6 +15,7 @@ require 'fortitude/widget/capturing'
 require 'fortitude/widget/rendering'
 require 'fortitude/widget/temporary_overrides'
 require 'fortitude/widget/files'
+require 'fortitude/widget/convenience'
 
 require 'fortitude/doctypes'
 
@@ -40,6 +41,7 @@ module Fortitude
     include Fortitude::Widget::Rendering
     include Fortitude::Widget::TemporaryOverrides
     include Fortitude::Widget::Files
+    include Fortitude::Widget::Convenience
 
     if defined?(::Rails)
       require 'fortitude/rails/widget_methods'

data/lib/fortitude/widget/convenience.rb

@@ -0,0 +1,30 @@
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module Convenience
+      def content_and_attributes_from_tag_arguments(content_or_attributes = nil, attributes = nil)
+        if (! attributes) && content_or_attributes.kind_of?(Hash)
+          [ nil, (content_or_attributes || { }) ]
+        else
+          [ content_or_attributes, (attributes || { }) ]
+        end
+      end
+
+      def add_css_classes(classes_to_add, a = nil, b = nil)
+        classes_to_add = Array(classes_to_add)
+        content, attributes = content_and_attributes_from_tag_arguments(a, b)
+
+        attributes = if attributes.has_key?('class')
+          attributes.merge('class' => (Array(attributes['class'] || [ ]) + classes_to_add))
+        else
+          attributes.merge(:class => (Array(attributes[:class] || [ ]) + classes_to_add))
+        end
+
+        [ content, attributes ]
+      end
+
+      alias_method :add_css_class, :add_css_classes
+    end
+  end
+end

data/lib/fortitude/widget/files.rb

@@ -7,14 +7,16 @@ module Fortitude
       extend ActiveSupport::Concern
 
       class CannotDetermineWidgetClassNameError < StandardError
-        attr_reader :tried_class_names, :filename, :magic_comment_texts
+        attr_reader :tried_class_names, :filename, :magic_comment_texts, :resulting_objects, :class_names_to_try
 
         def initialize(tried_class_names, options = { })
-          options.assert_valid_keys(:filename, :magic_comment_texts)
+          options.assert_valid_keys(:filename, :magic_comment_texts, :resulting_objects, :class_names_to_try)
 
           @tried_class_names = tried_class_names
           @filename = options[:filename]
           @magic_comment_texts = options[:magic_comment_texts]
+          @resulting_objects = options[:resulting_objects]
+          @class_names_to_try = options[:class_names_to_try]
           from_what = filename ? "from the file '#{filename}'" : "from some Fortitude source code"
 
           super %{You asked for a Fortitude widget class #{from_what},
@@ -25,9 +27,10 @@ We tried the following class names, in order:
 #{tried_class_names.join("\n")}
 
 ...but none of them both existed and were a class that eventually inherits from
-::Fortitude::Widget.
+::Fortitude::Widget. (We got back resulting objects: #{resulting_objects.inspect})
 
-You can either pass the class name into this method via the :class_names_to_try option,
+You can either pass the class name into this method via the :class_names_to_try option
+(we were passed #{class_names_to_try.inspect}),
 or add a "magic comment" to the source code of this widget that looks like this:
 
 #!<token>: <class_name>
@@ -70,8 +73,9 @@ or add a "magic comment" to the source code of this widget that looks like this:
             scan_source_for_possible_class_names(source)
 
           out = widget_class_from_class_names(all_class_names)
+          resulting_objects = out[:resulting_objects]
 
-          unless out
+          unless out[:widget_class]
             if options[:filename]
               require options[:filename]
             else
@@ -79,11 +83,13 @@ or add a "magic comment" to the source code of this widget that looks like this:
             end
 
             out = widget_class_from_class_names(all_class_names)
+            resulting_objects += out[:resulting_objects]
           end
 
-          out || (
+          out[:widget_class] || (
             raise CannotDetermineWidgetClassNameError.new(all_class_names, :magic_comment_texts => magic_comment_texts,
-              :filename => options[:filename]))
+              :filename => options[:filename], :resulting_objects => resulting_objects,
+              :class_names_to_try => options[:class_names_to_try]))
         end
 
         private
@@ -118,8 +124,9 @@ or add a "magic comment" to the source code of this widget that looks like this:
           while module_nesting.length > 0
             possible_module_name = module_nesting.join("::")
             out.reverse.each do |class_name|
-              out.unshift("#{possible_module_name}::#{class_name}")
+              out.push("#{possible_module_name}::#{class_name}")
             end
+            out.push(possible_module_name)
             module_nesting.pop
           end
 
@@ -127,7 +134,10 @@ or add a "magic comment" to the source code of this widget that looks like this:
         end
 
         def widget_class_from_class_names(class_names)
-          out = nil
+          out = {
+            :widget_class      => nil,
+            :resulting_objects => [ ]
+          }
 
           class_names.each do |class_name|
             class_name = $1 if class_name =~ /^:+(.*)$/i
@@ -138,11 +148,12 @@ or add a "magic comment" to the source code of this widget that looks like this:
             end
 
             if is_widget_class?(klass)
-              out = klass
+              out[:widget_class] = klass
               break
+            elsif klass
+              out[:resulting_objects] << klass
             end
           end
-
           out
         end
 

data/lib/fortitude/widget/needs.rb

@@ -80,11 +80,13 @@ module Fortitude
 
         # PUBLIC API
         def extract_needed_assigns_from(input)
-          input = input.with_indifferent_access
-
           out = { }
           needs_as_hash.keys.each do |name|
-            out[name] = input[name] if input.has_key?(name)
+            if input.has_key?(name)
+              out[name] = input[name]
+            elsif input.has_key?(name.to_s)
+              out[name] = input[name.to_s]
+            end
           end
           out
         end

data/spec/helpers/system_helpers.rb

@@ -66,6 +66,7 @@ module SystemHelpers
     tag :script, :newline_before => true, :escape_direct_content => false
     tag :head, :newline_before => true
     tag :style, :newline_before => true, :escape_direct_content => false
+    tag :pre, :newline_before => true, :suppress_formatting_inside => true
   end
 
   class TestWidgetClass < Fortitude::Widget

data/spec/rails/development_mode_system_spec.rb

@@ -97,7 +97,6 @@ describe "Rails development-mode support", :type => :rails do
       end
 
       sleep 1
-      $stderr.puts "checking for #{current_form.inspect}"
       expect_match("edit", /#{Regexp.escape(current_form.to_s)}/i)
 
       current_form = if current_form == :full_reference

data/spec/rails/rendering_system_spec.rb

@@ -52,10 +52,16 @@ describe "Rails rendering support", :type => :rails do
       expect(response.header['Content-Type']).to match(%r{text/html}i)
     end
 
-    it "should let you render a widget with 'render \"foo\"'" do
+    it "should let you render a widget with 'render \"foo\" and the full path'" do
+      skip "Rails 4.2 makes this mean something different (render :template, vs. render :file)" unless rails_server.rails_version =~ /^(3\.|4\.[01]\.)/
       expect_match("render_widget_via_file_path", /hello from a widget named Fred/)
     end
 
+    it "should let you render a widget with 'render \"foo\"' and the template path" do
+      skip "Rails 4.2 enables this" if rails_server.rails_version =~ /^(3\.|4\.[01]\.)/
+      expect_match("render_widget_via_template_path", /hello, world/)
+    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
@@ -67,6 +73,19 @@ describe "Rails rendering support", :type => :rails do
     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
+
+    it "should let you pass a subclass of Hash, and not accidentally get rid of it via #with_indifferent_access" do
+      expect_match("render_hash_subclass", /the_hash class: MyHash/,
+        /the_hash\[:foo\] "bar"/,
+        /the_hash\["foo"\] nil/,
+        /the_hash\[:bar\] nil/,
+        /the_hash\["bar"\] :baz/,
+        /other_hash class: Hash/,
+        /other_hash\[:quux\] nil/,
+        /other_hash\["quux"\] "bazzle"/,
+        /other_hash\[:marph\] :bar/,
+        /other_hash\["marph"\] nil/)
+    end
   end
 
   describe "rendering in a widget" do

data/spec/rails/templates/rendering_system_spec/app/controllers/rendering_system_spec_controller.rb

@@ -37,6 +37,10 @@ class RenderingSystemSpecController < ApplicationController
     render File.join(Rails.root, 'app', 'views', 'widget_to_render')
   end
 
+  def render_widget_via_template_path
+    render "rendering_system_spec/trivial_widget"
+  end
+
   def render_widget_via_colon_file
     @name = "Fred"
     render :file => File.join(Rails.root, 'app', 'views', 'widget_to_render')
@@ -125,4 +129,13 @@ class RenderingSystemSpecController < ApplicationController
     @d = "quux<marph"
     @e = "marph>foo".html_safe
   end
+
+  def render_hash_subclass
+    require 'my_hash'
+
+    @the_hash = MyHash.new
+    @the_hash[:foo] = 'bar'
+    @the_hash['bar'] = :baz
+    @other_hash = { 'quux' => 'bazzle', :marph => :bar }
+  end
 end

data/spec/rails/templates/rendering_system_spec/app/views/rendering_system_spec/render_hash_subclass.rb

@@ -0,0 +1,18 @@
+class Views::RenderingSystemSpec::RenderHashSubclass < Fortitude::Widgets::Html5
+  needs :the_hash, :other_hash
+
+  def content
+    text "the_hash class: #{the_hash.class.name}\n"
+    # text "is_my_hash? #{the_hash.is_my_hash?.inspect}\n"
+    text "the_hash[:foo] #{the_hash[:foo].inspect}\n"
+    text "the_hash[\"foo\"] #{the_hash['foo'].inspect}\n"
+    text "the_hash[:bar] #{the_hash[:bar].inspect}\n"
+    text "the_hash[\"bar\"] #{the_hash['bar'].inspect}\n"
+
+    text "other_hash class: #{other_hash.class.name}\n"
+    text "other_hash[:quux] #{other_hash[:quux].inspect}\n"
+    text "other_hash[\"quux\"] #{other_hash['quux'].inspect}\n"
+    text "other_hash[:marph] #{other_hash[:marph].inspect}\n"
+    text "other_hash[\"marph\"] #{other_hash['marph'].inspect}\n"
+  end
+end

data/spec/rails/templates/rendering_system_spec/lib/my_hash.rb

@@ -0,0 +1,5 @@
+class MyHash < Hash
+  def is_my_hash?
+    :my_hash
+  end
+end

data/spec/system/convenience_methods_system_spec.rb

@@ -49,4 +49,170 @@ hi, there
 </div>})
     end
   end
+
+  describe "#content_and_attributes_from_tag_arguments" do
+    let(:test_widget_instance) { widget_class.new }
+
+    def caafta(*args)
+      test_widget_instance.content_and_attributes_from_tag_arguments(*args)
+    end
+
+    it "should return nil and empty-hash for passing nothing" do
+      expect(caafta()).to eq([ nil, { } ])
+    end
+
+    it "should return text if passed just text" do
+      expect(caafta("foo")).to eq([ "foo", { } ])
+    end
+
+    it "should return attributes if passed just that" do
+      expect(caafta(:class => :bar)).to eq([ nil, { :class => :bar }])
+    end
+
+    it "should return text and attributes if passed that" do
+      expect(caafta("foo", :class => :bar)).to eq([ "foo", { :class => :bar }])
+    end
+  end
+
+  describe "#add_css_classes" do
+    let(:widget_class_with_p_added_base) {
+      widget_class do
+        def classes_to_add
+          [ :foo, :bar ]
+        end
+
+        def call_add_css_classes(*args)
+          add_css_classes(classes_to_add, *args)
+        end
+
+        def p_added(*args, &block)
+          p(*call_add_css_classes(*args), &block)
+        end
+      end
+    }
+
+    def widget_class_with_p_added(&block)
+      widget_class(:superclass => widget_class_with_p_added_base, &block)
+    end
+
+    def widget_class_with_p_added_content(&block)
+      widget_class_with_content(:superclass => widget_class_with_p_added_base, &block)
+    end
+
+    it "should correctly add classes if passed nothing at all" do
+      expect(render(widget_class_with_p_added_content { p_added })).to eq(%{<p class="foo bar"></p>})
+    end
+
+    it "should correctly add classes if passed just text" do
+      expect(render(widget_class_with_p_added_content { p_added "hello" })).to eq(%{<p class="foo bar">hello</p>})
+    end
+
+    it "should correctly add classes if passed just other attributes" do
+      output = render(widget_class_with_p_added_content { p_added :id => :whatever })
+      expect(output).to match(%r{<p [^>]*></p>})
+      expect(output).to match(%r{id="whatever"})
+      expect(output).to match(%r{class="foo bar"})
+    end
+
+    it "should correctly add classes if passed text, then attributes" do
+      output = render(widget_class_with_p_added_content { p_added "hello", :id => :whatever })
+      expect(output).to match(%r{<p [^>]*>hello</p>})
+      expect(output).to match(%r{id="whatever"})
+      expect(output).to match(%r{class="foo bar"})
+    end
+
+    it "should correctly add classes if passed nil, then attributes" do
+      output = render(widget_class_with_p_added_content { p_added nil, :id => :whatever })
+      expect(output).to match(%r{<p [^>]*></p>})
+      expect(output).to match(%r{id="whatever"})
+      expect(output).to match(%r{class="foo bar"})
+    end
+
+    it "should correctly add classes if passed text, then explicitly-nil attributes" do
+      output = render(widget_class_with_p_added_content { p_added "hello", nil })
+      expect(output).to match(%r{<p class="foo bar">hello</p>})
+    end
+
+    it "should correctly add classes if passed nil and nil" do
+      expect(render(widget_class_with_p_added_content { p_added nil, nil })).to eq(%{<p class="foo bar"></p>})
+    end
+
+    it "should correctly add just a single class" do
+      wc = widget_class_with_p_added do
+        def classes_to_add
+          :foo
+        end
+
+        def content
+          p_added "hello"
+        end
+      end
+      expect(render(wc)).to eq(%{<p class="foo">hello</p>})
+    end
+
+    def render_and_extract_classes(class_or_widget)
+      output = render(class_or_widget)
+
+      if output =~ %r{^<p class="(.*)"></p>}
+        $1.split(" ")
+      else
+        raise "Unexpected content: #{output.inspect}"
+      end
+    end
+
+    def expect_classes_transform(original_hash, expected_classes)
+      expect(render_and_extract_classes(widget_class_with_p_added_content { p_added(original_hash) }).sort).to eq(
+        expected_classes.sort)
+    end
+
+    it "should correctly add classes if the base has classes specified with a symbol" do
+      expect_classes_transform({ :class => 'orig' }, %w{orig foo bar})
+    end
+
+    it "should correctly add classes if the base has classes specified with a string" do
+      expect_classes_transform({ 'class' => 'orig' }, %w{orig foo bar})
+    end
+
+    it "should correctly add classes if the base has multiple classes" do
+      expect_classes_transform({ :class => [ 'orig1', 'orig2', 'orig3' ] }, %w{orig1 orig2 orig3 foo bar})
+    end
+
+    it "should correctly add classes if the base has just one class" do
+      expect_classes_transform({ :class => 'orig' }, %w{orig foo bar})
+    end
+
+    it "should correctly add classes if the base has explicit nil for :class" do
+      expect_classes_transform({ 'class' => nil }, %w{foo bar})
+    end
+
+    it "should correctly add classes if the base has explicit empty-string for :class" do
+      expect_classes_transform({ 'class' => '' }, %w{foo bar})
+    end
+
+    it "should correctly add classes if the base has explicit false for :class" do
+      expect_classes_transform({ :class => false }, %w{foo bar})
+    end
+
+    it "should correctly add classes if the base has an array for :class" do
+      expect_classes_transform({ :class => [ 'orig1', 'orig2', 'orig3' ] }, %w{orig1 orig2 orig3 foo bar})
+    end
+
+    it "should correctly add classes if the base has a whitespace-separated array of classes for :class" do
+      expect_classes_transform({ 'class' => 'orig1 orig2 orig3' }, %w{foo bar orig1 orig2 orig3})
+    end
+
+    it "should allow being called as #add_css_class" do
+      add_css_class_class = widget_class do
+        def p_added(*args, &block)
+          p(*add_css_class('foo', *args), &block)
+        end
+
+        def content
+          p_added "hello"
+        end
+      end
+
+      expect(render(add_css_class_class)).to eq('<p class="foo">hello</p>')
+    end
+  end
 end