rake-pipeline-web-filters 0.5.0 → 0.7.0

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+node_modules
+.project

data/Gemfile

@@ -4,3 +4,4 @@ source "http://rubygems.org"
 gemspec
 
 gem "rake-pipeline", :git => "git://github.com/livingsocial/rake-pipeline.git"
+gem "pry"

data/Rakefile

@@ -1,2 +1,10 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require "bundler/setup"
+
+desc "run the specs"
+task :spec do
+  sh "rspec -cfs spec"
+end
+
+task :default => :spec

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

@@ -10,7 +10,21 @@ module Rake
 end
 
 require "rake-pipeline-web-filters/version"
-require "rake-pipeline-web-filters/tilt_filter"
-require "rake-pipeline-web-filters/sass_compiler"
+require "rake-pipeline-web-filters/cache_buster_filter"
+require "rake-pipeline-web-filters/filter_with_dependencies"
+require "rake-pipeline-web-filters/markdown_filter"
 require "rake-pipeline-web-filters/minispade_filter"
-require "rake-pipeline-web-filters/ordering_concat_filter"
+require "rake-pipeline-web-filters/neuter_filter"
+require "rake-pipeline-web-filters/sass_filter"
+require "rake-pipeline-web-filters/stylus_filter"
+require "rake-pipeline-web-filters/tilt_filter"
+require "rake-pipeline-web-filters/coffee_script_filter"
+require "rake-pipeline-web-filters/yui_javascript_filter"
+require "rake-pipeline-web-filters/yui_css_filter"
+require "rake-pipeline-web-filters/gzip_filter"
+require "rake-pipeline-web-filters/uglify_filter"
+require "rake-pipeline-web-filters/chained_filter"
+require "rake-pipeline-web-filters/less_filter"
+require "rake-pipeline-web-filters/handlebars_filter"
+require "rake-pipeline-web-filters/iife_filter"
+require "rake-pipeline-web-filters/helpers"

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

@@ -0,0 +1,42 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that inserts a cache-busting key into the outputted file name.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets"
+  #     output "public"
+  #
+  #     filter Rake::Pipeline::Web::Filters::CacheBusterFilter
+  #   end
+  class CacheBusterFilter < Rake::Pipeline::Filter
+
+    # @return [Proc] the default cache key generator, which
+    #   takes the MD5 hash of the input's file name and contents.
+    DEFAULT_KEY_GENERATOR = proc { |input|
+      require 'digest/md5'
+      Digest::MD5.new << input.path << input.read
+    }
+
+    # @param [Proc] key_generator a block to use as the Filter's method of
+    #   turning input file wrappers into cache keys; defaults to
+    #   +DEFAULT_KEY_GENERATOR+
+    def initialize(&key_generator)
+      key_generator ||= DEFAULT_KEY_GENERATOR
+      output_name_generator = proc { |path, file|
+        parts = path.split('.')
+        index_to_modify = parts.length > 1 ? -2 : -1
+        parts[index_to_modify] << "-#{key_generator.call(file)}"
+        parts.join('.')
+      }
+      super(&output_name_generator)
+    end
+
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        output.write input.read
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,116 @@
+module Rake::Pipeline::Web::Filters
+  # Implement the FileWrapper API. Because filters are defined
+  # in terms of the FileWrapper API, we can implement an
+  # alternative that doesn't write to disk but still utilizes
+  # the same filter definitions.
+  class MemoryFileWrapper < Struct.new(:root, :path, :encoding, :body)
+    def with_encoding(new_encoding)
+      self.class.new(root, path, new_encoding, body)
+    end
+
+    def fullpath
+      File.join(root, path)
+    end
+
+    def create
+      self.body = ""
+      yield
+    end
+
+    alias read body
+
+    def write(contents)
+      self.body << contents
+    end
+  end
+
+  # The purpose of ChainedFilter is to enable filters to
+  # be applied to files based upon their file extensions.
+  #
+  # Filters are applied repeatedly to files for each
+  # extension.
+  #
+  # @example
+  #
+  #   filter ChainedFilter, :types => {
+  #     :erb => ErbFilter,
+  #     :coffee => CoffeeFilter,
+  #     :scss => ScssFilter
+  #   }
+  #
+  # In this example, files with the extensions +erb+,
+  # +coffee+, and +scss+ will be processed using the
+  # specified filters. If a file has multiple extensions,
+  # all of the filters will be applied.
+  #
+  # For example, with the above filter specification,
+  # a file like +application.js.coffee.erb+ will first
+  # apply the +ErbFilter+, then the +CoffeeFilter+, and
+  # then output +application.js+.
+  #
+  # This filter is largely designed for use with the
+  # {ProjectHelpers#register register} helper, which
+  # will transparently add a ChainedFilter before each
+  # input block with the registered extensions.
+  class ChainedFilter < Rake::Pipeline::Filter
+    attr_reader :filters
+
+    # @param [Hash] options
+    # @option options [Hash] :types
+    #   A hash of file extensions and their associated
+    #   filters. See the class description for more
+    #   information.
+    def initialize(options={}, &block)
+      @filters = options[:types]
+
+      keys = @filters.keys
+      pattern = keys.map { |key| "\\.#{key}" }.join("|")
+      @pattern = Regexp.new("(#{pattern})*$", "i")
+
+      block ||= proc do |input|
+        input.sub(@pattern, '')
+      end
+
+      super(&block)
+    end
+
+    # @private
+    #
+    # Implement +generate_output+
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        output.write process_filters(input)
+      end
+    end
+
+    # @private
+    #
+    # Process an input file by applying the filter for each
+    # extension in the file.
+    def process_filters(input)
+      keys = input.path.match(@pattern)[0].scan(/(?<=\.)\w+/)
+
+      filters = keys.reverse_each.map do |key|
+        @filters[key.to_sym]
+      end
+
+      filters.each do |filter|
+        input = process_with_filter(input, filter)
+      end
+
+      input.read
+    end
+
+    # @private
+    #
+    # Process an individual file with a filter.
+    def process_with_filter(input, filter_class)
+      filter = filter_class.new
+
+      output = MemoryFileWrapper.new("/output", input.path, "UTF-8")
+      output.create { filter.generate_output([input], output) }
+
+      output
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Rake::Pipeline::Web::Filters
+  # A filter that compiles CoffeeScript to JavaScript.
+  class CoffeeScriptFilter < Rake::Pipeline::Filter
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    # @return [Hash] a hash of options to pass to CoffeeScript when
+    #   rendering.
+    attr_reader :options
+
+    # By default, the CoffeeScriptFilter converts inputs
+    # with the extension +.coffee+ to +.js+.
+    #
+    # @param [Hash] options options to pass to the CoffeeScript
+    #   compiler.
+    # @param [Proc] block the output name generator block
+    def initialize(options = {}, &block)
+      block ||= proc { |input| input.sub(/\.coffee$/, '.js') }
+      super(&block)
+      @options = options
+    end
+
+    # The body of the filter. Compile each input file into
+    # a CoffeeScript compiled output file.
+    #
+    # @param [Array] inputs an Array of FileWrapper objects.
+    # @param [FileWrapper] output a FileWrapper object
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        begin
+          output.write CoffeeScript.compile(input, options)
+        rescue ExecJS::Error => error
+          raise error, "Error compiling #{input.path}. #{error.message}"
+        end
+      end
+    end
+
+    def external_dependencies
+      [ "coffee-script" ]
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Rake::Pipeline::Web::Filters
+  # A mixin for filters that have dependencies on external
+  # libraries. Include this module in the filter class and
+  # declare a private `external_dependencies` method that
+  # returns an array of strings. Each one will be passed
+  # to `Kernel#require` when an instance of the filter
+  # is created.
+  module FilterWithDependencies
+
+    def initialize(*args, &block)
+      require_dependencies!
+      super(*args, &block)
+    end
+
+    private
+
+    def require_dependencies!
+      external_dependencies.each do |d|
+        begin
+          require d
+        rescue LoadError => error
+          raise error, "#{self.class} requires #{d}, but it is not available."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'rake-pipeline-web-filters/filter_with_dependencies'
+
+module Rake::Pipeline::Web::Filters
+  # A filter that gzips input files using zlib
+  #
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Compress each JS file under the app/assets
+  #     # directory.
+  #     filter Rake::Pipeline::Web::Filters::GzipFilter
+  #   end
+  class GzipFilter < Rake::Pipeline::Filter
+
+    include Rake::Pipeline::Web::Filters::FilterWithDependencies
+
+    processes_binary_files
+
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(&block)
+      block ||= proc { |input| input.sub(/\.(.*)$/, '.\1.gz') }
+      super(&block)
+    end
+
+    # Implement the {#generate_output} method required by
+    # the {Filter} API. Compresses each input file with
+    # Zlib.GzipWriter.
+    #
+    # @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|
+        # gzip input file to stream
+        fakefile = StringIO.new
+        gz = Zlib::GzipWriter.new(fakefile)
+        gz.write(input.read)
+        gz.close
+
+        # send gzipped contents to output
+        output.write fakefile.string
+      end
+    end
+
+  private
+
+    def external_dependencies
+      [ 'stringio', 'zlib' ]
+    end
+  end
+end
+

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

@@ -5,7 +5,7 @@ module Rake::Pipeline::Web::Filters
   # Instead of:
   #   !!!ruby
   #   match("*.scss") do
-  #     filter Rake::Pipeline::Web::Filters::SassCompiler, :syntax => :sass
+  #     filter Rake::Pipeline::Web::Filters::SassFilter, :syntax => :sass
   #   end
   #
   # You can do:
@@ -13,38 +13,120 @@ module Rake::Pipeline::Web::Filters
   #   match("*.scss") do
   #     sass :syntax => :sass
   #   end
-  module Helpers
-    # If the first argument is an Array, add a new {OrderingConcatFilter}
-    # to the pipeline. Otherwise add a new {Rake::Pipeline::ConcatFilter}.
-    # @see OrderingConcatFilter#initialize
-    # @see Rake::Pipeline::ConcatFilter#initialize
-    def concat(*args, &block)
-      if args.first.kind_of?(Array)
-        filter(Rake::Pipeline::Web::Filters::OrderingConcatFilter, *args, &block)
-      else
-        filter(Rake::Pipeline::ConcatFilter, *args, &block)
-      end
-    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 {SassCompiler} to the pipeline.
-    # @see SassCompiler#initialize
+    # 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::SassCompiler, *args, &block)
+      filter(Rake::Pipeline::Web::Filters::SassFilter, *args, &block)
     end
     alias_method :scss, :sass
 
+    # 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
 
-Rake::Pipeline::DSL.send(:include, Rake::Pipeline::Web::Filters::Helpers)
+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)