roger 1.4.6 → 1.5.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: ff392fddffc0c128c0f1c2ed637a0fb34cfa056d
-  data.tar.gz: 8732e488d0ad390ebcf49aba40bf6a654446b6bf
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTExNTllMmViNTJmMjIwNDJkZmQ3NWIyM2RiNDZmNWMzNDA2MDNiMw==
+  data.tar.gz: !binary |-
+    MjRlNGI2OWY2NTJmY2YxMTMyYjdkYzUyZTljN2Q5MTk1NGMxNWJhNg==
 SHA512:
-  metadata.gz: d9c61357b6b2497f66e4f01ae627ed8ea20cc8cbe96f9a71db15ac15737019da9fecdd9e606723cdff76443b78f4328f1c3ac5dee3fafeca7ab4c3294b0b365d
-  data.tar.gz: 73320c598c51c6585c7cc82d5ab84f23446adea024371a67e42c7e26ca6f89fb8001d05b3ba97861c1450b8ed646ba7cf5c3b25ab78a29856f5dcc7554389eb6
+  metadata.gz: !binary |-
+    ZDBlYWNhNzc3Zjk2YjMwY2RlYTBiYTZiZTkwYThmZTZmZGZiODNkM2QzMjE5
+    YjdlMDZhY2VhZjFjNDBmMTVhNDQ1YzhkOTg2MjEyZGQ5ZjA4N2M3NGY5YjVl
+    N2YyNDM5NTUyNmZmZTk2ODQyZDE3ZDcyNmQ2MTcxZjVhMDUzMWU=
+  data.tar.gz: !binary |-
+    ZTcxYWI2MGJlMWU0YTZmYTVmNjAxMDdiOGE1MzAxYzI0ZTFjZmFhMWY1MmQ1
+    YmRhNzMzMjczZDA1NTJiOTY1MjEwN2NhZGVlY2QwYjE1MDVjZWVhYTBmMWJi
+    ODAxZTFmNjNhYzQwMjc0MmYyMjMzNGJlMmJiNjU0NTVmNmRiZTU=

data/.travis.yml

@@ -1,9 +1,9 @@
 language: ruby
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.1
   - 2.2.2
+  - 2.3.0
 before_script:
   - git config --global user.email "travis-ci@digitpaint.nl"
   - git config --global user.name "Travis-CI"

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## Version 1.5.0
+* Roger won't be tested on Ruby 1.9.x anymore
+* The way we render templates has been revamped. It is now possible to have multi-pass templates so you can do `.md.erb` which will first be processed by `erb` and then by the `md` tilt template handler. 
+* The way templates are searched has changed to be more predictable. You may notice the change when you have the same filenames with different extensions.
+* You can now use local partials by just using an underscore as prefix. So `<%= partial('bla') %>` will look for `_bla.*` relative to the current template first and `bla.*` in the partials directory second (current behaviour).
+* Template recursion will be detected and prevented instead of giving a stack overflow.
+* Add `render_file` method to renderer and as helper so you can render any template on disk.
+* Minor doc improvements
+
 ## Version 1.4.6
 * Allow setting target_path in dir finalizer
 * Always create target_paths if they don't exist

data/doc/templating.md

@@ -113,7 +113,12 @@ The is the rest of the content
 
 ## Partials
 
-Partials are little pieces of template that can be easily reused. You can access the partials throught the `partial("partialpath")` method. You can optionall pass variables to the partial by passing a ruby hash of options as a second parameter. This works like this:
+Partials are little pieces of template that can be easily reused. You can access the partials throught the `partial("partialpath")` method. The renderer will search for partials:
+
+* relative to the template currently being rendered with `partialpath` being prefixed with and underscore (so: `_partialpath`).
+* relative to the partial path that has been set up.
+
+You can optionally pass variables to the partial by passing a ruby hash of options as a second parameter. This works like this:
 
 ```ruby
 partial("path/to/partial/relative/to/partials-path", {:key => "value"})
@@ -149,14 +154,14 @@ Template helpers allow you to have custom functions in your templates. These fun
 A helper is nothing more than a plain old Ruby module containing a bunch of functions.
 
 ### Registering helpers
-Registering helpers can best be done in the Rogerfile. For every helper you want to register you need to call:
+Registering helpers can best be done in the Rogerfile. Register this module as following:
 
 ```ruby
 Roger::Template.register MyHelperModule
 ```
 
-After registration the helpers are available for use in all templates, partials, layouts, etc.
+After registration the helpers are available for use in all templates, partials, layouts, etc. See the [template helpers tests](../test/unit/template/template_helper_test.rb) for example usage.
 
 ## Access to Project 
 
-You can access the Roger project with all it's might and glory by accessing `env["roger.project"]`.
+You can access the Roger project with all it's might and glory by accessing `env["roger.project"]`.

data/lib/roger/rack/roger.rb

@@ -3,6 +3,7 @@ require "rack/response"
 require "rack/file"
 
 require File.dirname(__FILE__) + "/../resolver"
+require File.dirname(__FILE__) + "/../renderer"
 
 module Roger
   module Rack
@@ -34,8 +35,8 @@ module Roger
       protected
 
       def build_response(template_path, env)
-        templ = ::Roger::Template.open(
-          template_path,
+        renderer = ::Roger::Renderer.new(
+          env,
           partials_path: @project.partials_path,
           layouts_path: @project.layouts_path
         )
@@ -43,7 +44,7 @@ module Roger
         ::Rack::Response.new do |res|
           res.headers["Content-Type"] = mime if mime
           res.status = 200
-          res.write templ.render(env)
+          res.write renderer.render(template_path)
         end
       end
     end

data/lib/roger/release/processors/mockup.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) + "/../../renderer"
+
 module Roger::Release::Processors
   # The Mockup processor that will process all templates
   class Mockup < Base
@@ -37,43 +39,50 @@ module Roger::Release::Processors
     end
 
     def run_on_file!(file_path, env = {})
-      template = Roger::Template.open(
-        file_path,
-        partials_path: project.partial_path,
-        layouts_path: project.layouts_path
-      )
+      output = run_on_file(file_path, env)
 
       # Clean up source file
       FileUtils.rm(file_path)
 
       # Write out new file
-      File.open(target_path(file_path, template).to_s, "w") do |f|
-        f.write(template.render(env.dup))
+      File.open(target_path(file_path).to_s, "w") do |f|
+        f.write(output)
       end
     end
 
     # Runs the template on a single file and return processed source.
-    def extract_source_from_file(file_path, env = {})
-      Roger::Template.open(
-        file_path,
+    def run_on_file(file_path, env = {})
+      renderer = Roger::Renderer.new(
+        env.dup,
         partials_path: project.partial_path,
         layouts_path: project.layouts_path
-      ).render(env.dup)
+      )
+      renderer.render(file_path)
     end
 
     # Determines the output path for a mockup path with a certain template
     #
     # @return [Pathname]
-    def target_path(path, template)
-      parts, dir = split_path(path)
+    def target_path(path)
+      parts = File.basename(path.to_s).split(".")
+      path = path.to_s
 
       # Always return .html directly as it will cause too much trouble otherwise
       return Pathname.new(path) if parts.last == "html"
 
-      # Strip last extension if we have a double extension
-      return dir + parts[0..-2].join(".") if parts.size > 2
+      target_ext = Roger::Renderer.target_extension_for(path)
+      source_ext = Roger::Renderer.source_extension_for(path)
 
-      dir + extension_based_on_mime_type(parts, template.template.class.default_mime_type)
+      # If there is no target extension
+      return Pathname.new(path) if target_ext.empty?
+
+      # If we have at least one extension
+      if parts.size > 1
+        source_ext_regexp = /#{Regexp.escape(source_ext)}\Z/
+        Pathname.new(path.gsub(source_ext_regexp, target_ext))
+      else
+        Pathname.new(path + "." + target_ext)
+      end
     end
 
     protected
@@ -97,32 +106,6 @@ module Roger::Release::Processors
       release.log(self, "  Env     : #{options[:env].inspect}", true)
       release.log(self, "  Files   :", true)
     end
-
-    # Split the path into two parts:
-    # 1. Filename, in an array, split by .
-    # 2. Pathname of directory
-    def split_path(path)
-      [
-        File.basename(path.to_s).split("."),
-        Pathname.new(File.dirname(path.to_s))
-      ]
-    end
-
-    def extension_based_on_mime_type(parts, mime_type)
-      # 2. Try to figure out the extension based on the template's mime-type
-      extension = MIME_TYPES_TO_EXTENSION[mime_type]
-
-      # No matching extension, let's return path
-      return parts.join(".") if extension.nil?
-
-      if parts.size > 1
-        # Strip extension and replace with extension
-        (parts[0..-2] << extension).join(".")
-      else
-        # Let's just add the extension
-        (parts << extension).join(".")
-      end
-    end
   end
 end
 Roger::Release::Processors.register(:mockup, Roger::Release::Processors::Mockup)

data/lib/roger/renderer.rb

@@ -0,0 +1,294 @@
+require File.dirname(__FILE__) + "/template"
+require File.dirname(__FILE__) + "/template/template_context"
+require File.dirname(__FILE__) + "/resolver"
+
+module Roger
+  # Roger Renderer class
+  #
+  # The renderer will set up an environment so you can consistently render templates
+  # within that environment
+  class Renderer
+    class << self
+      # Register a helper module that should be included in
+      # every template context.
+      def helper(mod)
+        @helpers ||= []
+        @helpers << mod
+      end
+
+      def helpers
+        @helpers || []
+      end
+
+      # Try to infer the final extension of the output file.
+      def target_extension_for(path)
+        if type = MIME::Types[target_mime_type_for(path)].first
+          # Dirty little hack to enforce the use of .html instead of .htm
+          if type.sub_type == "html"
+            "html"
+          else
+            type.extensions.first
+          end
+        else
+          File.extname(path.to_s).sub(/^\./, "")
+        end
+      end
+
+      def source_extension_for(path)
+        parts = File.basename(File.basename(path.to_s)).split(".")
+        if parts.size > 2
+          parts[-2..-1].join(".")
+        else
+          File.extname(path.to_s).sub(/^\./, "")
+        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_for(path)
+        mime =
+          mime_type_from_template(path) ||
+          mime_type_from_filename(path) ||
+          mime_type_from_sub_extension(path)
+
+        mime.to_s if mime
+      end
+
+      protected
+
+      # Check last template processor default
+      # output mime type
+      def mime_type_from_template(path)
+        templates = Tilt.templates_for(path.to_s)
+        templates.last && templates.last.default_mime_type
+      end
+
+      def mime_type_from_filename(path)
+        MIME::Types.type_for(File.basename(path.to_s)).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(path)
+        parts = File.basename(path.to_s).split(".")
+        MIME::Types.type_for(parts[0..-2].join(".")).first if parts.size > 2
+      end
+    end
+
+    attr_accessor :data
+    attr_reader :template_nesting
+
+    def initialize(env = {}, options = {})
+      @options = options
+      @context = prepare_context(env)
+
+      @paths = {
+        partials: [@options[:partials_path]].flatten,
+        layouts: [@options[:layouts_path]].flatten
+      }
+
+      # State data. Whenever we render a new template
+      # we need to update:
+      #
+      # - data from front matter
+      # - template_nesting
+      # - current_template
+      @data = {}
+      @template_nesting = []
+    end
+
+    # The render function
+    #
+    # The render function will take care of rendering the right thing
+    # in the right context. It will:
+    #
+    # - Wrap templates with layouts if it's defined in the frontmatter and
+    #   load them from the right layout path.
+    # - Render only partials if called from within an existing template
+    #
+    # If you just want to render an arbitrary file, use #render_file instead
+    #
+    # @option options [Hash] :locals
+    # @option options [String] :source
+    def render(path, options = {}, &block)
+      template, layout = template_and_layout_for_render(path, options)
+
+      # Set new current template
+      template_nesting.push(template)
+
+      # Copy data to our data store. A bit clunky; as this should be inherited
+      @data = {}.update(@data).update(template.data)
+
+      # Render the template first so we have access to
+      # it's data in the layout.
+      render_result = template.render(options[:locals] || {}, &block)
+
+      # Wrap it in a layout
+      layout.render do
+        render_result
+      end
+    ensure
+      template_nesting.pop
+    end
+
+    # Render any file on disk. No magic. Just rendering.
+    #
+    # A couple of things to keep in mind:
+    # - The file will be rendered in this rendering context
+    # - Does not have layouts or block style
+    # - When you pass a relative path and we are within another template
+    #   it will be relative to that template.
+    #
+    # @options options [Hash] :locals
+    def render_file(path, options = {})
+      pn = Pathname.new(path)
+
+      if pn.relative?
+        # We're explicitly checking for source_path instead of real_source_path
+        # as you could also just have an inline template.
+        if current_template && current_template.source_path
+          pn = (Pathname.new(current_template.source_path).dirname + pn).realpath
+        else
+          err = "Only within another template you can use relative paths"
+          fail ArgumentError, err
+        end
+      else
+        pn = pn.realpath
+      end
+
+      template = template(pn.to_s, nil)
+      template.render(options[:locals] || {})
+    end
+
+    # The current template being rendered
+    def current_template
+      template_nesting.last
+    end
+
+    # The parent template in the nesting.
+    def parent_template
+      template_nesting[-2]
+    end
+
+    protected
+
+    def template_and_layout_for_render(path, options = {})
+      # A previous template has been set so it's a partial
+      # If no previous template is set, we're
+      # at the top level and this means we get to do layouts!
+      template_type = current_template ? :partial : :template
+      template = template(path, options[:source], template_type)
+
+      # Only attempt to load layout for toplevel
+      if !current_template && template.data[:layout]
+        layout = template(template.data[:layout], nil, :layout)
+      else
+        layout = BlankTemplate.new
+      end
+
+      [template, layout]
+    end
+
+    # Will check the template nesting if we haven't already
+    # rendered this path before. If it has we'll throw an argumenteerror
+    def prevent_recursion!(template)
+      # If this template is not a real file it cannot ever conflict.
+      return unless template.real_source_path
+
+      caller_template = template_nesting.detect do |t|
+        t.real_source_path == template.real_source_path
+      end
+
+      # We're good, no recursion!
+      return unless caller_template
+
+      err = "Recursive render detected for '#{template.source_path}'"
+      err += " in '#{current_template.source_path}'"
+
+      fail ArgumentError, err
+    end
+
+    # Will instantiate a Template or throw an ArgumentError
+    # if it could not find the template
+    def template(path, source, type = :template)
+      if source
+        template = Template.new(source, @context, source_path: path)
+      else
+        case type
+        when :partial
+          template_path = find_partial(path)
+        when :layout
+          template_path = find_layout(path)
+        else
+          template_path = path
+        end
+
+        if template_path && File.exist?(template_path)
+          template = Template.open(template_path, @context)
+        else
+          template_not_found!(type, path)
+        end
+      end
+
+      prevent_recursion!(template)
+
+      template
+    end
+
+    def template_not_found!(type, path)
+      err = "No such #{type} #{path}"
+      err += " in #{@current_template.source_path}" if @current_template
+      fail ArgumentError, err
+    end
+
+    # Find a partial
+    def find_partial(name)
+      current_path, current_ext = current_template_path_and_extension
+
+      # Try to find _ named partials first.
+      # This will alaso search for partials relative to the current path
+      local_name = [File.dirname(name), "_" + File.basename(name)].join("/")
+      resolver = Resolver.new([File.dirname(current_path)] + @paths[:partials])
+      result = resolver.find_template(local_name, prefer: current_ext)
+
+      return result if result
+
+      # Try to look for templates the old way
+      resolver = Resolver.new(@paths[:partials])
+      resolver.find_template(name, prefer: current_ext)
+    end
+
+    def find_layout(name)
+      _, current_ext = current_template_path_and_extension
+
+      resolver = Resolver.new(@paths[:layouts])
+      resolver.find_template(name, prefer: current_ext)
+    end
+
+    def current_template_path_and_extension
+      path = nil
+      extension = nil
+
+      # We want the preferred extension to be the same as ours
+      if current_template
+        path = current_template.source_path
+        extension = self.class.target_extension_for(path)
+      end
+
+      [path, extension]
+    end
+
+    # Will set up a new  template context for this renderer
+    def prepare_context(env)
+      context = Roger::Template::TemplateContext.new(self, env)
+
+      # Extend context with all helpers
+      self.class.helpers.each do |mod|
+        context.extend(mod)
+      end
+
+      context
+    end
+  end
+end