extruder 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+Gemfile.lock
+.bundle
+.config

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,71 @@
+# A simplified rewrite of Yehuda Katz & Tom Dale's awesome rake-pipeline gem.
+
+...documentation / server / executable / assetfile support / tests etc coming.
+
+## A trip through the extruder looks like this:
+
+1. Define input directories to be processed.
+2. Define output directory for processed files.
+3. Define matches with file globs (ie: *.js) to determine which files from the input directories will be processed.
+4. Define filters within each match block that will process files.
+5. When processing an Extruder instance, the first step is to create a FileSet of eligible files from the input directories.
+6. As each match block is opened, the files that matched the glob are removed from the FileSet and passed in.
+7. As each filter is run, the files created by the previous filter are passed on to the next.
+4. As each match block is closed, the filter-created/modified files are added to the Extruder's FileSet.
+5. After the final match block has run, FileSet.create is called, writing the filtered files to disk.
+
+Extruder layout:
+
+```ruby
+inputs      => {'app/js'=>'*/**','app/css'=>'*/**'},
+output_root => 'build',
+matches     => [
+  { glob: "*.js", filters: [<ConcatFilter>] },
+  { glob: "*.txt", filters: [<ClosureFilter>,<CopyFilter>,<CopyFilter>] }
+]
+```
+
+## New concepts
+FileSets contain an array of FileWrappers.  A FileSet instance has a glob value (ie: *.js) which is transformed into a regular expression that can be used to determine which files match.  An array of matching FileWrappers can be retrieved any time by calling the instance function 'eligible_files'
+
+FileWrappers write to the instance variable @contents until the instance function create is called, at which point @contents is dumped to the output_root+path.
+
+All filtering occurs in memory.
+
+## Junky proof of concept trial run:
+
+1. Build and install gem
+2. Grab the emberjs/todos repo
+3. Load irb in its root
+4. Run this
+
+```ruby
+require 'extruder'
+require 'json'
+class ClosureFilter < Extruder::Filter
+  def generate_output(inputs, output)
+    inputs.each do |input|
+      output.write "(function() { #{input.read.to_json} })()"
+    end
+  end
+end
+
+extruder = Extruder.build do
+  input "app"
+  output "output"
+  match "*.js" do
+    concat "test.txt"
+  end
+  match "*.txt" do
+    filter ClosureFilter
+    copy "1.txt"
+    copy "2.txt"
+  end
+end
+
+# show resulting fileset
+extruder.result
+
+# save resulting fileset
+extruder.result.create
+```

data/extruder.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/extruder/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Yehuda Katz", "Tom Dale", "Tyler Kellen"]
+  gem.email         = ["tyler@sleekcode.net"]
+  gem.description   = "A simple and powerful file pipeline."
+  gem.summary       = "A simple and powerful file pipeline."
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.name          = "extruder"
+  gem.require_paths = ["lib"]
+  gem.version       = Extruder::VERSION
+
+end

data/lib/extruder.rb

@@ -0,0 +1,8 @@
+require 'extruder/version'
+require 'extruder/main'
+require 'extruder/file_wrapper'
+require 'extruder/file_set'
+require 'extruder/filter'
+require 'extruder/filters/concat_filter'
+require 'extruder/filters/ordering_concat_filter'
+require 'extruder/dsl'

data/lib/extruder/dsl.rb

@@ -0,0 +1,155 @@
+module Extruder
+
+  ##
+  #
+  # This class exists purely to provide a convenient DSL for
+  # configuring an extruder.
+  #
+  # All instance methods of {DSL} are available in the context
+  # the block passed to {Extruder.build}
+  #
+  class DSL
+
+    # @return [Extruder::Main] the extruder the DSL should configure
+    attr_reader :extruder
+
+    ##
+    #
+    # Configure an extruder with a passed block.
+    #
+    # @param [extruder] extruder the extruder that the DSL
+    #   should configure.
+    # @param [Proc] block the block describing the
+    #   configuration. This block will be evaluated in
+    #   the context of a new instance of {DSL}
+    # @return [void]
+    #
+    def self.evaluate(extruder, &block)
+      # create instance of self with the pipline passed
+      # and evalute the block within it
+      new(extruder).instance_eval(&block)
+    end
+
+    ##
+    #
+    # Create a new {DSL} to configure an extruder.
+    #
+    # @param [Extruder::Main] extruder the extruder that the DSL
+    #   should configure.
+    # @return [void]
+    #
+    def initialize(extruder)
+      @extruder = extruder
+    end
+
+    ##
+    #
+    # Define the input location and files for the extruder.
+    #
+    # @example
+    #   !!!ruby
+    #   Extruder.build do
+    #     input "app/assets", "**/*.js"
+    #     # ...
+    #   end
+    #
+    # @param [String] root the root path where the extruder
+    #   should find its input files.
+    # @param [String] glob a file pattern that represents
+    #   the list of all files that the extruder should
+    #   process within +root+. The default is +"**/*"+.
+    # @return [void]
+    #
+    def input(root, pattern='**/*')
+      extruder.add_input root, pattern
+    end
+
+    ##
+    #
+    # Add a match to the pipeline with a passed block
+    # containing filters that belong to it.
+    #
+    # @example
+    #   !!!ruby
+    #   Extruder.build do
+    #     input "app/assets"
+    #
+    #     match "*.js" do
+    #       concat "app.js"
+    #     end
+    #
+    #   end
+    #
+    # @param [String] root the output directory.
+    # @return [void]
+    #
+    def match(pattern, &block)
+      extruder.add_match pattern
+      block.call
+    end
+
+    ##
+    #
+    # Add a filter to the pipeline, normally called from
+    # within a match block.  If a filter is added without
+    # a match block, the Extruder will automatically create
+    # one that matches all input files.
+    #
+    # In addition to a filter class, {#filter} takes a
+    # block that describes how the filter should map
+    # input files to output files.
+    #
+    # By default, the block maps an input file into
+    # an output file with the same name.
+    #
+    # Any additional arguments passed to {#filter} will
+    # be passed on to the filter class's constructor.
+    #
+    # @see Filter#outputs Filter#output (for an example
+    #   of how a list of input files gets mapped to
+    #   its outputs)
+    #
+    # @param [Class] filter_class the class of the filter.
+    # @param [Array] ctor_args a list of arguments to pass
+    #   to the filter's constructor.
+    # @param [Proc] block an output file name generator.
+    # @return [void]
+    #
+    def filter(filter_class, *ctor_args, &block)
+      filter = filter_class.new(*ctor_args, &block)
+      extruder.add_filter(filter)
+    end
+
+    ##
+    #
+    # Specify the output directory for the pipeline.
+    #
+    # @param [String] root the output directory.
+    # @return [void]
+    #
+    def output(root)
+      extruder.output_root = root
+    end
+
+    ##
+    #
+    # A helper method for adding a concat filter to
+    # the Extruder.
+    # If the first argument is an Array, it adds a new
+    # {OrderingConcatFilter}, otherwise it adds a new
+    # {ConcatFilter}.
+    #
+    # @see OrderingConcatFilter#initialize
+    # @see ConcatFilter#initialize
+    #
+    def concat(*args, &block)
+      if args.first.kind_of?(Array)
+        filter(OrderingConcatFilter, *args, &block)
+      else
+        filter(ConcatFilter, *args, &block)
+      end
+    end
+    alias_method :copy, :concat
+
+  end
+end

data/lib/extruder/errors.rb

@@ -0,0 +1,13 @@
+module Extruder
+  # The general Extruder error class
+  class Error < ::StandardError
+  end
+  # The error that Extruder uses when it detects
+  # that a file uses an improper encoding.
+  class EncodingError < Error
+  end
+  # The error that Extruder uses if you try to
+  # write to a FileWrapper before creating it.
+  class UnopenedFile < Error
+  end
+end

data/lib/extruder/file_set.rb

@@ -0,0 +1,141 @@
+require "strscan"
+
+module Extruder
+
+  ##
+  #
+  # This class contains an array of {FileWrapper}s which can be
+  # searched with a glob.
+  #
+  class FileSet
+
+    # @return [Array[FileWrapper]] an array of FileWrapped files
+    attr_accessor :files
+
+    # @return [String] a glob that a set of input files are matched against
+    attr_accessor :glob
+
+    # @return [String] regular expression pattern to match against input files
+    attr_reader :pattern
+
+    def initialize(files, glob='**/*')
+      @files = files
+      self.glob = glob
+    end
+
+    def glob=(glob)
+      @glob = glob
+      @pattern = build_pattern(glob)
+    end
+
+    # Build a regular expression pattern from a file glob that
+    # can be used to narrow a selection of files from a Extruder.
+    def build_pattern(glob)
+
+      scanner = StringScanner.new(glob)
+
+      output, pos = "", 0
+
+      # keep scanning until end of String
+      until scanner.eos?
+
+        # look for **/, *, {...}, or the end of the string
+        new_chars = scanner.scan_until %r{
+            \*\*/
+          | /\*\*/
+          | \*
+          | \{[^\}]*\}
+          | $
+        }x
+
+        # get the new part of the string up to the match
+        before = new_chars[0, new_chars.size - scanner.matched_size]
+
+        # get the match and new position
+        match = scanner.matched
+        pos = scanner.pos
+
+        # add any literal characters to the output
+        output << Regexp.escape(before) if before
+
+        output << case match
+        when "/**/"
+          # /**/ matches either a "/" followed by any number
+          # of characters or a single "/"
+          "(/.*|/)"
+        when "**/"
+          # **/ matches the beginning of the path or
+          # any number of characters followed by a "/"
+          "(^|.*/)"
+        when "*"
+          # * matches any number of non-"/" characters
+          "[^/]*"
+        when /\{.*\}/
+          # {...} is split over "," and glued back together
+          # as an or condition
+          "(" + match[1...-1].gsub(",", "|") + ")"
+        else String
+          # otherwise, we've grabbed until the end
+          match
+        end
+      end
+
+      if glob.include?("/")
+        # if the pattern includes a /, it must match the
+        # entire input, not just the end.
+        @pattern = Regexp.new("^#{output}$", "i")
+      else
+        # anchor the pattern either at the beginning of the
+        # path or at any "/" character
+        @pattern = Regexp.new("(^|/)#{output}$", "i")
+      end
+    end
+
+    ##
+    #
+    # A list of eligible files based on the current glob
+    #
+    # @return [Array<FileWrapper>]
+    #
+    def eligible_files
+      files.select do |file|
+        file.path =~ @pattern
+      end
+    end
+
+    ##
+    #
+    # Remove eligible files from this {FileSet} and return them
+    #
+    # @return [Array<FileWrapper>]
+    #
+    def extract_eligible
+      keep = eligible_files
+      @files -= keep
+      keep
+    end
+
+    ##
+    #
+    # Select files in this {FileSet} which will be saved to disk
+    # if {#create} is run.  The save flag is set true for any file
+    # that passed through a filter.
+    #
+    # @return [Array<FileWrapper>]
+    #
+    def will_save
+      files.select { |file| file.save }
+    end
+
+    ##
+    #
+    # Write all files in this {FileSet} to their output_root.
+    #
+    def create
+      will_save.each do |file|
+        file.create
+      end
+    end
+
+  end
+end

data/lib/extruder/file_wrapper.rb

@@ -0,0 +1,191 @@
+require 'fileutils'
+
+module Extruder
+
+  ##
+  #
+  # This class wraps a file for consumption inside of filters. It is
+  # initialized with a root and path, and filters usually use the
+  # {#read} and {#write} methods to work with these files.
+  #
+  # The {#root} and +path+ parameters are provided by the {Extruder}
+  # class' internal implementation.  Individual filters do not need
+  # to worry about them.
+  #
+  # The root of a {FileWrapper} is always an absolute path.
+  #
+  class FileWrapper
+    # @return [String] an absolute path representing this {FileWrapper}'s
+    #   root directory.
+    attr_accessor :root
+
+    # @return [String] the path to the file represented by the {FileWrapper}
+    #   relative to its {#root}.
+    attr_accessor :path
+
+    # @return [String] contents of the file represented by the {FileWrapper}
+    attr_accessor :contents
+
+    # @return [String] the encoding that the file represented by this
+    #   {FileWrapper} is encoded in. Filters set the {#encoding} to
+    #   +BINARY+ if they are declared as processing binary data.
+    attr_accessor :encoding
+
+    # @return [Boolean] true if created by a filter, otherwise false
+    #   this flag determines if a file will be written when its container
+    #   {FileSet} is saved.
+    attr_accessor :save
+
+    # @return [String] A pretty representation of the {FileWrapper}.
+    def inspect
+      "#<FileWrapper root=#{root.inspect} path=#{path.inspect} encoding=#{encoding.inspect}>"
+    end
+    alias to_s inspect
+
+    ##
+    #
+    # Create a new {FileWrapper}, passing in optional root, path, and
+    # encoding. Any of the parameters can be ommitted and supplied later.
+    #
+    # @return [void]
+    #
+    def initialize(root=nil, path=nil, encoding="UTF-8")
+      @root, @path, @encoding = root, path, encoding
+      @created_file = nil
+      @save = false
+    end
+
+    ##
+    #
+    # Create a new {FileWrapper} with the same root and path as
+    # this {FileWrapper}, but with a specified encoding.
+    #
+    # @param [String] encoding the encoding for the new object
+    # @return [FileWrapper]
+    #
+    def with_encoding(encoding)
+      self.class.new(@root, @path, encoding)
+    end
+
+    ##
+    #
+    # A {FileWrapper} is equal to another {FileWrapper} for hashing purposes
+    # if they have the same {#root} and {#path}
+    #
+    # @param [FileWrapper] other another {FileWrapper} to compare.
+    # @return [true,false]
+    #
+    def eql?(other)
+      return false unless other.is_a?(self.class)
+      root == other.root && path == other.path
+    end
+    alias == eql?
+
+    ##
+    #
+    # Similar to {#eql?}, generate a {FileWrapper}'s {#hash} from its {#root}
+    # and {#path}
+    #
+    # @see #eql?
+    # @return [Fixnum] a hash code
+    #
+    def hash
+      [root, path].hash
+    end
+
+    ##
+    #
+    # The full path of a FileWrapper is its root joined with its path
+    #
+    # @return [String] the {FileWrapper}'s full path
+    #
+    def fullpath
+      raise "#{root}, #{path}" unless root =~ /^\//
+      File.join(root, path)
+    end
+
+    ##
+    #
+    # Make FileWrappers sortable
+    #
+    # @param [FileWrapper] other {FileWrapper FileWrapper}
+    # @return [Fixnum] -1, 0, or 1
+    #
+    def <=>(other)
+      [root, path, encoding] <=> [other.root, other.path, other.encoding]
+    end
+
+    ##
+    #
+    # Does the file represented by the {FileWrapper} exist in the file system?
+    #
+    # @return [true,false]
+    #
+    def exists?
+      File.exists?(fullpath)
+    end
+
+    ##
+    #
+    # Read the contents of the file represented by the {FileWrapper}.
+    #
+    # Read the file using the {FileWrapper}'s encoding, which will result in
+    # this method returning a +String+ tagged with the {FileWrapper}'s encoding.
+    #
+    # @return [String] the contents of the file
+    # @raise [EncodingError] when the contents of the file are not valid in the
+    #   expected encoding specified in {#encoding}.
+    #
+    def read
+      if @contents.nil?
+
+        @contents = if "".respond_to?(:encode)
+          File.read(fullpath, :encoding => encoding)
+        else
+          File.read(fullpath)
+        end
+
+        if "".respond_to?(:encode) && !@contents.valid_encoding?
+          raise EncodingError, "The file at the path #{fullpath} is not valid UTF-8. Please save it again as UTF-8."
+        end
+      end
+
+      @contents
+    end
+
+    ##
+    #
+    # Append a string to the cached contents of the file this wrapper
+    # represents.  This method is called repeatedly by a {Filter}'s
+    # +#generate_output+ method.
+    #
+    def write(string)
+      @contents = "" if contents.nil?
+      @contents << string
+    end
+
+    ##
+    #
+    # Create a new file at the {FileWrapper}'s {#fullpath} and fill it
+    # with the value of @contents. If the file already exists, it will
+    # be overwritten.
+    #
+    # @return [File]
+    #
+    def create
+      FileUtils.mkdir_p(File.dirname(fullpath))
+
+      @created_file = if "".respond_to?(:encode)
+        File.open(fullpath, "w:#{encoding}")
+      else
+        File.open(fullpath, "w")
+      end
+
+      @created_file.write(@contents)
+      @created_file.close
+      @created_file
+    end
+
+  end
+
+end

data/lib/extruder/filter.rb

@@ -0,0 +1,172 @@
+module Extruder
+
+  ##
+  #
+  # This abstract class is used for building Filters that will be
+  # assigned to an Extruder.  Their function is to transform one
+  # array of FileWrappers to another.
+  #
+  # @abstract
+  #
+  class Filter
+
+    # @return [Array[FileWrapper]] the files that this filter
+    #   will operate on.
+    attr_accessor :files
+
+    # @return [String] the expanded root path that this
+    #   filter's created files will eventually be written to.
+    attr_accessor :output_root
+
+    # @return [Proc] a block that returns the relative output
+    #   filename for a particular input file. If the block accepts
+    #   just one argument, it will be passed the input's path. If
+    #   it accepts two, it will also be passed the file contents.
+    attr_accessor :output_name_generator
+
+    ##
+    #
+    # Invoke this method in a subclass of Filter to declare that
+    # it expects to work with BINARY data, and that data that is
+    # not valid UTF-8 should be allowed.
+    #
+    # @return [void]
+    #
+    def self.processes_binary_files
+      define_method(:encoding) { "BINARY" }
+    end
+
+    ##
+    #
+    # ...more soon
+    #
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    #
+    def initialize(&block)
+      if self.respond_to?(:external_dependencies)
+        require_dependencies!
+      end
+      block ||= proc { |input| input }
+      @output_name_generator = block
+      @files = []
+    end
+
+    ##
+    #
+    # A hash of output files pointing at their associated input
+    # files. The output names are created by applying the
+    # {#output_name_generator} to each input file.
+    #
+    # For exmaple, if you had the following input files:
+    #
+    #     javascripts/jquery.js
+    #     javascripts/sproutcore.js
+    #     stylesheets/sproutcore.css
+    #
+    # And you had the following {#output_name_generator}:
+    #
+    #     !!!ruby
+    #     filter.output_name_generator = proc do |filename|
+    #       # javascripts/jquery.js becomes:
+    #       # ["javascripts", "jquery", "js"]
+    #       directory, file, ext = file.split(/[\.\/]/)
+    #
+    #       "#{directory}.#{ext}"
+    #     end
+    #
+    # You would end up with the following hash:
+    #
+    #     !!!ruby
+    #     {
+    #       #<FileWrapper path="javascripts.js"> => [
+    #         #<FileWrapper path="javascripts/jquery.js">,
+    #         #<FileWrapper path="javascripts/sproutcore.js">
+    #       ],
+    #       #<FileWrapper path="stylesheets.css"> => [
+    #         #<FileWrapper path="stylesheets/sproutcore.css">
+    #       ]
+    #     }
+    #
+    # @return [Hash{FileWrapper => Array<FileWrapper>}]
+    #
+    def outputs
+      hash = {}
+
+      @files.each do |file|
+        outputs = output_paths(file)
+
+        output_wrappers(file).each do |output|
+          hash[output] ||= []
+          hash[output] << file
+        end
+      end
+
+      hash
+    end
+
+    ##
+    #
+    # For each {FileWrapper} file this filter will create, call
+    # generate_output (defined in subclasses of this) to fill the
+    # @contents.
+    #
+    # These files should be flagged as saveable so the {FileSet} that
+    # they wind up in will know they should ultimately be written to
+    # the output directory.
+    #
+    # @return [Array{FileWrapper}] An array of FileWrapped ouputs for
+    #   this filter.
+    #
+    def process
+      outputs.map do |output, inputs|
+        generate_output(inputs, output)
+        output.save = true
+        output
+      end
+    end
+
+    private
+      def encoding
+        "UTF-8"
+      end
+
+      ##
+      #
+      # ...more soon
+      #
+      # @return [FileWrapper]
+      #
+      def output_wrappers(input)
+        output_paths(input).map do |path|
+          FileWrapper.new(output_root, path, encoding)
+        end
+      end
+
+      ##
+      #
+      # ...more soon
+      #
+      # @return [Array]
+      #
+      def output_paths(input)
+        args = [ input.path ]
+        args << input if output_name_generator.arity == 2
+        Array(output_name_generator.call(*args))
+      end
+
+      ##
+      #
+      # ... more soon
+      #
+      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/extruder/filters/concat_filter.rb

@@ -0,0 +1,139 @@
+module Extruder
+
+  ##
+  #
+  # A built-in filter that simply accepts a series
+  # of inputs and concatenates them into output files
+  # with the output file generator.
+  #
+  # @example
+  #   !!!ruby
+  #   Extruder.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # create a concatenated output file for each
+  #     # directory of inputs.
+  #     filter(Extruder::ConcatFilter) do |input|
+  #       # input files will look something like:
+  #       #   javascripts/admin/main.js
+  #       #   javascripts/admin/app.js
+  #       #   javascripts/users/main.js
+  #       #
+  #       # and the outputs will look like:
+  #       #   javascripts/admin.js
+  #       #   javascripts/users.js
+  #       directory = File.dirname(input)
+  #       ext = File.extname(input)
+  #
+  #       "#{directory}#{ext}"
+  #     end
+  #   end
+  #
+  class ConcatFilter < Extruder::Filter
+    ##
+    #
+    # ... more soon
+    #
+    # @param [String] string the name of the output file to
+    #   concatenate inputs to.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(string=nil, &block)
+      block = proc { string } if string
+      super(&block)
+    end
+
+    # @method encoding
+    # @return [String] the String +"BINARY"+
+    processes_binary_files
+
+    ###
+    #
+    # implement the {#generate_output} method required by
+    # the {Filter} API. In this case, simply loop through
+    # the inputs and write their contents to the output.
+    #
+    # Recall that this method will be called once for each
+    # unique output file.
+    #
+    # @param [Array<FileWrapper>] inputs an Array of
+    #   {FileWrapper} objects representing the inputs to
+    #   this filter.
+    # @param [FileWrapper] a single {FileWrapper} object
+    #   representing the output.
+    #
+    def generate_output(inputs, output)
+      inputs.each do |input|
+        output.write input.read
+      end
+    end
+  end
+end
+
+
+module Extruder
+  # 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 < Extruder::Filter
+
+    # @return [Hash] a hash of options to pass to Sass
+    #   when compiling.
+    attr_reader :options
+
+    # @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)
+      Compass.add_project_configuration
+      @options = Compass.configuration.to_sass_engine_options
+      @options[:load_paths].concat(Array(options.delete(: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|
+        sass_opts = if input.path.match(/\.sass$/)
+          options.merge(:syntax => :sass)
+        else
+          options
+        end
+        output.write Sass.compile(input.read, sass_opts)
+      end
+    end
+
+    private
+
+    def external_dependencies
+      [ 'sass', 'compass' ]
+    end
+  end
+end

data/lib/extruder/filters/ordering_concat_filter.rb

@@ -0,0 +1,50 @@
+module Extruder
+
+  ##
+  #
+  # A filter that concats files in a specified order.
+  #
+  # @example
+  #   !!!ruby
+  #   Extruder.build do
+  #     input "app/assets"
+  #     output "public"
+  #
+  #     # Concat each file into libs.js but make sure
+  #     # that jQuery and Ember come first.
+  #     match "**/*.js"
+  #       filter Rake::Extruder::OrderingConcatFilter, ["jquery.js", "ember.js"], "libs.js"
+  #     end
+  #   end
+  #
+  class OrderingConcatFilter < ConcatFilter
+
+    ##
+    #
+    # @param [Array<String>] ordering an Array of Strings
+    #   of file names that should come in the specified order
+    # @param [String] string the name of the output file to
+    #   concatenate inputs to.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    #
+    def initialize(ordering, string=nil, &block)
+      @ordering = ordering
+      super(string, &block)
+    end
+
+    ##
+    #
+    # Extend the {#generate_output} method supplied by {ConcatFilter}.
+    # Re-orders the inputs such that the specified files come first.
+    # If a file is not in the list it will come after the specified files.
+    #
+    def generate_output(inputs, output)
+      @ordering.reverse.each do |name|
+        file = inputs.find{|i| i.path == name }
+        inputs.unshift(inputs.delete(file)) if file
+      end
+      super
+    end
+  end
+end

data/lib/extruder/main.rb

@@ -0,0 +1,166 @@
+module Extruder
+
+  ##
+  #
+  # Build a new Extruder taking a block. The block will be evaluated
+  # by Extruder::DSL.
+  #
+  # @example
+  #   Extruder.build do
+  #     input "app"
+  #     output "public"
+  #
+  #     match "*.js"
+  #       concat "app.js"
+  #     end
+  #   end
+  #
+  #   All instance methods of Extruder::DSL are available inside
+  #   the build block.
+  #
+  # @return [Extruder] the newly configured Extruder
+  #
+  def self.build(&block)
+    extruder = Main.new
+    DSL.evaluate(extruder, &block) if block
+    extruder
+  end
+
+  ##
+  #
+  # The main Extruder class, this is where everything gets tied together.
+  #
+  class Main
+
+    # @return [Hash[String, String]] the directory paths for the input files
+    #   and their matching globs.
+    attr_accessor :inputs
+
+    # @return [[{:glob=>"",:filters=>[Filter,Filter]}]] this Extruder's matches
+    #   and the filters they contain.
+    attr_accessor :matches
+
+    # @return [String] this Extruder's output directory
+    attr_reader :output_root
+
+    ##
+    #
+    # Initalize matches and inputs on instantiation.
+    #
+    def initialize
+      @matches = []
+      @inputs = {}
+    end
+
+    ##
+    #
+    # Set the output root of this Extruder and expand its path.
+    #
+    # @param [String] root this Extruder's output root
+    #
+    def output_root=(root)
+      @output_root = File.expand_path(root)
+    end
+
+    ##
+    #
+    # Add an input directory, optionally filtering which files within
+    # the input directory are included.
+    #
+    # @param [String] root the input root directory; required
+    # @param [String] pattern a pattern to match within +root+;
+    #   optional; defaults to "**/*"
+    #
+    def add_input(root, pattern='**/*')
+      @inputs[root] = pattern
+    end
+
+    ##
+    #
+    # Add a match and initialize it's filters to an array.
+    #
+    # @param [String] glob the file glob to match with
+    #
+    def add_match(glob)
+      @matches.push({:glob=>glob,:filters=>[]})
+    end
+
+    ##
+    #
+    # Add a filter to the current match.
+    #
+    # @param [Extruder::Filter] filter a filter to run
+    #
+    def add_filter(filter)
+      # add a match that accepts everything if none are specified
+      add_match('**/*') if @matches.empty?
+      @matches.last[:filters].push(filter)
+    end
+
+    ##
+    #
+    # Return a sorted array of FileWrappers representing all files
+    # in the input paths.
+    #
+    # @return [Array[FileWrapper]]
+    #
+    def input_files
+
+      if inputs.empty?
+        raise Extruder::Error, "You cannot get input files without " \
+                               "first providing an input root"
+      end
+
+      result = []
+
+      @inputs.each do |root, glob|
+        expanded_root = File.expand_path(root)
+        files = Dir[File.join(expanded_root, glob)].select { |f| File.file?(f) }
+
+        files.each do |file|
+          relative_path = file.sub(%r{^#{Regexp.escape(expanded_root)}/}, '')
+          result << FileWrapper.new(expanded_root, relative_path)
+        end
+      end
+
+      result.sort
+    end
+
+    ##
+    #
+    # Create a {FileSet} from {#input_files}, iterate through matches,
+    # running the filters on the files they contain.
+    #
+    # @return [FileSet] a {FileSet} containing the filtered files.
+    #
+    def result
+      # create a fileset to process filters with
+      fileset = FileSet.new(input_files)
+
+      matches.each do |match|
+
+        # set match on fileset for filter
+        fileset.glob = match[:glob]
+
+        # get files for filter (and remove them from fileset)
+        files = fileset.extract_eligible
+
+        # add the results of this match to the fileset
+        fileset.files += match[:filters].map do |filter|
+
+          # hand filter its files
+          filter.files = files
+
+          # tell filter where to save them
+          filter.output_root = output_root
+
+          # process files and return them for another loop
+          files = filter.process
+        end.flatten
+      end
+
+      fileset
+    end
+
+  end
+end

data/lib/extruder/version.rb

@@ -0,0 +1,3 @@
+module Extruder
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: extruder
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Yehuda Katz
+- Tom Dale
+- Tyler Kellen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-07 00:00:00.000000000 Z
+dependencies: []
+description: A simple and powerful file pipeline.
+email:
+- tyler@sleekcode.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- extruder.gemspec
+- lib/extruder.rb
+- lib/extruder/dsl.rb
+- lib/extruder/errors.rb
+- lib/extruder/file_set.rb
+- lib/extruder/file_wrapper.rb
+- lib/extruder/filter.rb
+- lib/extruder/filters/concat_filter.rb
+- lib/extruder/filters/ordering_concat_filter.rb
+- lib/extruder/main.rb
+- lib/extruder/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A simple and powerful file pipeline.
+test_files: []
+has_rdoc: