fortitude 0.0.4-java

data/lib/fortitude/rails/renderer.rb

@@ -0,0 +1,43 @@
+require 'fortitude/rendering_context'
+
+::ActiveSupport::SafeBuffer.class_eval do
+  alias_method :fortitude_concat, :original_concat
+  public :fortitude_concat
+end
+
+module Fortitude
+  module Rails
+    class Renderer
+      class << self
+        # TODO: Refactor this and render :widget => ... support into one method somewhere.
+        def render(widget_class, template_handler, local_assigns, &block)
+          total_assigns = template_handler.assigns.symbolize_keys.merge(local_assigns.symbolize_keys)
+
+          needed_assigns = if widget_class.extra_assigns == :use
+            total_assigns
+          else
+            widget_class.extract_needed_assigns_from(total_assigns)
+          end
+
+          widget = widget_class.new(needed_assigns)
+          template_handler.with_output_buffer do
+            rendering_context_options = { :delegate_object => template_handler, :yield_block => block }
+            controller = template_handler.controller
+            rendering_context = controller.fortitude_rendering_context(rendering_context_options)
+
+            # TODO: Refactor this -- both passing it into the constructor and setting yield_block here is gross.
+            #
+            # We need to call #with_yield_block here, because we can actually be invoked with different yield blocks
+            # in the case of "partial layouts" (which most people probably don't even realize exist); we use the same
+            # RC for both the initial view rendering and for the partial layout, but they need different yield blocks.
+            # Yuck, but this does the job.
+            rendering_context.with_yield_block(block) do
+              widget.render_to(rendering_context)
+            end
+            rendering_context.flush!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/rails/template_handler.rb

@@ -0,0 +1,23 @@
+require 'fortitude/rails/renderer'
+
+module Fortitude
+  module Rails
+    class TemplateHandler
+      def call(template, &block)
+        require_dependency template.identifier
+        widget_class_name = "views/#{template.identifier =~ %r(views/([^.]*)(\..*)?\.rb) && $1}".camelize
+        is_partial = File.basename(template.identifier) =~ /^_/
+
+        <<-SRC
+        Fortitude::Rails::Renderer.render(#{widget_class_name}, self, local_assigns) { |*args| yield *args }
+        SRC
+      end
+
+      def supports_streaming?
+        true
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler :rb, Fortitude::Rails::TemplateHandler.new

data/lib/fortitude/rails/widget_methods.rb

@@ -0,0 +1,13 @@
+require 'active_support'
+
+module Fortitude
+  module Rails
+    module WidgetMethods
+      extend ActiveSupport::Concern
+
+      def widget_locale
+        I18n.locale || I18n.default_locale
+      end
+    end
+  end
+end

data/lib/fortitude/rails/yielded_object_outputter.rb

@@ -0,0 +1,31 @@
+module Fortitude
+  module Rails
+    YIELDED_OBJECT_OUTPUTTER_SUPERCLASS = if defined?(::BasicObject) then ::BasicObject else ::Object end
+    class YieldedObjectOutputter < YIELDED_OBJECT_OUTPUTTER_SUPERCLASS
+      def initialize(widget, yielded_object, method_names)
+        @widget = widget
+        @yielded_object = yielded_object
+        @method_names_hash = { }
+        method_names.each do |method_name|
+          @method_names_hash[method_name.to_sym] = true
+        end
+      end
+
+      EMPTY_RETURN_VALUE = ''.freeze
+
+      def method_missing(method_name, *args, &block)
+        return_value = @yielded_object.send(method_name, *args, &block)
+        if @method_names_hash[method_name.to_sym]
+          @widget.rawtext(return_value)
+          EMPTY_RETURN_VALUE
+        else
+          return_value
+        end
+      end
+
+      def respond_to?(symbol, include_all = false)
+        @yielded_object.respond_to?(symbol, include_all)
+      end
+    end
+  end
+end

data/lib/fortitude/rendering_context.rb

@@ -0,0 +1,205 @@
+require 'fortitude/support/instance_variable_set'
+
+module Fortitude
+  class RenderingContext
+    attr_reader :output_buffer_holder, :instance_variable_set, :helpers_object
+
+    def initialize(options)
+      options.assert_valid_keys(:delegate_object, :output_buffer_holder, :helpers_object, :instance_variables_object,
+        :yield_block, :render_yield_result)
+
+      @output_buffer_holder = options[:output_buffer_holder]
+      if (! @output_buffer_holder) && options[:delegate_object] && options[:delegate_object].respond_to?(:output_buffer)
+        @output_buffer_holder = options[:delegate_object]
+      end
+      @output_buffer_holder ||= OutputBufferHolder.new
+      @helpers_object = options[:helpers_object] || options[:delegate_object] || Object.new
+
+      instance_variables_object = options[:instance_variables_object] || options[:delegate_object] || Object.new
+      @instance_variable_set = Fortitude::Support::InstanceVariableSet.new(instance_variables_object)
+
+      @render_yield_result = true unless options.has_key?(:render_yield_result) && (! options[:render_yield_result])
+
+      @indent = 0
+      @newline_needed = false
+      @have_output = false
+      @indenting_disabled = false
+
+      @current_element_nesting = [ ]
+      @current_widget_nesting = [ ]
+      @ids_used = { }
+
+      @yield_block = options[:yield_block]
+    end
+
+    def with_element_nesting_validation(value)
+      old_value = @element_nesting_validation_disabled
+      @element_nesting_validation_disabled = !value
+      begin
+        yield
+      ensure
+        @element_nesting_validation_disabled = old_value
+      end
+    end
+
+    def with_attribute_validation(value)
+      old_value = @attribute_validation_disabled
+      @attribute_validation_disabled = !value
+      begin
+        yield
+      ensure
+        @attribute_validation_disabled = old_value
+      end
+    end
+
+    def with_id_uniqueness(value)
+      old_value = @id_uniqueness_disabled
+      @id_uniqueness_disabled = !value
+      begin
+        yield
+      ensure
+        @id_uniqueness_disabled = old_value
+      end
+    end
+
+    def attribute_validation_disabled?
+      !! @attribute_validation_disabled
+    end
+
+    def record_widget(widget)
+      start_widget!(widget)
+      @current_widget_nesting << widget
+      begin
+        yield
+      ensure
+        last = @current_widget_nesting.pop
+        unless last.equal?(widget)
+          raise "Something horrible happened -- the last widget we started was #{last}, but now we're ending #{widget}?!?"
+        end
+        end_widget!(widget)
+      end
+    end
+
+    def start_widget!(widget)
+      # nothing here
+    end
+
+    def end_widget!(widget)
+      # nothing here
+    end
+
+    def current_widget_depth
+      @current_widget_nesting.length - 1
+    end
+
+    def record_tag(widget, tag_object)
+      validate_element_for_rules(widget, tag_object)
+      @current_element_nesting << tag_object
+
+      begin
+        yield
+      ensure
+        last = @current_element_nesting.pop
+        unless last.equal?(tag_object)
+          raise "Something horrible happened -- the last tag we started was #{last}, but now we're ending #{tag_object}?!?"
+        end
+      end
+    end
+
+    def format_output?
+      true
+    end
+
+    def increase_indent!
+      @indent += 1
+    end
+
+    def decrease_indent!
+      @indent -= 1
+    end
+
+    def needs_newline!
+      @newline_needed = true
+    end
+
+    def current_indent
+      ("  " * @indent).freeze
+    end
+
+    def with_indenting_disabled
+      old_indenting_disabled = @indenting_disabled
+      @indenting_disabled = true
+      begin
+        yield
+      ensure
+        @indenting_disabled = old_indenting_disabled
+      end
+    end
+
+    def about_to_output_non_whitespace!
+      if @newline_needed
+        if @have_output
+          o = @output_buffer_holder.output_buffer
+          o.original_concat(NEWLINE)
+          o.original_concat(current_indent) unless @indenting_disabled
+        end
+
+        @newline_needed = false
+      end
+
+      @have_output = true
+    end
+
+    def with_yield_block(new_yield_block)
+      old_yield_block, @yield_block = @yield_block, new_yield_block
+      begin
+        yield
+      ensure
+        @yield_block = old_yield_block
+      end
+    end
+
+    NEWLINE = "\n"
+
+    def yield_from_widget(*args)
+      raise "No layout to yield to!" unless @yield_block
+      result = @yield_block.call(*args)
+      @output_buffer_holder.output_buffer << result if @render_yield_result
+      result
+    end
+
+    def flush!
+      # nothing here right now
+    end
+
+    def validate_id_uniqueness(widget, tag_name, id)
+      id = id.to_s
+      if @ids_used[id] && (! @id_uniqueness_disabled)
+        (already_used_widget, already_used_tag_name) = @ids_used[id]
+        raise Fortitude::Errors::DuplicateId.new(widget, id, already_used_widget, already_used_tag_name, tag_name)
+      else
+        @ids_used[id] = [ widget, tag_name ]
+      end
+    end
+
+    private
+    def validate_element_for_rules(widget, tag_object)
+      current = @current_element_nesting[-1]
+      current.validate_can_enclose!(widget, tag_object) if current && (! @element_nesting_validation_disabled)
+    end
+
+    class OutputBufferHolder
+      attr_accessor :output_buffer
+
+      def initialize
+        if defined?(::ActionView::OutputBuffer)
+          @output_buffer = ::ActionView::OutputBuffer.new
+        else
+          @output_buffer = ::ActiveSupport::SafeBuffer.new
+        end
+
+        @output_buffer.force_encoding(Encoding::UTF_8) if @output_buffer.respond_to?(:force_encoding)
+      end
+    end
+  end
+end

data/lib/fortitude/support/assigns_proxy.rb

@@ -0,0 +1,77 @@
+require 'active_support/core_ext'
+
+module Fortitude
+  module Support
+    class AssignsProxy
+      def initialize(widget, keys)
+        @widget = widget
+        @keys = { }
+        keys.each { |k| @keys[k] = true }
+      end
+
+      def is_default?(x)
+        !! @widget._fortitude_default_assigns[x.to_sym]
+      end
+
+      def keys
+        @keys.keys
+      end
+
+      def has_key?(x)
+        !! @keys[x.to_sym]
+      end
+
+      def [](x)
+        if has_key?(x)
+          ivar_name = @widget.class.instance_variable_name_for_need(x)
+          @widget.instance_variable_get(ivar_name)
+        end
+      end
+
+      def []=(x, y)
+        if has_key?(x)
+          ivar_name = @widget.class.instance_variable_name_for_need(x)
+          @widget.instance_variable_set(ivar_name, y)
+        end
+      end
+
+      def to_hash
+        out = { }
+        keys.each { |k| out[k] = self[k] }
+        out
+      end
+
+      def to_h
+        to_hash
+      end
+
+      def length
+        @keys.length
+      end
+
+      def size
+        @keys.size
+      end
+
+      def to_s
+        "<Assigns for #{@widget}: #{to_hash}>"
+      end
+
+      def inspect
+        "<Assigns for #{@widget}: #{to_hash.inspect}>"
+      end
+
+      def member?(x)
+        has_key?(x)
+      end
+
+      def store(key, value)
+        self[key] = value
+      end
+
+      delegate :==, :assoc, :each, :each_pair, :each_key, :each_value, :empty?, :eql?, :fetch, :flatten,
+        :has_value?, :hash, :include?, :invert, :key, :key?, :merge, :rassoc, :reject, :select,
+        :to_a, :value?, :values, :values_at, :to => :to_hash
+    end
+  end
+end

data/lib/fortitude/support/class_inheritable_attributes.rb

@@ -0,0 +1,98 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  module Support
+    module ClassInheritableAttributes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def _fortitude_invoke_class_inheritable_attribute(attribute_name, allowable_values, *args)
+          raise ArgumentError, "Invalid arguments: #{args.inspect}" if args.length > 1
+          instance_variable_name = "@_fortitude_#{attribute_name}"
+          if args.length == 0
+            _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, false)
+          else
+            _fortitude_write_class_inheritable_attribute(attribute_name, instance_variable_name, allowable_values, args[0])
+          end
+        end
+
+        def _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, allow_not_present)
+          return instance_variable_get(instance_variable_name) if instance_variable_defined?(instance_variable_name)
+          return superclass.send(attribute_name) if superclass.respond_to?(attribute_name)
+
+          if allow_not_present
+            :_fortitude_class_inheritable_attribute_not_present
+          else
+            raise "Fortitude class-inheritable attribute error: there should always be a declared value for #{attribute_name} at the top of the inheritance hierarchy somewhere"
+          end
+        end
+
+        def _fortitude_write_class_inheritable_attribute(attribute_name, instance_variable_name, allowable_values, new_value)
+          allowed = if allowable_values.respond_to?(:call)
+            allowable_values.call(new_value, self)
+          else
+            allowable_values.include?(new_value)
+          end
+
+          if (! allowed)
+            error = "#{attribute_name} cannot be set to #{new_value.inspect}"
+            error << "; valid values are: #{allowable_values.inspect}" unless allowable_values.respond_to?(:call)
+            raise ArgumentError, error
+          end
+
+          old_value = _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, true)
+
+          instance_variable_set(instance_variable_name, new_value)
+
+          if (old_value != :_fortitude_class_inheritable_attribute_not_present) && (new_value != old_value)
+            _fortitude_class_inheritable_attribute_changed!(attribute_name, old_value, new_value)
+          end
+
+          new_value
+        end
+
+        def _fortitude_class_inheritable_attribute(attribute_name, default_value, allowable_values)
+          metaclass = (class << self; self; end)
+
+          metaclass.send(:define_method, attribute_name) do |*args|
+            _fortitude_invoke_class_inheritable_attribute(attribute_name, allowable_values, *args)
+          end
+
+          send(attribute_name, default_value)
+        end
+
+        def _fortitude_on_class_inheritable_attribute_change(*attribute_names, &block)
+          if attribute_names.length == 0
+            raise ArgumentError, "You must pass at least one attribute name, not: #{attribute_names.inspect}"
+          end
+
+          @_fortitude_class_inheritable_attribute_change_callbacks ||= { }
+          attribute_names.each do |attribute_name|
+            @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] ||= [ ]
+            @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] |= [ block ]
+          end
+        end
+
+        def _fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+          out = if superclass.respond_to?(:_fortitude_class_inheritable_attribute_callbacks_for)
+            superclass._fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+          else
+            [ ]
+          end
+
+          @_fortitude_class_inheritable_attribute_change_callbacks ||= { }
+          out += @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] || [ ]
+
+          out
+        end
+
+        def _fortitude_class_inheritable_attribute_changed!(attribute_name, old_value, new_value)
+          callbacks = _fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+          # klass = self
+          callbacks.each { |cb| instance_exec(attribute_name, old_value, new_value, &cb) }
+        end
+      end
+    end
+  end
+end