rake-pipeline-fork 0.8.0

data/lib/rake-pipeline/rails_plugin.rb

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

data/lib/rake-pipeline/railtie.rb

@@ -0,0 +1,34 @@
+require "rake-pipeline/middleware"
+
+module Rake
+  class Pipeline
+    # Use Rake::Pipeline inside of Rails 3.x. To use, simply add
+    # Rake::Pipeline to your +Gemfile+:
+    #
+    #   !!!ruby
+    #   gem 'rake-pipeline'
+    #
+    # Then, activate it in development mode. In config/development.rb:
+    #
+    #   !!!ruby
+    #   config.rake_pipeline_enabled = true
+    #
+    class Railtie < ::Rails::Railtie
+      config.rake_pipeline_enabled = false
+      config.rake_pipeline_assetfile = 'Assetfile'
+
+      rake_tasks do
+        load "rake-pipeline/precompile.rake"
+      end
+
+      initializer "rake-pipeline.assetfile" do |app|
+        if config.rake_pipeline_enabled
+          assetfile = File.join(Rails.root, config.rake_pipeline_assetfile)
+          project = Rake::Pipeline::Project.new assetfile
+
+          config.app_middleware.insert ActionDispatch::Static, Rake::Pipeline::Middleware, project
+        end
+      end
+    end
+  end
+end

data/lib/rake-pipeline/reject_matcher.rb

@@ -0,0 +1,29 @@
+module Rake
+  class Pipeline
+    # A RejectMatcher is a pipeline that does no processing. It
+    # simply filters out some files. You can use this when
+    # you have more complex logic that doesn't fit nicely
+    # in a glob.
+    #
+    # You can pass a block or a glob (just like {DSL#match}).
+    # Files matching the glob will be rejected from the pipeline.
+    # Files are rejected when the block evaluates to true. Specify
+    # either a glob or a block.
+    #
+    # In general, you should not use RejectMatcher directly. Instead use
+    # {DSL#reject} in the block passed to {Pipeline.build}.
+    class RejectMatcher < Matcher
+      attr_accessor :block
+
+      def output_files
+        input_files.reject do |file|
+          if block
+            block.call file
+          else
+            file.path =~ @pattern
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rake-pipeline/server.rb

@@ -0,0 +1,15 @@
+require "rake-pipeline/middleware"
+require "rack/server"
+
+module Rake
+  class Pipeline
+    class Server < Rack::Server
+      def app
+        not_found = proc { [404, { "Content-Type" => "text/plain" }, ["not found"]] }
+        project = Rake::Pipeline::Project.new "Assetfile"
+
+        Middleware.new(not_found, project)
+      end
+    end
+  end
+end

data/lib/rake-pipeline/sorted_pipeline.rb

@@ -0,0 +1,19 @@
+module Rake
+  class Pipeline
+    class SortedPipeline < Pipeline
+      attr_accessor :pipeline, :comparator
+
+      def output_files
+        input_files.sort(&comparator)
+      end
+
+      # Override {Pipeline#finalize} to do nothing. We want to pass
+      # on our unmatched inputs to the next part of the pipeline.
+      #
+      # @return [void]
+      # @api private
+      def finalize
+      end
+    end
+  end
+end

data/lib/rake-pipeline/version.rb

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

data/rails/init.rb

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

data/rake-pipeline.gemspec

@@ -0,0 +1,24 @@
+# -*- 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-fork"
+  gem.require_paths = ["lib"]
+  gem.version       = Rake::Pipeline::VERSION
+
+  gem.add_dependency "rake", "~> 10.0.0"
+  gem.add_dependency "thor"
+  gem.add_dependency "json"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rack-test"
+end

data/spec/cli_spec.rb

@@ -0,0 +1,71 @@
+describe "Rake::Pipeline::CLI" do
+  attr_reader :project, :pipeline
+
+  before do
+    @project = Rake::Pipeline::Project.new
+    @project.stub(:clean)
+    @project.stub(:invoke)
+    @project.stub(:output_files).and_return([])
+    Rake::Pipeline::Project.stub(:new).and_return(@project)
+  end
+
+  def rakep(*args)
+    Rake::Pipeline::CLI.start(args)
+  end
+
+  describe "build" do
+    context "with no arguments" do
+      it "invokes a project" do
+        project.should_receive :invoke
+        rakep "build"
+      end
+
+      it "cleans up the tmpdir" do
+        project.should_receive :cleanup_tmpdir
+        rakep "build"
+      end
+    end
+
+    context "with a --pretend argument" do
+      it "doesn't invoke a project" do
+        project.should_not_receive :invoke
+        rakep "build", "--pretend"
+      end
+    end
+
+    context "with a --clean argument" do
+      it "cleans a project" do
+        project.should_receive :clean
+        rakep "build", "--clean"
+      end
+
+      it "invokes a project" do
+        project.should_receive :invoke
+        rakep "build", "--clean"
+      end
+    end
+  end
+
+  describe "clean" do
+    context "with no arguments" do
+      it "cleans a project" do
+        project.should_receive :clean
+        rakep "clean"
+      end
+    end
+  end
+
+  describe "server" do
+    let(:server) { double "server" }
+
+    before do
+      require 'rake-pipeline/server'
+      Rake::Pipeline::Server.stub(:new).and_return(server)
+    end
+
+    it "starts a Rake::Pipeline::Server" do
+      server.should_receive :start
+      rakep "server"
+    end
+  end
+end

data/spec/concat_filter_spec.rb

@@ -0,0 +1,37 @@
+describe "ConcatFilter" do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  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.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    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/pipeline_dsl_spec.rb

@@ -0,0 +1,165 @@
+describe "Rake::Pipeline::PipelineDSL" do
+  ConcatFilter = Rake::Pipeline::SpecHelpers::Filters::ConcatFilter
+
+  let(:pipeline) { Rake::Pipeline.new }
+  let(:dsl) { Rake::Pipeline::DSL::PipelineDSL.new(pipeline) }
+
+  def filter
+    pipeline.filters.last
+  end
+
+  it "accepts a pipeline in its constructor" do
+    dsl.pipeline.should == pipeline
+  end
+
+  describe "#input" do
+    it "adds an input to the pipeline" do
+      dsl.input "/app"
+      pipeline.inputs["/app"].should == '**/*'
+    end
+
+    it "configures the input's glob" do
+      dsl.input "/app", "*.js"
+      pipeline.inputs['/app'].should == "*.js"
+    end
+
+    it "defaults input's glob to **/*" do
+      dsl.input "/app"
+      pipeline.inputs['/app'].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
+      filter.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)
+      filter.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"
+      filter.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") {}
+      filter.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 "#concat" do
+    it "creates a ConcatFilter" do
+      dsl.concat "octopus"
+      filter.should be_kind_of(Rake::Pipeline::ConcatFilter)
+    end
+
+    context "passed an Array first argument" do
+      it "creates an OrderingConcatFilter" do
+        dsl.concat ["octopus"]
+        filter.should be_kind_of(Rake::Pipeline::OrderingConcatFilter)
+      end
+    end
+  end
+
+  describe "#sort" do
+    it "adds a SortedPipeline for the given comparator" do
+      comparator = proc { }
+      matcher = dsl.sort(&comparator)
+      matcher.should be_kind_of(Rake::Pipeline::SortedPipeline)
+      matcher.comparator.should == comparator
+    end
+  end
+
+  describe "#copy" do
+    it "creates a ConcatFilter" do
+      dsl.copy
+      filter.should be_kind_of(Rake::Pipeline::ConcatFilter)
+    end
+  end
+
+  describe "#reject" do
+    it "creates a new RejectMatcher for the given glob" do
+      matcher = dsl.reject("*.glob") {}
+      matcher.should be_kind_of(Rake::Pipeline::RejectMatcher)
+      matcher.glob.should == "*.glob"
+    end
+
+    it "creates a new RejectMatcher with the given block" do
+      block = proc { }
+      matcher = dsl.reject(&block)
+      matcher.should be_kind_of(Rake::Pipeline::RejectMatcher)
+      matcher.block.should == block
+    end
+
+    it "adds the new reject matcher to the pipeline's filters" do
+      matcher = dsl.reject("*.glob") {}
+      filter.should == matcher
+    end
+  end
+
+  describe "#skip" do
+    it "adds a new RejectMatcher" do
+      dsl.skip "*.glob"
+      filter.should be_kind_of(Rake::Pipeline::RejectMatcher)
+    end
+  end
+
+  describe "#exclude" do
+    it "adds a new RejectMatcher" do
+      dsl.exclude "*.glob"
+      filter.should be_kind_of(Rake::Pipeline::RejectMatcher)
+    end
+  end
+
+  describe "#gsub" do
+    it "creates a GsubFilter" do
+      dsl.gsub
+      filter.should be_kind_of(Rake::Pipeline::GsubFilter)
+    end
+  end
+
+  describe "#replace" do
+    it "creates a GsubFilter" do
+      dsl.replace
+      filter.should be_kind_of(Rake::Pipeline::GsubFilter)
+    end
+  end
+
+  describe "#strip" do
+    it "creates a GsubFilter with no replacement" do
+      regex = /mock/
+      dsl.should_receive(:filter).with(Rake::Pipeline::GsubFilter, regex, '')
+      dsl.strip /mock/
+    end
+  end
+end

data/spec/dsl/project_dsl_spec.rb

@@ -0,0 +1,41 @@
+describe "Rake::Pipeline::ProjectDSL" do
+  ConcatFilter ||= Rake::Pipeline::SpecHelpers::Filters::ConcatFilter
+
+  let(:project) { Rake::Pipeline::Project.new }
+  let(:dsl) { Rake::Pipeline::DSL::ProjectDSL.new(project) }
+
+  it "accepts a project in its constructor" do
+    dsl.project.should == project
+  end
+
+  describe "#output" do
+    it "configures the project's default_output_root" do
+      dsl.output "/path/to/output"
+      project.default_output_root.should == "/path/to/output"
+    end
+  end
+
+  describe "#tmpdir" do
+    it "sets the project's tmpdir" do
+      dsl.tmpdir "/path/to/tmpdir"
+      project.tmpdir.should == "/path/to/tmpdir"
+    end
+  end
+
+  describe "#input" do
+    it "uses Project#build_pipeline to add a new pipeline to the project" do
+      project.should_receive(:build_pipeline)
+      dsl.input("app") {}
+    end
+  end
+
+  describe "#map" do
+    it "saves the block in a hash on the project" do
+      project.maps.keys.size.should == 0
+      run_me = lambda { }
+      dsl.map("foo", &run_me)
+      dsl.project.maps["foo"].should == run_me
+    end
+  end
+end
+