fortitude 0.0.1

data/lib/fortitude/errors.rb

@@ -0,0 +1,153 @@
+module Fortitude
+  module Errors
+    class Base < StandardError; end
+
+    class MissingNeed < Base
+      attr_reader :widget, :missing_needs, :assigns
+
+      def initialize(widget, missing_needs, assigns)
+        super(%{The widget #{widget} requires the following parameters to render, but they were not supplied: #{missing_needs.sort_by(&:to_s).join(", ")}})
+        @widget = widget
+        @missing_needs = missing_needs
+        @assigns = assigns
+      end
+    end
+
+    class BlockPassedToNeedMethod < Base
+      attr_reader :widget, :method_name
+
+      def initialize(widget, method_name)
+        super(%{You passed a block to a method that's a 'needs' method of a Fortitude widget, #{widget}. } +
+          %{This can mean you've declared a 'need' with the same name as a Fortitude tag method (e.g., "needs :#{method_name}"), } +
+          %{and think you're calling the method that will generate that tag, when you're actually calling a method } +
+          %{that will ignore the block you passed and just return the value of that 'need'. If that is the case, try } +
+          %{calling the tag with 'tag_' prefixed to it (e.g., 'tag_#{method_name}'), which does the same thing; if not, remove } +
+          %{the block and try again.})
+        @widget = widget
+        @method_name = method_name
+      end
+    end
+
+    class ExtraAssigns < Base
+      attr_reader :widget, :extra_assigns
+
+      def initialize(widget, extra_assigns)
+        super(%{The widget #{widget} does not accept the following parameters: #{extra_assigns.keys.sort_by(&:to_s).join(", ")}})
+        @widget = widget
+        @extra_assigns = extra_assigns
+      end
+    end
+
+    class InvalidElementNesting < Base
+      attr_reader :widget, :enclosing_element_name, :enclosed_element_name
+
+      def initialize(widget, enclosing_tag, enclosed_tag)
+        message = %{The widget #{widget} tried to render an element that is not allowed by element nesting rules: you can't put a <#{enclosed_tag.name}> inside a <#{enclosing_tag.name}>.}
+        if enclosing_tag.spec
+          message << " (See '#{enclosing_tag.spec}' for more details.)"
+        end
+
+        super(message)
+        @widget = widget
+        @enclosing_tag = enclosing_tag
+        @enclosed_tag = enclosed_tag
+      end
+
+      def enclosing_tag_name
+        @enclosing_tag.name
+      end
+
+      def enclosed_tag_name
+        @enclosed_tag.name
+      end
+    end
+
+    class InvalidElementAttributes < Base
+      attr_reader :widget, :invalid_attributes_hash, :allowed_attribute_names
+
+      def initialize(widget, tag, invalid_attributes_hash, allowed_attribute_names)
+        message = %{The widget #{widget} tried to render an element, <#{tag.name}>, with attributes that are not allowed: #{invalid_attributes_hash.inspect}. Only these attributes are allowed: #{allowed_attribute_names.sort_by(&:to_s).inspect}}
+        if tag.spec
+          message << " (See '#{tag.spec}' for more details.)"
+        end
+
+        super(message)
+        @widget = widget
+        @tag = tag
+        @invalid_attributes_hash = invalid_attributes_hash
+        @allowed_attribute_names = allowed_attribute_names
+      end
+
+      def tag_name
+        @tag.name
+      end
+    end
+
+    class DuplicateId < Base
+      attr_reader :widget, :id, :already_used_widget, :already_used_tag_name, :tag_name
+
+      def initialize(widget, id, already_used_widget, already_used_tag_name, tag_name)
+        super(%{The widget #{widget} tried to use a DOM ID, '#{id}', that has already been used. It was originally used on a <#{already_used_tag_name}> tag within widget #{already_used_widget}, and is now trying to be used on a <#{tag_name}> tag.})
+        @widget = widget
+        @id = id
+        @already_used_widget = already_used_widget
+        @already_used_tag_name = already_used_tag_name
+        @tag_name = tag_name
+      end
+    end
+
+    class DynamicAccessFromStaticMethod < Base
+      attr_reader :widget, :static_method_name, :method_called
+
+      def initialize(widget, static_method_name, method_called)
+        super(%{The widget class #{widget.class.name} declared method #{static_method_name.inspect} to be static, but, when we went to make it static, we found that it called #{method_called.inspect}, and that accesses dynamic data; this therefore can't possibly be made static safely.})
+        @widget = widget
+        @static_method_name = static_method_name
+        @method_called = method_called
+      end
+    end
+
+    class NoContentAllowed < Base
+      attr_reader :widget
+
+      def initialize(widget, tag)
+        message = %{The widget #{widget} tried to render an element, <#{tag.name}>, with content inside it, but that element doesn't accept content.}
+        if tag.spec
+          message << " (See '#{tag.spec}' for more details.)"
+        end
+
+        super(message)
+        @widget = widget
+        @tag = tag
+      end
+
+      def tag_name
+        @tag
+      end
+    end
+
+    class NoReturnValueFromTag < Base
+      attr_reader :method_name
+
+      def initialize(method_name)
+        super(%{You're trying to call a method, #{method_name.inspect}, on the return value of a Fortitude
+tag; tags don't return anything usable. (If you're migrating from Erector, this may
+be a place where you used Erector syntax for classes or IDs -- e.g., p.some_class,
+div.some_id!. Fortitude doesn't support these for important performance reasons;
+you simply need to convert these to "p :class => :some_class" or
+"div :id => :some_id".)})
+        @method_name = method_name
+      end
+    end
+
+    class TagNotFound < Base
+      attr_reader :tag_store, :tag_name
+
+      def initialize(tag_store, tag_name)
+        super(%{The tag store #{tag_store} has no tag named #{tag_name.inspect}.})
+        @tag_store = tag_store
+        @tag_name = tag_name
+      end
+    end
+  end
+end

data/lib/fortitude/fortitude_ruby_ext.rb

@@ -0,0 +1,71 @@
+require 'erb'
+
+::String.class_eval do
+  def fortitude_append_escaped_string(output)
+    raise ArgumentError, "You can only append to a String" unless output.kind_of?(String)
+
+    if html_safe?
+      output.original_concat(self)
+    else
+      output.original_concat(ERB::Util.html_escape(self))
+    end
+  end
+end
+
+::Hash.class_eval do
+  FORTITUDE_HYPHEN = "-".html_safe.freeze
+  FORTITUDE_EQUALS_QUOTE = "=\"".html_safe.freeze
+  FORTITUDE_QUOTE = "\"".html_safe.freeze
+  FORTITUDE_SPACE = " ".html_safe.freeze
+
+  TARGET_BASE = "".html_safe.freeze
+
+  def fortitude_append_as_attributes(output, prefix)
+    raise ArgumentError, "You can only append to a String" unless output.kind_of?(String)
+
+    target = TARGET_BASE.dup
+
+    each do |key, value|
+      if value.kind_of?(Hash)
+        new_prefix = case prefix
+        when String then fortitude_append_to(key, prefix.dup)
+        when nil then fortitude_append_to(key, "".html_safe)
+        else raise ArgumentError, "You can only use a String as a prefix"
+        end
+
+        new_prefix.original_concat(FORTITUDE_HYPHEN)
+        value.fortitude_append_as_attributes(target, new_prefix)
+      else
+        target.original_concat(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
+
+        fortitude_append_to(key, target)
+        target.original_concat(FORTITUDE_EQUALS_QUOTE)
+        fortitude_append_to(value, target)
+        target.original_concat(FORTITUDE_QUOTE)
+      end
+    end
+
+    output.original_concat(target)
+  end
+
+  private
+  def fortitude_append_to(object, output)
+    case object
+    when String then object.fortitude_append_escaped_string(output)
+    when Symbol then object.to_s.fortitude_append_escaped_string(output)
+    when Array then object.each_with_index do |o,i|
+      output.original_concat(" ") if i > 0
+      fortitude_append_to(o, output)
+    end
+    when nil then nil
+    when Integer then output.original_concat(object.to_s)
+    else object.to_s.fortitude_append_escaped_string(output)
+    end
+  end
+end

data/lib/fortitude/instance_variable_set.rb

@@ -0,0 +1,74 @@
+module Fortitude
+  class InstanceVariableSet
+    def initialize(target_object)
+      @target_object = target_object
+    end
+
+    def [](name)
+      target_object.instance_variable_get("@#{name}")
+    end
+
+    def []=(name, value)
+      target_object.instance_variable_set("@#{name}", value)
+    end
+
+    def keys
+      target_object.instance_variables.map do |instance_variable_name|
+        $1.to_sym if instance_variable_name.to_s =~ /^@(.*)$/
+      end.compact
+    end
+
+    def each
+      keys.each { |k| yield k, self[k] }
+    end
+
+    def with_instance_variable_copying(widget)
+      before_copy = widget.instance_variables
+      skip_copy = before_copy - target_object.instance_variables
+
+      copy_to_widget(widget)
+      begin
+        yield
+      ensure
+        copy_from_widget(widget, skip_copy)
+      end
+    end
+
+    private
+    def copy_to_widget(widget)
+      needs = widget.needs_as_hash
+      extras = widget.widget_extra_assigns
+
+      target_object.instance_variables.each do |instance_variable_name|
+        if instance_variable_name =~ /^@(.*)$/
+          without_at = $1.to_sym
+          next if needs.has_key?(without_at)
+          next if extras.has_key?(without_at)
+
+          value = target_object.instance_variable_get(instance_variable_name)
+          widget.instance_variable_set(instance_variable_name, value)
+        end
+      end
+    end
+
+    def copy_from_widget(widget, exclude_variables = [ ])
+      needs = widget.needs_as_hash
+      extras = widget.widget_extra_assigns
+
+      (widget.instance_variables - exclude_variables).each do |instance_variable_name|
+        next if instance_variable_name =~ /^@_fortitude_/
+
+        if instance_variable_name =~ /^@(.*)$/i
+          without_at = $1.to_sym
+          next if needs.has_key?(without_at)
+          next if extras.has_key?(without_at)
+
+          value = widget.instance_variable_get(instance_variable_name)
+          target_object.instance_variable_set(instance_variable_name, value)
+        end
+      end
+    end
+
+    attr_reader :target_object
+  end
+end

data/lib/fortitude/need_assignment_template.rb.smpl

@@ -0,0 +1,16 @@
+# Need '#{need}' -------------------------------------------------
+@_fortitude_extra_assigns.delete(:#{need})           # :if [ :error, :use ].include?(extra_assigns)
+
+value = assigns.fetch(:#{need}, NOT_PRESENT_NEED)
+if value == NOT_PRESENT_NEED
+  value = assigns.fetch('#{need}', NOT_PRESENT_NEED)
+  if value == NOT_PRESENT_NEED
+    value = nil                                      # :if ! has_default
+    missing << :#{need}                              # :if ! has_default
+    have_missing = true                              # :if ! has_default
+    value = the_needs[:#{need}]                      # :if has_default
+    @_fortitude_default_assigns[:#{need}] = true     # :if has_default
+  end
+end
+
+#{ivar_name} = value

data/lib/fortitude/need_method_template.rb.smpl

@@ -0,0 +1,4 @@
+def #{need}
+  raise Fortitude::Errors::BlockPassedToNeedMethod.new(self, :#{need}) if block_given? # :if debug
+  #{ivar_name}
+end

data/lib/fortitude/non_rails_widget_methods.rb

@@ -0,0 +1,15 @@
+require 'active_support'
+
+module Fortitude
+  module NonRailsWidgetMethods
+    extend ActiveSupport::Concern
+
+    def widget_locale
+      nil
+    end
+
+    module ClassMethods
+
+    end
+  end
+end

data/lib/fortitude/partial_tag_placeholder.rb

@@ -0,0 +1,17 @@
+module Fortitude
+  class PartialTagPlaceholder
+    class << self
+      def instance
+        @instance ||= new
+      end
+    end
+
+    def name
+      :_fortitude_partial_placeholder
+    end
+
+    def validate_can_enclose!(widget, tag_object)
+      # nothing here, always OK
+    end
+  end
+end

data/lib/fortitude/rails/helpers.rb

@@ -0,0 +1,153 @@
+module Fortitude
+  module Rails
+    module Helpers
+      class << self
+        def helper(name, options = { })
+          @helpers ||= { }
+          @helpers[name] = options
+        end
+
+        def helper_options(name)
+          @helpers[name.to_s.strip.downcase.to_sym]
+        end
+
+        def apply_refined_helpers_to!(o)
+          @helpers.each do |name, options|
+            o.helper(name, options)
+          end
+        end
+      end
+
+      # tags/
+      # active_model_helper
+      # asset_tag_helper
+      helper :javascript_include_tag, :transform => :output_return_value
+      helper :stylesheet_link_tag, :transform => :output_return_value
+      helper :auto_discovery_link_tag, :transform => :output_return_value
+      helper :favicon_link_tag, :transform => :output_return_value
+      helper :image_tag, :transform => :output_return_value
+      helper :video_tag, :transform => :output_return_value
+      helper :audio_tag, :transform => :output_return_value
+
+      # asset_url_helper
+      # atom_feed_helper
+      # cache_helper
+      # capture_helper
+      # controller_helper
+      # csrf_helper
+      helper :csrf_meta_tags, :transform => :output_return_value
+      helper :csrf_meta_tag, :transform => :output_return_value
+
+      # date_helper
+      helper :date_select, :transform => :output_return_value
+      helper :time_select, :transform => :output_return_value
+      helper :datetime_select, :transform => :output_return_value
+      helper :select_datetime, :transform => :output_return_value
+      helper :select_date, :transform => :output_return_value
+      helper :select_time, :transform => :output_return_value
+      helper :select_second, :transform => :output_return_value
+      helper :select_minute, :transform => :output_return_value
+      helper :select_hour, :transform => :output_return_value
+      helper :select_day, :transform => :output_return_value
+      helper :select_month, :transform => :output_return_value
+      helper :select_year, :transform => :output_return_value
+      helper :time_tag, :transform => :output_return_value
+
+      # debug_helper
+      helper :debug, :transform => :output_return_value
+
+      # 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{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{week_field} +
+
+        # From form_options_helper
+        %w{select collection_select grouped_collection_select time_zone_select options_for_select} +
+        %w{options_from_collection_for_select option_groups_from_collection_for_select grouped_options_for_select} +
+        %w{time_zone_options_for_select collection_radio_buttons collection_check_boxes}
+
+      helper :form_for, :transform => :output_return_value, :output_yielded_methods => FORM_FOR_YIELDED_METHODS_TO_OUTPUT
+      helper :fields_for, :transform => :output_return_value, :output_yielded_methods => FORM_FOR_YIELDED_METHODS_TO_OUTPUT
+
+      # form_options_helper
+      # helper :select, :transform => :output_return_value # conflicts with HTML <select> tag
+      helper :collection_select, :transform => :output_return_value
+      helper :grouped_collection_select, :transform => :output_return_value
+      helper :time_zone_select, :transform => :output_return_value
+      helper :options_for_select, :transform => :output_return_value
+      helper :options_from_collection_for_select, :transform => :output_return_value
+      helper :option_groups_from_collection_for_select, :transform => :output_return_value
+      helper :grouped_options_for_select, :transform => :output_return_value
+      helper :time_zone_options_for_select, :transform => :output_return_value
+      helper :collection_radio_buttons, :transform => :output_return_value
+      helper :collection_check_boxes, :transform => :output_return_value
+
+      # form_tag_helper
+      helper :form_tag, :transform => :output_return_value
+      helper :select_tag, :transform => :output_return_value
+      helper :text_field_tag, :transform => :output_return_value
+      helper :label_tag, :transform => :output_return_value
+      helper :hidden_field_tag, :transform => :output_return_value
+      helper :file_field_tag, :transform => :output_return_value
+      helper :password_field_tag, :transform => :output_return_value
+      helper :text_area_tag, :transform => :output_return_value
+      helper :check_box_tag, :transform => :output_return_value
+      helper :radio_button_tag, :transform => :output_return_value
+      helper :submit_tag, :transform => :output_return_value
+      helper :button_tag, :transform => :output_return_value
+      helper :image_submit_tag, :transform => :output_return_value
+      helper :field_set_tag, :transform => :output_return_value
+      helper :color_field_tag, :transform => :output_return_value
+      helper :search_field_tag, :transform => :output_return_value
+      helper :telephone_field_tag, :transform => :output_return_value
+      helper :phone_field_tag, :transform => :output_return_value
+      helper :date_field_tag, :transform => :output_return_value
+      helper :time_field_tag, :transform => :output_return_value
+      helper :datetime_field_tag, :transform => :output_return_value
+      helper :datetime_local_field_tag, :transform => :output_return_value
+      helper :month_field_tag, :transform => :output_return_value
+      helper :week_field_tag, :transform => :output_return_value
+      helper :url_field_tag, :transform => :output_return_value
+      helper :email_field_tag, :transform => :output_return_value
+      helper :number_field_tag, :transform => :output_return_value
+      helper :range_field_tag, :transform => :output_return_value
+      helper :utf8_enforcer_tag, :transform => :output_return_value
+
+      # javascript_helper
+      helper :javascript_tag, :transform => :output_return_value
+      helper :javascript_cdata_section, :transform => :output_return_value
+      helper :button_to_function, :transform => :output_return_value
+      helper :link_to_function, :transform => :output_return_value
+
+      # number_helper
+      # output_safety_helper
+      # record_tag_helper
+      helper :div_for, :transform => :output_return_value
+      helper :content_tag_for, :transform => :output_return_value
+
+      # rendering_helper
+      # #render is special-cased; Widget implements it directly
+
+      # sanitize_helper
+      # tag_helper
+      # #tag conflicts with Widget's #tag method, and probably isn't something you want anyway
+      helper :content_tag, :transform => :output_return_value
+      helper :cdata_section, :transform => :output_return_value
+
+      # text_helper
+      # translation_helper
+      # url_helper
+      helper :link_to, :transform => :output_return_value
+      helper :button_to, :transform => :output_return_value
+      helper :link_to_unless_current, :transform => :output_return_value
+      helper :link_to_unless, :transform => :output_return_value
+      helper :link_to_if, :transform => :output_return_value
+      helper :mail_to, :transform => :output_return_value
+
+      helper :capture
+    end
+  end
+end

data/lib/fortitude/rails/renderer.rb

@@ -0,0 +1,43 @@
+require 'fortitude/rendering_context'
+
+::ActiveSupport::SafeBuffer.class_eval do
+  alias_method :fortitude_concat, :original_concat
+  public :fortitude_concat
+end
+
+module Fortitude
+  module Rails
+    class Renderer
+      class << self
+        # TODO: Refactor this and render :widget => ... support into one method somewhere.
+        def render(widget_class, template_handler, local_assigns, &block)
+          total_assigns = template_handler.assigns.symbolize_keys.merge(local_assigns.symbolize_keys)
+
+          needed_assigns = if widget_class.extra_assigns == :use
+            total_assigns
+          else
+            widget_class.extract_needed_assigns_from(total_assigns)
+          end
+
+          widget = widget_class.new(needed_assigns)
+          template_handler.with_output_buffer do
+            rendering_context_options = { :delegate_object => template_handler, :yield_block => block }
+            controller = template_handler.controller
+            rendering_context = controller.fortitude_rendering_context(rendering_context_options)
+
+            # TODO: Refactor this -- both passing it into the constructor and setting yield_block here is gross.
+            #
+            # We need to call #with_yield_block here, because we can actually be invoked with different yield blocks
+            # in the case of "partial layouts" (which most people probably don't even realize exist); we use the same
+            # RC for both the initial view rendering and for the partial layout, but they need different yield blocks.
+            # Yuck, but this does the job.
+            rendering_context.with_yield_block(block) do
+              widget.to_html(rendering_context)
+            end
+            rendering_context.flush!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/rails/template_handler.rb

@@ -0,0 +1,23 @@
+require 'fortitude/rails/renderer'
+
+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) =~ /^_/
+
+        <<-SRC
+        Fortitude::Rails::Renderer.render(#{widget_class_name}, self, local_assigns) { |*args| yield *args }
+        SRC
+      end
+
+      def supports_streaming?
+        true
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler :rb, Fortitude::Rails::TemplateHandler.new

data/lib/fortitude/rails/widget_methods.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+
+module Fortitude
+  module Rails
+    module WidgetMethods
+      extend ActiveSupport::Concern
+
+      def widget_locale
+        I18n.locale || I18n.default_locale
+      end
+
+      module ClassMethods
+
+      end
+    end
+  end
+end

data/lib/fortitude/rails/yielded_object_outputter.rb

@@ -0,0 +1,31 @@
+module Fortitude
+  module Rails
+    YIELDED_OBJECT_OUTPUTTER_SUPERCLASS = if defined?(::BasicObject) then ::BasicObject else ::Object end
+    class YieldedObjectOutputter < YIELDED_OBJECT_OUTPUTTER_SUPERCLASS
+      def initialize(widget, yielded_object, method_names)
+        @widget = widget
+        @yielded_object = yielded_object
+        @method_names_hash = { }
+        method_names.each do |method_name|
+          @method_names_hash[method_name.to_sym] = true
+        end
+      end
+
+      EMPTY_RETURN_VALUE = ''.freeze
+
+      def method_missing(method_name, *args, &block)
+        return_value = @yielded_object.send(method_name, *args, &block)
+        if @method_names_hash[method_name.to_sym]
+          @widget.rawtext(return_value)
+          EMPTY_RETURN_VALUE
+        else
+          return_value
+        end
+      end
+
+      def respond_to?(symbol, include_all = false)
+        @yielded_object.respond_to?(symbol, include_all)
+      end
+    end
+  end
+end