machined 0.1.0

data/lib/machined/helpers/asset_tag_helpers.rb

@@ -0,0 +1,135 @@
+require "active_support/concern"
+
+module Machined
+  module Helpers
+    module AssetTagHelpers
+      extend  ActiveSupport::Concern
+      include Padrino::Helpers::AssetTagHelpers
+      
+      # Pattern for checking if a given path
+      # is an external URI.
+      URI_MATCH = %r(^[-a-z]+://|^cid:|^//)
+      
+      # Returns a path to an asset, either in the output path
+      # or in the assets environment. It will default to appending
+      # the old-school timestamp.
+      def asset_path(kind, source)
+        return source if source =~ URI_MATCH
+        
+        # Append extension if necessary.
+        if [:css, :js].include?(kind)
+          source << ".#{kind}" unless source =~ /\.#{kind}$/
+        end
+        
+        # If the source points to an asset in the assets
+        # environment use `AssetPath` to generate the full path.
+        machined.assets.resolve(source) do |path|
+          return AssetPath.new(machined, machined.assets.find_asset(path)).to_s
+        end
+        
+        # Default to using a basic `FilePath` to generate the
+        # full path.
+        FilePath.new(machined, source, kind).to_s
+      end
+      
+      # `FilePath` generates a full path for a regular file
+      # in the output path. It's used by #asset_path to generate
+      # paths when using asset tags like #javascript_include_tag,
+      # #stylesheet_link_tag, and #image_tag
+      class FilePath
+        # A reference to the Machined environment.
+        attr_reader :machined
+        
+        # The path from which to generate the full path to the asset.
+        attr_reader :source
+        
+        # The expected kind of file (:css, :js, :images).
+        attr_reader :kind
+      
+        #
+        def initialize(machined, source, kind)
+          @machined = machined
+          @source   = source.to_s
+          @kind     = kind
+        end
+        
+        # Returns the full path to the asset, complete with
+        # timestamp.
+        def to_s
+          path = rewrite_base_path(source)
+          path = rewrite_timestamp(path)
+          path
+        end
+        
+        protected
+        
+        # Prepends the base path if the path is not
+        # already an absolute path.
+        def rewrite_base_path(path) # :nodoc:
+          if path =~ %r(^/)
+            path
+          else
+            File.join(base_path, path)
+          end
+        end
+        
+        # Appends an asset timestamp based on the
+        # modification time of the asset.
+        def rewrite_timestamp(path) # :nodoc:
+          if timestamp = mtime(path)
+            "#{path}?#{timestamp.to_i}" unless path =~ /\?\d+$/
+          else
+            path
+          end
+        end
+        
+        # Returns the expected base path for this asset.
+        def base_path # :nodoc:
+          case kind
+          when :css then "/stylesheets"
+          when :js  then "/javascripts"
+          else
+            "/#{kind}"
+          end
+        end
+        
+        # Returns the mtime for the given path (relative to
+        # the output path). Returns nil if the file doesn't exist.
+        def mtime(path) # :nodoc:
+          output_path = File.join(machined.output_path.to_s, path)
+          File.exist?(output_path) ? File.mtime(output_path) : nil
+        end
+      end
+      
+      # `AssetPath` generates a full path for an asset
+      # that exists in Machined's `assets` environment.
+      class AssetPath < FilePath
+        attr_reader :asset
+        
+        def initialize(machined, asset)
+          @machined = machined
+          @asset    = asset
+          @source   = digest? ? asset.digest_path : asset.logical_path
+        end
+        
+        protected
+        
+        def rewrite_timestamp(path)
+          digest? ? path : super
+        end
+        
+        def digest?
+          machined.config.digest_assets
+        end
+        
+        def base_path
+          machined.assets.config.url
+        end
+        
+        def mtime(path)
+          asset.mtime
+        end
+      end
+    end
+  end
+end

data/lib/machined/helpers/locals_helpers.rb

@@ -0,0 +1,57 @@
+require "active_support/concern"
+require "active_support/hash_with_indifferent_access"
+
+module Machined
+  module Helpers
+    module LocalsHelpers
+      extend ActiveSupport::Concern
+      
+      # Adds psuedo local variables from the given hash, where
+      # the key is the name of the variable. This is provided so
+      # processors can add local variables without having access
+      # to the next processor or template.
+      def locals=(locals)
+        if locals.nil?
+          @locals = nil
+        else
+          self.locals.merge! locals
+        end
+      end
+      
+      # Returns the locals hash. It's actually an instance
+      # of `ActiveSupport::HashWithIndifferentAccess`, so strings
+      # and symbols can be used interchangeably.
+      def locals
+        @locals ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+      
+      # Returns true if the given +name+ has been set as a local
+      # variable.
+      def has_local?(name)
+        locals.key? name
+      end
+      
+      # Returns the default layout, unless overridden by
+      # the YAML front matter.
+      def layout
+        if has_local?(:layout)
+          locals[:layout]
+        else
+          machined.config.layout
+        end
+      end
+      
+      def method_missing(method, *args, &block) # :nodoc:
+        if args.empty? && has_local?(method)
+          locals[method]
+        else
+          super
+        end
+      end
+      
+      def respond_to?(method) # :nodoc:
+        super or has_local?(method)
+      end
+    end
+  end
+end

data/lib/machined/helpers/output_helpers.rb

@@ -0,0 +1,43 @@
+require "active_support/concern"
+require "active_support/memoizable"
+require "tilt"
+
+# We need to ensure that Tilt's ERB template uses
+# the same output variable that Padrino's helpers expect.
+Tilt::ERBTemplate.default_output_variable = "@_out_buf"
+
+module Machined
+  module Helpers
+    module OutputHelpers
+      extend ActiveSupport::Concern
+      extend ActiveSupport::Memoizable
+      
+      # A hash of Tilt templates that support
+      # capture blocks where the key is the name
+      # of the template.
+      CAPTURE_ENGINES = {
+        "Tilt::HamlTemplate"   => :haml,
+        "Tilt::ERBTemplate"    => :erb,
+        "Tilt::ErubisTemplate" => :erubis,
+        "Slim::Template"       => :slim
+      }
+      
+      protected
+      
+      # Attempts to return the current engine based on
+      # the processors for this file. This is used by
+      # Padrino's helpers to determine which type of template
+      # engine to use when capturing blocks.
+      def current_engine
+        processors = environment.attributes_for(self.pathname).processors
+        processors or return
+        processors.each do |processor|
+          engine = CAPTURE_ENGINES[processor.to_s] and return engine
+        end
+        
+        nil
+      end
+      memoize :current_engine
+    end
+  end
+end

data/lib/machined/helpers/render_helpers.rb

@@ -0,0 +1,138 @@
+require "pathname"
+require "active_support/concern"
+
+module Machined
+  module Helpers
+    module RenderHelpers
+      extend  ActiveSupport::Concern
+      include LocalsHelpers
+      
+      # This is the short form of both #render_partial and #render_collection.
+      # It works exactly like #render_partial, except if you pass the
+      # +:collection+ option:
+      #
+      #   <%= render "ad", :collection => advertisements %>
+      #   # is the same as:
+      #   <%= render_collection advertisements, "ad" %>
+      # 
+      def render(partial, options = {})
+        if collection = options.delete(:collection)
+          render_collection collection, partial, options
+        else
+          render_partial partial, options
+        end
+      end
+      
+      # Renders the given +collection+ of objects with the given
+      # +partial+ template. This follows the same conventions
+      # of Rails' partial rendering, where the individual objects
+      # will be set as local variables based on the name of the partial:
+      #
+      #   <%= render_collection advertisements, "ad" %>
+      #
+      # This will render the "ad" template 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+.
+      def render_collection(collection, partial, options = {})
+        return if collection.nil? || collection.empty?
+        
+        template = resolve_partial(partial)
+        counter  = 0
+        collection.inject('') do |output, object|
+          counter += 1
+          output << render_partial(template, options.merge(:object => object, :counter => counter))
+        end
+      end
+      
+      # Renders a single +partial+. The primary options are:
+      #
+      #   * <tt>:locals</tt> - A hash of local variables to use when
+      #                        rendering the partial.
+      #   * <tt>:object</tt> - The object rendered in the partial.
+      #   * <tt>:as</tt>     - The name of the object to use.
+      #
+      # == Some Examples
+      #
+      #   <%= render_partial "account" %>
+      #
+      # This will look for a template in the views paths with the name
+      # "account" or "_account". The files can be any processable Tilt
+      # template files, like ".erb", ".md", or ".haml" - or just plain ".html".
+      #
+      #   <%= render_partial "account", :locals => { :account => buyer } %>
+      #
+      # This will set `buyer` as a local variable named "account". This can
+      # actually be written a few different ways:
+      #
+      #   <%= render_partial "account", :account => buyer %>
+      #   # Leftover options are assumed to be locals.
+      #   <%= render_partial "account", :object => buyer %>
+      #   # The local variable name "account" is inferred.
+      #
+      # As mentioned above, any options that are not used by #render_partial
+      # are assumed to be locals when the +:locals+ option is not set.
+      #
+      # Also mentioned above, the +:object+ option works like in Rails,
+      # where the local variable name will be inferred from the partial name.
+      # This can be overridden with the +:as+ option:
+      #
+      #   <%= render_partial "account", :object => buyer, :as => "user" %>
+      #
+      # This is equivalent to:
+      #
+      #   <%= render_partial "account", :locals => { :user => buyer } %>
+      #
+      def render_partial(partial, options = {})
+        template = resolve_partial(partial)
+        depend_on template
+        
+        # Add object with the name of the partial
+        # as the local variable name.
+        if object = options.delete(:object)
+          object_name = options.delete(:as) || template.to_s[/_?(\w+)(\.\w+)*$/, 1]
+          self.locals[object_name] = object
+          self.locals["#{object_name}_counter"] = options.delete(:counter)
+        end
+        
+        # Add locals from leftover options
+        if locals = options.delete(:locals) || options
+          self.locals = locals
+        end
+        
+        evaluate_without_processor template, Machined::Processors::LayoutProcessor
+      end
+      
+      protected
+      
+      # Attempts to find a view with the given path,
+      # while also looking for a version with a partial-style
+      # name (prefixed with an "_").
+      def resolve_partial(path) # :nodoc:
+        path = Pathname.new(path)
+        path.absolute? and return path
+        
+        # First look for the normal path
+        machined.views.resolve(path) { |found| return found }
+        
+        # Then look for the partial-style version
+        unless path.basename.to_s =~ /^_/
+          partial = path.dirname.join("_#{path.basename}")
+          machined.views.resolve(partial) { |found| return found }
+        end
+        
+        raise Sprockets::FileNotFound, "couldn't find file '#{path}'"
+      end
+      
+      # Evaluates the given path without using the given processor.
+      # This is used to evaluate templates without wrapping
+      # them in layouts.
+      def evaluate_without_processor(path, processor) # :nodoc:
+        processors = environment.attributes_for(path).processors.dup
+        processors.delete processor
+        evaluate path, :processors => processors
+      end
+    end
+  end
+end

data/lib/machined/processors/front_matter_processor.rb

@@ -0,0 +1,35 @@
+require "yaml"
+require "tilt"
+
+module Machined
+  module Processors
+    class FrontMatterProcessor < Tilt::Template
+      # The Regexp that separates the YAML
+      # front matter from the content.
+      FRONT_MATTER_PARSER = /
+        (
+          \A\s*       # Beginning of file
+          ^---\s*$\n* # Start YAML Block
+          (.*?)\n*    # YAML data
+          ^---\s*$\n* # End YAML Block
+        )
+        (.*)\Z        # Rest of File
+      /mx
+      
+      # See `Tilt::Template#prepare`.
+      def prepare
+      end
+      
+      # See `Tilt::Template#evaluate`.
+      def evaluate(context, locals = {}, &block)
+        output = data
+        if FRONT_MATTER_PARSER.match data
+          locals         = YAML.load $2
+          context.locals = locals if locals
+          output         = $3
+        end
+        output
+      end
+    end
+  end
+end

data/lib/machined/processors/layout_processor.rb

@@ -0,0 +1,71 @@
+require "tilt"
+
+module Machined
+  module Processors
+    class LayoutProcessor < Tilt::Template
+      # A reference to the Sprockets context
+      attr_reader :context
+      
+      # Path to the layout file
+      attr_reader :layout_path
+      
+      # See `Tilt::Template#prepare`.
+      def prepare
+      end
+      
+      # See `Tilt::Template#evaluate`.
+      def evaluate(context, locals, &block)
+        @context = context
+        if layout? && @layout_path = resolve_layout
+          context.depend_on @layout_path
+          evaluate_layout
+        else
+          data
+        end
+      end
+      
+      protected
+      
+      # A reference to the Views sprocket, where the
+      # layout asset will be.
+      def views
+        context.machined.views
+      end
+      
+      # Determine if we should attempt to wrap the
+      # content with a layout.
+      def layout?
+        context.layout != false
+      end
+      
+      # Attempt to find the layout file in the Views
+      # sprocket.
+      def resolve_layout
+        views.resolve "layouts/#{context.layout}", :content_type => context.content_type
+      rescue Sprockets::FileNotFound, Sprockets::ContentTypeMismatch
+        nil
+      end
+      
+      # Recreate `Sprockets::Context#evaluate`, because it doesn't
+      # support yielding. I'm not even sure it's necessary to
+      # support multiple processors for a layout, though.
+      def evaluate_layout
+        processors = views.attributes_for(layout_path).processors
+        result     = Sprockets::Utils.read_unicode layout_path
+        
+        processors.each do |processor|
+          begin
+            template = processor.new(layout_path.to_s) { result }
+            result   = template.render(context, {}) { data }
+          rescue Exception => e
+            context.annotate_exception! e
+            raise
+          end
+        end
+        
+        result
+      end
+    end
+  end
+end
+