fortitude 0.0.4-java

data/lib/fortitude/tags/tags_module.rb

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

data/lib/fortitude/tilt.rb

@@ -0,0 +1,17 @@
+begin
+  gem 'tilt'
+rescue Gem::LoadError => le
+  # ok
+end
+
+begin
+  require 'tilt'
+rescue LoadError => le
+  # ok, whatever
+end
+
+if defined?(::Tilt)
+  require 'fortitude/tilt/fortitude_template'
+
+  Tilt.register(Fortitude::Tilt::FortitudeTemplate, 'rb')
+end

data/lib/fortitude/tilt/fortitude_template.rb

@@ -0,0 +1,169 @@
+require 'tilt'
+require 'active_support/inflector'
+require 'fortitude/rendering_context'
+require 'fortitude/doctypes'
+
+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 prepare
+        ::Object.class_eval(data)
+        @fortitude_class = explicit_fortitude_class || first_class_that_is_a_widget_class(all_possible_class_names)
+
+        # 2014-06-19 ageweke -- Earlier versions of Tilt try to instantiate the engine with an empty tempate as a way
+        # of making sure it can be created, so we have to support this case.
+        if (! @fortitude_class) && (data != "")
+          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.render_to(rendering_context)
+        rendering_context.output_buffer_holder.output_buffer
+      end
+
+      private
+      def fortitude_class
+        @fortitude_class
+      end
+
+      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 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.4"
+end

data/lib/fortitude/widget.rb

@@ -0,0 +1,54 @@
+require 'fortitude/widget/widget_class_inheritable_attributes'
+require 'fortitude/widget/tags'
+require 'fortitude/widget/needs'
+require 'fortitude/widget/modules_and_subclasses'
+require 'fortitude/widget/doctypes'
+require 'fortitude/widget/start_and_end_comments'
+require 'fortitude/widget/tag_like_methods'
+require 'fortitude/widget/staticization'
+require 'fortitude/widget/integration'
+require 'fortitude/widget/content'
+require 'fortitude/widget/around_content'
+require 'fortitude/widget/localization'
+require 'fortitude/widget/helpers'
+require 'fortitude/widget/capturing'
+require 'fortitude/widget/rendering'
+require 'fortitude/widget/temporary_overrides'
+
+require 'fortitude/doctypes'
+
+module Fortitude
+  # TODO: rename all non-interface methods as _fortitude_*
+  # TODO: Make 'element' vs. 'tag' naming consistent
+  # TODO: Make naming consistent across enforcement/validation/rules (tag nesting, attributes, ID uniqueness)
+  class Widget
+    include Fortitude::Widget::WidgetClassInheritableAttributes
+    include Fortitude::Widget::Tags
+    include Fortitude::Widget::Needs
+    include Fortitude::Widget::ModulesAndSubclasses
+    include Fortitude::Widget::Doctypes
+    include Fortitude::Widget::StartAndEndComments
+    include Fortitude::Widget::TagLikeMethods
+    include Fortitude::Widget::Staticization
+    include Fortitude::Widget::Integration
+    include Fortitude::Widget::Content
+    include Fortitude::Widget::AroundContent
+    include Fortitude::Widget::Localization
+    include Fortitude::Widget::Helpers
+    include Fortitude::Widget::Capturing
+    include Fortitude::Widget::Rendering
+    include Fortitude::Widget::TemporaryOverrides
+
+    if defined?(::Rails)
+      require 'fortitude/rails/widget_methods'
+      include Fortitude::Rails::WidgetMethods
+    else
+      require 'fortitude/widget/non_rails_widget_methods'
+      include Fortitude::Widget::NonRailsWidgetMethods
+    end
+
+    rebuild_run_content!(:initial_setup)
+    rebuild_needs!(:initial_setup)
+    rebuild_text_methods!(:initial_setup)
+  end
+end

data/lib/fortitude/widget/around_content.rb

@@ -0,0 +1,53 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module AroundContent
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # PUBLIC API
+        def around_content(*method_names)
+          return if method_names.length == 0
+          @_fortitude_around_content_methods ||= [ ]
+          @_fortitude_around_content_methods += method_names.map { |x| x.to_s.strip.downcase.to_sym }
+          rebuild_run_content!(:around_content_added)
+        end
+
+        # PUBLIC API
+        def remove_around_content(*method_names)
+          options = method_names.extract_options!
+          options.assert_valid_keys(:fail_if_not_present)
+
+          not_found = [ ]
+          method_names.each do |method_name|
+            not_found << method_name unless (@_fortitude_around_content_methods || [ ]).delete(method_name)
+          end
+
+          rebuild_run_content!(:around_content_removed)
+          unless (not_found.length == 0) || (options.has_key?(:fail_if_not_present) && (! options[:fail_if_not_present]))
+            raise ArgumentError, "no such methods: #{not_found.inspect}"
+          end
+        end
+
+        # INTERNAL USE ONLY
+        def around_content_methods
+          superclass_methods = if superclass.respond_to?(:around_content_methods)
+            superclass.around_content_methods
+          else
+            [ ]
+          end
+
+          (superclass_methods + this_class_around_content_methods).uniq
+        end
+
+        # INTERNAL USE ONLY
+        def this_class_around_content_methods
+          @_fortitude_around_content_methods ||= [ ]
+        end
+        private :this_class_around_content_methods
+      end
+    end
+  end
+end

data/lib/fortitude/widget/capturing.rb

@@ -0,0 +1,37 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module Capturing
+      extend ActiveSupport::Concern
+
+      # PUBLIC API
+      def capture(&block)
+        helpers = @_fortitude_rendering_context.helpers_object
+        if helpers && helpers.respond_to?(:capture, true) &&
+          [ 0, -1 ].include?(helpers.method(:capture).arity)
+          helpers.capture(&block)
+        else
+          _fortitude_builtin_capture(&block)
+        end
+      end
+
+      # INTERNAL USE ONLY
+      def _fortitude_builtin_capture(&block)
+        old_buffer = nil
+        new_buffer = nil
+        begin
+          new_buffer = _fortitude_new_buffer
+          old_buffer, @_fortitude_output_buffer_holder.output_buffer = @_fortitude_output_buffer_holder.output_buffer, new_buffer
+          _fortitude_new_buffer.force_encoding(old_buffer.encoding) if old_buffer && old_buffer.respond_to?(:encoding)
+          block.call
+          new_buffer
+        ensure
+          @_fortitude_output_buffer_holder.output_buffer = old_buffer
+        end
+      end
+      private :_fortitude_builtin_capture
+    end
+  end
+end

data/lib/fortitude/widget/content.rb

@@ -0,0 +1,61 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module Content
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def inline_subclass(&block)
+          out = Class.new(self)
+          out.send(:define_method, :content, &block)
+          out
+        end
+
+        def inline_html(assigns = { }, &block)
+          inline_subclass(&block).new(assigns).to_html
+        end
+
+        # INTERNAL USE ONLY
+        def rebuild_run_content!(why, klass = self)
+          rebuilding(:run_content, why, klass) do
+            acm = around_content_methods
+            text = "def run_content(*args, &block)\n"
+            text += "  out = nil\n"
+            acm.each_with_index do |method_name, index|
+              text += "  " + ("  " * index) + "#{method_name}(*args) do\n"
+            end
+
+            if has_localized_content_methods?
+              text += "  " + ("  " * acm.length) + "the_locale = widget_locale\n"
+              text += "  " + ("  " * acm.length) + "locale_method_name = \"localized_content_\#{the_locale}\" if the_locale\n"
+              text += "  " + ("  " * acm.length) + "out = if locale_method_name && respond_to?(locale_method_name)\n"
+              text += "  " + ("  " * acm.length) + "  send(locale_method_name, *args, &block)\n"
+              text += "  " + ("  " * acm.length) + "else\n"
+              text += "  " + ("  " * acm.length) + "  content(*args, &block)\n"
+              text += "  " + ("  " * acm.length) + "end\n"
+            else
+              text += "  " + ("  " * acm.length) + "out = content(*args, &block)\n"
+            end
+
+            (0..(acm.length - 1)).each do |index|
+              text += "  " + ("  " * (acm.length - (index + 1))) + "end\n"
+            end
+            text += "  out\n"
+            text += "end"
+
+            class_eval(text)
+
+            direct_subclasses.each { |s| s.rebuild_run_content!(why, klass) }
+          end
+        end
+      end
+
+      # PUBLIC API
+      def content
+        raise "Must override in #{self.class.name}"
+      end
+    end
+  end
+end

data/lib/fortitude/widget/doctypes.rb

@@ -0,0 +1,53 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module Doctypes
+      extend ActiveSupport::Concern
+
+      # PUBLIC API
+      def doctype(s)
+        tag_rawtext "<!DOCTYPE #{s}>"
+      end
+
+      # PUBLIC API
+      def doctype!
+        dt = self.class.doctype
+        raise "You must set a doctype at the class level, using something like 'doctype :html5', before you can use this method." unless dt
+        dt.declare!(self)
+      end
+
+      module ClassMethods
+        # PUBLIC API
+        def doctype(new_doctype = nil)
+          if new_doctype
+            new_doctype = case new_doctype
+            when Fortitude::Doctypes::Base then new_doctype
+            when Symbol then Fortitude::Doctypes.standard_doctype(new_doctype)
+            else raise ArgumentError, "You must supply a Symbol or an instance of Fortitude::Doctypes::Base, not: #{new_doctype.inspect}"
+            end
+
+            current_doctype = doctype
+            if current_doctype
+              if new_doctype != current_doctype
+                raise ArgumentError, "The doctype has already been set to #{current_doctype} on this widget class or a superclass. You can't set it to #{new_doctype}; if you want to use a different doctype, you will need to make a new subclass that has no doctype set yet."
+              end
+            end
+
+            if new_doctype.close_void_tags_must_be != nil
+              self.close_void_tags(new_doctype.close_void_tags_must_be)
+            end
+
+            @_fortitude_doctype = new_doctype
+            tags_added!(new_doctype.tags.values)
+          else
+            return @_fortitude_doctype if @_fortitude_doctype
+            return superclass.doctype if superclass.respond_to?(:doctype)
+            nil
+          end
+        end
+      end
+    end
+  end
+end