fortitude 0.0.1 → 0.0.2

data/lib/fortitude/widget/needs.rb

@@ -0,0 +1,164 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/method_templates/simple_template'
+require 'fortitude/support/assigns_proxy'
+
+module Fortitude
+  class Widget
+    module Needs
+      extend ActiveSupport::Concern
+
+      # INTERNAL USE ONLY
+      REQUIRED_NEED = Object.new
+      # INTERNAL USE ONLY
+      NOT_PRESENT_NEED = Object.new
+
+      # INTERNAL USE ONLY
+      included do
+        attr_reader :_fortitude_default_assigns
+      end
+
+      module ClassMethods
+        # PUBLIC API
+        def needs(*names)
+          previous_needs = needs_as_hash
+          return previous_needs if names.length == 0
+
+          @this_class_needs ||= { }
+
+          with_defaults_raw = { }
+          with_defaults_raw = names.pop if names[-1] && names[-1].kind_of?(Hash)
+
+          names = names.map { |n| n.to_s.strip.downcase.to_sym }
+          with_defaults = { }
+          with_defaults_raw.each { |k,v| with_defaults[k.to_s.strip.downcase.to_sym] = v }
+
+          bad_names = names.select { |n| ! is_valid_ruby_method_name?(n.to_s) }
+          raise ArgumentError, "Needs in a Fortitude widget class must be valid Ruby method names; these are not: #{bad_names.inspect}" if bad_names.length > 0
+
+          names.each do |name|
+            @this_class_needs[name] = REQUIRED_NEED
+          end
+
+          with_defaults.each do |name, default_value|
+            @this_class_needs[name] = default_value.freeze
+          end
+
+          rebuild_needs!(:need_declared)
+
+          needs_as_hash
+        end
+
+        # INTERNAL USE ONLY
+        def is_valid_ruby_method_name?(s)
+          s.to_s =~ /^[A-Za-z_][A-Za-z0-9_]*[\?\!]?$/
+        end
+
+        # INTERNAL USE ONLY
+        def needs_as_hash
+          @_fortitude_needs_as_hash ||= begin
+            out = { }
+            out = superclass.needs_as_hash if superclass.respond_to?(:needs_as_hash)
+            out.merge(@this_class_needs || { })
+          end
+        end
+
+        # INTERNAL USE ONLY
+        def rebuild_needs!(why, klass = self)
+          rebuilding(:needs, why, klass) do
+            @_fortitude_needs_as_hash = nil
+            rebuild_my_needs_methods!
+            direct_subclasses.each { |s| s.rebuild_needs!(why, klass) }
+          end
+        end
+
+        # PUBLIC API
+        def extract_needed_assigns_from(input)
+          input = input.with_indifferent_access
+
+          out = { }
+          needs_as_hash.keys.each do |name|
+            out[name] = input[name] if input.has_key?(name)
+          end
+          out
+        end
+
+        # INTERNAL USE ONLY
+        STANDARD_INSTANCE_VARIABLE_PREFIX = "_fortitude_assign_"
+
+        # INTERNAL USE ONLY
+        def instance_variable_name_for_need(need_name)
+          effective_name = need_name.to_s
+          effective_name.gsub!("!", "_fortitude_bang")
+          effective_name.gsub!("?", "_fortitude_question")
+          "@" + (use_instance_variables_for_assigns ? "" : STANDARD_INSTANCE_VARIABLE_PREFIX) + effective_name
+        end
+
+        # INTERNAL USE ONLY
+        def rebuild_my_needs_methods!
+          n = needs_as_hash
+
+          needs_text = n.map do |need, default_value|
+            Fortitude::MethodTemplates::SimpleTemplate.template('need_assignment_template').result(:extra_assigns => extra_assigns,
+              :need => need, :has_default => (default_value != REQUIRED_NEED),
+              :ivar_name => instance_variable_name_for_need(need)
+            )
+          end.join("\n\n")
+
+          assign_locals_from_text = Fortitude::MethodTemplates::SimpleTemplate.template('assign_locals_from_template').result(
+            :extra_assigns => extra_assigns, :needs_text => needs_text)
+          class_eval(assign_locals_from_text)
+
+          n.each do |need, default_value|
+            text = Fortitude::MethodTemplates::SimpleTemplate.template('need_method_template').result(
+              :need => need, :ivar_name => instance_variable_name_for_need(need),
+              :debug => self.debug)
+            needs_module.module_eval(text)
+          end
+        end
+        private :rebuild_my_needs_methods!
+      end
+
+      # PUBLIC API
+      def shared_variables
+        @_fortitude_rendering_context.instance_variable_set
+      end
+
+      # INTERNAL USE ONLY
+      def instance_variable_name_for_need(need)
+        self.class.instance_variable_name_for_need(need)
+      end
+
+      # INTERNAL USE ONLY
+      def needs_as_hash
+        @_fortitude_needs_as_hash ||= self.class.needs_as_hash
+      end
+
+      # PUBLIC API
+      def assigns
+        @_fortitude_assigns_proxy ||= begin
+          keys = needs_as_hash.keys
+          keys |= (@_fortitude_raw_assigns.keys.map(&:to_sym)) if self.class.extra_assigns == :use
+
+          Fortitude::Support::AssignsProxy.new(self, keys)
+        end
+      end
+
+      # INTERNAL USE ONLY
+      def widget_extra_assigns
+        (@_fortitude_extra_assigns || { })
+      end
+
+      # INTERNAL USE ONLY
+      def transfer_shared_variables(*args, &block)
+        if self.class.implicit_shared_variable_access
+          @_fortitude_rendering_context.instance_variable_set.with_instance_variable_copying(self, *args, &block)
+        else
+          block.call(*args)
+        end
+      end
+      private :transfer_shared_variables
+    end
+  end
+end

data/lib/fortitude/widget/non_rails_widget_methods.rb

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

data/lib/fortitude/widget/rendering.rb

@@ -0,0 +1,93 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/tags/partial_tag_placeholder'
+
+module Fortitude
+  class Widget
+    module Rendering
+      extend ActiveSupport::Concern
+
+      # PUBLIC API
+      def render(*args, &block)
+        call_through = lambda do
+          @_fortitude_rendering_context.record_widget(args) do
+            tag_rawtext(invoke_helper(:render, *args, &block))
+          end
+        end
+
+        if self.class.enforce_element_nesting_rules && args[0].kind_of?(Hash) && args[0].has_key?(:partial)
+          @_fortitude_rendering_context.record_tag(self, Fortitude::Tags::PartialTagPlaceholder.instance, &call_through)
+        else
+          call_through.call
+        end
+      end
+
+      # PUBLIC API
+      def to_html(rendering_context)
+        @_fortitude_rendering_context = rendering_context
+        @_fortitude_output_buffer_holder = rendering_context.output_buffer_holder
+
+        block = lambda { |*args| @_fortitude_rendering_context.yield_from_widget(*args) }
+
+        rendering_context.record_widget(self) do
+          begin
+            run_content(&block)
+          ensure
+            @_fortitude_rendering_context = nil
+          end
+        end
+      end
+
+      # PUBLIC API
+      def rendering_context
+        @_fortitude_rendering_context
+      end
+
+      # PUBLIC API
+      def widget(w)
+        w.to_html(@_fortitude_rendering_context)
+      end
+
+      # PUBLIC API
+      def output_buffer
+        @_fortitude_output_buffer_holder.output_buffer
+      end
+
+      # PUBLIC API
+      def initialize(assigns = { })
+        assign_locals_from(assigns)
+      end
+
+      # INTERNAL USE ONLY
+      def _fortitude_new_buffer
+        _fortitude_class_for_new_buffer.new
+      end
+      private :_fortitude_new_buffer
+
+      POTENTIAL_NEW_BUFFER_CLASSES = %w{ActionView::OutputBuffer ActiveSupport::SafeBuffer String}
+
+      # INTERNAL USE ONLY
+      def _fortitude_class_for_new_buffer
+        @_fortitude_class_for_new_buffer ||= begin
+          out = nil
+          POTENTIAL_NEW_BUFFER_CLASSES.each do |class_name|
+            klass = eval(class_name) rescue nil
+            if klass
+              out = klass
+              break
+            end
+          end
+          raise "Huh? NONE of the following classes appear to be defined?!? #{POTENTIAL_NEW_BUFFER_CLASSES.inspect}" unless out
+          out
+        end
+      end
+      private :_fortitude_class_for_new_buffer
+
+      # PUBLIC API
+      def yield_from_widget(*args)
+        @_fortitude_rendering_context.yield_from_widget(*args)
+      end
+    end
+  end
+end

data/lib/fortitude/widget/start_and_end_comments.rb

@@ -0,0 +1,69 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module StartAndEndComments
+      extend ActiveSupport::Concern
+
+      # INTERNAL USE ONLY
+      def widget_nesting_depth
+        @_fortitude_widget_nesting_depth ||= @_fortitude_rendering_context.current_widget_depth
+      end
+      private :widget_nesting_depth
+
+      MAX_START_COMMENT_VALUE_STRING_LENGTH = 100
+      START_COMMENT_VALUE_STRING_TOO_LONG_ELLIPSIS = "...".freeze
+      MAX_ASSIGNS_LENGTH_BEFORE_MULTIPLE_LINES = 200
+      START_COMMENT_EXTRA_INDENT_FOR_NEXT_LINE = " " * 5
+
+      # INTERNAL USE ONLY
+      def start_and_end_comments
+        if self.class.start_and_end_comments
+          fo = self.class.format_output
+
+          comment_text = "BEGIN #{self.class.name} depth #{widget_nesting_depth}"
+
+          assign_keys = assigns.keys
+          if assign_keys.length > 0
+
+            assign_text = assign_keys.map do |assign|
+              value = assigns[assign]
+              out = ":#{assign} => "
+              out << "(DEFAULT) " if assigns.is_default?(assign)
+
+              value_string = if value.respond_to?(:to_fortitude_comment_string) then value.to_fortitude_comment_string else value.inspect end
+              if value_string.length > MAX_START_COMMENT_VALUE_STRING_LENGTH
+                value_string = value_string[0..(MAX_START_COMMENT_VALUE_STRING_LENGTH - START_COMMENT_VALUE_STRING_TOO_LONG_ELLIPSIS.length)] + START_COMMENT_VALUE_STRING_TOO_LONG_ELLIPSIS
+              end
+              out << value_string
+              out
+            end
+
+            total_length = assign_text.map(&:length).inject(0, &:+)
+            if total_length > MAX_ASSIGNS_LENGTH_BEFORE_MULTIPLE_LINES
+              newline_and_indent = "\n#{@_fortitude_rendering_context.current_indent}"
+              newline_and_extra_indent = newline_and_indent + START_COMMENT_EXTRA_INDENT_FOR_NEXT_LINE
+
+              comment_text << ":"
+              assign_text.each do |at|
+                comment_text << newline_and_extra_indent
+                comment_text << at
+              end
+              comment_text << newline_and_indent
+            else
+              comment_text << ": "
+              comment_text << assign_text.join(", ")
+            end
+          end
+          tag_comment comment_text
+          yield
+          tag_comment "END #{self.class.name} depth #{widget_nesting_depth}"
+        else
+          yield
+        end
+      end
+      private :start_and_end_comments
+    end
+  end
+end

data/lib/fortitude/widget/staticization.rb

@@ -0,0 +1,50 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/support/staticized_method'
+
+module Fortitude
+  class Widget
+    module Staticization
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # PUBLIC API
+        def static(*method_names)
+          options = method_names.extract_options!
+
+          method_names.each do |method_name|
+            method_name = method_name.to_sym
+            staticized_method = Fortitude::Support::StaticizedMethod.new(self, method_name, options)
+            staticized_method.create_method!
+          end
+        end
+      end
+
+      METHODS_TO_DISABLE_WHEN_STATIC = [ :assigns, :shared_variables ]
+
+      # INTERNAL USE ONLY
+      def with_staticness_enforced(static_method_name, &block)
+        methods_to_disable = METHODS_TO_DISABLE_WHEN_STATIC + self.class.needs_as_hash.keys
+        metaclass = (class << self; self; end)
+
+        methods_to_disable.each do |method_name|
+          metaclass.class_eval do
+            alias_method "_static_disabled_#{method_name}", method_name
+            define_method(method_name) { raise Fortitude::Errors::DynamicAccessFromStaticMethod.new(self, static_method_name, method_name) }
+          end
+        end
+
+        begin
+          block.call
+        ensure
+          methods_to_disable.each do |method_name|
+            metaclass.class_eval do
+              alias_method method_name, "_static_disabled_#{method_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/widget/tag_like_methods.rb

@@ -0,0 +1,102 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module TagLikeMethods
+      extend ActiveSupport::Concern
+
+      # From http://www.w3.org/TR/html5/syntax.html#comments:
+      #
+      # Comments must start with the four character sequence U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK,
+      # U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS (<!--). Following this sequence, the comment may have text,
+      # with the additional restriction that the text must not start with a single ">" (U+003E) character,
+      # nor start with a U+002D HYPHEN-MINUS character (-) followed by a ">" (U+003E) character, nor contain
+      # two consecutive U+002D HYPHEN-MINUS characters (--), nor end with a U+002D HYPHEN-MINUS character (-).
+      # Finally, the comment must be ended by the three character sequence U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS,
+      # U+003E GREATER-THAN SIGN (-->).
+
+      # INTERNAL USE ONLY
+      def comment_escape(string)
+        string = "_#{string}" if string =~ /^\s*(>|->)/
+        string = string.gsub("--", "- - ") if string =~ /\-\-/ # don't gsub if it doesn't match to avoid generating garbage
+        string = "#{string}_" if string =~ /\-\s*$/i
+        string
+      end
+      private :comment_escape
+
+      # PUBLIC API
+      def tag_comment(s)
+        fo = self.class.format_output
+        @_fortitude_rendering_context.needs_newline! if fo
+        raise ArgumentError, "You cannot pass a block to a comment" if block_given?
+        tag_rawtext "<!-- "
+        tag_rawtext comment_escape(s)
+        tag_rawtext " -->"
+        @_fortitude_rendering_context.needs_newline! if fo
+      end
+
+      # PUBLIC API
+      def tag_javascript(content = nil, &block)
+        args = if content.kind_of?(Hash)
+          [ self.class.doctype.default_javascript_tag_attributes.merge(content) ]
+        elsif content
+          if block
+            raise ArgumentError, "You can't supply JavaScript content both via text and a block"
+          else
+            block = lambda { tag_rawtext content }
+            [ self.class.doctype.default_javascript_tag_attributes.dup ]
+          end
+        else
+          [ self.class.doctype.default_javascript_tag_attributes.dup ]
+        end
+
+        actual_block = block
+        if self.class.doctype.needs_cdata_in_javascript_tag?
+          actual_block = lambda do
+            tag_rawtext "\n//#{CDATA_START}\n"
+            block.call
+            tag_rawtext "\n//#{CDATA_END}\n"
+          end
+        end
+
+        @_fortitude_rendering_context.with_indenting_disabled do
+          script(*args, &actual_block)
+        end
+      end
+
+      %w{comment javascript}.each do |non_tag_method|
+        alias_method non_tag_method, "tag_#{non_tag_method}"
+      end
+
+      CDATA_START = "<![CDATA[".freeze
+      CDATA_END = "]]>".freeze
+
+      # PUBLIC API
+      def cdata(s = nil, &block)
+        if s
+          raise ArgumentError, "You can only pass literal text or a block, not both" if block
+
+          components = s.split("]]>")
+
+          if components.length > 1
+            components.each_with_index do |s, i|
+              this_component = s
+              this_component = ">#{this_component}" if i > 0
+              this_component = "#{this_component}]]" if i < (components.length - 1)
+              cdata(this_component)
+            end
+          else
+            tag_rawtext CDATA_START
+            tag_rawtext s
+            tag_rawtext CDATA_END
+          end
+        else
+          tag_rawtext CDATA_START
+          yield
+          tag_rawtext CDATA_END
+        end
+      end
+    end
+  end
+end