fortitude 0.0.4-java

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

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,98 @@
+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
+
+      def render_to(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 to_html(rendering_context = ::Fortitude::RenderingContext.new({ }))
+        render_to(rendering_context)
+        rendering_context.output_buffer_holder.output_buffer
+      end
+
+      # PUBLIC API
+      def rendering_context
+        @_fortitude_rendering_context
+      end
+
+      # PUBLIC API
+      def widget(w)
+        w.render_to(@_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