rake-pipeline-web-filters 0.5.0 → 0.7.0

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/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

@@ -9,7 +9,7 @@ module Rake::Pipeline::Web::Filters
   #     output "public"
   #
   #     # Wrap each JS file in a minispade.register closure.
-  #     filter Rake::Pipeleine::Web::Filters::MinispadeFilter
+  #     filter Rake::Pipeline::Web::Filters::MinispadeFilter
   #   end
   class MinispadeFilter < Rake::Pipeline::Filter
 
@@ -18,11 +18,18 @@ module Rake::Pipeline::Web::Filters
     #   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]
+      @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
@@ -37,9 +44,18 @@ module Rake::Pipeline::Web::Filters
     def generate_output(inputs, output)
       inputs.each do |input|
         code = input.read
-        code = '"use strict"; ' + code if @use_strict
-        function = "function() { #{code} }"
-        ret = "minispade.register('#{@module_id_generator.call(input)}',#{function});"
+        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//@ sourceURL=#{module_id}}.to_json
+        else
+          contents = "function() {#{code}\n}"
+        end
+        ret = "minispade.register('#{module_id}', #{contents});"
         output.write ret
       end
     end

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

@@ -0,0 +1,110 @@
+module Rake::Pipeline::Web::Filters
+
+  class NeuterBatch
+    def initialize(config, known_files)
+      @config = config || {}
+      @known_files = known_files
+      @required = []
+    end
+
+    def file_wrapper(klass, *args)
+      file = klass.new(*args)
+      file.extend NeuterWrapper
+      file.batch(self)
+      file
+    end
+
+    def required(req)
+      unless @known_files.include?(req)
+        warn "Included '#{req}', which is not listed in :additional_dependencies. The pipeline may not invalidate properly."
+      end
+      @required << req
+    end
+
+    def required?(req)
+      @required.include?(req)
+    end
+
+    def strip_requires(source)
+      requires = []
+      regexp = @config[:require_regexp] || %r{^\s*require\(['"]([^'"]*)['"]\);?\s*}
+      # FIXME: This $1 may not be reliable with other regexps
+      source.gsub!(regexp){ requires << $1; '' }
+      requires
+    end
+
+    def transform_path(path, input)
+      @config[:path_transform] ? @config[:path_transform].call(path, input) : path
+    end
+
+    def closure_wrap(source)
+      @config[:closure_wrap] ? "(function() {\n#{source}\n})();\n\n" : source
+    end
+
+    def filename_comment(input)
+      @config[:filename_comment] ? @config[:filename_comment].call(input) + "\n" : ""
+    end
+  end
+
+  module NeuterWrapper
+    def batch(batch)
+      @batch = batch
+      @batch.required(fullpath)
+    end
+
+    def read
+      source = super
+
+      required_files = @batch.strip_requires(source).map do |req|
+        req_path = @batch.transform_path(req, self)
+        if req_path && !@batch.required?(File.expand_path(req_path, root))
+          @batch.file_wrapper(self.class, root, req_path, encoding).read
+        else
+          nil
+        end
+      end.compact
+
+      file = @batch.filename_comment(self) + @batch.closure_wrap(source)
+
+      (required_files << file).join("\n\n")
+    end
+  end
+
+  # A filter that takes files with requires and collapses them into a single
+  # file without requires.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     filter Rake::Pipeline::Web::Filters::NeuterFilter, "neutered.js"
+  #   end
+  class NeuterFilter < Rake::Pipeline::ConcatFilter
+    def initialize(string=nil, config={}, &block)
+      if string.is_a?(Hash)
+        config = string
+        string = nil
+      end
+
+      @config = config
+
+      super(string, &block)
+    end
+
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        known_files = [input.fullpath] + additional_dependencies(input)
+        batch = NeuterBatch.new(@config, known_files)
+        file = batch.file_wrapper(file_wrapper_class, input.root, input.path, input.encoding)
+        output.write file.read
+      end
+    end
+
+    def additional_dependencies(input)
+      method = @config[:additional_dependencies]
+      method ? method.call(input).map{|p| File.expand_path(p, input.root) } : []
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that compiles input files written in SCSS
+  # to CSS using the Sass compiler and the Compass CSS
+  # framework.
+  #
+  # Requires {http://rubygems.org/gems/sass sass} and
+  # {http://rubygems.org/gems/compass compass}
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.scss"
+  #     output "public"
+  #
+  #     # Compile each SCSS file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::SassFilter
+  #   end
+  class SassFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options to pass to Sass
+    #   when compiling.
+    attr_reader :options, :additional_load_paths
+
+    # @param [Hash] options options to pass to the Sass
+    #   compiler
+    # @option options [Array] :additional_load_paths a
+    #   list of paths to append to Sass's :load_path.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      block ||= proc { |input| input.sub(/\.(scss|sass)$/, '.css') }
+      super(&block)
+
+      @options = compass_options
+      @additional_load_paths = Array(options.delete(:additional_load_paths))
+      @options[:load_paths].concat(@additional_load_paths)
+      @options.merge!(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 Sass.compile(input.read, sass_options_for_file(input))
+      end
+    end
+
+    def additional_dependencies(input)
+      engine = Sass::Engine.new(input.read, sass_options_for_file(input))
+      engine.dependencies.map { |dep| dep.options[:filename] }
+    end
+
+  private
+
+    def external_dependencies
+      [ 'sass', 'compass' ]
+    end
+
+    # @return the Sass options for the current Compass
+    #   configuration.
+    def compass_options
+      Compass.add_project_configuration
+      Compass.configuration.to_sass_engine_options
+    end
+
+    # @return the Sass options for the given +file+.
+    #   Adds a +:syntax+ option if the filter's options
+    #   don't already include one.
+    def sass_options_for_file(file)
+      added_opts = {
+        :filename => file.fullpath,
+        :syntax => file.path.match(/\.sass$/) ? :sass : :scss
+      }
+      added_opts.merge(@options)
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that compiles input files written in Stylus
+  # to CSS using the Stylus compiler
+  #
+  # Requires http://rubygems.org/gems/stylus
+  #
+  # You will need the `node` command on your runtime
+  # for this to work. See https://github.com/lucasmazza/ruby-stylus
+  # for more information.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.styl"
+  #     output "public"
+  #
+  #     # Compile each Stylus file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::StylusFilter
+  #   end
+  class StylusFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+    
+    attr_reader :options
+
+    # @param [Hash] options options to pass to Stylus
+    # @option options [Array] :use Plugins to import from Node
+    # @option options [Boolean] :debug Output debug info
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      block ||= proc { |input| input.sub(/\.(styl)$/, '.css') }
+      super(&block)
+      @options = options
+    end
+
+    def generate_output(inputs, output)
+      options.each do |key, value|
+        if key == :use
+          Stylus.send key, *value
+          next
+        end
+        Stylus.send "#{key}=", value
+      end
+      inputs.each do |input|
+        output.write Stylus.compile(input.read)
+      end
+    end
+
+  private
+
+    def external_dependencies
+      [ 'stylus' ]
+    end
+    
+  end
+end