fortitude 0.0.1 → 0.0.2

data/lib/fortitude/support/class_inheritable_attributes.rb

@@ -0,0 +1,98 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  module Support
+    module ClassInheritableAttributes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def _fortitude_invoke_class_inheritable_attribute(attribute_name, allowable_values, *args)
+          raise ArgumentError, "Invalid arguments: #{args.inspect}" if args.length > 1
+          instance_variable_name = "@_fortitude_#{attribute_name}"
+          if args.length == 0
+            _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, false)
+          else
+            _fortitude_write_class_inheritable_attribute(attribute_name, instance_variable_name, allowable_values, args[0])
+          end
+        end
+
+        def _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, allow_not_present)
+          return instance_variable_get(instance_variable_name) if instance_variable_defined?(instance_variable_name)
+          return superclass.send(attribute_name) if superclass.respond_to?(attribute_name)
+
+          if allow_not_present
+            :_fortitude_class_inheritable_attribute_not_present
+          else
+            raise "Fortitude class-inheritable attribute error: there should always be a declared value for #{attribute_name} at the top of the inheritance hierarchy somewhere"
+          end
+        end
+
+        def _fortitude_write_class_inheritable_attribute(attribute_name, instance_variable_name, allowable_values, new_value)
+          allowed = if allowable_values.respond_to?(:call)
+            allowable_values.call(new_value, self)
+          else
+            allowable_values.include?(new_value)
+          end
+
+          if (! allowed)
+            error = "#{attribute_name} cannot be set to #{new_value.inspect}"
+            error << "; valid values are: #{allowable_values.inspect}" unless allowable_values.respond_to?(:call)
+            raise ArgumentError, error
+          end
+
+          old_value = _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, true)
+
+          instance_variable_set(instance_variable_name, new_value)
+
+          if (old_value != :_fortitude_class_inheritable_attribute_not_present) && (new_value != old_value)
+            _fortitude_class_inheritable_attribute_changed!(attribute_name, old_value, new_value)
+          end
+
+          new_value
+        end
+
+        def _fortitude_class_inheritable_attribute(attribute_name, default_value, allowable_values)
+          metaclass = (class << self; self; end)
+
+          metaclass.send(:define_method, attribute_name) do |*args|
+            _fortitude_invoke_class_inheritable_attribute(attribute_name, allowable_values, *args)
+          end
+
+          send(attribute_name, default_value)
+        end
+
+        def _fortitude_on_class_inheritable_attribute_change(*attribute_names, &block)
+          if attribute_names.length == 0
+            raise ArgumentError, "You must pass at least one attribute name, not: #{attribute_names.inspect}"
+          end
+
+          @_fortitude_class_inheritable_attribute_change_callbacks ||= { }
+          attribute_names.each do |attribute_name|
+            @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] ||= [ ]
+            @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] |= [ block ]
+          end
+        end
+
+        def _fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+          out = if superclass.respond_to?(:_fortitude_class_inheritable_attribute_callbacks_for)
+            superclass._fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+          else
+            [ ]
+          end
+
+          @_fortitude_class_inheritable_attribute_change_callbacks ||= { }
+          out += @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] || [ ]
+
+          out
+        end
+
+        def _fortitude_class_inheritable_attribute_changed!(attribute_name, old_value, new_value)
+          callbacks = _fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+          # klass = self
+          callbacks.each { |cb| instance_exec(attribute_name, old_value, new_value, &cb) }
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/support/instance_variable_set.rb

@@ -0,0 +1,76 @@
+module Fortitude
+  module Support
+    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
+end

data/lib/fortitude/support/staticized_method.rb

@@ -0,0 +1,87 @@
+module Fortitude
+  module Support
+    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
+end

data/lib/fortitude/tags/partial_tag_placeholder.rb

@@ -0,0 +1,19 @@
+module Fortitude
+  module Tags
+    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
+end

data/lib/fortitude/tags/tag.rb

@@ -0,0 +1,189 @@
+require 'fortitude/tags/tag_support'
+require 'fortitude/method_templates/simple_template'
+
+# Note on handling tags that have no content inside them:
+#
+# - If the tag cannot ever have content inside it -- a "void tag" as denoted by HTML, specified here by
+#   :content_allowed => false -- then we can either render it as "<tag>" (if :close_void_tags is set to false,
+#   the default, on the widget class), or "<tag/>" (if :close_void_tags is set to true on the widget class).
+# - If the tag can have content inside it, but this instance of it does not, then we always render it as
+#   <tag></tag> (or <tag attr="value"...></tag>).
+#
+# Further, doctypes restrict the values you can set close_void_tags to on a widget: HTML5 allows either, HTML4
+# requires it to be false, and XHTML requires it to be true.
+#
+# This is all per the information at:
+#
+# http://stackoverflow.com/questions/3558119/are-self-closing-tags-valid-in-html5
+# http://www.w3.org/TR/xhtml-media-types/#C_2
+# http://www.colorglare.com/2014/02/03/to-close-or-not-to-close.html
+module Fortitude
+  module Tags
+    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::Tags::TagSupport)
+        end
+
+        if @content_allowed
+          alone_tag = "<#{name}></#{name}>"
+          partial_open_alone_end = "></#{name}>"
+        elsif options[:close_void_tags]
+          alone_tag = "<#{name}/>"
+          partial_open_alone_end = "/>"
+        else
+          alone_tag = "<#{name}>"
+          partial_open_alone_end = ">"
+        end
+
+        ensure_constants(mod, :ALONE => alone_tag, :OPEN => "<#{name}>", :CLOSE => "</#{name}>",
+          :PARTIAL_OPEN => "<#{name}", :TAG_OBJECT => self, :PARTIAL_OPEN_ALONE_END => partial_open_alone_end)
+
+        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::MethodTemplates::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 => tag_constant_name(: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
+end