fortitude 0.0.1 → 0.0.2

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,51 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module Content
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # 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

data/lib/fortitude/widget/helpers.rb

@@ -0,0 +1,62 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/rails/yielded_object_outputter'
+
+module Fortitude
+  class Widget
+    module Helpers
+      extend ActiveSupport::Concern
+
+      # PUBLIC API
+      def invoke_helper(name, *args, &block)
+        @_fortitude_rendering_context.helpers_object.send(name, *args, &block)
+      end
+
+      module ClassMethods
+        # PUBLIC API
+        def helper(*args)
+          options = args.extract_options!
+          options.assert_valid_keys(:transform, :call, :output_yielded_methods)
+
+          args.each do |name|
+            source_method_name = options[:call] || name
+
+            prefix = "return"
+            suffix = ""
+            case (transform = options[:transform])
+            when :output_return_value
+              prefix = "text"
+              suffix = "; nil"
+            when :return_output
+              prefix = "return capture { "
+              suffix = " }"
+            when :none, nil, false then nil
+            else raise ArgumentError, "Invalid value for :transform: #{transform.inspect}"
+            end
+
+            block_transform = "effective_block = block"
+
+            yielded_methods = options[:output_yielded_methods]
+            if yielded_methods
+              block_transform = <<-EOS
+      effective_block = lambda do |yielded_object|
+        block.call(Fortitude::Rails::YieldedObjectOutputter.new(self, yielded_object, #{yielded_methods.inspect}))
+      end
+EOS
+            end
+
+            text = <<-EOS
+    def #{name}(*args, &block)
+      #{block_transform}
+      #{prefix}(@_fortitude_rendering_context.helpers_object.#{source_method_name}(*args, &effective_block))#{suffix}
+    end
+EOS
+
+            helpers_module.module_eval(text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/widget/integration.rb

@@ -0,0 +1,76 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/method_templates/simple_template'
+
+module Fortitude
+  class Widget
+    module Integration
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # INTERNAL USE ONLY
+        def rebuilding(what, why, klass, &block)
+          ActiveSupport::Notifications.instrument("fortitude.rebuilding", :what => what, :why => why, :originating_class => klass, :class => self, &block)
+        end
+        private :rebuilding
+
+        # 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))
+            direct_subclasses.each { |s| s.rebuild_text_methods!(why, klass) }
+          end
+        end
+      end
+
+      # RUBY CALLBACK
+      def method_missing(name, *args, &block)
+        if self.class.extra_assigns == :use
+          ivar_name = self.class.instance_variable_name_for_need(name)
+          return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+        end
+
+        if self.class.automatic_helper_access && @_fortitude_rendering_context && @_fortitude_rendering_context.helpers_object && @_fortitude_rendering_context.helpers_object.respond_to?(name, true)
+          @_fortitude_rendering_context.helpers_object.send(name, *args, &block)
+        else
+          super(name, *args, &block)
+        end
+      end
+
+      included do
+        _fortitude_on_class_inheritable_attribute_change(
+          :format_output, :enforce_element_nesting_rules) 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|
+          rebuild_tag_methods!(:"#{attribute_name}_changed")
+        end
+
+        _fortitude_on_class_inheritable_attribute_change(
+          :debug, :extra_assigns, :use_instance_variables_for_assigns) do |attribute_name, old_value, new_value|
+          rebuild_needs!(:"#{attribute_name}_changed")
+        end
+
+        _fortitude_on_class_inheritable_attribute_change(:implicit_shared_variable_access) do |attribute_name, old_value, new_value|
+          if new_value
+            around_content :transfer_shared_variables
+          else
+            remove_around_content :transfer_shared_variables, :fail_if_not_present => false
+          end
+        end
+
+        _fortitude_on_class_inheritable_attribute_change(:start_and_end_comments) do |attribute_name, old_value, new_value|
+          if new_value
+            around_content :start_and_end_comments
+          else
+            remove_around_content :start_and_end_comments, :fail_if_not_present => false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/widget/localization.rb

@@ -0,0 +1,63 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  class Widget
+    module Localization
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # RUBY CALLBACK
+        def method_added(method_name)
+          super(method_name)
+          check_localized_methods!
+        end
+
+        # RUBY CALLBACK
+        def method_removed(method_name)
+          super(method_name)
+          check_localized_methods!
+        end
+
+        # RUBY CALL
+        def include(*args)
+          super(*args)
+          check_localized_methods!
+        end
+
+        LOCALIZED_CONTENT_PREFIX = "localized_content_"
+
+        # INTERNAL USE ONLY
+        def check_localized_methods!(original_class = self)
+          currently_has = instance_methods(true).detect { |i| i =~ /^#{LOCALIZED_CONTENT_PREFIX}/i }
+          if currently_has != @last_localized_methods_check_has
+            @last_localized_methods_check_has = currently_has
+            rebuild_run_content!(:localized_methods_presence_changed, original_class)
+          end
+          direct_subclasses.each { |s| s.check_localized_methods!(original_class) }
+        end
+
+        # INTERNAL USE ONLY
+        def has_localized_content_methods?
+          !! (instance_methods(true).detect { |i| i =~ /^#{LOCALIZED_CONTENT_PREFIX}/i })
+        end
+        private :has_localized_content_methods?
+      end
+
+      # PUBLIC API
+      def t(key, *args)
+        base = self.class.translation_base
+        if base && key.to_s =~ /^\./
+          super("#{base}#{key}", *args)
+        else
+          super(key, *args)
+        end
+      end
+
+      # PUBLIC API
+      def ttext(key, *args)
+        tag_text t(".#{key}", *args)
+      end
+    end
+  end
+end

data/lib/fortitude/widget/modules_and_subclasses.rb

@@ -0,0 +1,58 @@
+require 'active_support'
+require 'active_support/concern'
+
+require 'fortitude/tags/tags_module'
+
+module Fortitude
+  class Widget
+    module ModulesAndSubclasses
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # INTERNAL USE ONLY
+        def direct_subclasses
+          @direct_subclasses || [ ]
+        end
+        private :direct_subclasses
+
+        # INTERNAL USE ONLY -- RUBY CALLBACK
+        def inherited(subclass)
+          @direct_subclasses ||= [ ]
+          @direct_subclasses |= [ subclass ]
+        end
+
+        # INTERNAL USE ONLY
+        def create_modules!
+          raise "We already seem to have created our modules" if @tags_module || @needs_module || @helpers_module
+          @tags_module = Fortitude::Tags::TagsModule.new(self)
+          @helpers_module = Module.new
+          include @helpers_module
+          @needs_module = Module.new
+          include @needs_module
+        end
+        private :create_modules!
+
+        # INTERNAL USE ONLY
+        def tags_module
+          create_modules! unless @tags_module
+          @tags_module
+        end
+        private :tags_module
+
+        # INTERNAL USE ONLY
+        def needs_module
+          create_modules! unless @needs_module
+          @needs_module
+        end
+        private :needs_module
+
+        # INTERNAL USE ONLY
+        def helpers_module
+          create_modules! unless @helpers_module
+          @helpers_module
+        end
+        private :helpers_module
+      end
+    end
+  end
+end