rake-pipeline-web-filters-fork 0.6.0

data/lib/rake-pipeline-web-filters/handlebars_filter.rb

@@ -0,0 +1,62 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that converts handlebars templates to javascript
+  # and stores them in a defined variable.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "**/*.handlebars"
+  #     output "public"
+  #
+  #     # Compile each handlebars file to JS
+  #     handlebars
+  #   end
+  class HandlebarsFilter < Rake::Pipeline::Filter
+
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options for generate_output
+    attr_reader :options
+
+    # @param [Hash] options
+    #   options to pass to the output generator
+    # @option options [Array] :target
+    #   the variable to store templates in
+    # @option options [Array] :compile_open
+    #   the js to wrap template contents in
+    # @option options [Array] :compile_close
+    #   the js to wrap template contents in
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={},&block)
+      # Convert .handlebars file extensions to .js
+      block ||= proc { |input| input.sub(/\.handlebars|\.hbs$/, '.js') }
+      super(&block)
+      @options = {
+          :target =>'Ember.TEMPLATES',
+          :wrapper_proc => proc { |source| "Ember.Handlebars.compile(#{source});" },
+          :key_name_proc => proc { |input| File.basename(input.path, File.extname(input.path)) }
+        }.merge(options)
+    end
+
+    def generate_output(inputs, output)
+
+      inputs.each do |input|
+        # The name of the template is the filename, sans extension
+        name = options[:key_name_proc].call(input)
+
+        # Read the file and escape it so it's a valid JS string
+        source = input.read.to_json
+
+        # Write out a JS file, saved to target, wrapped in compiler
+        output.write "#{options[:target]}['#{name}']=#{options[:wrapper_proc].call(source)}"
+      end
+    end
+
+    private 
+
+    def external_dependencies
+      [ 'json' ]
+    end
+  end
+end

data/lib/rake-pipeline-web-filters/helpers.rb

@@ -0,0 +1,138 @@
+module Rake::Pipeline::Web::Filters
+  # Extends the Rake::Pipeline DSL to include shortcuts
+  # for adding filters to the pipeline.
+  #
+  # Instead of:
+  #   !!!ruby
+  #   match("*.scss") do
+  #     filter Rake::Pipeline::Web::Filters::SassFilter, :syntax => :sass
+  #   end
+  #
+  # You can do:
+  #   !!!ruby
+  #   match("*.scss") do
+  #     sass :syntax => :sass
+  #   end
+  module PipelineHelpers
+    # Add a new {MinispadeFilter} to the pipeline.
+    # @see MinispadeFilter#initialize
+    def minispade(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::MinispadeFilter, *args, &block)
+    end
+
+    # Add a new {NeuterFilter} to the pipeline.
+    # @see NeuterFilter#initialize
+    def neuter(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::NeuterFilter, *args, &block)
+    end
+
+    # Add a new {SassFilter} to the pipeline.
+    # @see SassFilter#initialize
+    def sass(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::SassFilter, *args, &block)
+    end
+    alias_method :scss, :sass
+
+  # Add a new {JadeFilter} to the pipeline.
+    # @see JadeFilter#initialize
+    def jade(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::JadeFilter, *args, &block)
+    end
+
+    # Add a new {StylusFilter} to the pipeline.
+    # @see StylusFilter#initialize
+    def stylus(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::StylusFilter, *args, &block)
+    end
+
+    # Add a new {TiltFilter} to the pipeline.
+    # @see TiltFilter#initialize
+    def tilt(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::TiltFilter, *args, &block)
+    end
+
+    # Add a new {MarkdownFilter} to the pipeline.
+    # @see MarkdownFilter#initialize
+    def markdown(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::MarkdownFilter, *args, &block)
+    end
+
+    # Add a new {CacheBusterFilter} to the pipeline.
+    # @see CacheBusterFilter#initialize
+    def cache_buster(&block)
+      filter(Rake::Pipeline::Web::Filters::CacheBusterFilter, &block)
+    end
+
+    # Add a new {CoffeeScriptFilter} to the pipeline.
+    # @see CoffeeScriptFilter#initialize
+    def coffee_script(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::CoffeeScriptFilter, *args, &block)
+    end
+
+    # Add a new {YUIJavaScriptFilter} to the pipeline.
+    # @see YUIJavaScriptFilter#initialize
+    def yui_javascript(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::YUIJavaScriptFilter, *args, &block)
+    end
+
+    # Add a new {YUICssFilter} to the pipeline.
+    # @see YUICssFilter#initialize
+    def yui_css(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::YUICssFilter, *args, &block)
+    end
+
+    # Add a new {GzipFilter} to the pipeline.
+    # @see GzipFilter#initialize
+    def gzip(&block)
+      filter(Rake::Pipeline::Web::Filters::GzipFilter, &block)
+    end
+
+    # Add a new {UglifyFilter} to the pipeline.
+    # @see UglifyFilter#initialize
+    def uglify(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::UglifyFilter, *args, &block)
+    end
+
+    # Add a new {LessFilter} to the pipeline.
+    # @see LessFilter#initialize
+    def less(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::LessFilter, *args, &block)
+    end
+
+    # Add a new {HandlebarsFilter} to the pipeline.
+    # @see HandlebarsFilter#initialize
+    def handlebars(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::HandlebarsFilter, *args, &block)
+    end
+    #
+    # Add a new {IifeFilter} to the pipeline.
+    # @see IifeFilter#initialize
+    def iife(*args, &block)
+      filter(Rake::Pipeline::Web::Filters::IifeFilter, *args, &block)
+    end
+  end
+
+  module ProjectHelpers
+    # Register a filter class for a particular file extension
+    # and add a ChainedFilter as a before filter.
+    #
+    # If this is the first use of +register+, it will set up
+    # the before filter. Subsequent uses will just update the
+    # types hash.
+    #
+    # @see ChainedFilter
+    def register(extension, klass)
+      if @types_hash
+        @types_hash[extension] = klass
+      else
+        @types_hash = { extension => klass }
+        before_filter ChainedFilter, { :types => @types_hash }
+      end
+    end
+  end
+end
+
+require "rake-pipeline/dsl"
+
+Rake::Pipeline::DSL::PipelineDSL.send(:include, Rake::Pipeline::Web::Filters::PipelineHelpers)
+Rake::Pipeline::DSL::ProjectDSL.send(:include, Rake::Pipeline::Web::Filters::ProjectHelpers)

data/lib/rake-pipeline-web-filters/iife_filter.rb

@@ -0,0 +1,38 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that wraps input files in an IIFE (immediately invoked functional expression)
+  #
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Wrap each file in: (function() { ... })();"
+  #     filter Rake::Pipeline::Web::Filters::IifeFilter
+  #   end
+  class IifeFilter < Rake::Pipeline::Filter
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(&block)
+      block ||= proc { |input| input }
+      super(&block)
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Wraps each input in an IIFE.
+    # 
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] output a single {FileWrapper}
+    #   object representing the output.
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        output.write "(function() {\n"
+        output.write input.read
+        output.write "})();"
+      end
+    end
+  end
+end

data/lib/rake-pipeline-web-filters/jade_filter.rb

@@ -0,0 +1,61 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that compiles input files written in Jade
+  # to HTML using the Jade compiler
+  #
+  # Requires node and https://npmjs.org/package/jade by
+  # [sudo] npm install jade -g
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.jade"
+  #     output "public"
+  #
+  #     # Compile each Jade file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::JadeFilter
+  #   end
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.jade"
+  #     output "public"
+  #
+  #     jade :pretty
+  #   end
+  class JadeFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+    
+    # @return [Hash] a hash of options to pass to Less
+    #   when compiling.
+    # @option option :prettify output
+    attr_reader :options
+
+    def initialize(options={}, &block)
+      block ||= proc { |input| input.sub(/\.(jade)$/, '.html') }
+      super(&block)
+      @options = options
+    end
+
+    def generate_output(inputs, output)
+
+      inputs.each do |input|
+        if options[:pretty]
+          `jade < #{input.root}/#{input.path} -P --path #{input.root}/#{input.path} > #{output.root}/#{output.path}`
+        else
+          `jade < #{input.root}/#{input.path} --path #{input.root}/#{input.path} > #{output.root}/#{output.path}`
+        end
+        out = output.read
+        output.write out
+      end
+    end
+
+  private
+
+    def external_dependencies
+      [ ]
+    end
+    
+  end
+end

data/lib/rake-pipeline-web-filters/less_filter.rb

@@ -0,0 +1,55 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that accepts a series of inputs and translates
+  # them using the Tilt template interface, which will attempt
+  # to guess which template language to use based on the input
+  # file extension.
+  #
+  # Requires {https://rubygems.org/gems/less-js less-js}
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.less"
+  #     output "public"
+  #
+  #     # Compile each less file with Less.js
+  #     filter Rake::Pipeline::Web::Filters::LessFilter
+  #   end
+  class LessFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options to pass to Less
+    #   when compiling.
+    attr_reader :options
+
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, context = nil, &block)
+      block ||= proc { |input| input.sub(/\.less$/, '.css') }
+      super(&block)
+      @options = options
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Attempts to compile each input file
+    # with LessJs.
+    #
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] output a single {FileWrapper}
+    #   object representing the output.
+    def generate_output(inputs, output)
+      parser = Less::Parser.new options
+      inputs.each do |input|
+        output.write parser.parse(input.read).to_css
+      end
+    end
+
+    def external_dependencies
+      [ 'less' ]
+    end
+  end
+end

data/lib/rake-pipeline-web-filters/markdown_filter.rb

@@ -0,0 +1,70 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that compiles input files written in Markdown
+  # to Markdown using the Redcarpet compiler.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.md"
+  #     output "public"
+  #
+  #     # Compile each .md file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::MarkdownFilter
+  #   end
+  #
+  class MarkdownFilter < Rake::Pipeline::Filter
+
+    # @param [Hash] options options to pass to the markdown
+    #   compiler
+    # @see http://rubydoc.info/gems/redcarpet/2.0.0/frames for more information
+    #   about options
+    # @option options [#call] :compiler If you wish to use a different
+    #   Markdown compiler, you can do so by passing anything that responds
+    #   to `:call`, which will be passed the Markdown text and any
+    #   options (other than `:compiler`).
+    # @option options [Redcarpet::Render::Base] :renderer a
+    #   Redcarpet renderer. Used only if using the default compiler.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      block ||= proc { |input| input.sub(/\.(md|mdown|mkdown|markdown)$/, '.html') }
+      super(&block)
+      @compiler = options.delete(:compiler)
+      @options = options
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Compiles each input file with Sass.
+    #
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] output a single {FileWrapper}
+    #   object representing the output.
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        output.write compile(input.read)
+      end
+    end
+
+    private
+
+    def compile(markdown)
+      if @compiler
+        @compiler.call(markdown, @options)
+      else
+        default_compiler.render(markdown)
+      end
+    end
+
+    def default_compiler
+      @default_renderer ||= begin
+                            require 'redcarpet'
+                            renderer = @options.delete(:renderer) || Redcarpet::Render::HTML.new
+                            Redcarpet::Markdown.new(renderer, @options)
+                          end
+    end
+
+  end
+end

data/lib/rake-pipeline-web-filters/minispade_filter.rb

@@ -0,0 +1,63 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that wraps JavaScript files in a minispade.register closure
+  # for use in minispade.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Wrap each JS file in a minispade.register closure.
+  #     filter Rake::Pipeline::Web::Filters::MinispadeFilter
+  #   end
+  class MinispadeFilter < Rake::Pipeline::Filter
+
+    # @param [Hash] options
+    # @option options [Boolean] :use_strict Whether to add "use strict" to
+    #   each outputted function; defaults to false.
+    # @option options [Proc] :module_id_generator a proc to use to generate
+    #   the minispade module id.
+    # @option options [Boolean] :rewrite_requires If true, change calls to
+    #   +require+ in the source to +minispade.require+.
+    # @option options [Boolean] :string If true, compiles the output as
+    #   a String instead of a closure. This means that @sourceURL can be
+    #   appended for good stack traces and debugging.
+    def initialize(options = {})
+      super()
+      @use_strict = options[:use_strict]
+      @module_id_generator = options[:module_id_generator] ||
+        proc { |input| input.fullpath.sub(Dir.pwd, '') }
+      @rewrite_requires = options[:rewrite_requires]
+      @string_module = options[:string]
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Wraps each input file in a minispade.register
+    # closure.
+    #
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] output a single {FileWrapper}
+    #   object representing the output.
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        code = input.read
+        code.gsub!(%r{^\s*require\s*\(\s*}, 'minispade.require(') if @rewrite_requires
+        code.gsub!(%r{^\s*requireAll\s*\(\s*}, 'minispade.requireAll(') if @rewrite_requires
+        code = %["use strict";\n] + code if @use_strict
+
+        module_id = @module_id_generator.call(input)
+
+        if @string_module
+          contents = %{(function() {#{code}\n})();\n/*@if (@_jscript) @else @*/\n//@ sourceURL=#{module_id}\n/*@end@*/}.to_json
+        else
+          contents = "function() {#{code}\n}"
+        end
+        ret = "minispade.register('#{module_id}', #{contents});"
+        output.write ret
+      end
+    end
+  end
+end