roger 1.4.6 → 1.5.0

data/lib/roger/resolver.rb

@@ -1,6 +1,31 @@
 module Roger
   # The resolver is here to resolve urls to paths and sometimes vice-versa
   class Resolver
+    # Maps output extensions to template extensions to find
+    # source files.
+    EXTENSION_MAP = {
+      "html" => %w(
+        rhtml
+        markdown
+        mkd
+        md
+        ad
+        adoc
+        asciidoc
+        rdoc
+        textile
+      ),
+      "csv" => %w(
+        rcsv
+      ),
+      # These are generic template languages
+      nil => %w(
+        erb
+        erubis
+        str
+      )
+    }
+
     attr_reader :load_paths
 
     def initialize(paths)
@@ -13,15 +38,12 @@ module Roger
     # @param [String] url The url to resolve to a path
     # @param [Hash] options Options
     #
-    # @option options [true,false] :exact_match Wether or not to match exact paths,
-    #   this is mainly used in the path_to_url method to match .js, .css, etc files.
-    # @option options [String] :preferred_extension The part to chop off
-    #   and re-add to search for more complex double-extensions. (Makes it possible to have context
-    #   aware partials)
+    # @option options [String] :prefer The preferred template extension. When searching for
+    #  templates, the preferred template extension defines what file type we're requesting
+    #  when we ask for a file without an extension
     def find_template(url, options = {})
       options = {
-        exact_match: false,
-        preferred_extension: "html"
+        prefer: "html"
       }.update(options)
 
       orig_path, _qs, _anch = strip_query_string_and_anchor(url.to_s)
@@ -30,13 +52,7 @@ module Roger
 
       load_paths.find do |load_path|
         path = File.join(load_path, orig_path)
-
-        # If it's an exact match we're done
-        if options[:exact_match] && File.exist?(path)
-          output = Pathname.new(path)
-        else
-          output = find_file_with_extension(path, options[:preferred_extension])
-        end
+        output = find_template_path(path, options)
       end
 
       output
@@ -97,37 +113,102 @@ module Roger
 
     protected
 
-    # Tries all extensions on path to see what file exists
-    # @return [Pathname,nil] returns a pathname of the full file path if found. nil otherwise
-    def find_file_with_extension(path, preferred_extension)
-      output = nil
+    # Finds the template path for "name"
+    def find_template_path(name, options = {})
+      options = {
+        prefer: "html", # Prefer a template with extension
+      }.update(options)
 
-      file_path = path
+      path = sanitize_name(name, options[:prefer])
 
-      # If it's a directory, add "/index"
-      file_path = File.join(file_path, "index") if File.directory?(file_path)
+      # Exact match
+      return Pathname.new(path) if File.exist?(path)
 
-      # Strip of extension
-      if path =~ /\.#{preferred_extension}\Z/
-        file_path.sub!(/\.#{preferred_extension}\Z/, "")
-      end
+      # Split extension and path
+      path_extension, path_without_extension = split_path(path)
+
+      # Get possible output extensions for path_extension
+      template_extensions = template_extensions_for_output(path_extension, options[:prefer])
 
-      possible_extensions(preferred_extension).find do |ext|
-        path_with_extension = file_path + "." + ext
-        if File.exist?(path_with_extension)
-          output = Pathname.new(path_with_extension)
+      # Let's look at the disk to see what files we've got
+      files = Dir.glob(path_without_extension + ".*")
+
+      results = filter_files(files, path, path_without_extension, template_extensions)
+
+      # Our result if any
+      results[0] && Pathname.new(results[0])
+    end
+
+    # Filter a list of files to see wether or not we can process them.
+    # Will take into account that the longest match with path will
+    # be the first result.
+    def filter_files(files, path, path_without_extension, template_extensions)
+      results = []
+
+      files.each do |file|
+        if file.start_with?(path)
+          match = path
+        else
+          match = path_without_extension
+        end
+
+        processable_extensions = file[(match.length + 1)..-1].split(".")
+
+        # All processable_extensions must be processable
+        # by a template_extension
+        next unless (processable_extensions - template_extensions).length == 0
+
+        if file.start_with?(path)
+          # The whole path is found in the filename, not just
+          # the path without the extension.
+          # it must have priority over all else
+          results.unshift(file)
+        else
+          results.push(file)
         end
       end
-      output
+      results
+    end
+
+    # Check if the name is a directory and append index
+    # Append preferred extension or html if it doesn't have one yet
+    def sanitize_name(name, prefer = nil)
+      path = name.to_s
+
+      # If it's a directory append "index"
+      path = File.join(path, "index") if File.directory?(name)
+
+      # Check if we haven't got an extension
+      # we'll assume you're looking for prefer or "html" otherwise
+      path += ".#{prefer || 'html'}" unless File.basename(path).include?(".")
+
+      path
+    end
+
+    # Split path in to extension an path without extension
+    def split_path(path)
+      path = path.to_s
+      extension = File.extname(path)[1..-1]
+      path_without_extension = path.sub(/\.#{Regexp.escape(extension)}\Z/, "")
+      [extension, path_without_extension]
     end
 
-    # Makes a list of all Tilt extensions
-    # Also adds a list of double extensions. Example:
-    # tilt_extensions = %w(erb md); second_extension = "html"
-    # return %w(erb md html.erb html.md)
-    def possible_extensions(second_extension)
-      extensions = Tilt.default_mapping.template_map.keys + Tilt.default_mapping.lazy_map.keys
-      extensions + extensions.map { |ext| "#{second_extension}.#{ext}" }
+    def template_extensions_for_output(ext, prefer = nil)
+      template_extensions = []
+
+      # The preferred template_extension is first
+      template_extensions += prefer.to_s.split(".") if prefer
+
+      # Any exact template matches for extension
+      template_extensions += EXTENSION_MAP[ext] if EXTENSION_MAP[ext]
+
+      # Any generic templates
+      template_extensions += EXTENSION_MAP[nil]
+
+      # Myself to pass extension matching later on
+      template_extensions += [ext]
+
+      template_extensions
     end
 
     def relative_path_to_url(path, relative_to, base)

data/lib/roger/template.rb

@@ -3,160 +3,89 @@ require "mime/types"
 require "yaml"
 require "ostruct"
 
-require File.dirname(__FILE__) + "/template/template_context"
-
 # We're enforcing Encoding to UTF-8
 Encoding.default_external = "UTF-8"
 
 module Roger
+  # Blank template is an empty template
+  #
+  # This is usefull for wrapping other templates
+  class BlankTemplate
+    def render(_locals = {}, &_block)
+      yield if block_given?
+    end
+  end
+
   # Roger template processing class
-  class Template
+  class Template < BlankTemplate
     # The source
     attr_accessor :source
 
     # Store the frontmatter
     attr_accessor :data
 
-    # The actual Tilt template
-    attr_accessor :template
-
     # The path to the source file for this template
     attr_accessor :source_path
 
-    class << self
-      def open(path, options = {})
-        fail "Unknown file #{path}" unless File.exist?(path)
-        new(File.read(path), options.update(source_path: path))
-      end
-
-      # Register a helper module that should be included in
-      # every template context.
-      def helper(mod)
-        @helpers ||= []
-        @helpers << mod
-      end
+    # The current tilt template being used
+    attr_reader :current_tilt_template
 
-      def helpers
-        @helpers || []
+    class << self
+      def open(path, context = nil, options = {})
+        new(File.read(path), context, options.update(source_path: path))
       end
     end
 
     # @option options [String,Pathname] :source_path The path to
     #   the source of the template being processed
-    # @option options [String,Pathname] :layouts_path The path to where all layouts reside
-    # @option options [String,Pathname] :partials_path The path to where all partials reside
-    def initialize(source, options = {})
-      @options = options
+    def initialize(source, context = nil, options = {})
+      @context = context
 
       self.source_path = options[:source_path]
       self.data, self.source = extract_front_matter(source)
-      self.template = Tilt.new(source_path.to_s) { self.source }
-
-      initialize_layout
-    end
-
-    def render(env = {})
-      context = prepare_context(env)
-
-      if @layout_template
-        content_for_layout = template.render(context, {}) # yields
 
-        @layout_template.render(context, {}) do |content_for|
-          if content_for
-            context._content_for_blocks[content_for]
-          else
-            content_for_layout
-          end
-        end
-      else
-        template.render(context, {})
-      end
+      @templates = Tilt.templates_for(source_path)
     end
 
-    def find_template(name, path_type)
-      unless [:partials_path, :layouts_path].include?(path_type)
-        fail(ArgumentError, "path_type must be one of :partials_path or :layouts_path")
+    def render(locals = {}, &block)
+      @templates.inject(source) do |src, template|
+        render_with_tilt_template(template, src, locals, &block)
       end
-
-      return nil unless @options[path_type]
-
-      @resolvers ||= {}
-      @resolvers[path_type] ||= Resolver.new(@options[path_type])
-
-      @resolvers[path_type].find_template(name, preferred_extension: target_extension)
     end
 
-    # Try to infer the final extension of the output file.
-    def target_extension
-      return @target_extension if @target_extension
+    # Actual path on disk, nil if it doesn't exist
+    # The nil case is mostly used with inline rendering.
+    def real_source_path
+      return @_real_source_path if @_real_source_path_cached
 
-      if type = MIME::Types[target_mime_type].first
-        # Dirty little hack to enforce the use of .html instead of .htm
-        if type.sub_type == "html"
-          @target_extension = "html"
-        else
-          @target_extension = type.extensions.first
-        end
-      else
-        @target_extension = File.extname(source_path.to_s).sub(/^\./, "")
-      end
-    end
-
-    def source_extension
-      parts = File.basename(File.basename(source_path.to_s)).split(".")
-      if parts.size > 2
-        parts[-2..-1].join(".")
+      @_real_source_path_cached = true
+      if File.exist?(source_path)
+        @_real_source_path = Pathname.new(source_path).realpath
       else
-        File.extname(source_path.to_s).sub(/^\./, "")
+        @_real_source_path = nil
       end
     end
 
-    # Try to figure out the mime type based on the Tilt class and if that doesn't
-    # work we try to infer the type by looking at extensions (needed for .erb)
-    def target_mime_type
-      mime =
-        mime_type_from_template ||
-        mime_type_from_filename ||
-        mime_type_from_sub_extension
-
-      mime.to_s if mime
-    end
-
     protected
 
-    def prepare_context(env)
-      context = TemplateContext.new(self, env)
+    # Render source with a specific tilt template class
+    def render_with_tilt_template(template_class, src, locals, &_block)
+      @current_tilt_template = template_class
+      template = template_class.new(source_path) { src }
 
-      # Extend context with all helpers
-      self.class.helpers.each do |mod|
-        context.extend(mod)
+      if block_given?
+        block_content = yield
+      else
+        block_content = ""
       end
 
-      context
-    end
-
-    def initialize_layout
-      return unless data[:layout]
-      layout_template_path = find_template(data[:layout], :layouts_path)
-
-      @layout_template = Tilt.new(layout_template_path.to_s) if layout_template_path
-    end
-
-    def mime_type_from_template
-      template.class.default_mime_type
-    end
-
-    def mime_type_from_filename
-      path = File.basename(source_path.to_s)
-      MIME::Types.type_for(path).first
-    end
-
-    # Will get mime_type from source_path extension
-    # but it will only look at the second extension so
-    # .html.erb will look at .html
-    def mime_type_from_sub_extension
-      parts = File.basename(source_path.to_s).split(".")
-      MIME::Types.type_for(parts[0..-2].join(".")).first if parts.size > 2
+      template.render(@context, locals) do |name|
+        if name
+          @context._content_for_blocks[name]
+        else
+          block_content
+        end
+      end
     end
 
     # Get the front matter portion of the file and extract it.

data/lib/roger/template/helpers/capture.rb

@@ -27,8 +27,10 @@ module Roger
 
         # rubocop:disable Lint/Eval
         def capture(&block)
-          unless template.template.is_a?(Tilt::ERBTemplate)
-            fail ArgumentError, "content_for works only with ERB Templates"
+          unless template.current_tilt_template == Tilt::ERBTemplate
+            err  = "content_for works only with ERB Templates"
+            err += "(was: #{template.current_tilt_template.inspect})"
+            fail ArgumentError, err
           end
 
           @block_counter ||= 0

data/lib/roger/template/helpers/partial.rb

@@ -3,34 +3,23 @@ module Roger
     module Helpers
       # The partial helper
       module Partial
-        # rubocop:disable Lint/Eval
         def partial(name, options = {}, &block)
-          template_path = template.find_template(name, :partials_path)
-          if template_path
-            out = render_partial(template_path, options, &block)
-            if block_given?
-              eval "_erbout.concat(#{out.dump})", block.binding
-            else
-              out
-            end
+          if block_given?
+            partial_with_block(name, options, &block)
           else
-            fail ArgumentError, "No such partial #{name}, referenced from #{template.source_path}"
+            renderer.render(name, options)
           end
         end
-        # rubocop:enable Lint/Eval
 
         protected
 
-        # Capture a block and render the partial
-        def render_partial(template_path, options, &block)
-          partial_template = Tilt.new(template_path.to_s)
-          if block_given?
-            block_content = capture(&block)
-          else
-            block_content = ""
-          end
-          partial_template.render(self, options[:locals] || {}) { block_content }
+        # rubocop:disable Lint/Eval
+        def partial_with_block(name, options, &block)
+          block_content = capture(&block)
+          result = renderer.render(name, options) { block_content }
+          eval "_erbout.concat(#{result.dump})", block.binding
         end
+        # rubocop:enable Lint/Eval
       end
     end
   end