fortitude 0.0.1

data/lib/fortitude/tag.rb

@@ -0,0 +1,162 @@
+require 'fortitude/tag_support'
+require 'fortitude/simple_template'
+
+module Fortitude
+  class Tag
+    attr_reader :name, :spec
+    attr_accessor :newline_before, :content_allowed, :allow_data_attributes, :allow_aria_attributes, :escape_direct_content
+
+    class << self
+      def normalize_tag_name(name)
+        name.to_s.strip.downcase.to_sym
+      end
+    end
+
+    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)
+
+      @name = self.class.normalize_tag_name(name)
+
+      self.valid_attributes = options[:valid_attributes]
+      self.can_enclose = options[:can_enclose]
+      @newline_before = !! options[:newline_before]
+      @content_allowed = true unless options.has_key?(:content_allowed) && (! options[:content_allowed])
+      @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])
+      @spec = options[:spec]
+    end
+
+    def valid_attributes
+      @allowable_attributes.keys if @allowable_attributes
+    end
+
+    def valid_attributes=(attributes)
+      @allowable_attributes = to_symbol_hash(attributes)
+    end
+
+    def can_enclose
+      @allowable_enclosed_elements.keys if @allowable_enclosed_elements
+    end
+
+    def can_enclose=(tags)
+      @allowable_enclosed_elements = to_symbol_hash(tags)
+      @allowable_enclosed_elements[:_fortitude_partial_placeholder] = true if @allowable_enclosed_elements
+    end
+
+    def dup
+      self.class.new(name, {
+        :valid_attributes => valid_attributes,
+        :can_enclose => can_enclose,
+        :content_allowed => content_allowed,
+        :allow_data_attributes => allow_data_attributes,
+        :allow_aria_attributes => allow_aria_attributes,
+        :escape_direct_content => escape_direct_content,
+        :spec => spec
+      })
+    end
+
+    CONCAT_METHOD = "original_concat"
+
+    def validate_can_enclose!(widget, tag_object)
+      return unless @allowable_enclosed_elements
+      unless @allowable_enclosed_elements[tag_object.name]
+        raise Fortitude::Errors::InvalidElementNesting.new(widget, self, tag_object)
+      end
+    end
+
+    def validate_attributes(widget, attributes_hash)
+      return unless @allowable_attributes
+      disabled_sym = attributes_hash.delete(:_fortitude_skip_attribute_rule_enforcement)
+      disabled_string = attributes_hash.delete('_fortitude_skip_attribute_rule_enforcement')
+      return if disabled_sym || disabled_string
+      return if widget.rendering_context.attribute_validation_disabled?
+      bad = { }
+      attributes_hash.each do |k, v|
+        bad[k] = v unless is_valid_attribute?(k, v)
+      end
+      raise Fortitude::Errors::InvalidElementAttributes.new(widget, self, bad, @allowable_attributes.keys) if bad.size > 0
+    end
+
+    def is_valid_attribute?(k, v)
+      return true if @allowable_attributes.include?(k.to_sym)
+
+      if @allow_data_attributes
+        return true if k.to_s =~ /^data-\S/i || (k.to_s =~ /^data$/i && v.kind_of?(Hash))
+      end
+
+      if @allow_aria_attributes
+        return true if k.to_s =~ /^aria-\S/i || (k.to_s =~ /^aria$/i && v.kind_of?(Hash))
+      end
+
+      return false
+    end
+
+    def validate_id_uniqueness(widget, attributes_hash)
+      id = attributes_hash[:id] || attributes_hash['id']
+      widget.rendering_context.validate_id_uniqueness(widget, name, id) if id
+    end
+
+    def define_method_on!(mod, options = {})
+      options.assert_valid_keys(:enforce_element_nesting_rules, :enforce_attribute_rules, :enable_formatting, :enforce_id_uniqueness, :close_void_tags)
+
+      unless mod.respond_to?(:fortitude_tag_support_included?) && mod.fortitude_tag_support_included?
+        mod.send(:include, ::Fortitude::TagSupport)
+      end
+
+      alone_tag = if @content_allowed || options[:close_void_tags] then "<#{name}/>" else "<#{name}>" end
+
+      ensure_constants(mod, :ALONE => alone_tag, :OPEN => "<#{name}>", :CLOSE => "</#{name}>",
+        :PARTIAL_OPEN => "<#{name}", :TAG_OBJECT => self)
+
+      needs_formatting = !! options[:enable_formatting]
+
+      if needs_formatting && @newline_before
+        yield_call = "_fortitude_formatted_output_tag_yield(:#{name}) { yield }"
+      elsif needs_formatting
+        yield_call = "yield; rc.about_to_output_non_whitespace!"
+      else
+        yield_call = "yield"
+      end
+
+      text = Fortitude::SimpleTemplate.template('tag_method_template').result(
+        :name => name.to_s, :method_name => "tag_#{name}".to_s, :yield_call => yield_call, :concat_method => CONCAT_METHOD,
+        :needs_element_rules => !! options[:enforce_element_nesting_rules],
+        :needs_attribute_rules => !! options[:enforce_attribute_rules],
+        :needs_id_uniqueness => !! options[:enforce_id_uniqueness],
+        :needs_formatting => needs_formatting, :content_allowed => @content_allowed,
+        :newline_before => @newline_before,
+        :escape_direct_content => @escape_direct_content,
+        :alone_const => tag_constant_name(:ALONE), :open_const => tag_constant_name(:OPEN),
+        :close_const => tag_constant_name(:CLOSE), :partial_open_const => tag_constant_name(:PARTIAL_OPEN),
+        :tag_object_const => tag_constant_name(:TAG_OBJECT), :partial_open_end_const => :FORTITUDE_TAG_PARTIAL_OPEN_END,
+        :partial_open_alone_end_const => :FORTITUDE_TAG_PARTIAL_OPEN_ALONE_END)
+
+      mod.module_eval(text)
+      mod.alias_method(name, "tag_#{name}")
+    end
+
+    private
+    def tag_constant_name(key)
+      "FORTITUDE_TAG_#{name.to_s.upcase}_#{key}".to_sym
+    end
+
+    def ensure_constants(target, map)
+      map.each { |name, value| ensure_constant(target, tag_constant_name(name), value.freeze) }
+    end
+
+    def ensure_constant(target, const_name, const_value)
+      target.send(:remove_const, const_name) if target.const_defined?(const_name)
+      target.const_set(const_name, const_value.freeze)
+    end
+
+    def to_symbol_hash(array)
+      if array
+        out = { }
+        array.each { |a| out[a.to_s.strip.to_sym] = true }
+        out
+      end
+    end
+  end
+end

data/lib/fortitude/tag_method_template.rb.smpl

@@ -0,0 +1,68 @@
+def #{method_name}(content_or_attributes = nil, attributes = nil)
+  o = @_fortitude_output_buffer_holder.output_buffer
+  rc = @_fortitude_rendering_context                                       # :if needs_element_rules || needs_formatting
+
+  this_tag = #{tag_object_const}                                           # :if needs_element_rules || needs_attribute_rules || needs_id_uniqueness
+  rc.record_tag(self, this_tag) do                                         # :if needs_element_rules
+    format_output = rc.format_output?                                      # :if needs_formatting
+    if format_output                                                       # :if needs_formatting
+      rc.needs_newline!                                                    # :if needs_formatting && newline_before
+      rc.about_to_output_non_whitespace!                                   # :if needs_formatting
+    end                                                                    # :if needs_formatting
+
+    if (! content_or_attributes)
+      if block_given?
+        _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
+        o.#{concat_method}(#{open_const})
+        #{yield_call}
+        o.#{concat_method}(#{close_const})
+      else
+        o.#{concat_method}(#{alone_const})
+      end
+    elsif content_or_attributes.kind_of?(Hash)
+      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)
+
+      if block_given?
+        _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
+        o.#{concat_method}(#{partial_open_end_const})
+        #{yield_call}
+        o.#{concat_method}(#{close_const})
+      else
+        o.#{concat_method}(#{partial_open_alone_end_const})
+      end
+    elsif (! attributes)
+      _fortitude_raise_no_content_allowed_error(#{tag_object_const})       # :if ! content_allowed
+      o.#{concat_method}(#{open_const})
+      rc.record_tag(self, FORTITUDE_TEXT_PSEUDOTAG) { } unless content_or_attributes.instance_variable_get("@html_safe") # :if needs_element_rules
+      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?
+        _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
+        #{yield_call}
+      end
+      o.#{concat_method}(#{close_const})
+    else
+      _fortitude_raise_no_content_allowed_error(#{tag_object_const})       # :if ! content_allowed
+      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)
+      o.#{concat_method}(#{partial_open_end_const})
+
+      rc.record_tag(self, FORTITUDE_TEXT_PSEUDOTAG) { } unless content_or_attributes.instance_variable_get("@html_safe") # :if needs_element_rules
+      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?
+        _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
+        #{yield_call}
+      end
+      o.#{concat_method}(#{close_const})
+    end
+    rc.needs_newline! if format_output                                     # :if needs_formatting && newline_before
+  end                                                                      # :if needs_element_rules
+
+  FORTITUDE_NO_RETURN_VALUE_FROM_TAGS
+end

data/lib/fortitude/tag_return_value.rb

@@ -0,0 +1,11 @@
+require 'fortitude/errors'
+
+module Fortitude
+  TAG_RETURN_VALUE_SUPERCLASS = if defined?(::BasicObject) then ::BasicObject else ::Object end
+
+  class TagReturnValue < TAG_RETURN_VALUE_SUPERCLASS
+    def method_missing(name, *args)
+      ::Kernel.raise ::Fortitude::Errors::NoReturnValueFromTag.new(name)
+    end
+  end
+end

data/lib/fortitude/tag_store.rb

@@ -0,0 +1,48 @@
+module Fortitude
+  module TagStore
+    def tag(name, options = nil)
+      @_tags_by_name ||= { }
+
+      name = Fortitude::Tag.normalize_tag_name(name)
+      tag_object = Fortitude::Tag.new(name, options || { })
+      @_tags_by_name[name] = tag_object
+
+      tags_added!([ tag_object ])
+    end
+
+    def modify_tag(name)
+      name = Fortitude::Tag.normalize_tag_name(name)
+      existing_tag = tags[name]
+
+      unless existing_tag
+        raise Fortitude::Errors::TagNotFound.new(self, name)
+      end
+
+      new_tag = existing_tag.dup
+      yield new_tag
+      @_tags_by_name ||= { }
+      @_tags_by_name[name] = new_tag
+
+      tags_changed!([ new_tag ])
+    end
+
+    def tags
+      out = { }
+      (delegate_tag_stores || [ ]).each { |d| out.merge!(d.tags) }
+      out.merge!(@_tags_by_name || { })
+      out
+    end
+
+    def tags_added!(tags)
+      tags_changed!(tags)
+    end
+
+    def tags_changed!(tags)
+      # nothing here
+    end
+
+    def delegate_tag_stores
+      [ ]
+    end
+  end
+end

data/lib/fortitude/tag_support.rb

@@ -0,0 +1,48 @@
+require 'fortitude/tag_return_value'
+require 'active_support/concern'
+
+module Fortitude
+  module TagSupport
+    extend ActiveSupport::Concern
+
+    class TextPseudotag
+      def name
+        :_text
+      end
+    end
+
+    FORTITUDE_TEXT_PSEUDOTAG = TextPseudotag.new
+
+    FORTITUDE_TAG_PARTIAL_OPEN_END = ">".freeze
+    FORTITUDE_TAG_PARTIAL_OPEN_ALONE_END = "/>".freeze
+
+    def _fortitude_formatted_output_tag_yield(tag_name)
+      rc = @_fortitude_rendering_context
+      if rc.format_output?
+        rc.needs_newline!
+        rc.increase_indent!
+        begin
+          yield
+        ensure
+          rc.decrease_indent!
+          rc.needs_newline!
+          rc.about_to_output_non_whitespace!
+        end
+      else
+        yield
+      end
+    end
+
+    def _fortitude_raise_no_content_allowed_error(tag_name)
+      raise Fortitude::Errors::NoContentAllowed.new(self, tag_name)
+    end
+
+    FORTITUDE_NO_RETURN_VALUE_FROM_TAGS = Fortitude::TagReturnValue.new
+
+    module ClassMethods
+      def fortitude_tag_support_included?
+        true
+      end
+    end
+  end
+end

data/lib/fortitude/tags_module.rb

@@ -0,0 +1,14 @@
+require 'fortitude/tag_support'
+
+module Fortitude
+  class TagsModule < Module
+    def initialize(widget_class)
+      include Fortitude::TagSupport
+
+      @widget_class = widget_class
+      @widget_class.send(:include, self)
+    end
+
+    public :alias_method
+  end
+end

data/lib/fortitude/text_method_template.rb.smpl

@@ -0,0 +1,17 @@
+def tag_text(s)
+  @_fortitude_rendering_context.about_to_output_non_whitespace!    # :if format_output
+
+  unless s.instance_variable_get("@html_safe")                     # :if needs_element_rules
+    @_fortitude_rendering_context.record_tag(self, FORTITUDE_TEXT_PSEUDOTAG) { } # :if needs_element_rules
+  end                                                              # :if needs_element_rules
+
+  s.to_s.fortitude_append_escaped_string(@_fortitude_output_buffer_holder.output_buffer)
+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)
+end
+
+alias_method :text, :tag_text
+alias_method :rawtext, :tag_rawtext

data/lib/fortitude/tilt/fortitude_template.rb

@@ -0,0 +1,169 @@
+require 'tilt'
+require 'active_support/inflector'
+
+module Fortitude
+  module Tilt
+    class CannotDetermineTemplateClassError < StandardError
+      attr_reader :tried_class_names
+
+      def initialize(tried_class_names)
+        @tried_class_names = tried_class_names
+        super %{Due to the way Tilt is designed, Fortitude unfortunately has to guess, given a template,
+what the actual class name of the widget it contains is. Despite our best efforts, we were unable to
+guess what the name of the class involved is.
+
+Given the source of the template, we tried the following class names:
+
+#{tried_class_names.join("\n")}
+
+You can correct this problem either by passing a :fortitude_class option to Tilt, giving
+either the name of the widget class or the actual widget Class object, or by adding a
+comment to the source of the template, like so:
+
+#!fortitude_tilt_class: Foo::Bar::MyWidget}
+      end
+    end
+
+    class NotATemplateClassError < StandardError
+      attr_reader :class_name, :actual_object
+
+      def initialize(class_name, actual_object)
+        @class_name = class_name
+        @actual_object = actual_object
+
+        super %{You explicitly told Fortitude's Tilt support (either with a comment in your template, or
+with a :fortitude_class option) that the class we should render for this template is
+#{class_name.inspect}, but that turns out to be #{actual_object.inspect},
+which is not a Class that inherits from Fortitude::Widget.}
+      end
+    end
+
+    class FortitudeTemplate < ::Tilt::Template
+      def initialize(*args)
+        super(*args)
+      end
+
+      def prepare
+        evaluate_template!
+
+        @fortitude_class = explicit_fortitude_class || first_class_that_is_a_widget_class(all_possible_class_names)
+        unless @fortitude_class
+          raise CannotDetermineTemplateClassError.new(all_possible_class_names)
+        end
+      end
+
+      def render(scope=Object.new, locals={}, &block)
+        rendering_context = Fortitude::RenderingContext.new({
+          :yield_block => block, :render_yield_result => false,
+          :helpers_object => scope, :instance_variables_object => scope })
+
+        widget_assigns = { }.with_indifferent_access
+
+        scope.instance_variables.each do |instance_variable_name|
+          if instance_variable_name.to_s =~ /^\@(.*)$/
+            widget_assigns[$1] = scope.instance_variable_get(instance_variable_name)
+          end
+        end
+
+        widget_assigns = widget_assigns.merge(locals)
+        widget_assigns = @fortitude_class.extract_needed_assigns_from(widget_assigns) unless @fortitude_class.extra_assigns == :use
+
+        widget = @fortitude_class.new(widget_assigns)
+        widget.to_html(rendering_context)
+        rendering_context.output_buffer_holder.output_buffer
+      end
+
+      private
+      def explicit_fortitude_class
+        explicit_fortitude_class_from_option || explicit_fortitude_class_from_comment
+      end
+
+      def explicit_fortitude_class_from_option
+        string_or_class_to_widget_class(options[:fortitude_class])
+      end
+
+      def explicit_fortitude_class_from_comment
+        out = nil
+        data.scan(/^\s*\#\s*\!\s*fortitude_tilt_class\s*:\s*(\S+)\s*$/) do |*args|
+          out = args.first.first
+        end
+        string_or_class_to_widget_class(out)
+      end
+
+      def string_or_class_to_widget_class(string_or_class)
+        out = string_or_class
+
+        if out.kind_of?(String)
+          begin
+            out = out.constantize
+          rescue NameError => ne
+            raise NotATemplateClassError.new(string_or_class, nil)
+          end
+        end
+
+        if out
+          raise NotATemplateClassError.new(string_or_class, out) unless is_widget_class?(out)
+        end
+        out
+      end
+
+      def all_possible_class_names
+        out = [ ]
+        module_nesting = [ ]
+
+        data.scan(/\bmodule\s+(\S+)/) do |module_name|
+          module_nesting << module_name
+        end
+
+        data.scan(/\bclass\s+(\S+)/) do |*args|
+          out << args.first.first
+        end
+
+        out.uniq!
+
+        while module_nesting.length > 0
+          possible_module_name = module_nesting.join("::")
+          out.reverse.each do |class_name|
+            out.unshift("#{possible_module_name}::#{class_name}")
+          end
+          module_nesting.pop
+        end
+
+        out
+      end
+
+      def first_class_that_is_a_widget_class(class_names)
+        class_names.each do |class_name|
+          begin
+            klass = "::#{class_name}".constantize
+            return klass if is_widget_class?(klass)
+          rescue NameError => ne
+            # ok, keep going
+          end
+        end
+
+        nil
+      end
+
+      def evaluate_template!
+        ::Object.class_eval(data)
+      end
+
+      def is_widget_class?(klass)
+        if (! klass)
+          false
+        elsif (! klass.kind_of?(Class))
+          false
+        elsif defined?(::BasicObject) && (klass == ::BasicObject)
+          false
+        elsif klass == Object
+          false
+        elsif klass == ::Fortitude::Widget
+          true
+        else
+          is_widget_class?(klass.superclass)
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/version.rb

@@ -0,0 +1,3 @@
+module Fortitude
+  VERSION = "0.0.1"
+end