nanoc 3.2.4 → 3.3.0

data/lib/nanoc/filters/erb.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8                                                                                                           
+
+require 'erb'
+
+module Nanoc::Filters
+  class ERB < Nanoc::Filter
+
+    # Runs the content through [ERB](http://ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html).
+    #
+    # @param [String] content The content to filter
+    #
+    # @option params [Integer] safe_level (nil) The safe level (`$SAFE`) to
+    #   use while running this filter
+    #
+    # @option params [String] trim_mode (nil) The trim mode to use
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Add locals
+      assigns.merge!(params[:locals] || {})
+
+      # Create context
+      context = ::Nanoc::Context.new(assigns)
+
+      # Get binding
+      proc = assigns[:content] ? lambda { assigns[:content] } : nil 
+      assigns_binding = context.get_binding(&proc)
+
+      # Get result
+      safe_level = params[:safe_level]
+      trim_mode = params[:trim_mode]
+      erb = ::ERB.new(content, safe_level, trim_mode)
+      erb.filename = filename
+      erb.result(assigns_binding)
+    end 
+
+  end 
+end

data/lib/nanoc/filters/erubis.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'erubis'
+
+module Nanoc::Filters
+  class Erubis < Nanoc::Filter
+
+    # The same as `::Erubis::Eruby` but adds `_erbout` as an alias for the
+    # `_buf` variable, making it compatible with nanoc’s helpers that rely
+    # on `_erbout`, such as {Nanoc::Helpers::Capturing}.
+    class ErubisWithErbout < ::Erubis::Eruby
+      include ::Erubis::ErboutEnhancer
+    end
+
+    # Runs the content through [Erubis](http://www.kuwata-lab.com/erubis/).
+    # This method takes no options.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Create context
+      context = ::Nanoc::Context.new(assigns)
+
+      # Get binding
+      proc = assigns[:content] ? lambda { assigns[:content] } : nil
+      assigns_binding = context.get_binding(&proc)
+
+      # Get result
+      ErubisWithErbout.new(content, :filename => filename).result(assigns_binding)
+    end
+
+  end
+end

data/lib/nanoc/filters/haml.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'haml'
+
+module Nanoc::Filters
+  class Haml < Nanoc::Filter
+
+    # Runs the content through [Haml](http://haml-lang.com/).
+    # Parameters passed to this filter will be passed on to Haml.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Get options
+      options = params.merge(:filename => filename)
+
+      # Create context
+      context = ::Nanoc::Context.new(assigns)
+
+      # Get result
+      proc = assigns[:content] ? lambda { assigns[:content] } : nil
+      ::Haml::Engine.new(content, options).render(context, assigns, &proc)
+    end
+
+  end
+end

data/lib/nanoc/filters/kramdown.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'kramdown'
+
+module Nanoc::Filters
+  class Kramdown < Nanoc::Filter
+
+    # Runs the content through [Kramdown](http://kramdown.rubyforge.org/).
+    # Parameters passed to this filter will be passed on to Kramdown.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Get result
+      ::Kramdown::Document.new(content, params).to_html
+    end
+
+  end
+end

data/lib/nanoc/filters/less.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'less'
+
+module Nanoc::Filters
+  class Less < Nanoc::Filter
+
+    # Runs the content through [LESS](http://lesscss.org/).
+    # This method takes no options.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Find imports (hacky)
+      imports = []
+      imports.concat(content.scan(/^@import\s+(["'])([^\1]+?)\1;/))
+      imports.concat(content.scan(/^@import\s+url\((["']?)([^)]+?)\1\);/))
+      imported_filenames = imports.map do |i|
+        i[1].match(/\.(less|css)$/) ? i[1] : i[1] + '.less'
+      end
+
+      # Convert to items
+      imported_items = imported_filenames.map do |filename|
+        # Find directory for this item
+        current_dir_pathname = Pathname.new(@item[:content_filename]).dirname.realpath
+
+        # Find absolute pathname for imported item
+        imported_pathname    = Pathname.new(filename)
+        if imported_pathname.relative?
+          imported_pathname = current_dir_pathname + imported_pathname
+        end
+        next if !imported_pathname.exist?
+        imported_filename = imported_pathname.realpath
+
+        # Find matching item
+        @items.find do |i|
+          next if i[:content_filename].nil?
+          Pathname.new(i[:content_filename]).realpath == imported_filename
+        end
+      end.compact
+
+      # Create dependencies
+      depend_on(imported_items)
+
+      # Add filename to load path
+      paths = [ File.dirname(@item[:content_filename]) ]
+      parser = ::Less::Parser.new(:paths => paths)
+      parser.parse(content).to_css
+    end
+
+  end
+end

data/lib/nanoc/filters/markaby.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'markaby'
+
+module Nanoc::Filters
+  class Markaby < Nanoc::Filter
+
+    # Runs the content through [Markaby](http://markaby.rubyforge.org/).
+    # This method takes no options.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Get result
+      ::Markaby::Builder.new(assigns).instance_eval(content).to_s
+    end
+
+  end
+end

data/lib/nanoc/filters/maruku.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'maruku'
+
+module Nanoc::Filters
+  class Maruku < Nanoc::Filter
+
+    # Runs the content through [Maruku](http://maruku.rubyforge.org/).
+    # Parameters passed to this filter will be passed on to Maruku.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Get result
+      ::Maruku.new(content, params).to_html
+    end
+
+  end
+end

data/lib/nanoc/filters/mustache.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'mustache'
+
+module Nanoc::Filters
+
+  # @since 3.2.0
+  class Mustache < Nanoc::Filter
+
+    # Runs the content through
+    # [Mustache](http://github.com/defunkt/mustache). This method takes no
+    # options.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Get result
+      ::Mustache.render(content, item.attributes)
+    end
+
+  end
+
+end

data/lib/nanoc/filters/rainpress.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'rainpress'
+
+module Nanoc::Filters
+  class Rainpress < Nanoc::Filter
+
+    # Runs the content through [Rainpress](http://code.google.com/p/rainpress/).
+    # Parameters passed to this filter will be passed on to Rainpress.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      ::Rainpress.compress(content, params)
+    end
+
+  end
+end

data/lib/nanoc/filters/rdiscount.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'rdiscount'
+
+module Nanoc::Filters
+  class RDiscount < Nanoc::Filter
+
+    # Runs the content through [RDiscount](http://github.com/rtomayko/rdiscount).
+    #
+    # @option params [Array] symbol ([]) A list of RDiscount extensions
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      extensions = params[:extensions] || []
+
+      ::RDiscount.new(content, *extensions).to_html
+    end
+
+  end
+end

data/lib/nanoc/filters/rdoc.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+begin
+  # new RDoc
+  require 'rdoc/markup'
+  require 'rdoc/markup/to_html'
+rescue LoadError
+  # old RDoc
+  require 'rdoc/markup/simple_markup'
+  require 'rdoc/markup/simple_markup/to_html'
+end
+
+module Nanoc::Filters
+  class RDoc < Nanoc::Filter
+
+    # Runs the content through [RDoc::Markup](http://rdoc.rubyforge.org/RDoc/Markup.html).
+    # This method takes no options.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      begin
+        # new RDoc
+        ::RDoc::Markup.new.convert(content, ::RDoc::Markup::ToHtml.new)
+      rescue LoadError
+        # old RDoc
+        ::SM::SimpleMarkup.new.convert(content, ::SM::ToHtml.new)
+      end
+    end
+
+  end
+end

data/lib/nanoc/filters/redcarpet.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'redcarpet'
+
+module Nanoc::Filters
+
+  # @since 3.2.0
+  class Redcarpet < Nanoc::Filter
+
+    # Runs the content through [Redcarpet](https://github.com/tanoku/redcarpet/).
+    # This method optionally takes processing options to pass on to Redcarpet.
+    #
+    # @overload run(content, params={})
+    #
+    #   For Redcarpet 1.x
+    #
+    #   @param [String] content The content to filter
+    #
+    #   @option params [Array] :options ([]) A list of options to pass on to
+    #     Redcarpet
+    #
+    #   @return [String] The filtered content
+    #   
+    # @overload run(content, params={})
+    #
+    #   For Redcarpet 2.x
+    #
+    #   @since 3.2.4
+    #
+    #   @param [String] content The content to filter
+    #
+    #   @option params [Hash] :options ({}) A list of options to pass on to
+    #     Redcarpet itself (not the renderer)
+    #
+    #   @option params [::Redcarpet::Render::Base] :renderer
+    #     (::Redcarpet::Render::HTML) The class of the renderer to use
+    #
+    #   @option params [Hash] :renderer_options ({}) A list of options to pass
+    #     on to the Redcarpet renderer
+    #
+    #   @return [String] The filtered content
+    def run(content, params={})
+      if ::Redcarpet::VERSION > '2'
+        options          = params[:options]          || {}
+        renderer_class   = params[:renderer]         || ::Redcarpet::Render::HTML
+        renderer_options = params[:renderer_options] || {}
+
+        if options.is_a?(Array)
+          warn 'WARNING: You are passing an array of options to the :redcarpet filter, but Redcarpet 2.x expects a hash instead. This will likely fail.'
+        end
+
+        renderer = renderer_class.new(renderer_options)
+        ::Redcarpet::Markdown.new(renderer, options).render(content)
+      else
+        options = params[:options] || []
+        ::Redcarpet.new(content, *options).to_html
+      end
+    end
+
+  end
+
+end

data/lib/nanoc/filters/redcloth.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'redcloth'
+
+module Nanoc::Filters
+  class RedCloth < Nanoc::Filter
+
+    # Runs the content through [RedCloth](http://redcloth.org/). This method
+    # takes the following options:
+    #
+    # * `:filter_class`
+    # * `:filter_html`
+    # * `:filter_ids`
+    # * `:filter_style`
+    # * `:hard_breaks`
+    # * `:lite_mode`
+    # * `:no_span_caps`
+    # * `:sanitize_htm`
+    #
+    # Each of these options sets the corresponding attribute on the `RedCloth`
+    # instance. For example, when the `:hard_breaks => false` option is passed
+    # to this filter, the filter will call `r.hard_breaks = false` (with `r`
+    # being the `RedCloth` instance).
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Create formatter
+      r = ::RedCloth.new(content)
+
+      # Set options
+      r.filter_classes = params[:filter_classes] if params.has_key?(:filter_classes)
+      r.filter_html    = params[:filter_html]    if params.has_key?(:filter_html)
+      r.filter_ids     = params[:filter_ids]     if params.has_key?(:filter_ids)
+      r.filter_styles  = params[:filter_styles]  if params.has_key?(:filter_styles)
+      r.hard_breaks    = params[:hard_breaks]    if params.has_key?(:hard_breaks)
+      r.lite_mode      = params[:lite_mode]      if params.has_key?(:lite_mode)
+      r.no_span_caps   = params[:no_span_caps]   if params.has_key?(:no_span_caps)
+      r.sanitize_html  = params[:sanitize_html]  if params.has_key?(:sanitize_html)
+
+      # Get result
+      r.to_html
+    end
+
+  end
+end

data/lib/nanoc/filters/relativize_paths.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+module Nanoc::Filters
+  class RelativizePaths < Nanoc::Filter
+
+    require 'nanoc/helpers/link_to'
+    include Nanoc::Helpers::LinkTo
+
+    SELECTORS = [ 'a/@href', 'img/@src', 'script/@src', 'link/@href' ]
+
+    # Relativizes all paths in the given content, which can be HTML, XHTML, XML
+    # or CSS. This filter is quite useful if a site needs to be hosted in a
+    # subdirectory instead of a subdomain. In HTML, all `href` and `src`
+    # attributes will be relativized. In CSS, all `url()` references will be
+    # relativized.
+    #
+    # @param [String] content The content to filter
+    #
+    # @option params [Symbol] :type The type of content to filter; can be
+    #   `:html`, `:xhtml`, `:xml` or `:css`.
+    #
+    # @option params [Array] :select The XPath expressions that matches the
+    #   nodes to modify. This param is useful only for the `:xml` and `:xhtml`
+    #   types.
+    #
+    # @option params [Hash] :namespaces The pairs `prefix => uri` to define
+    #   any namespace you want to use in the XPath expressions. This param 
+    #   is useful only for the `:xml` and `:xhtml` types.
+    #
+    # @return [String] The filtered content
+    def run(content, params={})
+      # Set assigns so helper function can be used
+      @item_rep = assigns[:item_rep] if @item_rep.nil?
+
+      # Filter
+      case params[:type]
+      when :html
+        # FIXME parse HTML the proper way using nokogiri
+        content.gsub(/(<[^>]+\s+(src|href))=(['"]?)(\/(?:[^\/].*?)?)\3([\s\/>])/) do
+          $1 + '=' + $3 + relative_path_to($4) + $3 + $5
+        end
+      when :css
+        # FIXME parse CSS the proper way using csspool or something
+        content.gsub(/url\((['"]?)(\/(?:[^\/].*?)?)\1\)/) do
+          'url(' + $1 + relative_path_to($2) + $1 + ')'
+        end
+      when :xml, :xhtml
+        selectors  = params.fetch(:select) { SELECTORS }
+        namespaces = params[:namespaces] || {}
+
+        if params[:type] == :xhtml
+          # FIXME cleanup because it is ugly
+          # this cleans the XHTML namespace to process fragments and full
+          # documents in the same way. At least, Nokogiri adds this namespace
+          # if detects the `html` element.
+          content.sub!(%r{(<html[^>]+)xmlns="http://www.w3.org/1999/xhtml"}, '\1')
+        end
+
+        nokogiri_process(content, selectors, namespaces, params[:type])
+      else
+        raise RuntimeError.new(
+          "The relativize_paths needs to know the type of content to " +
+          "process. Pass a :type to the filter call (:html for HTML, " +
+          ":xhtml for XHTML, :xml for XML, or :css for CSS).")
+      end
+    end
+
+  private
+
+    def nokogiri_process(content, selectors, namespaces, type)
+      require 'nokogiri'
+
+      # Ensure that all prefixes are strings
+      namespaces = namespaces.inject({}) { |new, (prefix, uri)| new.merge(prefix.to_s => uri) }
+
+      doc = ::Nokogiri::XML.fragment(content)
+      selectors.map { |sel| "descendant-or-self::#{sel}" }.each do |selector|
+        doc.xpath(selector, namespaces).each do |node|
+          node.content = relative_path_to(node.content)
+        end
+      end
+      result = doc.send("to_#{type}")
+
+      # FIXME cleanup because it is ugly
+      # Because using the `Nokogiri::XML::DocumentFragment` class DOCTYPE 
+      # pseudonodes becomes even more creepy than usual.
+      result.sub!(/(!DOCTYPE.+?)(&gt;)/, '<\1>')
+
+      result
+    end
+    
+    
+  end
+end