rake-pipeline-web-filters-fork 0.6.0

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

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

@@ -0,0 +1,70 @@
+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 {http://rubygems.org/gems/tilt/ tilt}
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.scss"
+  #     output "public"
+  #
+  #     # Compile each SCSS file using Tilt, replacing the
+  #     # scss extension with css.
+  #     filter(Rake::Pipeline::Web::Filters::TiltFilter) do |input|
+  #       input.sub(/\.scss$/, 'css')
+  #     end
+  #   end
+  class TiltFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options to pass to Tilt
+    #   when rendering.
+    attr_reader :options
+
+    # @return [Object] an object to use as the rendering
+    #   context.
+    attr_reader :context
+
+    # @param [Hash] options options to pass to the Tilt
+    #   template class constructor.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, context = nil, &block)
+      super(&block)
+      @options = options
+      @context = context || Object.new
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Attempts to compile each input file
+    # with Tilt, passing the file through unchanged if Tilt
+    # can't find a template class for the file.
+    #
+    # @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|
+        out = if (template_class = Tilt[input.path])
+          template_class.new(nil, 1, options) { |t| input.read }.render(context)
+        else
+          input.read
+        end
+
+        output.write out
+      end
+    end
+
+    def external_dependencies
+      [ 'tilt' ]
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that uses the Uglify JS compressor to compress
+  # JavaScript input files.
+  #
+  # Requires {http://rubygems.org/gems/uglifier uglifier}.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Compile each JS file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::UglifyFilter
+  #   end
+  class UglifyFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options to pass to Uglify
+    #   when compiling.
+    attr_reader :options
+
+    # @param [Hash] options options to pass to Uglify
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      block ||= proc { |input| 
+        if input =~ %r{.min.js$}
+          input
+        else
+          input.sub(/\.js$/, '.min.js')
+        end
+      }
+
+      @preserve_input = options.delete :preserve_input
+
+      super(&block)
+      @options = options
+    end
+
+    def should_skip_minify?(input, output)
+      (@preserve_input && input.path == output.path) ||
+      input.path =~ %r{.min.js$}
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Compiles each input file with Uglify.
+    #
+    # @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|
+        if should_skip_minify?(input, output)
+          output.write input.read
+        else
+          output.write Uglifier.compile(input.read, options)
+        end
+      end
+    end
+
+    private
+
+    def output_paths(input)
+      paths = super(input)
+      if @preserve_input
+        raise 'cannot preserve unminified input if output path is not different' if paths.include?(input.path)
+        paths.unshift(input.path)
+      end
+      paths
+    end
+
+    def external_dependencies
+      [ 'uglifier' ]
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Rake
+  class Pipeline
+    module Web
+      module Filters
+        VERSION = "0.6.0"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that compresses CSS input files using
+  # the YUI CSS compressor.
+  #
+  # Requires {https://rubygems.org/gems/yui-compressor yui-compressor}
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Compress each CSS file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::YUICssFilter
+  #   end
+  class YUICssFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options to pass to the
+    #   YUI compressor when compressing.
+    attr_reader :options
+
+    # @param [Hash] options options to pass to the YUI
+    #   CSS compressor.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(options={}, &block)
+      block ||= proc { |input| 
+        if input =~ %r{min.css$}
+          input
+        else
+          input.sub /\.css$/, '.min.css'
+        end
+      }
+
+      super(&block)
+      @options = options
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Compresses each input file with
+    # the YUI CSS compressor.
+    #
+    # @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)
+      compressor = YUI::CssCompressor.new(options)
+      inputs.each do |input|
+        if input.path !~ /min\.css/
+          output.write compressor.compress(input.read)
+        else
+          output.write input.read
+        end
+      end
+    end
+
+  private
+
+    def external_dependencies
+      [ 'yui/compressor' ]
+    end
+  end
+end
+