rake-pipeline 0.5.0

data/lib/rake-pipeline/filters.rb

@@ -0,0 +1 @@
+require "rake-pipeline/filters/concat"

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

@@ -0,0 +1,63 @@
+module Rake
+  class Pipeline
+    # A built-in filter that simply accepts a series
+    # of inputs and concatenates them into output files
+    # based on the output file name generator.
+    #
+    # @example
+    #   !!!ruby
+    #   Pipeline.build do
+    #     input "app/assets", "**/*.js"
+    #     output "public"
+    #
+    #     # create a concatenated output file for each
+    #     # directory of inputs.
+    #     filter(Rake::Pipeline::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 < Rake::Pipeline::Filter
+      # @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
+end

data/lib/rake-pipeline/matcher.rb

@@ -0,0 +1,106 @@
+require "strscan"
+
+module Rake
+  class Pipeline
+    # A Matcher is a type of pipeline that restricts its
+    # filters to a particular pattern.
+    #
+    # A Matcher's pattern is a File glob.
+    #
+    # For instance, to restrict filters to operating on
+    # JavaScript files in the +app+ directory, the Matcher's
+    # {Pipeline#input_root input_root} should be +"app"+,
+    # and its glob would be +"*.js"+.
+    #
+    # In general, you should not use Matcher directly. Instead use
+    # {DSL#match} in the block passed to {Pipeline.build}.
+    class Matcher < Pipeline
+      attr_reader :glob
+
+      # A glob matcher that a filter's input files must match
+      # in order to be processed by the filter.
+      #
+      # @return [String]
+      def glob=(pattern)
+        @glob = pattern
+        scanner = StringScanner.new(pattern)
+
+        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
+
+        # anchor the pattern either at the beginning of the
+        # path or at any "/" character
+        @pattern = Regexp.new("(^|/)#{output}$", "i")
+      end
+
+      # A list of the output files that invoking this pipeline will
+      # generate. This will include the outputs of files matching
+      # the {#glob glob} and any inputs that did not match the
+      # glob.
+      #
+      # This will make those inputs available to any additional
+      # filters or matchers.
+      #
+      # @return [Array<FileWrapper>]
+      def output_files
+        super + input_files.reject do |file|
+          file.path =~ @pattern
+        end
+      end
+
+    private
+      # Override the default {Pipeline#eligible_input_files}
+      # to include only files that match the {#glob glob}.
+      #
+      # @return [Array<FileWrapper>]
+      def eligible_input_files
+        input_files.select do |file|
+          file.path =~ @pattern
+        end
+      end
+    end
+  end
+end

data/lib/rake-pipeline/middleware.rb

@@ -0,0 +1,70 @@
+require "rack"
+
+module Rake
+  class Pipeline
+    # This middleware is used to provide a server that will continuously
+    # compile your files on demand.
+    #
+    # @example
+    #   !!!ruby
+    #   use Rake::Pipeline::Middleware, Rake::Pipeline.build {
+    #     input "app/assets"
+    #     output "public"
+    #
+    #     ...
+    #   }
+    class Middleware
+      attr_accessor :pipeline
+
+      # @param [#call] a Rack application
+      # @param [Pipeline] a Rake::Pipeline
+      def initialize(app, pipeline)
+        @app = app
+
+        if pipeline.is_a?(String)
+          pipeline_source = File.read(pipeline)
+          pipeline = Pipeline.class_eval "build do\n#{pipeline_source}\nend", pipeline, 1
+        end
+
+        @pipeline = pipeline
+      end
+
+      # Automatically compiles your assets if required and
+      # serves them up.
+      #
+      # @param [Hash] env a Rack environment
+      # @return [Array(Fixnum, Hash, #each)] A rack response
+      def call(env)
+        pipeline.invoke_clean
+        path = env["PATH_INFO"]
+
+        if filename = file_for(path)
+          if File.directory?(filename)
+            index = File.join(filename, "index.html")
+            filename = File.file?(index) ? index : nil
+          end
+
+          if filename
+            return response_for(filename)
+          end
+        end
+
+        @app.call(env)
+      end
+
+    private
+      def response_for(file)
+        [ 200, headers_for(file), File.open(file, "r") ]
+      end
+
+      def file_for(path)
+        Dir[File.join(pipeline.output_root, path)].first
+      end
+
+      def headers_for(path)
+        mime = Rack::Mime.mime_type(File.extname(path), "text/plain")
+        { "Content-Type" => mime }
+      end
+    end
+  end
+end

data/lib/rake-pipeline/rails_plugin.rb

@@ -0,0 +1,8 @@
+require 'rake-pipeline/middleware'
+
+Rails.configuration.after_initialize do
+  if defined?(RAKEP_ENABLED) && RAKEP_ENABLED
+    assetfile = defined?(RAKEP_ASSETFILE) ? RAKEP_ASSETFILE : 'Assetfile'
+    Rails.configuration.middleware.use(Rake::Pipeline::Middleware, assetfile)
+  end
+end

data/lib/rake-pipeline/railtie.rb

@@ -0,0 +1,17 @@
+require "rake-pipeline/middleware"
+
+module Rake
+  class Pipeline
+    class Railtie < ::Rails::Railtie
+      config.rake_pipeline_enabled = false
+      config.rake_pipeline_assetfile = 'Assetfile'
+
+      initializer "rake-pipeline.assetfile" do |app|
+        if config.rake_pipeline_enabled
+          assetfile = File.join(Rails.root, config.rake_pipeline_assetfile)
+          config.app_middleware.use(Rake::Pipeline::Middleware, assetfile)
+        end
+      end
+    end
+  end
+end

data/lib/rake-pipeline/version.rb

@@ -0,0 +1,6 @@
+module Rake
+  class Pipeline
+    # @version 0.5.0
+    VERSION = "0.5.0"
+  end
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+# For Rails 2
+require 'rake-pipeline'

data/rake-pipeline.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rake-pipeline/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Yehuda Katz", "Tom Dale"]
+  gem.email         = ["wycats@gmail.com"]
+  gem.description   = "Simple Asset Management"
+  gem.summary       = "Simple Asset Management"
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "rake-pipeline"
+  gem.require_paths = ["lib"]
+  gem.version       = Rake::Pipeline::VERSION
+
+  gem.add_dependency "rake", "~> 0.9.0"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rack-test"
+end

data/spec/concat_filter_spec.rb

@@ -0,0 +1,60 @@
+describe "ConcatFilter" do
+  class MemoryFileWrapper < Struct.new(:root, :path, :encoding, :body)
+    @@files = {}
+
+    def self.files
+      @@files
+    end
+
+    def with_encoding(new_encoding)
+      self.class.new(root, path, new_encoding, body)
+    end
+
+    def fullpath
+      File.join(root, path)
+    end
+
+    def create
+      @@files[fullpath] = self
+      self.body = ""
+      yield
+    end
+
+    alias read body
+
+    def write(contents)
+      self.body << contents
+    end
+  end
+
+  let(:input_files) {
+    [
+      MemoryFileWrapper.new("/path/to/input", "javascripts/jquery.js", "UTF-8", "jQuery = {};"),
+      MemoryFileWrapper.new("/path/to/input", "javascripts/sproutcore.js", "UTF-8", "SC = {};")
+    ]
+  }
+
+  it "generates output" do
+    filter = Rake::Pipeline::ConcatFilter.new { "application.js" }
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.output_root = "/path/to/output"
+    filter.input_files = input_files
+
+    filter.output_files.should == [MemoryFileWrapper.new("/path/to/output", "application.js", "BINARY")]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/application.js"]
+    file.body.should == "jQuery = {};SC = {};"
+    file.encoding.should == "BINARY"
+  end
+
+  it "accepts a string to use as the output file name" do
+    filter = Rake::Pipeline::ConcatFilter.new("app.js")
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.output_root = "/path/to/output"
+    filter.input_files = input_files
+    filter.output_files.should == [MemoryFileWrapper.new("/path/to/output", "app.js", "BINARY")]
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,86 @@
+describe "Rake::Pipeline::DSL" do
+  ConcatFilter = Rake::Pipeline::SpecHelpers::Filters::ConcatFilter
+
+  let(:pipeline) { Rake::Pipeline.new }
+  let(:dsl) { Rake::Pipeline::DSL.new(pipeline) }
+
+  before do
+    pipeline.input_root = "."
+  end
+
+  it "accepts a pipeline in its constructor" do
+    dsl.pipeline.should == pipeline
+  end
+
+  describe "#input" do
+    it "configures the pipeline's input_root" do
+      dsl.input "/app"
+      pipeline.input_root.should == "/app"
+    end
+
+    it "configures the pipeline's input_glob" do
+      dsl.input "/app", "*.js"
+      pipeline.input_glob.should == "*.js"
+    end
+
+    it "defaults the pipeline's input_glob to **/*" do
+      dsl.input "/app"
+      pipeline.input_glob.should == "**/*"
+    end
+  end
+
+  describe "#filter" do
+
+    it "adds a new instance of the filter class to the pipeline's filters" do
+      pipeline.filters.should be_empty
+      dsl.filter ConcatFilter
+      pipeline.filters.should_not be_empty
+      pipeline.filters.last.should be_kind_of(ConcatFilter)
+    end
+
+    it "takes a block to configure the filter's output file names" do
+      generator = proc { |input| "main.js" }
+      dsl.filter(ConcatFilter, &generator)
+      pipeline.filters.last.output_name_generator.should == generator
+    end
+
+    it "passes any extra arguments to the filter's constructor" do
+      filter_class = Class.new(Rake::Pipeline::Filter) do
+        attr_reader :args
+        def initialize(*args)
+          @args = args
+        end
+      end
+
+      dsl.filter filter_class, "foo", "bar"
+      pipeline.filters.last.args.should == %w(foo bar)
+    end
+  end
+
+  describe "#match" do
+    it "creates a Matcher for the given glob" do
+      matcher = dsl.match("*.glob") {}
+      matcher.should be_kind_of(Rake::Pipeline::Matcher)
+      matcher.glob.should == "*.glob"
+    end
+
+    it "adds the new matcher to the pipeline's filters" do
+      matcher = dsl.match("*.glob") {}
+      pipeline.filters.last.should == matcher
+    end
+  end
+
+  describe "#output" do
+    it "configures the pipeline's output_root" do
+      dsl.output "/path/to/output"
+      pipeline.output_root.should == "/path/to/output"
+    end
+  end
+
+  describe "#tmpdir" do
+    it "configures the pipeline's tmpdir" do
+      dsl.tmpdir "/temporary"
+      pipeline.tmpdir.should == "/temporary"
+    end
+  end
+end