rake-pipeline-web-filters-fork 0.6.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+node_modules
+.project

data/.rspec

@@ -0,0 +1 @@
+-cfs -r spec_helper.rb

data/.travis.yml

@@ -0,0 +1,11 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+
+bundler_args: --without docs
+
+before_script: npm install -g jade
+
+notifications:
+  email:
+    - wycats@gmail.com

data/.yardopts

@@ -0,0 +1,2 @@
+--readme README.yard
+

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem "rake-pipeline", :git => "git://github.com/livingsocial/rake-pipeline.git"
+
+# Specify your gem's dependencies in rake-pipeline-web-filters.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,58 @@
+# Rake::Pipeline::Web::Filters [![Build Status](https://secure.travis-ci.org/wycats/rake-pipeline-web-filters.png?branch=master)](http://travis-ci.org/wycats/rake-pipeline-web-filters)
+
+This project contains a set of rake-pipeline filters for building web
+apps. 
+
+It includes these filters:
+
+* Cache Buster - Write a fingerprint into each file name
+* Coffescript - Convert Coffeescript to Javascript
+* GZip - Create gzip'd version of your files
+* Handlebars - Process handlebars templates
+* IIFE - Wrap source files in Immediately Invoked Function Expressions
+* Jade - Process Jade templates
+* LESS - Convert LESS to CSS
+* Markdown - Convert Markdown to HTML
+* Minispade - Wrap JS files in Minispade modules
+* Neuter - Require files in a file and generate one single combined file
+* SASS - Convert SASS to CSS
+* Stylus - Convert Stylus to CSS
+* Tilt - Use Tilt to process 
+* Uglify - Minify JS
+* YUI CSS - Minify CSS
+* YUI Javascript - Minify JS
+
+Here's a quick example of a realistic project's Assetfile:
+
+```ruby
+# Assetfile
+require 'rake-pipeline-web-filters'
+
+output "site"
+
+input "javascripts" do
+  match "**/*.coffee" do
+    coffee_script
+  end
+
+  match "**/*.js" do
+    minispade
+    concat "application.js"
+    uglify
+  end
+end
+
+input "stylesheets" do
+  match "**/*.sass" do
+    sass
+  end
+
+  match "**/*.css" do
+    concat "application.css"
+    yui_css
+  end
+end
+```
+
+API documentation is hosted at
+<a href="http://rubydoc.info/github/wycats/rake-pipeline-web-filters/master/file/README.yard">rubydoc.info</a>

data/README.yard

@@ -0,0 +1,25 @@
+= Rake::Pipeline::Web::Filters
+
+Rake::Pipeline::Web::Filters is a collection of filters for Rake::Pipeline
+for creating pipelines to generate web content.
+
+= Usage
+
+In your +Assetfile+:
+
+  !!!ruby
+  require "rake-pipeline-web-filters"
+
+  input "assets"
+  output "public"
+
+  # Take all JS inputs and wrap each of them in code to
+  # register them with the Minispade module loader.
+  match "*.js" do
+    filter Rake::Pipeline::Web::Filters::MinispadeFilter
+  end
+
+  # Take all SCSS inputs and compile them with Sass
+  match "*.scss" do
+    filter Rake::Pipeline::Web::Filters::SassCompiler
+  end

data/Rakefile

@@ -0,0 +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

@@ -0,0 +1,31 @@
+require "rake-pipeline"
+
+module Rake
+  class Pipeline
+    module Web
+      module Filters
+      end
+    end
+  end
+end
+
+require "rake-pipeline-web-filters/version"
+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/neuter_filter"
+require "rake-pipeline-web-filters/sass_filter"
+require "rake-pipeline-web-filters/stylus_filter"
+require "rake-pipeline-web-filters/jade_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
+