fortitude 0.0.7 → 0.0.9

data/lib/fortitude/errors.rb

@@ -149,5 +149,21 @@ you simply need to convert these to "p :class => :some_class" or
         @tag_name = tag_name
       end
     end
+
+    class NoBlockToYieldTo < Base
+      attr_reader :widget
+
+      def initialize(widget)
+        super(%{You're trying to call 'yield' (or 'yield_from_widget', or the Erector-compatibility method 'call_block')
+from the widget #{widget}; however, there is nothing to yield to. Fortitude
+looks for something to yield to in this order:
+  1. A block passed to a yield at render time directly (usually via the 'widget' call);
+  2. A block passed to the constructor of the widget;
+  3. The layout the widget is being rendered in.
+None of these exist here, and so calling 'yield', 'yield_from_widget', or 'call_block' is an
+undefined operation.})
+        @widget = widget
+      end
+    end
   end
 end

data/lib/fortitude/extensions/fortitude_ruby_ext.rb

@@ -25,7 +25,7 @@ end
     const_set(constant_name, value)
   end
 
-  def fortitude_append_as_attributes(output, prefix)
+  def fortitude_append_as_attributes(output, prefix, allows_bare_attributes)
     raise ArgumentError, "You can only append to a String" unless output.kind_of?(String)
 
     target = ::Hash::TARGET_BASE.dup
@@ -39,20 +39,35 @@ end
         end
 
         new_prefix.original_concat(::Hash::FORTITUDE_HYPHEN)
-        value.fortitude_append_as_attributes(target, new_prefix)
+        value.fortitude_append_as_attributes(target, new_prefix, allows_bare_attributes)
       else
-        target.original_concat(::Hash::FORTITUDE_SPACE)
+        if value == nil || value == false
+          # nothing
+        else
+          target.original_concat(::Hash::FORTITUDE_SPACE)
 
-        case prefix
-        when String then target.original_concat(prefix)
-        when nil then nil
-        else raise ArgumentError, "You can only use a String as a prefix"
-        end
+          case prefix
+          when String then target.original_concat(prefix)
+          when nil then nil
+          else raise ArgumentError, "You can only use a String as a prefix"
+          end
 
-        fortitude_append_to(key, target)
-        target.original_concat(::Hash::FORTITUDE_EQUALS_QUOTE)
-        fortitude_append_to(value, target)
-        target.original_concat(::Hash::FORTITUDE_QUOTE)
+          fortitude_append_to(key, target)
+
+          if value == true
+            if allows_bare_attributes
+              # nothing here
+            else
+              target.original_concat(::Hash::FORTITUDE_EQUALS_QUOTE)
+              fortitude_append_to(key, target)
+              target.original_concat(::Hash::FORTITUDE_QUOTE)
+            end
+          else
+            target.original_concat(::Hash::FORTITUDE_EQUALS_QUOTE)
+            fortitude_append_to(value, target)
+            target.original_concat(::Hash::FORTITUDE_QUOTE)
+          end
+        end
       end
     end
 

data/lib/fortitude/method_templates/assign_locals_from_template.rb.smpl

@@ -1,4 +1,6 @@
 def assign_locals_from(assigns)
+  return assign_locals_from(assigns) if self.class.ensure_needs_methods_are_valid!
+
   @_fortitude_raw_assigns = assigns
   @_fortitude_raw_assigns = @_fortitude_raw_assigns.delete_if { |k,v| ! self.class.is_valid_ruby_method_name?(k) } # :if extra_assigns == :use
   @_fortitude_default_assigns = { }

data/lib/fortitude/method_templates/need_assignment_template.rb.smpl

@@ -2,9 +2,9 @@
 @_fortitude_extra_assigns.delete(:#{need})           # :if [ :error, :use ].include?(extra_assigns)
 
 value = assigns.fetch(:#{need}, NOT_PRESENT_NEED)
-if value == NOT_PRESENT_NEED
+if value.equal?(NOT_PRESENT_NEED)
   value = assigns.fetch('#{need}', NOT_PRESENT_NEED)
-  if value == NOT_PRESENT_NEED
+  if value.equal?(NOT_PRESENT_NEED)
     value = nil                                      # :if ! has_default
     missing << :#{need}                              # :if ! has_default
     have_missing = true                              # :if ! has_default

data/lib/fortitude/method_templates/simple_compiled_template.rb

@@ -0,0 +1,94 @@
+require 'active_support'
+require 'active_support/core_ext/hash'
+
+module Fortitude
+  module MethodTemplates
+    class SimpleCompiledTemplate
+      class << self
+        def template(name)
+          @templates ||= { }
+          @templates[name] ||= new(File.join(File.dirname(__FILE__), "#{name}.rb.smpl"))
+        end
+      end
+
+      def initialize(source_file)
+        @source_file = source_file
+        method_text_lines = [
+          "def result",
+          "  output = ''"
+        ]
+        pending_fixed_strings = [ ]
+
+        File.read(source_file).split(/\r\n|\r|\n/).each do |line|
+          needs_end = false
+          line = line.chomp
+
+          if line =~ /^(.*)\#\s*\:if\s*(.*?)\s*$/i
+            if pending_fixed_strings.length > 0
+              method_text_lines << "    output << <<EOS"
+              method_text_lines += pending_fixed_strings
+              method_text_lines << "EOS"
+              pending_fixed_strings = [ ]
+            end
+
+            line = $1
+            condition = $2
+            method_text_lines << "  if #{condition}"
+            method_text_lines << "    output << <<EOS"
+            method_text_lines << line
+            method_text_lines << "EOS"
+            method_text_lines << "  end"
+          else
+            pending_fixed_strings << line
+          end
+        end
+
+        if pending_fixed_strings.length > 0
+          method_text_lines << "    output << <<EOS"
+          method_text_lines += pending_fixed_strings
+          method_text_lines << "EOS"
+          pending_fixed_strings = [ ]
+        end
+
+        method_text_lines << "  output"
+        method_text_lines << "end"
+
+        @method_text = method_text_lines.join("\n")
+        @evaluation_object = EvaluationObject.new
+        metaclass = (class << @evaluation_object; self; end)
+        metaclass.class_eval(method_text_lines.join("\n"))
+      end
+
+      class EvaluationObject
+        def initialize
+          @hash = nil
+        end
+
+        def hash=(h)
+          @hash = h.symbolize_keys
+        end
+
+        def define_hash_method!(name)
+          symbol_name = name.to_sym
+          string_name = name.to_s
+
+          metaclass = (class << self; self; end)
+          metaclass.send(:define_method, name) do
+            @hash[symbol_name]
+          end
+        end
+
+        def method_missing(name, *args)
+          define_hash_method!(name)
+          send(name, *args)
+        end
+      end
+
+      def result(bindings)
+        @evaluation_object.hash = bindings
+        out = @evaluation_object.result
+        out
+      end
+    end
+  end
+end

data/lib/fortitude/method_templates/tag_method_template.rb.smpl

@@ -23,7 +23,7 @@ def #{method_name}(content_or_attributes = nil, attributes = nil)
       this_tag.validate_attributes(self, content_or_attributes)            # :if needs_attribute_rules
       this_tag.validate_id_uniqueness(self, content_or_attributes)         # :if needs_id_uniqueness
       o.#{concat_method}(#{partial_open_const})
-      content_or_attributes.fortitude_append_as_attributes(o, nil)
+      content_or_attributes.fortitude_append_as_attributes(o, nil, #{allows_bare_attributes})
 
       if block_given?
         _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
@@ -36,7 +36,7 @@ def #{method_name}(content_or_attributes = nil, attributes = nil)
     elsif (! attributes)
       _fortitude_raise_no_content_allowed_error(#{tag_object_const})       # :if ! content_allowed
       o.#{concat_method}(#{open_const})
-      rc.emitting_tag!(self, FORTITUDE_TEXT_PSEUDOTAG, content_or_attributes, nil) { } unless content_or_attributes.instance_variable_get("@html_safe") # :if record_emitting_tag
+      rc.emitting_tag!(self, FORTITUDE_TEXT_PSEUDOTAG, content_or_attributes, nil) { } unless content_or_attributes.instance_variable_get('@html_safe') # :if record_emitting_tag
       content_or_attributes.to_s.fortitude_append_escaped_string(o)        # :if escape_direct_content
       o.#{concat_method}(content_or_attributes.to_s)                       # :if ! escape_direct_content
       if block_given?
@@ -49,10 +49,10 @@ def #{method_name}(content_or_attributes = nil, attributes = nil)
       this_tag.validate_attributes(self, attributes)                       # :if needs_attribute_rules
       this_tag.validate_id_uniqueness(self, attributes)                    # :if needs_id_uniqueness
       o.#{concat_method}(#{partial_open_const})
-      attributes.fortitude_append_as_attributes(o, nil)
+      attributes.fortitude_append_as_attributes(o, nil, #{allows_bare_attributes})
       o.#{concat_method}(#{partial_open_end_const})
 
-      rc.emitting_tag!(self, FORTITUDE_TEXT_PSEUDOTAG, content_or_attributes, nil) { } unless content_or_attributes.instance_variable_get("@html_safe") # :if record_emitting_tag
+      rc.emitting_tag!(self, FORTITUDE_TEXT_PSEUDOTAG, content_or_attributes, nil) { } unless content_or_attributes.instance_variable_get('@html_safe') # :if record_emitting_tag
       content_or_attributes.to_s.fortitude_append_escaped_string(o)        # :if escape_direct_content
       o.#{concat_method}(content_or_attributes.to_s)                       # :if ! escape_direct_content
       if block_given?

data/lib/fortitude/method_templates/text_method_template.rb.smpl

@@ -1,7 +1,7 @@
 def tag_text(s)
   @_fortitude_rendering_context.about_to_output_non_whitespace!    # :if format_output
 
-  unless s.instance_variable_get("@html_safe")                     # :if record_emitting_tag
+  unless s.instance_variable_get('@html_safe')                     # :if record_emitting_tag
     @_fortitude_rendering_context.emitting_tag!(self, FORTITUDE_TEXT_PSEUDOTAG, s, nil) { } # :if record_emitting_tag
   end                                                              # :if record_emitting_tag
 
@@ -10,7 +10,7 @@ end
 
 def tag_rawtext(s)
   @_fortitude_rendering_context.about_to_output_non_whitespace!    # :if format_output
-  @_fortitude_output_buffer_holder.output_buffer.original_concat(s)
+  @_fortitude_output_buffer_holder.output_buffer.original_concat(s) if s != nil
 end
 
 alias_method :text, :tag_text

data/lib/fortitude/rails/railtie.rb

@@ -151,13 +151,17 @@ module Fortitude
               if File.directory?(directory)
                 filename = File.basename(full_path)
 
-                regexp1 = /^#{Regexp.escape(filename)}\./
+                regexp1 = /^_?#{Regexp.escape(filename)}\./
                 regexp2 = /\.rb$/i
                 applicable_entries = Dir.entries(directory).select do |entry|
                   ((entry == filename) || (entry =~ regexp1 && entry =~ regexp2)) && File.file?(File.join(directory, entry))
                 end
                 return nil if applicable_entries.length == 0
 
+                # Prefer those without an underscore
+                without_underscore = applicable_entries.select { |e| e !~ /^_/ }
+                applicable_entries = without_underscore if without_underscore.length > 0
+
                 entry_to_use = applicable_entries.sort_by { |e| e.length }.reverse.first
                 return File.join(directory, entry_to_use)
               end

data/lib/fortitude/rails/rendering_methods.rb

@@ -1,4 +1,5 @@
 require 'active_support/concern'
+require 'action_controller/metal/renderers'
 
 module Fortitude
   module Rails
@@ -19,55 +20,60 @@ module Fortitude
         ::Fortitude::RenderingContext.new(options)
       end
 
-      # This is our support for render :widget. Although, originally, it looked like creating a new subclass
-      # of ActionView::Template was going to be the correct thing to do here, it turns out it isn't: the entire
-      # template system is predicated around the idea that you have a template, which is compiled to output
-      # Ruby source code, and then that gets evaluated to actually generate output.
-      #
-      # Because <tt>render :widget => ...</tt> takes an already-instantiated widget as input, this simply isn't
-      # possible: you can't reverse-engineer an arbitrary Ruby object into source code, and, without source code,
-      # the whole templating paradigm doesn't make sense.
-      #
-      # So, instead, we simply transform <tt>render :widget => ...</tt> into a <tt>render :text => ...</tt> of the
-      # widget's output, and let Rails take it away from there.
+      def self._fortitude_render_widget(controller, widget, options)
+        if ::Fortitude::Erector.is_erector_widget_class?(widget) || ::Fortitude::Erector.is_erector_widget_class?(widget.class)
+          return ::Erector::Rails.render(widget, controller.view_context, { }, false, options)
+        end
+
+        if widget.kind_of?(Class)
+          if widget < ::Fortitude::Widget
+            widget = widget.new(widget.extract_needed_assigns_from(controller.view_context.assigns))
+          else
+            raise "You tried to render something using 'render :widget' that is a class, but not a subclass of Fortitude::Widget: #{widget.inspect}"
+          end
+        end
+
+        if (! widget.kind_of?(::Fortitude::Widget))
+          raise "You tried to render something using 'render :widget' that is neither an instance of a subclass of Fortitude::Widget, nor a class that inherits from Fortitude::Widget: #{widget.inspect}"
+        end
+
+        rendering_context = controller.create_fortitude_rendering_context(:helpers_object => controller.view_context)
+        widget.render_to(rendering_context)
+
+        passed_options = options.dup
+        passed_options.delete(:widget)
+        passed_options[:text] = rendering_context.output_buffer_holder.output_buffer.to_s
+        passed_options[:layout] = true unless passed_options.has_key?(:layout)
+
+        return controller.render_to_string(passed_options)
+      end
+
+      def self._fortitude_register_renderer!
+        ::ActionController.add_renderer_without_fortitude(:widget) do |widget, options|
+          ::Fortitude::Rails::RenderingMethods._fortitude_render_widget(self, widget, options)
+        end
+      end
+
       def render_with_fortitude(*args, &block)
-        if (options = args[0]).kind_of?(Hash)
-          if (widget = options[:widget])
-            rendering_context = fortitude_rendering_context_for(self, nil)
-            widget.render_to(rendering_context)
-
-            options = options.dup
-            options[:text] = rendering_context.output_buffer_holder.output_buffer.html_safe
-            options[:layout] = true unless options.has_key?(:layout)
-
-            new_args = [ options ] + args[1..-1]
-            return render_without_fortitude(*new_args, &block)
-          elsif (widget_block = options[:inline]) && (options[:type] == :fortitude)
-            options.delete(:inline)
-
-            rendering_context = fortitude_rendering_context_for(self, nil)
-            widget_class = Class.new(Fortitude::Widgets::Html5)
-            widget_class.use_instance_variables_for_assigns(true)
-            widget_class.extra_assigns(:use)
-            widget_class.send(:define_method, :content, &widget_block)
-
-            assigns = { }
-            instance_variables.each do |ivar_name|
-              value = instance_variable_get(ivar_name)
-              assigns[$1.to_sym] = value if ivar_name =~ /^@(.*)$/
-            end
-            assigns = assigns.merge(options[:locals] || { })
-
-            widget = widget_class.new(assigns)
-            widget.render_to(rendering_context)
-
-            options = options.dup
-            options[:text] = rendering_context.output_buffer_holder.output_buffer.html_safe
-            options[:layout] = true unless options.has_key?(:layout)
-
-            new_args = [ options ] + args[1..-1]
-            return render_without_fortitude(*new_args, &block)
+        if (options = args[0]).kind_of?(Hash) && (widget_block = options[:inline]) && (options[:type] == :fortitude)
+          options.delete(:inline)
+
+          rendering_context = fortitude_rendering_context_for(self, nil)
+          widget_class = Class.new(Fortitude::Widgets::Html5)
+          widget_class.use_instance_variables_for_assigns(true)
+          widget_class.extra_assigns(:use)
+          widget_class.send(:define_method, :content, &widget_block)
+
+          assigns = { }
+          instance_variables.each do |ivar_name|
+            value = instance_variable_get(ivar_name)
+            assigns[$1.to_sym] = value if ivar_name =~ /^@([^_].*)$/
           end
+          assigns = assigns.merge(options[:locals] || { })
+
+          widget = widget_class.new(assigns)
+          new_args = [ options.merge(:widget => widget) ] + args[1..-1]
+          return render_without_fortitude(*new_args, &block)
         end
 
         return render_without_fortitude(*args, &block)
@@ -75,3 +81,16 @@ module Fortitude
     end
   end
 end
+
+::ActionController.module_eval do
+  class << self
+    def add_renderer_with_fortitude(key, *args, &block)
+      add_renderer_without_fortitude(key, *args, &block)
+      ::Fortitude::Rails::RenderingMethods._fortitude_register_renderer!
+    end
+
+    alias_method_chain :add_renderer, :fortitude
+  end
+end
+
+::Fortitude::Rails::RenderingMethods._fortitude_register_renderer!

data/lib/fortitude/rails/template_handler.rb

@@ -4,7 +4,6 @@ module Fortitude
   module Rails
     class TemplateHandler
       def call(template, &block)
-        require_dependency template.identifier
         widget_class_name = "views/#{template.identifier =~ %r(views/([^.]*)(\..*)?\.rb) && $1}".camelize
         is_partial = !! (File.basename(template.identifier) =~ /^_/)
 

data/lib/fortitude/rendering_context.rb

@@ -179,8 +179,8 @@ module Fortitude
 
     NEWLINE = "\n"
 
-    def yield_from_widget(*args)
-      raise "No layout to yield to!" unless @yield_block
+    def yield_from_widget(widget, *args)
+      raise Fortitude::Errors::NoBlockToYieldTo.new(widget) unless @yield_block
       result = @yield_block.call(*args)
       @output_buffer_holder.output_buffer << result if @render_yield_result
       result

data/lib/fortitude/tags/tag.rb

@@ -1,5 +1,5 @@
 require 'fortitude/tags/tag_support'
-require 'fortitude/method_templates/simple_template'
+require 'fortitude/method_templates/simple_compiled_template'
 
 # Note on handling tags that have no content inside them:
 #
@@ -118,7 +118,7 @@ module Fortitude
       def define_method_on!(mod, options = {})
         options.assert_valid_keys(
           :record_emitting_tag, :enforce_attribute_rules, :enable_formatting,
-          :enforce_id_uniqueness, :close_void_tags)
+          :enforce_id_uniqueness, :close_void_tags, :allows_bare_attributes)
 
         unless mod.respond_to?(:fortitude_tag_support_included?) && mod.fortitude_tag_support_included?
           mod.send(:include, ::Fortitude::Tags::TagSupport)
@@ -148,11 +148,12 @@ module Fortitude
           yield_call = "yield"
         end
 
-        text = Fortitude::MethodTemplates::SimpleTemplate.template('tag_method_template').result(
+        text = Fortitude::MethodTemplates::SimpleCompiledTemplate.template('tag_method_template').result(
           :name => name.to_s, :method_name => generated_method_name.to_s, :yield_call => yield_call, :concat_method => CONCAT_METHOD,
           :record_emitting_tag => (!! options[:record_emitting_tag]),
           :needs_attribute_rules => !! options[:enforce_attribute_rules],
           :needs_id_uniqueness => !! options[:enforce_id_uniqueness],
+          :allows_bare_attributes => (!! options[:allows_bare_attributes]),
           :needs_formatting => needs_formatting, :content_allowed => @content_allowed,
           :newline_before => @newline_before,
           :escape_direct_content => @escape_direct_content,

data/lib/fortitude/version.rb

@@ -1,3 +1,3 @@
 module Fortitude
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 end