reactive-mvc 0.2.0

data/lib/reactive-mvc/view/helpers.rb

@@ -0,0 +1,38 @@
+module Reactive::Mvc::View
+  module Helpers
+    def inject_output_helpers
+      <<-EOS
+helpers_module = HelperModule.new #{output_helper_names.inspect}, <<-EOC
+#{read_output_helpers.gsub('#', '\#')}
+EOC
+extend(*helpers_module.helpers)
+      EOS
+    end
+  
+    def output_helper_names
+      parts = controller_name.split('/')
+      (["application_helper.#{request.format}.rb"] + Enumerable::Enumerator.new(parts, :each_index).collect{|i| "#{parts[0..i].join('/')}_helper.#{request.format}.rb"}).uniq.select{|path| File.file?(Reactive.path_for(:helper, path))}
+    end
+  
+    def read_output_helpers(names = output_helper_names)
+      names.inject("") {|code, path| code << File.read(Reactive.path_for(:helper, path))}
+    end
+  
+  end
+end
+
+=begin
+      def include_application_helpers(request)
+        include_helper('application_helper')
+        parts = controller_name.split('/')
+        Enumerable::Enumerator.new(parts, :each_index).collect{|i| parts[0..i].join('/')}.each do |path|
+          include_helper("#{path}_helper")
+        end
+      end
+    
+      def include_helper(name)
+        @helpers.include(name.classify.constantize)
+      rescue NameError, LoadError
+        # Helper files are not mandatory
+      end
+=end

data/lib/reactive-mvc/view/partials.rb

@@ -0,0 +1,207 @@
+module Reactive::Mvc::View
+  # There's also a convenience method for rendering sub templates within the current controller that depends on a
+  # single object (we call this kind of sub templates for partials). It relies on the fact that partials should
+  # follow the naming convention of being prefixed with an underscore -- as to separate them from regular
+  # templates that could be rendered on their own.
+  #
+  # In a template for Advertiser#account:
+  #
+  #  <%= render :partial => "account" %>
+  #
+  # This would render "advertiser/_account.erb" and pass the instance variable @account in as a local variable
+  # +account+ to the template for display.
+  #
+  # In another template for Advertiser#buy, we could have:
+  #
+  #   <%= render :partial => "account", :locals => { :account => @buyer } %>
+  #
+  #   <% for ad in @advertisements %>
+  #     <%= render :partial => "ad", :locals => { :ad => ad } %>
+  #   <% end %>
+  #
+  # This would first render "advertiser/_account.erb" with @buyer passed in as the local variable +account+, then
+  # render "advertiser/_ad.erb" and pass the local variable +ad+ to the template for display.
+  #
+  # == Rendering a collection of partials
+  #
+  # The example of partial use describes a familiar pattern where a template needs to iterate over an array and
+  # render a sub template for each of the elements. This pattern has been implemented as a single method that
+  # accepts an array and renders a partial by the same name as the elements contained within. So the three-lined
+  # example in "Using partials" can be rewritten with a single line:
+  #
+  #   <%= render :partial => "ad", :collection => @advertisements %>
+  #
+  # This will render "advertiser/_ad.erb" and pass the local variable +ad+ to the template for display. An
+  # iteration counter will automatically be made available to the template with a name of the form
+  # +partial_name_counter+. In the case of the example above, the template would be fed +ad_counter+.
+  #
+  # NOTE: Due to backwards compatibility concerns, the collection can't be one of hashes. Normally you'd also
+  # just keep domain objects, like Active Records, in there.
+  #
+  # == Rendering shared partials
+  #
+  # Two controllers can share a set of partials and render them like this:
+  #
+  #   <%= render :partial => "advertisement/ad", :locals => { :ad => @advertisement } %>
+  #
+  # This will render the partial "advertisement/_ad.erb" regardless of which controller this is being called from.
+  #
+  # == Rendering partials with layouts
+  #
+  # Partials can have their own layouts applied to them. These layouts are different than the ones that are
+  # specified globally for the entire action, but they work in a similar fashion. Imagine a list with two types
+  # of users:
+  #
+  #   <%# app/views/users/index.html.erb &>
+  #   Here's the administrator:
+  #   <%= render :partial => "user", :layout => "administrator", :locals => { :user => administrator } %>
+  #
+  #   Here's the editor:
+  #   <%= render :partial => "user", :layout => "editor", :locals => { :user => editor } %>
+  #
+  #   <%# app/views/users/_user.html.erb &>
+  #   Name: <%= user.name %>
+  #
+  #   <%# app/views/users/_administrator.html.erb &>
+  #   <div id="administrator">
+  #     Budget: $<%= user.budget %>
+  #     <%= yield %>
+  #   </div>
+  #
+  #   <%# app/views/users/_editor.html.erb &>
+  #   <div id="editor">
+  #     Deadline: <%= user.deadline %>
+  #     <%= yield %>
+  #   </div>
+  #
+  # ...this will return:
+  #
+  #   Here's the administrator:
+  #   <div id="administrator">
+  #     Budget: $<%= user.budget %>
+  #     Name: <%= user.name %>
+  #   </div>
+  #
+  #   Here's the editor:
+  #   <div id="editor">
+  #     Deadline: <%= user.deadline %>
+  #     Name: <%= user.name %>
+  #   </div>
+  #
+  # You can also apply a layout to a block within any template:
+  #
+  #   <%# app/views/users/_chief.html.erb &>
+  #   <% render(:layout => "administrator", :locals => { :user => chief }) do %>
+  #     Title: <%= chief.title %>
+  #   <% end %>
+  #
+  # ...this will return:
+  #
+  #   <div id="administrator">
+  #     Budget: $<%= user.budget %>
+  #     Title: <%= chief.name %>
+  #   </div>
+  #
+  # As you can see, the <tt>:locals</tt> hash is shared between both the partial and its layout.
+  #
+  # If you pass arguments to "yield" then this will be passed to the block. One way to use this is to pass
+  # an array to layout and treat it as an enumerable.
+  #
+  #   <%# app/views/users/_user.html.erb &>
+  #   <div class="user">
+  #     Budget: $<%= user.budget %>
+  #     <%= yield user %>
+  #   </div>
+  #
+  #   <%# app/views/users/index.html.erb &>
+  #   <% render :layout => @users do |user| %>
+  #     Title: <%= user.title %>
+  #   <% end %>
+  #
+  # This will render the layout for each user and yield to the block, passing the user, each time.
+  #
+  # You can also yield multiple times in one layout and use block arguments to differentiate the sections.
+  #
+  #   <%# app/views/users/_user.html.erb &>
+  #   <div class="user">
+  #     <%= yield user, :header %>
+  #     Budget: $<%= user.budget %>
+  #     <%= yield user, :footer %>
+  #   </div>
+  #
+  #   <%# app/views/users/index.html.erb &>
+  #   <% render :layout => @users do |user, section| %>
+  #     <%- case section when :header -%>
+  #       Title: <%= user.title %>
+  #     <%- when :footer -%>
+  #       Deadline: <%= user.deadline %>
+  #     <%- end -%>
+  #   <% end %>
+  module Partials
+    extend ActiveSupport::Memoizable
+
+    private
+      def render_partial(options = {}) #:nodoc:
+        local_assigns = options[:locals] || {}
+
+        case partial_path = options[:partial]
+        when String, Symbol, NilClass
+          if options.has_key?(:collection)
+            render_partial_collection(options)
+          else
+            _pick_partial_template(partial_path).render_partial(self, options[:object], local_assigns)
+          end
+        when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::NamedScope::Scope
+          render_partial_collection(options.except(:partial).merge(:collection => partial_path))
+        else
+raise Error, "RecordIdentifier not available"
+          object = partial_path
+          render_partial(
+            :partial => ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path),
+            :object => object,
+            :locals => local_assigns
+          )
+        end
+      end
+
+      def render_partial_collection(options = {}) #:nodoc:
+        return nil if options[:collection].blank?
+
+        partial = options[:partial]
+        spacer = options[:spacer_template] ? render(:partial => options[:spacer_template]) : ''
+        local_assigns = options[:locals] ? options[:locals].clone : {}
+        as = options[:as]
+
+        index = 0
+        options[:collection].map do |object|
+          _partial_path ||= partial #||
+#            ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path)
+          template = _pick_partial_template(_partial_path)
+          local_assigns[template.counter_name] = index
+          result = template.render_partial(self, object, local_assigns.dup, as)
+          index += 1
+          result
+        end.join(spacer)
+      end
+
+      def _pick_partial_template(partial_path) #:nodoc:
+        if partial_path.include?('/')
+          path = File.join(File.dirname(partial_path), "_#{File.basename(partial_path)}")
+        elsif controller
+          path = "#{controller.class.controller_path}/_#{partial_path}"
+        else
+          path = "_#{partial_path}"
+        end
+
+        _pick_template(path)
+      end
+      memoize :_pick_partial_template
+      
+      def partial_template_exists?(partial_path)
+        _pick_partial_template(partial_path) ? true : false
+      rescue MissingTemplate
+        false
+      end
+      
+  end
+end

data/lib/reactive-mvc/view/paths.rb

@@ -0,0 +1,125 @@
+module Reactive::Mvc::View #:nodoc:
+  class PathSet < Array #:nodoc:
+    def self.type_cast(obj)
+      if obj.is_a?(String)
+        if Base.warn_cache_misses && defined?(Rails) && Rails.initialized?
+          Base.logger.debug "[PERFORMANCE] Processing view path during a " +
+            "request. This an expense disk operation that should be done at " +
+            "boot. You can manually process this view path with " +
+            "ActionView::Base.process_view_paths(#{obj.inspect}) and set it " +
+            "as your view path"
+        end
+        Path.new(obj)
+      else
+        obj
+      end
+    end
+
+    def initialize(*args)
+      super(*args).map! { |obj| self.class.type_cast(obj) }
+    end
+
+    def <<(obj)
+      super(self.class.type_cast(obj))
+    end
+
+    def concat(array)
+      super(array.map! { |obj| self.class.type_cast(obj) })
+    end
+
+    def insert(index, obj)
+      super(index, self.class.type_cast(obj))
+    end
+
+    def push(*objs)
+      super(*objs.map { |obj| self.class.type_cast(obj) })
+    end
+
+    def unshift(*objs)
+      super(*objs.map { |obj| self.class.type_cast(obj) })
+    end
+
+    class Path #:nodoc:
+      def self.eager_load_templates!
+        @eager_load_templates = true
+      end
+
+      def self.eager_load_templates?
+        @eager_load_templates || false
+      end
+
+      attr_reader :path, :paths
+      delegate :to_s, :to_str, :hash, :inspect, :to => :path
+
+      def initialize(path, load = true)
+        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
+        @path = path.freeze
+        reload! if load
+      end
+
+      def ==(path)
+        to_str == path.to_str
+      end
+
+      def eql?(path)
+        to_str == path.to_str
+      end
+
+      def [](path)
+        raise "Unloaded view path! #{@path}" unless @loaded
+        @paths[path]
+      end
+
+      def loaded?
+        @loaded ? true : false
+      end
+
+      def load
+        reload! unless loaded?
+        self
+      end
+
+      # Rebuild load path directory cache
+      def reload!
+        @paths = {}
+
+        templates_in_path do |template|
+          # Eager load memoized methods and freeze cached template
+          template.freeze if self.class.eager_load_templates?
+
+          @paths[template.path] = template
+          @paths[template.path_without_extension] ||= template
+        end
+
+        @paths.freeze
+        @loaded = true
+      end
+
+      private
+        def templates_in_path
+          (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
+            unless File.directory?(file)
+              yield Template.new(file.split("#{self}/").last, self)
+            end
+          end
+        end
+    end
+
+    def load
+      each { |path| path.load }
+    end
+
+    def reload!
+      each { |path| path.reload! }
+    end
+
+    def [](template_path)
+      each do |path|
+        if template = path[template_path]
+          return template
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/reactive-mvc/view/renderable.rb

@@ -0,0 +1,98 @@
+module Reactive::Mvc
+  module View
+    # NOTE: The template that this mixin is being included into is frozen
+    # so you cannot set or modify any instance variables
+    module Renderable #:nodoc:
+      extend ActiveSupport::Memoizable
+
+      def self.included(base)
+        @@mutex = Mutex.new
+      end
+
+      def filename
+        'compiled-template'
+      end
+
+      def handler
+        Template.handler_class_for_extension(extension)
+      end
+      memoize :handler
+
+      def compiled_source
+        handler.call(self)
+      end
+      memoize :compiled_source
+
+      def render(view, local_assigns = {})
+        compile(local_assigns)
+
+        stack = view.instance_variable_get(:@_render_stack)
+        stack.push(self)
+
+        view.send(:_evaluate_assigns_and_ivars)
+
+        result = view.send(method_name(local_assigns), local_assigns) do |*names|
+          ivar = :@_proc_for_layout
+          if !view.instance_variable_defined?(:"@content_for_#{names.first}") && view.instance_variable_defined?(ivar) && (proc = view.instance_variable_get(ivar))
+            view.capture(*names, &proc)
+          elsif view.instance_variable_defined?(ivar = :"@content_for_#{names.first || :layout}")
+            view.instance_variable_get(ivar)
+          end
+        end
+        
+        stack.pop
+        result
+      end
+
+      def method_name(local_assigns)
+        if local_assigns && local_assigns.any?
+          local_assigns_keys = "locals_#{local_assigns.keys.map { |k| k.to_s }.sort.join('_')}"
+        end
+        ['_run', extension, method_segment, local_assigns_keys].compact.join('_').to_sym
+      end
+
+      private
+        # Compile and evaluate the template's code (if necessary)
+        def compile(local_assigns)
+          render_symbol = method_name(local_assigns)
+
+          @@mutex.synchronize do
+            if recompile?(render_symbol)
+              compile!(render_symbol, local_assigns)
+            end
+          end
+        end
+
+        def compile!(render_symbol, local_assigns)
+          locals_code = local_assigns.keys.map { |key| "#{key} = local_assigns[:#{key}];" }.join
+
+          source = <<-end_src
+            def #{render_symbol}(local_assigns)
+              old_output_buffer = output_buffer;#{locals_code};#{compiled_source}
+            ensure
+              self.output_buffer = old_output_buffer
+            end
+          end_src
+
+          begin
+            Reactive::Mvc::View::Base::CompiledTemplates.module_eval(source, filename, 0)
+          rescue Exception => e # errors from template code
+            if logger = Base.logger
+              logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+              logger.debug "Function body: #{source}"
+              logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+            end
+
+            raise TemplateError.new(relative_path, source, e)
+          end
+        end
+
+        # Method to check whether template compilation is necessary.
+        # The template will be compiled if the file has not been compiled yet, or
+        # if local_assigns has a new key, which isn't supported by the compiled code yet.
+        def recompile?(symbol)
+          !(Reactive::Mvc::View::PathSet::Path.eager_load_templates? && Base::CompiledTemplates.method_defined?(symbol))
+        end
+    end
+  end
+end