actionview_precompiler 0.2.3 → 0.4.0

data/lib/actionview_precompiler/helper_parser.rb

@@ -0,0 +1,13 @@
+module ActionviewPrecompiler
+  class HelperParser
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def render_calls
+      src = File.read(@filename)
+      return [] unless src.include?("render")
+      RenderParser.new(src).render_calls
+    end
+  end
+end

data/lib/actionview_precompiler/helper_scanner.rb

@@ -0,0 +1,34 @@
+module ActionviewPrecompiler
+  class HelperScanner
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def template_renders
+      template_renders = []
+
+      each_helper do |fullpath|
+        parser = HelperParser.new(fullpath)
+        parser.render_calls.each do |render_call|
+          virtual_path = render_call.virtual_path
+
+          locals = render_call.locals_keys.map(&:to_s).sort
+
+          template_renders << [virtual_path, locals]
+        end
+      end
+
+      template_renders.uniq
+    end
+
+    private
+
+    def each_helper
+      Dir["#{@dir}/**/*_helper.rb"].sort.map do |fullpath|
+        next if File.directory?(fullpath)
+
+        yield fullpath
+      end
+    end
+  end
+end

data/lib/actionview_precompiler/precompiler.rb

@@ -1,95 +1,69 @@
+require "actionview_precompiler/template_scanner"
+require "actionview_precompiler/controller_scanner"
+require "actionview_precompiler/helper_scanner"
+require "actionview_precompiler/template_loader"
+
 module ActionviewPrecompiler
   class Precompiler
-    class Template
-      attr_reader :fullpath, :relative_path, :virtual_path
-      attr_reader :action, :prefix, :details
-
-      def initialize(fullpath, relative_path)
-        @fullpath = fullpath
-        @relative_path = relative_path
-        @virtual_path = relative_path.slice(0, relative_path.index("."))
-
-        parsed = ParsedFilename.new(relative_path)
-        @prefix = parsed.prefix
-        @action = parsed.action
-        @partial = parsed.partial?
-        @details = parsed.details
-      end
-
-      def partial?
-        @partial
-      end
+    def initialize(verbose: false)
+      @scanners = []
+      @loader = TemplateLoader.new
+      @verbose = verbose
+      @static_templates = []
+      @template_renders = nil
     end
 
-    attr_reader :templates
+    def scan_view_dir(view_dir)
+      @scanners << TemplateScanner.new(view_dir)
+    end
 
-    def initialize(view_dirs)
-      @templates =
-        view_dirs.flat_map do |view_dir|
-          Dir["**/*", base: view_dir].map do |file|
-            fullpath = File.expand_path(file, view_dir)
-            next if File.directory?(fullpath)
+    def scan_controller_dir(controller_dir)
+      @scanners << ControllerScanner.new(controller_dir)
+    end
 
-            Template.new(fullpath, file)
-          end.compact
-        end
+    def scan_helper_dir(controller_dir)
+      @scanners << HelperScanner.new(controller_dir)
+    end
 
-      determine_locals
+    def add_template(virtual_path, locals = [])
+      locals = locals.map(&:to_s).sort
+      @static_templates << [virtual_path, locals]
     end
 
-    def each_lookup_args
-      return enum_for(__method__) unless block_given?
+    def run
+      count = 0
+      template_renders.each do |virtual_path, locals|
+        debug "precompiling: #{virtual_path}"
 
-      each_template_render do |template, locals|
-        details = {
-          locale: Array(template.details[:locale]),
-          variants: Array(template.details[:variant]),
-          formats: Array(template.details[:format]),
-          handlers: Array(template.details[:handler])
-        }
+        templates = @loader.load_template(virtual_path, locals)
+        count += templates.count
 
-        yield [template.action, template.prefix, template.partial?, locals, details]
+        debug "  No templates found at #{virtual_path}" if templates.empty?
       end
 
-      nil
+      debug "Precompiled #{count} Templates"
     end
 
-    def each_template_render
-      return enum_for(__method__) unless block_given?
-
-      @templates.each do |template|
-        locals_set = @locals_sets[template.virtual_path]
-        if locals_set
-          locals_set.each do |locals|
-            yield template, locals
-          end
-        elsif !template.partial?
-          # For now, guess that non-partials we haven't seen take no locals
-          yield template, []
-        else
-          # Locals unknown
-        end
+    def template_renders
+      return @template_renders if @template_renders
+
+      template_renders = []
+
+      @scanners.each do |scanner|
+        template_renders.concat scanner.template_renders
       end
+
+      template_renders.concat @static_templates
+
+      template_renders.uniq!
+
+      @template_renders = template_renders
     end
 
-    def determine_locals
-      @locals_sets = {}
-
-      @templates.each do |template|
-        parser = TemplateParser.new(template.fullpath)
-        parser.render_calls.each do |render_call|
-          virtual_path = render_call.virtual_path
-          unless virtual_path.include?("/")
-            # Not necessarily true, since the perfix is based on the current
-            # controller, but is a safe bet most of the time.
-            virtual_path = "#{template.prefix}/#{virtual_path}"
-          end
-          @locals_sets[virtual_path] ||= []
-          @locals_sets[virtual_path] << render_call.locals_keys.map(&:to_s).sort
-        end
-      end
+    private
 
-      @locals_sets.each_value(&:uniq!)
+    def debug(msg)
+      puts msg if @verbose
     end
   end
 end

data/lib/actionview_precompiler/render_parser.rb

@@ -1,50 +1,84 @@
 module ActionviewPrecompiler
-  RenderCall = Struct.new(:render_type, :template, :locals, :locals_keys) do
-    def virtual_path
-      if render_type == :partial
-        @virtual_path ||= template.gsub(%r{(/|^)([^/]*)\z}, '\1_\2')
-      else
-        template
-      end
-    end
-  end
+  RenderCall = Struct.new(:virtual_path, :locals_keys)
 
   class RenderParser
-    include ASTParser
-
-    def initialize(code)
+    def initialize(code, parser: ASTParser, from_controller: false)
       @code = code
-      @code = parse(code) if code.is_a?(String)
+      @parser = parser
+      @from_controller = from_controller
     end
 
     def render_calls
-      render_nodes = extract_render_nodes(@code)
-      render_nodes.map do |node|
-        parse_render(node)
-      end.compact
+      render_nodes = @parser.parse_render_nodes(@code)
+      render_nodes.map do |method, nodes|
+        parse_method = case method
+        when :layout
+          :parse_layout
+        else
+          :parse_render
+        end
+
+        nodes.map { |n| send(parse_method, n) }
+      end.flatten.compact
     end
 
     private
 
+    # Convert
+    #   render("foo", ...)
+    # into either
+    #   render(template: "foo", ...)
+    # or
+    #   render(partial: "foo", ...)
+    # depending on controller or view context
+    def normalize_args(string, options_hash)
+      if @from_controller
+        if options_hash
+          options = parse_hash_to_symbols(options_hash)
+        else
+          options = {}
+        end
+        return nil unless options
+        options.merge(template: string)
+      else
+        if options_hash
+          { partial: string, locals: options_hash }
+        else
+          { partial: string }
+        end
+      end
+    end
+
     def parse_render(node)
       node = node.argument_nodes
-      if (node.length == 1 || node.length == 2) && node[0].string?
-        # FIXME: from template vs controller
-        options = {}
-        options[:partial] = node[0]
-        if node.length == 2
+      if (node.length == 1 || node.length == 2) && !node[0].hash?
+        if node.length == 1
+          options = normalize_args(node[0], nil)
+        elsif node.length == 2
           return unless node[1].hash?
-          options[:locals] = node[1]
+          options = normalize_args(node[0], node[1])
         end
+        return nil unless options
         return parse_render_from_options(options)
       elsif node.length == 1 && node[0].hash?
         options = parse_hash_to_symbols(node[0])
+        return nil unless options
         return parse_render_from_options(options)
       else
         nil
       end
     end
 
+    def parse_layout(node)
+      return nil unless from_controller?
+
+      template = parse_str(node.argument_nodes[0])
+      return nil unless template
+
+      virtual_path = layout_to_virtual_path(template)
+      RenderCall.new(virtual_path, [])
+    end
+
     def parse_hash(node)
       node.hash? && node.to_hash
     end
@@ -52,22 +86,28 @@ module ActionviewPrecompiler
     def parse_hash_to_symbols(node)
       hash = parse_hash(node)
       return unless hash
-      hash.transform_keys do |node|
-        key = parse_sym(node)
+      hash.transform_keys do |key_node|
+        key = parse_sym(key_node)
         return unless key
         key
       end
     end
 
-    RENDER_TYPE_KEYS = [:partial, :template, :layout]
-    IGNORED_KEYS = [:formats]
-    ALL_KNOWN_KEYS = [*RENDER_TYPE_KEYS, *IGNORED_KEYS, :locals, :object, :collection, :as]
+    ALL_KNOWN_KEYS = [:partial, :template, :layout, :formats, :locals, :object, :collection, :as, :status, :content_type, :location, :spacer_template]
 
     def parse_render_from_options(options_hash)
+      renders = []
       keys = options_hash.keys
 
-      unless (keys & RENDER_TYPE_KEYS).one?
-        # Must have one of partial:, template:, or layout:
+      render_type_keys =
+        if from_controller?
+          [:partial, :template]
+        else
+          [:partial, :template, :layout]
+        end
+
+      if (keys & render_type_keys).size < 1
+        # Must have at least one of render keys
         return nil
       end
 
@@ -76,8 +116,26 @@ module ActionviewPrecompiler
         return nil
       end
 
-      render_type = (keys & RENDER_TYPE_KEYS)[0]
-      template = parse_str(options_hash[render_type])
+      render_type = (keys & render_type_keys)[0]
+
+      node = options_hash[render_type]
+      if node.string?
+        template = node.to_string
+      else
+        if node.variable_reference?
+          dependency = node.variable_name.sub(/\A(?:\$|@{1,2})/, "")
+        elsif node.vcall?
+          dependency = node.variable_name
+        elsif node.call?
+          dependency = node.call_method_name
+          return unless dependency.is_a? String
+        else
+          return
+        end
+        object_template = true
+        template = "#{dependency.pluralize}/#{dependency.singularize}"
+      end
+
       return unless template
 
       if options_hash.key?(:locals)
@@ -93,7 +151,13 @@ module ActionviewPrecompiler
         locals_keys = []
       end
 
-      if options_hash.key?(:object) || options_hash.key?(:collection)
+      if spacer_template = render_template_with_spacer?(options_hash)
+        virtual_path = partial_to_virtual_path(:partial, spacer_template)
+        # Locals keys should not include collection keys
+        renders << RenderCall.new(virtual_path, locals_keys.dup)
+      end
+
+      if options_hash.key?(:object) || options_hash.key?(:collection) || object_template
         return nil if options_hash.key?(:object) && options_hash.key?(:collection)
         return nil unless options_hash.key?(:partial)
 
@@ -112,7 +176,28 @@ module ActionviewPrecompiler
         end
       end
 
-      RenderCall.new(render_type, template, locals, locals_keys)
+      virtual_path = partial_to_virtual_path(render_type, template)
+      renders << RenderCall.new(virtual_path, locals_keys)
+
+      # Support for rendering multiple templates (i.e. a partial with a layout)
+      if layout_template = render_template_with_layout?(render_type, options_hash)
+        virtual_path = if from_controller?
+          layout_to_virtual_path(layout_template)
+        else
+          if !layout_template.include?("/") &&
+            partial_prefix = template.match(%r{(.*)/([^/]*)\z})
+            # TODO: use the file path that this render call was found in to
+            # generate the partial prefix instead of rendered partial.
+            partial_prefix = partial_prefix[1]
+            layout_template = "#{partial_prefix}/#{layout_template}"
+          end
+          partial_to_virtual_path(:layout, layout_template)
+        end
+
+        renders << RenderCall.new(virtual_path, locals_keys)
+      end
+
+      renders
     end
 
     def parse_str(node)
@@ -123,21 +208,38 @@ module ActionviewPrecompiler
       node.symbol? && node.to_symbol
     end
 
+    private
+
     def debug(message)
       warn message
     end
 
-    def extract_render_nodes(node)
-      return [] unless node?(node)
-      renders = node.children.flat_map { |c| extract_render_nodes(c) }
-      if render_call?(node)
-        renders << node
+    def from_controller?
+      @from_controller
+    end
+
+    def render_template_with_layout?(render_type, options_hash)
+      if render_type != :layout && options_hash.key?(:layout)
+        parse_str(options_hash[:layout])
+      end
+    end
+
+    def render_template_with_spacer?(options_hash)
+      if !from_controller? && options_hash.key?(:spacer_template)
+        parse_str(options_hash[:spacer_template])
+      end
+    end
+
+    def partial_to_virtual_path(render_type, partial_path)
+      if render_type == :partial || render_type == :layout
+        partial_path.gsub(%r{(/|^)([^/]*)\z}, '\1_\2')
+      else
+        partial_path
       end
-      renders
     end
 
-    def render_call?(node)
-      fcall?(node, :render)
+    def layout_to_virtual_path(layout_path)
+      "layouts/#{layout_path}"
     end
   end
 end

data/lib/actionview_precompiler/template_file.rb

@@ -0,0 +1,22 @@
+module ActionviewPrecompiler
+  class TemplateFile
+    attr_reader :fullpath, :relative_path, :virtual_path
+    attr_reader :action, :prefix, :details
+
+    def initialize(fullpath, relative_path)
+      @fullpath = fullpath
+      @relative_path = relative_path
+      @virtual_path = relative_path.slice(0, relative_path.index("."))
+
+      parsed = ParsedFilename.new(relative_path)
+      @prefix = parsed.prefix
+      @action = parsed.action
+      @partial = parsed.partial?
+      @details = parsed.details
+    end
+
+    def partial?
+      @partial
+    end
+  end
+end

data/lib/actionview_precompiler/template_loader.rb

@@ -0,0 +1,36 @@
+module ActionviewPrecompiler
+  class TemplateLoader
+    VIRTUAL_PATH_REGEX = %r{\A(?:(?<prefix>.*)\/)?(?<partial>_)?(?<action>[^\/\.]+)}
+
+    def initialize
+      target = ActionController::Base
+      @lookup_context = ActionView::LookupContext.new(target.view_paths)
+      @view_context_class = target.view_context_class
+    end
+
+    def load_template(virtual_path, locals)
+      templates = find_all_templates(virtual_path, locals)
+      templates.each do |template|
+        template.send(:compile!, @view_context_class)
+      end
+    end
+
+    private
+
+    def find_all_templates(virtual_path, locals)
+      match = virtual_path.match(VIRTUAL_PATH_REGEX)
+      if match
+        action = match[:action]
+        prefix = match[:prefix] ? [match[:prefix]] : []
+        partial = !!match[:partial]
+
+        # Assume templates with different details take same locals
+        details = {}
+
+        @lookup_context.find_all(action, prefix, partial, locals, details)
+      else
+        []
+      end
+    end
+  end
+end

data/lib/actionview_precompiler/template_parser.rb

@@ -2,8 +2,6 @@ require "action_view"
 
 module ActionviewPrecompiler
   class TemplateParser
-    include ASTParser
-
     attr_reader :filename, :basename, :handler
 
     class FakeTemplate
@@ -24,24 +22,18 @@ module ActionviewPrecompiler
       @filename = filename
       @basename = File.basename(filename)
       handler_ext = @basename.split(".").last
-      @handler = ActionView::Template.handler_for_extension(handler_ext)
-      @is_partial = !!@basename.start_with?("_")
-    end
-
-    def partial?
-      @is_partial
+      @handler = HANDLERS_FOR_EXTENSION[handler_ext]
     end
 
     def render_calls
-      RenderParser.new(parsed).render_calls
-    end
-
-    def parsed
-      @parsed ||= parse(compiled_source)
-    end
-
-    def compiled_source
-      @handler.call(FakeTemplate.new, File.read(@filename))
+      src = File.read(@filename)
+      if src.include?("render")
+        compiled_source = @handler.call(FakeTemplate.new, File.read(@filename))
+        compiled_source = "def _template; #{compiled_source}; end"
+        RenderParser.new(compiled_source).render_calls
+      else
+        []
+      end
     end
   end
 end

data/lib/actionview_precompiler/template_scanner.rb

@@ -0,0 +1,44 @@
+require "actionview_precompiler/template_file"
+
+module ActionviewPrecompiler
+  class TemplateScanner
+    attr_reader :view_dir
+
+    def initialize(view_dir)
+      @view_dir = view_dir
+    end
+
+    def template_renders
+      template_renders = []
+
+      each_template do |template|
+        parser = TemplateParser.new(template.fullpath)
+        parser.render_calls.each do |render_call|
+          virtual_path = render_call.virtual_path
+          unless virtual_path.include?("/")
+            # Not necessarily true, since the perfix is based on the current
+            # controller, but is a safe bet most of the time.
+            virtual_path = "#{template.prefix}/#{virtual_path}"
+          end
+
+          locals = render_call.locals_keys.map(&:to_s).sort
+
+          template_renders << [virtual_path, locals]
+        end
+      end
+
+      template_renders.uniq
+    end
+
+    private
+
+    def each_template
+      Dir["**/*", base: view_dir].sort.map do |file|
+        fullpath = File.expand_path(file, view_dir)
+        next if File.directory?(fullpath)
+
+        yield TemplateFile.new(fullpath, file)
+      end.compact
+    end
+  end
+end

data/lib/actionview_precompiler/version.rb

@@ -1,3 +1,3 @@
 module ActionviewPrecompiler
-  VERSION = "0.2.3"
+  VERSION = "0.4.0"
 end

data/lib/actionview_precompiler.rb

@@ -1,33 +1,47 @@
+require "action_controller"
+require "action_view"
+
 require "actionview_precompiler/version"
 require "actionview_precompiler/ast_parser"
 require "actionview_precompiler/template_parser"
 require "actionview_precompiler/render_parser"
+require "actionview_precompiler/controller_parser"
+require "actionview_precompiler/helper_parser"
 require "actionview_precompiler/precompiler"
 require "actionview_precompiler/parsed_filename"
 
 module ActionviewPrecompiler
   class Error < StandardError; end
 
+  # Allow overriding from ActionView default handlers if necessary
+  HANDLERS_FOR_EXTENSION = Hash.new do |h, ext|
+    h[ext] = ActionView::Template.handler_for_extension(ext)
+  end
+
   def self.precompile(verbose: false)
-    target = ActionController::Base # fixme
-    view_paths = target.view_paths
-    lookup_context = ActionView::LookupContext.new(view_paths)
-    paths = view_paths.map(&:path)
-    precompiler = Precompiler.new(paths)
-
-    mod = target.view_context_class
-    count = 0
-    precompiler.each_lookup_args do |args|
-      templates = lookup_context.find_all(*args)
-      templates.each do |template|
-        puts "precompiling: #{template.inspect}" if verbose
-        count += 1
-        template.send(:compile!, mod)
+    precompiler = Precompiler.new(verbose: verbose)
+
+    if block_given?
+      # Custom configuration
+      yield precompiler
+    else
+      # Scan view dirs
+      ActionController::Base.view_paths.each do |view_path|
+        precompiler.scan_view_dir view_path.path
       end
-    end
 
-    if verbose
-      puts "Precompiled #{count} Templates"
+      # If we have an application, scan controllers
+      if Rails.respond_to?(:application)
+        Rails.application.paths["app/controllers"].each do |path|
+          precompiler.scan_controller_dir path.to_s
+        end
+
+        Rails.application.paths["app/helpers"].each do |path|
+          precompiler.scan_helper_dir path.to_s
+        end
+      end
     end
+
+    precompiler.run
   end
 end