fortitude 0.0.1 → 0.0.2

data/lib/fortitude/simple_template.rb

@@ -1,45 +0,0 @@
-module Fortitude
-  class SimpleTemplate
-    class << self
-      def template(name)
-        @templates ||= { }
-        @templates[name] ||= new(File.join(File.dirname(__FILE__), "#{name}.rb.smpl"))
-      end
-    end
-
-    def initialize(source_file)
-      @lines = File.read(source_file).split(/\r\n|\r|\n/)
-    end
-
-    def result(bindings)
-      bindings = bindings.stringify_keys
-      bindings_target = Object.new
-      bindings.each do |key, value|
-        (class << bindings_target; self; end).send(:define_method, key) { value }
-      end
-
-      result_lines = [ ]
-      @lines.each do |l|
-        if l =~ /^(.*)\#\s*\:if\s*(.*?)\s*$/i
-          l, condition = $1, $2
-          next unless bindings_target.instance_eval(condition)
-        end
-
-        while l =~ /[^\\]\#\{([^}]+)\}/ || l =~ /^\#\{([^}]+)\}/
-          name = $1
-          begin
-            value = bindings_target.send($1)
-          rescue => e
-            raise "Failed when processing #{l.inspect}: #{e.inspect}"
-          end
-          l = l.gsub("\#\{#{$1}\}", value.to_s)
-        end
-        l = l.gsub(/\\\#\{/, "\#\{")
-
-        result_lines << l
-      end
-
-      result_lines.join("\n")
-    end
-  end
-end

data/lib/fortitude/staticized_method.rb

@@ -1,85 +0,0 @@
-module Fortitude
-  class StaticizedMethod
-    def initialize(widget_class, method_name, options = { })
-      @widget_class = widget_class
-      @method_name = method_name
-
-      @output_by_locale = { }
-      @has_yield = false
-
-      @options = options
-      @options.assert_valid_keys(:locale_support)
-
-      set_constant!
-    end
-
-    def run!(widget)
-      locale = locale_support? ? widget.widget_locale : nil
-      output = (@output_by_locale[locale] ||= generate_content!(widget))
-
-      if output.kind_of?(Array)
-        widget.rawtext(output[0])
-        yield
-        widget.rawtext(output[1])
-      else
-        widget.rawtext(output)
-      end
-    end
-
-    def create_method!
-      unless widget_class.instance_methods.map(&:to_s).include?(dynamic_method_name.to_s)
-        widget_class.send(:alias_method, dynamic_method_name, method_name)
-      end
-
-      widget_class.class_eval <<-EOS
-  def #{method_name}
-    #{constant_name}.run!(self) { yield }
-  end
-EOS
-    end
-
-    private
-    attr_reader :widget_class, :method_name, :output_by_locale, :has_yield, :options
-
-    def locale_support?
-      ! (options.has_key?(:locale_support) && (! options[:locale_support]))
-    end
-
-    def generate_content!(widget)
-      yielded = false
-      pre_yield = nil
-
-      result = widget.capture do
-        widget.with_staticness_enforced(method_name) do
-          widget.send(dynamic_method_name) do
-            raise "This method yields more than once; you can't make it static" if yielded
-            pre_yield = widget.output_buffer.dup
-            yielded = true
-            widget.output_buffer.replace('')
-          end
-        end
-      end
-
-      @has_yield = yielded
-
-      if yielded
-        [ pre_yield, result ]
-      else
-        result
-      end
-    end
-
-    def set_constant!
-      widget_class.send(:remove_const, constant_name) if widget_class.const_defined?(constant_name)
-      widget_class.const_set(constant_name, self)
-    end
-
-    def constant_name
-      "FORTITUDE_STATICIZED_METHOD_#{method_name.to_s.upcase}"
-    end
-
-    def dynamic_method_name
-      "_#{method_name}_dynamic".to_sym
-    end
-  end
-end

data/lib/fortitude/tag.rb

@@ -1,162 +0,0 @@
-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_return_value.rb

@@ -1,11 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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