fortitude 0.0.4 → 0.0.5

data/lib/fortitude/tilt/fortitude_template.rb

@@ -5,50 +5,17 @@ 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)
+        if data.strip.length > 0
+          @fortitude_class = ::Fortitude::Widget.widget_class_from_source(
+            data,
+            :magic_comment_text => 'fortitude_tilt_class',
+            :class_names_to_try => Array(options[:fortitude_class]) + Array(options[:class_names_to_try]))
         end
       end
 
@@ -74,96 +41,7 @@ which is not a Class that inherits from Fortitude::Widget.}
       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
+      attr_reader :fortitude_class
     end
   end
 end

data/lib/fortitude/version.rb

@@ -1,3 +1,3 @@
 module Fortitude
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/fortitude/widget.rb

@@ -14,6 +14,7 @@ require 'fortitude/widget/helpers'
 require 'fortitude/widget/capturing'
 require 'fortitude/widget/rendering'
 require 'fortitude/widget/temporary_overrides'
+require 'fortitude/widget/files'
 
 require 'fortitude/doctypes'
 
@@ -38,6 +39,7 @@ module Fortitude
     include Fortitude::Widget::Capturing
     include Fortitude::Widget::Rendering
     include Fortitude::Widget::TemporaryOverrides
+    include Fortitude::Widget::Files
 
     if defined?(::Rails)
       require 'fortitude/rails/widget_methods'

data/lib/fortitude/widget/files.rb

@@ -0,0 +1,162 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module Files
+      extend ActiveSupport::Concern
+
+      class CannotDetermineWidgetClassNameError < StandardError
+        attr_reader :tried_class_names, :filename, :magic_comment_texts
+
+        def initialize(tried_class_names, options = { })
+          options.assert_valid_keys(:filename, :magic_comment_texts)
+
+          @tried_class_names = tried_class_names
+          @filename = options[:filename]
+          @magic_comment_texts = options[:magic_comment_texts]
+          from_what = filename ? "from the file '#{filename}'" : "from some Fortitude source code"
+
+          super %{You asked for a Fortitude widget class #{from_what},
+but we couldn't determine the class name of the widget that supposedly is inside.
+
+We tried the following class names, in order:
+
+#{tried_class_names.join("\n")}
+
+...but none of them both existed and were a class that eventually inherits from
+::Fortitude::Widget.
+
+You can either pass the class name into this method via the :class_names_to_try option,
+or add a "magic comment" to the source code of this widget that looks like this:
+
+#!<token>: <class_name>
+
+...where <token> is one of: #{magic_comment_texts.join(", ")}}
+        end
+      end
+
+      module ClassMethods
+        def widget_class_from_file(filename, options = { })
+          options.assert_valid_keys(:root_dirs, :class_names_to_try, :magic_comment_text)
+          filename = File.expand_path(filename)
+          source = File.read(filename)
+
+          class_names_to_try = Array(options[:class_names_to_try])
+          root_dirs = Array(options[:root_dirs])
+
+          root_dirs.each do |root_dir|
+            root_dir = File.expand_path(root_dir)
+
+            if filename[0..(root_dir.length - 1)].downcase == root_dir.downcase
+              subpath = filename[(root_dir.length + 1)..-1]
+              subpath = $1 if subpath =~ /^(.*)\.rb$/i
+              class_names_to_try << subpath.camelize if subpath && subpath.length > 1
+            end
+          end
+
+          widget_class_from_source(source,
+            :class_names_to_try => class_names_to_try, :magic_comment_text => options[:magic_comment_text],
+            :filename => filename)
+        end
+
+        def widget_class_from_source(source, options = { })
+          options.assert_valid_keys(:class_names_to_try, :magic_comment_text, :filename)
+
+          magic_comment_texts = Array(options[:magic_comment_text]) + DEFAULT_MAGIC_COMMENT_TEXTS
+          all_class_names =
+            magic_comment_class_from(source, magic_comment_texts) +
+            Array(options[:class_names_to_try]) +
+            scan_source_for_possible_class_names(source)
+
+          out = widget_class_from_class_names(all_class_names)
+
+          unless out
+            if options[:filename]
+              require options[:filename]
+            else
+              ::Object.class_eval(source)
+            end
+
+            out = widget_class_from_class_names(all_class_names)
+          end
+
+          out || (
+            raise CannotDetermineWidgetClassNameError.new(all_class_names, :magic_comment_texts => magic_comment_texts,
+              :filename => options[:filename]))
+        end
+
+        private
+        DEFAULT_MAGIC_COMMENT_TEXTS = %w{fortitude_class}
+
+        def magic_comment_class_from(source, magic_comment_texts)
+          magic_comment_texts = magic_comment_texts.map { |c| c.to_s.strip.downcase }.uniq
+
+          out = [ ]
+          source.scan(/^\s*\#\s*\!\s*(\S+)\s*:\s*([A-Za-z0-9_:]+)\s*$/) do |(comment_text, class_name)|
+            out << class_name if magic_comment_texts.include?(comment_text.strip.downcase)
+          end
+          out
+        end
+
+        def scan_source_for_possible_class_names(source)
+          out = [ ]
+          module_nesting = [ ]
+
+          source.scan(/\bmodule\s+([A-Za-z0-9_:]+)/) do |match_data|
+            module_name = match_data[0]
+            module_nesting << module_name
+          end
+
+          source.scan(/\bclass\s+([A-Za-z0-9_:]+)/) do |match_data|
+            class_name = match_data[0]
+            out << class_name
+          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 widget_class_from_class_names(class_names)
+          out = nil
+
+          class_names.each do |class_name|
+            klass = begin
+              "::#{class_name}".constantize
+            rescue NameError => ne
+              nil
+            end
+
+            if is_widget_class?(klass)
+              out = klass
+              break
+            end
+          end
+
+          out
+        end
+
+        def is_widget_class?(klass)
+          if (! klass)
+            false
+          elsif (! klass.kind_of?(Class))
+            false
+          elsif klass == ::Fortitude::Widget
+            true
+          else
+            is_widget_class?(klass.superclass)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/widget/integration.rb

@@ -18,7 +18,9 @@ module Fortitude
         # INTERNAL USE ONLY
         def rebuild_text_methods!(why, klass = self)
           rebuilding(:text_methods, why, klass) do
-            class_eval(Fortitude::MethodTemplates::SimpleTemplate.template('text_method_template').result(:format_output => format_output, :needs_element_rules => self.enforce_element_nesting_rules))
+            class_eval(Fortitude::MethodTemplates::SimpleTemplate.template('text_method_template').result(
+              :format_output => format_output,
+              :record_emitting_tag => self._fortitude_record_emitting_tag?))
             direct_subclasses.each { |s| s.rebuild_text_methods!(why, klass) }
           end
         end
@@ -40,13 +42,13 @@ module Fortitude
 
       included do
         _fortitude_on_class_inheritable_attribute_change(
-          :format_output, :enforce_element_nesting_rules) do |attribute_name, old_value, new_value|
+          :format_output, :enforce_element_nesting_rules, :record_tag_emission) do |attribute_name, old_value, new_value|
           rebuild_text_methods!(:"#{attribute_name}_changed")
         end
 
         _fortitude_on_class_inheritable_attribute_change(
           :format_output, :close_void_tags, :enforce_element_nesting_rules,
-          :enforce_attribute_rules, :enforce_id_uniqueness) do |attribute_name, old_value, new_value|
+          :enforce_attribute_rules, :enforce_id_uniqueness, :record_tag_emission) do |attribute_name, old_value, new_value|
           rebuild_tag_methods!(:"#{attribute_name}_changed")
         end
 

data/lib/fortitude/widget/modules_and_subclasses.rb

@@ -9,6 +9,23 @@ module Fortitude
       extend ActiveSupport::Concern
 
       module ClassMethods
+        def all_fortitude_superclasses
+          @all_fortitude_superclasses ||= begin
+            if self.name == ::Fortitude::Widget.name
+              [ ]
+            else
+              out = [ ]
+              klass = superclass
+              while true
+                out << klass
+                break if klass.name == ::Fortitude::Widget.name
+                klass = klass.superclass
+              end
+              out
+            end
+          end
+        end
+
         # INTERNAL USE ONLY
         def direct_subclasses
           @direct_subclasses || [ ]

data/lib/fortitude/widget/rendering.rb

@@ -11,13 +11,13 @@ module Fortitude
       # PUBLIC API
       def render(*args, &block)
         call_through = lambda do
-          @_fortitude_rendering_context.record_widget(args) do
+          @_fortitude_rendering_context.record_render(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)
+        if self.class._fortitude_record_emitting_tag? && args[0].kind_of?(Hash) && args[0].has_key?(:partial)
+          @_fortitude_rendering_context.emitting_tag!(self, Fortitude::Tags::PartialTagPlaceholder.instance, nil, nil, &call_through)
         else
           call_through.call
         end
@@ -50,8 +50,15 @@ module Fortitude
       end
 
       # PUBLIC API
-      def widget(w)
-        w.render_to(@_fortitude_rendering_context)
+      def widget(w, hash = nil)
+        if w.respond_to?(:render_to)
+          w.render_to(@_fortitude_rendering_context)
+        elsif w.kind_of?(Class)
+          hash ||= { }
+          w.new(hash).render_to(@_fortitude_rendering_context)
+        else
+          raise "You tried to render a widget, but this is not valid: #{w.inspect}(#{hash.inspect})"
+        end
       end
 
       # PUBLIC API

data/lib/fortitude/widget/start_and_end_comments.rb

@@ -22,7 +22,9 @@ module Fortitude
         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}"
+          class_name = self.class.name
+          class_name = "(anonymous widget class)" if (class_name || "") == ""
+          comment_text = "BEGIN #{class_name} depth #{widget_nesting_depth}"
 
           assign_keys = assigns.keys
           if assign_keys.length > 0
@@ -58,7 +60,7 @@ module Fortitude
           end
           tag_comment comment_text
           yield
-          tag_comment "END #{self.class.name} depth #{widget_nesting_depth}"
+          tag_comment "END #{class_name} depth #{widget_nesting_depth}"
         else
           yield
         end

data/lib/fortitude/widget/tags.rb

@@ -14,6 +14,7 @@ module Fortitude
         class << self
           # INTERNAL USE ONLY
           def tags_changed!(tags)
+            super
             rebuild_tag_methods!(:tags_declared, tags)
           end
           private :tags_changed!
@@ -30,6 +31,10 @@ module Fortitude
         end
       end
 
+      def validate_can_enclose!(widget, tag_object)
+        # ok, nothing here
+      end
+
       module ClassMethods
         # INTERNAL USE ONLY
         def rebuild_tag_methods!(why, which_tags_in = nil, klass = self)
@@ -40,7 +45,7 @@ module Fortitude
             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,
+                :record_emitting_tag => self._fortitude_record_emitting_tag?,
                 :enforce_attribute_rules => self.enforce_attribute_rules,
                 :enforce_id_uniqueness => self.enforce_id_uniqueness,
                 :close_void_tags => self.close_void_tags)