fortitude 0.0.4-java

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 || '(anonymous widget class)'} 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

data/lib/fortitude/widget/tags.rb

@@ -0,0 +1,55 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/tags/tag_store'
+
+module Fortitude
+  class Widget
+    module Tags
+      extend ActiveSupport::Concern
+
+      included do
+        extend Fortitude::Tags::TagStore
+
+        class << self
+          # INTERNAL USE ONLY
+          def tags_changed!(tags)
+            rebuild_tag_methods!(:tags_declared, tags)
+          end
+          private :tags_changed!
+
+          # INTERNAL USE ONLY
+          def delegate_tag_stores
+            out = [ doctype ]
+
+            out += superclass.delegate_tag_stores if superclass.respond_to?(:delegate_tag_stores)
+            out << superclass if superclass.respond_to?(:tags)
+
+            out.compact.uniq
+          end
+        end
+      end
+
+      module ClassMethods
+        # INTERNAL USE ONLY
+        def rebuild_tag_methods!(why, which_tags_in = nil, klass = self)
+          rebuilding(:tag_methods, why, klass) do
+            all_tags = tags.values
+
+            which_tags = Array(which_tags_in || all_tags)
+            which_tags.each do |tag_object|
+              tag_object.define_method_on!(tags_module,
+                :enable_formatting => self.format_output,
+                :enforce_element_nesting_rules => self.enforce_element_nesting_rules,
+                :enforce_attribute_rules => self.enforce_attribute_rules,
+                :enforce_id_uniqueness => self.enforce_id_uniqueness,
+                :close_void_tags => self.close_void_tags)
+            end
+
+            direct_subclasses.each { |s| s.rebuild_tag_methods!(why, which_tags_in, klass) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/widget/temporary_overrides.rb

@@ -0,0 +1,28 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module TemporaryOverrides
+      extend ActiveSupport::Concern
+
+      # PUBLIC API
+      def with_element_nesting_rules(on_or_off)
+        raise ArgumentError, "We aren't even enforcing nesting rules in the first place" if on_or_off && (! self.class.enforce_element_nesting_rules)
+        @_fortitude_rendering_context.with_element_nesting_validation(on_or_off) { yield }
+      end
+
+      # PUBLIC API
+      def with_attribute_rules(on_or_off)
+        raise ArgumentError, "We aren't even enforcing attribute rules in the first place" if on_or_off && (! self.class.enforce_attribute_rules)
+        @_fortitude_rendering_context.with_attribute_validation(on_or_off) { yield }
+      end
+
+      # PUBLIC API
+      def with_id_uniqueness(on_or_off)
+        raise ArgumentError, "We aren't even enforcing ID uniqueness in the first place" if on_or_off && (! self.class.enforce_id_uniqueness)
+        @_fortitude_rendering_context.with_id_uniqueness(on_or_off) { yield }
+      end
+    end
+  end
+end

data/lib/fortitude/widget/widget_class_inheritable_attributes.rb

@@ -0,0 +1,35 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/support/class_inheritable_attributes'
+
+module Fortitude
+  class Widget
+    module WidgetClassInheritableAttributes
+      extend ActiveSupport::Concern
+
+      include Fortitude::Support::ClassInheritableAttributes
+
+      included do
+        _fortitude_class_inheritable_attribute :format_output, false, [ true, false ]
+        _fortitude_class_inheritable_attribute :extra_assigns, :ignore, [ :error, :ignore, :use ]
+        _fortitude_class_inheritable_attribute :automatic_helper_access, true, [ true, false ]
+        _fortitude_class_inheritable_attribute :implicit_shared_variable_access, false, [ true, false ]
+        _fortitude_class_inheritable_attribute :enforce_element_nesting_rules, false, [ true, false ]
+        _fortitude_class_inheritable_attribute :enforce_attribute_rules, false, [ true, false ]
+        _fortitude_class_inheritable_attribute :enforce_id_uniqueness, false, [ true, false ]
+        _fortitude_class_inheritable_attribute :use_instance_variables_for_assigns, false, [ true, false ]
+        _fortitude_class_inheritable_attribute :start_and_end_comments, false, [ true, false ]
+        _fortitude_class_inheritable_attribute :translation_base, nil, lambda { |s, klass| s.kind_of?(String) || s.kind_of?(Symbol) || s == nil }
+        _fortitude_class_inheritable_attribute :close_void_tags, false, (lambda do |new_value, klass|
+          if klass.respond_to?(:doctype) && klass.doctype && klass.doctype.close_void_tags_must_be != nil && new_value != klass.doctype.close_void_tags_must_be
+            raise ArgumentError, "Doctype #{klass.doctype} requires that close_void_tags is #{klass.doctype.close_void_tags_must_be.inspect}; you cannot set it to #{new_value.inspect}."
+          else
+            [ true, false ].include?(new_value)
+          end
+        end)
+        _fortitude_class_inheritable_attribute :debug, false, [ true, false ]
+      end
+    end
+  end
+end

data/lib/fortitude/widgets.rb

@@ -0,0 +1,12 @@
+module Fortitude
+  module Widgets
+    autoload :Html5, 'fortitude/widgets/html5'
+    autoload :Html4Strict, 'fortitude/widgets/html4_strict'
+    autoload :Html4Transitional, 'fortitude/widgets/html4_transitional'
+    autoload :Html4Frameset, 'fortitude/widgets/html4_frameset'
+    autoload :Xhtml10Strict, 'fortitude/widgets/xhtml10_strict'
+    autoload :Xhtml10Transitional, 'fortitude/widgets/xhtml10_transitional'
+    autoload :Xhtml10Frameset, 'fortitude/widgets/xhtml10_frameset'
+    autoload :Xhtml11, 'fortitude/widgets/xhtml11'
+  end
+end

data/lib/fortitude/widgets/html4_frameset.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Html4Frameset < Fortitude::Widget
+      doctype :html4_frameset
+    end
+  end
+end

data/lib/fortitude/widgets/html4_strict.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Html4Strict < Fortitude::Widget
+      doctype :html4_strict
+    end
+  end
+end

data/lib/fortitude/widgets/html4_transitional.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Html4Transitional < Fortitude::Widget
+      doctype :html4_transitional
+    end
+  end
+end

data/lib/fortitude/widgets/html5.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Html5 < Fortitude::Widget
+      doctype :html5
+    end
+  end
+end

data/lib/fortitude/widgets/xhtml10_frameset.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Xhtml10Frameset < Fortitude::Widget
+      doctype :xhtml10_frameset
+    end
+  end
+end

data/lib/fortitude/widgets/xhtml10_strict.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Xhtml10Strict < Fortitude::Widget
+      doctype :xhtml10_strict
+    end
+  end
+end

data/lib/fortitude/widgets/xhtml10_transitional.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Xhtml10Transitional < Fortitude::Widget
+      doctype :xhtml10_transitional
+    end
+  end
+end

data/lib/fortitude/widgets/xhtml11.rb

@@ -0,0 +1,9 @@
+require 'fortitude/widget'
+
+module Fortitude
+  module Widgets
+    class Xhtml11 < Fortitude::Widget
+      doctype :xhtml11
+    end
+  end
+end