pipefitter 0.1.0

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pipefitter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Lee Jones
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Pipefitter
+
+A command-line tool that avoids unnecessary compiles when using the Rails Asset Pipeline.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pipefitter'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pipefitter
+
+## Usage
+
+The `pipefitter` command is a smart wrapper to use when compiling your assets:
+
+    $ pipefitter
+    Running `bundle exec rake assets:precompile`...
+    Finished compiling assets!
+
+It will automatically check if something changed that would require another compile:
+
+    $ pipefitter
+    Skipped compile because no changes were detected.
+
+You can archive a compile in case it can be reused later (ex. switching back and forth between branches)
+
+    $ pipefitter --archive
+    $ rm -rf public/assets # oh no!
+    $ pipefitter
+    Used compiled assests from local archive!
+    # boom. didn't even need to recompile
+
+Run a custom compile command:
+
+    $ pipefitter --command script/awesome_compile
+    Running `script/awesome_compile`...
+    Finished compiling assets!
+
+If something seems out of sorts with the change detection, you can force asset compilation:
+
+    $ pipefitter --force
+    Running `bundle exec rake assets:precompile`...
+    Finished compiling assets!
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/pipefitter

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/pipefitter.rb', __FILE__)
+
+begin
+  Pipefitter::Cli.run(ARGV.clone, :environment => ENV.clone)
+rescue Interrupt
+  exit 0
+end

data/lib/pipefitter/checksum.rb

@@ -0,0 +1,32 @@
+require 'pipefitter/error'
+
+class Pipefitter
+  class Checksum
+    attr_reader :paths
+
+    def initialize(paths)
+      @paths = Array(paths)
+    end
+
+    def self.checksum(paths)
+      new(paths).checksum
+    end
+
+    def checksum
+      verify_paths
+      `find #{paths.join(' ')} -type f -exec md5 -q {} + | md5 -q`.strip
+    end
+
+    private
+
+    def verify_paths
+      paths.each do |path|
+        unless File.exists?(path)
+          raise PathNotFound, "Could not find #{path}"
+        end
+      end
+    end
+
+    class PathNotFound < Pipefitter::Error; end
+  end
+end

data/lib/pipefitter/cli.rb

@@ -0,0 +1,104 @@
+require 'logger'
+
+class Pipefitter
+  class Cli
+    attr_reader :arguments
+
+    def self.run(arguments, options = {})
+      new(arguments, options).run
+    end
+
+    def initialize(arguments, options = {})
+      @arguments = arguments
+      @options = options
+    end
+
+    def run
+      if help_requested?
+        logger.info help_text
+      else
+        Pipefitter.compile(path, compiler_options)
+      end
+    end
+
+    private
+
+    def path
+      path_argument || environment.fetch(:PWD)
+    end
+
+    def path_argument
+      arguments.reject do |arg|
+        arg =~ /\A\-\-/ || arg == command_argument
+      end.first
+    end
+
+    def environment
+      @environment ||= begin
+        environment = options.fetch(:environment)
+        symbolize_keys(environment)
+      end
+    end
+
+    def compiler_options
+      c_options = { :logger => logger }
+      if arguments.include?('--force')
+        c_options[:force] = true
+      end
+      if arguments.include?('--archive')
+        c_options[:archive] = true
+      end
+      if arguments.include?('--command')
+        c_options[:command] = command_argument
+      end
+      c_options
+    end
+
+    def options
+      @options_with_symbolized_keys ||= symbolize_keys(@options)
+    end
+
+    def command_argument
+      @command_argument ||= begin
+        if arguments.include?('--command')
+          arguments[arguments.index('--command') + 1]
+        else
+          nil
+        end
+      end
+    end
+
+    def symbolize_keys(hash)
+      hash.inject({}) do |memo, (k, v)|
+        memo[k.to_sym] = v
+        memo
+      end
+    end
+
+    def logger
+      @logger ||= options.fetch(:logger, Pipefitter::Logger.new)
+    end
+
+    def help_requested?
+      arguments.include?('--help')
+    end
+
+    def help_text
+      <<-EOS
+# Pipefitter
+
+## Usage
+
+    pipefitter [project path] [options]
+
+### Arguments
+
+* project root - optional project path to compile (default: current working directory)
+* --force - forces a compile even when none is needed
+* --archive - archives the compile assets to tmp in the project root
+* --help - this help text :)
+EOS
+
+    end
+  end
+end

data/lib/pipefitter/compiler.rb

@@ -0,0 +1,56 @@
+class Pipefitter
+  class Compiler
+    attr_reader :base_path
+
+    def initialize(base_path, options = {})
+      @options = options
+      @base_path = base_path
+    end
+
+    def compile
+      logger.info "Running `#{compile_command}`..."
+      result = `cd #{base_path} && #{compile_command} 2>&1`.chomp
+      status = $?.to_i == 0
+      log_result(result, status)
+      status
+    end
+
+    private
+
+    def compile_command
+      options[:command] || default_compile_command
+    end
+
+    def default_compile_command
+      if using_bundler?
+        'bundle exec rake assets:precompile'
+      else
+        'rake assets:precompile'
+      end
+    end
+
+    def using_bundler?
+      File.exists?(gemfile)
+    end
+
+    def gemfile
+      gemfile = File.join(base_path, 'Gemfile')
+    end
+
+    def options
+      @options
+    end
+
+    def log_result(result, status = true)
+      if status
+        logger.info result unless result == ''
+      else
+        logger.error result unless result == ''
+      end
+    end
+
+    def logger
+      @logger ||= options.fetch(:logger, Pipefitter::Logger.new)
+    end
+  end
+end

data/lib/pipefitter/compressor.rb

@@ -0,0 +1,34 @@
+class Pipefitter
+  class Compressor
+    attr_reader :base_path
+
+    def initialize(base_path, target_path = nil)
+      @base_path = base_path
+    end
+
+    def compress(filename = nil)
+      `cd #{base_path}/public && tar -czf #{target(filename)} #{source}`
+    end
+
+    private
+
+    def source
+      './assets'
+    end
+
+    def target(filename = nil)
+      target_filename = filename || default_target_filename
+      File.join(target_path, target_filename)
+    end
+
+    def target_path
+      @target_path ||= begin
+        File.join(base_path, 'tmp', 'pipefitter')
+      end
+    end
+
+    def default_target_filename
+      "#{Time.now.to_i}.tar.gz"
+    end
+  end
+end

data/lib/pipefitter/error.rb

@@ -0,0 +1,4 @@
+class Pipefitter
+  class Error < RuntimeError
+  end
+end

data/lib/pipefitter/inventory.rb

@@ -0,0 +1,45 @@
+require 'yaml'
+require 'fileutils'
+
+class Pipefitter
+  class Inventory 
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+      FileUtils.mkdir_p(path)
+    end
+
+    def put(key, value) 
+      data[key] = value
+      save
+    end
+
+    def get(key)
+      data[key]
+    end
+
+    private
+    
+    def data
+      @data ||= begin
+        if File.exists?(data_file)
+          YAML.load_file(data_file) || {}
+        else
+          FileUtils.touch(data_file)
+          {}
+        end
+      end
+    end
+
+    def data_file
+      File.join(path, 'inventory.yml')
+    end
+
+    def save
+      File.open(data_file, 'w+') do |file|
+        file.write(data.to_yaml)
+      end
+    end
+  end
+end

data/lib/pipefitter/logger.rb

@@ -0,0 +1,14 @@
+require 'logger'
+
+class Pipefitter
+  class Logger < ::Logger
+    def initialize(logger = STDOUT)
+      super(logger)
+      original_formatter = ::Logger::Formatter.new
+      self.formatter = proc { |severity, datetime, progname, message|
+        "#{message}\n"
+      }
+      self
+    end
+  end
+end

data/lib/pipefitter/version.rb

@@ -0,0 +1,3 @@
+class Pipefitter
+  VERSION = "0.1.0"
+end

data/lib/pipefitter.rb

@@ -0,0 +1,156 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pipefitter/version'
+require 'fileutils'
+
+class Pipefitter
+  autoload 'Compiler', 'pipefitter/compiler'
+  autoload 'Checksum', 'pipefitter/checksum'
+  autoload 'Cli', 'pipefitter/cli'
+  autoload 'Compressor', 'pipefitter/compressor'
+  autoload 'Inventory', 'pipefitter/inventory'
+  autoload 'Error', 'pipefitter/error'
+  autoload 'Logger', 'pipefitter/logger'
+
+  attr_reader :base_path
+
+  def self.compile(base_path, options = {})
+    new(base_path, options).compile
+  end
+
+  def initialize(base_path, options = {})
+    @base_path = base_path
+    @options = options
+  end
+
+  def compile
+    setup
+    compile_if_necessary
+  end
+
+  def source_checksum
+    Checksum.checksum(source_paths)
+  end
+
+  def artifact_checksum
+    Checksum.checksum(artifact_paths)
+  end
+
+  private
+
+  def compile_if_necessary
+    if assets_need_compiling?
+      use_archive_or_compile
+    else
+      logger.info 'Skipped compile because no changes were detected.'
+    end
+  end
+
+  def use_archive_or_compile
+    if inventory_can_be_used?
+      move_archived_assets_into_place
+      logger.info 'Used compiled assests from local archive!'
+    else
+      compile_and_record_checksum
+      logger.info 'Finished compiling assets!'
+      archive
+    end
+  end
+
+  def compile_and_record_checksum
+    if compiler.compile
+      inventory.put(source_checksum, artifact_checksum)
+    else
+      raise CompilationError
+    end
+  end
+
+  def inventory_can_be_used?
+    ! compile_forced? && inventory_contains_compiled_assets?
+  end
+
+  def archive
+    if archiving_enabled?
+      logger.info 'Started archiving assets...'
+      compressor.compress("#{source_checksum}.tar.gz")
+      logger.info 'Finished archiving assets!'
+    end
+  end
+
+  def compiler
+    @compiler ||= Compiler.new(base_path,
+      :logger => logger,
+      :command => options[:command]
+    )
+  end
+
+  def compressor
+    @compressor ||= Compressor.new(base_path, :logger => logger)
+  end
+
+  def inventory
+    @inventory ||= Inventory.new(workspace)
+  end
+
+  def assets_need_compiling?
+    compile_forced? || inventory.get(source_checksum) != artifact_checksum
+  end
+
+  def archiving_enabled?
+    @archiving_enabled ||= options.fetch(:archive, false)
+  end
+
+  def workspace
+    File.join(base_path, 'tmp', 'pipefitter')
+  end
+
+  def setup
+    FileUtils.mkdir_p(workspace)
+    artifact_paths.each { |path| FileUtils.mkdir_p(path) }
+  end
+
+  def source_paths
+    paths = %w{
+      Gemfile
+      Gemfile.lock
+      app/assets
+      lib/assets
+      vendor/assets
+    }.map { |p| File.join(base_path, p) }
+  end
+
+  def artifact_paths
+    %w{
+      public/assets
+    }.map { |p| File.join(base_path, p) }
+  end
+
+  def inventory_contains_compiled_assets?
+    inventory_path = File.join(workspace, "#{source_checksum}.tar.gz")
+    inventory.get(source_checksum) && File.exists?(inventory_path)
+  end
+
+  def move_archived_assets_into_place
+    inventory_path = File.join(workspace, "#{source_checksum}.tar.gz")
+    FileUtils.rm_rf("#{base_path}/public/assets")
+    `cd #{base_path}/public && tar -xzf #{inventory_path}`
+    expected_artifact_checksum = inventory.get(source_checksum)
+    if expected_artifact_checksum != artifact_checksum
+      raise CompilationError, 'Archived assets did match stored checksum!'
+    end
+  end
+
+  def compile_forced?
+    options.fetch(:force, false)
+  end
+
+  def options
+    @options
+  end
+
+  def logger
+    @logger ||= options.fetch(:logger, Pipefitter::Logger.new)
+  end
+
+  class CompilationError < Pipefitter::Error; end
+end

data/pipefitter.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pipefitter/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pipefitter"
+  gem.version       = Pipefitter::VERSION
+  gem.authors       = ["Lee Jones"]
+  gem.email         = ["scribblethink@gmail.com"]
+  gem.description   = %q{A command-line tool that avoids unnecessary compiles when using the Rails Asset Pipeline.}
+  gem.summary       = %q{Pipefitter answers the age old question of "To compile or not to compile?"}
+  gem.homepage      = "https://github.com/leejones/pipefitter"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/pipefitter/checksum_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Pipefitter::Checksum do
+  include Pipefitter::SpecHelper
+
+  let(:test_root) { '/tmp/pipefitter_tests' }
+  let(:rails_root) { "#{test_root}/stubbed_rails_app" }
+
+  before(:each) do
+    stub_rails_app(test_root, :destroy_initially => true)
+  end
+
+  it 'checksums a group of files and directories' do
+    paths = %w{
+      Gemfile
+      Gemfile.lock
+      app/assets
+      lib/assets
+      vendor/assets
+    }.map { |p| File.join(rails_root, p) }
+    checksum = Pipefitter::Checksum.new(paths)
+    checksum.checksum.should eql('63af33df99e1f88bff6d3696f4ae6686')
+  end
+end

data/spec/pipefitter/cli_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Pipefitter::Cli do
+  include Pipefitter::SpecHelper
+
+  it 'compiles a path' do
+    Pipefitter.should_receive(:compile).with('/tmp/pipefitter_app', kind_of(Hash)).and_return(true)
+    environment = { :PWD => '/tmp' }
+    Pipefitter::Cli.run(['/tmp/pipefitter_app'], :environment => environment)
+  end
+
+  it 'compiles the PWD' do
+    Pipefitter.should_receive(:compile).with('/tmp/pipefitter_app', kind_of(Hash)).and_return(true)
+    environment = { :PWD => '/tmp/pipefitter_app' }
+    Pipefitter::Cli.run([], :environment => environment)
+  end
+
+  it 'forces a compile' do
+    Pipefitter.should_receive(:compile).with('/tmp/pipefitter_app', {
+      :logger => kind_of(Logger),
+      :force => true
+    }).and_return(true)
+    environment = { :PWD => '/tmp/pipefitter_app' }
+    Pipefitter::Cli.run(['--force'], :environment => environment)
+  end
+
+  it 'archives' do
+    Pipefitter.should_receive(:compile).with('/tmp/pipefitter_app', {
+      :logger => kind_of(Logger),
+      :archive => true
+    }).and_return(true)
+    environment = { :PWD => '/tmp/pipefitter_app' }
+    Pipefitter::Cli.run(['--archive'], :environment => environment)
+  end
+
+  it 'helps' do
+    Pipefitter.should_not_receive(:compile)
+    environment = { :PWD => '/tmp/pipefitter_app' }
+    null_logger.should_receive(:info).with(/Usage/)
+    Pipefitter::Cli.run(['--help'], {
+      :environment => environment,
+      :logger => null_logger
+    })
+  end
+
+  it 'uses a custom command' do
+    Pipefitter.should_receive(:compile).with('/tmp/pipefitter_app', {
+      :logger => kind_of(Logger),
+      :command => 'script/precompile_assets'
+    }).and_return(true)
+    environment = { :PWD => '/tmp/pipefitter_app' }
+    Pipefitter::Cli.run(['--command', 'script/precompile_assets'], :environment => environment)
+  end
+end

data/spec/pipefitter/compiler_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+require 'logger'
+
+describe Pipefitter::Compiler do
+  include Pipefitter::SpecHelper
+
+  let(:test_root) { '/tmp/pipefitter_tests' }
+  let(:rails_root) { "#{test_root}/stubbed_rails_app" }
+
+  before(:each) do
+    stub_rails_app(test_root, :destroy_initially => true)
+  end
+
+  it 'compiles assets' do
+    compiler = Pipefitter::Compiler.new(rails_root, :logger => null_logger)
+    compiler.compile
+    File.exists?("#{rails_root}/public/assets/manifest.yml").should be_true
+  end
+end

data/spec/pipefitter/inventory_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../../../lib/pipefitter.rb', __FILE__)
+require 'fileutils'
+
+describe Pipefitter::Inventory do
+  before(:each) do
+    cleanup_inventory
+  end
+
+  it 'stores a record of a compilation' do
+    inventory = Pipefitter::Inventory.new('/tmp/pipefitter_tests')
+    inventory.put('source_checksum', 'artifact_checksum').should be_true
+  end
+
+  it 'retrieves a record of a compilation' do
+    inventory = Pipefitter::Inventory.new('/tmp/pipefitter_tests')
+    inventory.put('source_checksum', 'artifact_checksum')
+    inventory.get('source_checksum').should eql('artifact_checksum')
+  end
+
+  private
+
+  def cleanup_inventory
+    FileUtils.rm_rf('/tmp/pipefitter_tests')
+  end
+end

data/spec/pipefitter_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+require 'yaml'
+
+describe Pipefitter do
+  include Pipefitter::SpecHelper
+
+  let(:test_root) { '/tmp/pipefitter_tests' }
+  let(:rails_root) { "#{test_root}/stubbed_rails_app" }
+
+  before(:each) do
+    stub_rails_app(test_root, :destroy_initially => true)
+  end
+
+  it 'compiles assets' do
+    Pipefitter.compile(rails_root, :logger => null_logger)
+    manifest_file = "#{rails_root}/public/assets/manifest.yml"
+    File.exists?(manifest_file).should be_true
+  end
+
+  it 'records a checksum' do
+    Pipefitter.compile(rails_root, :logger => null_logger)
+    inventory_file = "#{rails_root}/tmp/pipefitter/inventory.yml"
+    checksums = YAML.load_file(inventory_file)
+    checksums.has_key?('63af33df99e1f88bff6d3696f4ae6686').should be_true
+  end
+
+  it 'stores an archived copy of compiled assets' do
+    Pipefitter.compile(rails_root, :archive => true, :logger => null_logger)
+    archive_file = "#{rails_root}/tmp/pipefitter/63af33df99e1f88bff6d3696f4ae6686.tar.gz"
+    File.exists?(archive_file).should be_true
+    `cd #{test_root} && tar -xzf #{archive_file}`
+    archived_assets_checksum = `find #{test_root}/assets -type f -exec md5 -q {} + | md5 -q`.strip
+    compiled_assets_checksum = `find #{rails_root}/public/assets -type f -exec md5 -q {} + | md5 -q`.strip
+    archived_assets_checksum.should eql(compiled_assets_checksum)
+  end
+
+  it 'uses an archived copy of compiled assets when available' do
+    Pipefitter.compile(rails_root, :archive => true, :logger => null_logger)
+    original_checksum = Pipefitter::Checksum.new("#{rails_root}/public/assets").checksum
+    FileUtils.rm_rf("#{rails_root}/public/assets/manifest.yml")
+    compiler_stub = stub
+    Pipefitter::Compiler.stub(:new => compiler_stub)
+    compiler_stub.should_not_receive(:compile)
+    Pipefitter.compile(rails_root, :archive => true, :logger => null_logger)
+    final_checksum = Pipefitter::Checksum.new("#{rails_root}/public/assets").checksum
+    final_checksum.should eql(original_checksum)
+  end
+
+  it 'only compiles when needed' do
+    FileUtils.mkdir_p("#{rails_root}/tmp/pipefitter")
+    File.open("#{rails_root}/tmp/pipefitter/inventory.yml", 'w+') do |file|
+      file.write({
+        '63af33df99e1f88bff6d3696f4ae6686' => 'd41d8cd98f00b204e9800998ecf8427e'
+      }.to_yaml)
+    end
+    compiler_stub = stub
+    Pipefitter::Compiler.stub(:new => compiler_stub)
+    compiler_stub.should_not_receive(:compile)
+    Pipefitter.compile(rails_root, :logger => null_logger)
+  end
+
+  it 'does not record a checksum if the compile fails' do
+    FileUtils.rm("#{rails_root}/Rakefile")
+    expect { Pipefitter.compile(rails_root, :logger => null_logger) }.to raise_error(Pipefitter::CompilationError)
+    File.exists?("#{rails_root}/tmp/pipefitter/checksum.txt").should be_false
+  end
+
+  it 'forces a compile' do
+    Pipefitter.compile(rails_root, :logger => null_logger)
+    compiler_stub = stub
+    Pipefitter::Compiler.stub(:new => compiler_stub)
+    compiler_stub.should_receive(:compile).and_return(true)
+    Pipefitter.compile(rails_root, :force => true, :logger => null_logger)
+  end
+
+  it 'uses a custom compile command', :focus => true do
+    compiler_stub = stub
+    Pipefitter::Compiler.should_receive(:new).with('/tmp/pipefitter_tests/stubbed_rails_app', :logger => kind_of(Logger), :command => 'script/precompile_assets').and_return(compiler_stub)
+    compiler_stub.should_receive(:compile).and_return(true)
+    Pipefitter.compile(rails_root, :command => 'script/precompile_assets', :logger => null_logger)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../lib/pipefitter.rb', __FILE__)
+require 'fileutils' 
+require 'logger'
+
+class Pipefitter
+  module SpecHelper
+    private
+    
+    def stub_rails_app(base_working_directory, options = {})
+      if options[:destroy_initially]
+        FileUtils.rm_rf(base_working_directory)
+      end
+      FileUtils.mkdir_p(base_working_directory)
+      app_source_path = File.expand_path('../support/stubbed_rails_app', __FILE__)
+      FileUtils.cp_r(app_source_path, base_working_directory)
+    end
+
+    def null_logger
+      @null_logger ||= ::Logger.new('/dev/null')
+    end
+  end
+end

data/spec/support/stubbed_rails_app/Gemfile

@@ -0,0 +1,38 @@
+source 'https://rubygems.org'
+
+gem 'rails', '3.2.12'
+
+# Bundle edge Rails instead:
+# gem 'rails', :git => 'git://github.com/rails/rails.git'
+
+gem 'sqlite3'
+
+
+# Gems used only for assets and not required
+# in production environments by default.
+group :assets do
+  gem 'sass-rails',   '~> 3.2.3'
+  gem 'coffee-rails', '~> 3.2.1'
+
+  # See https://github.com/sstephenson/execjs#readme for more supported runtimes
+  # gem 'therubyracer', :platforms => :ruby
+
+  gem 'uglifier', '>= 1.0.3'
+end
+
+gem 'jquery-rails'
+
+# To use ActiveModel has_secure_password
+# gem 'bcrypt-ruby', '~> 3.0.0'
+
+# To use Jbuilder templates for JSON
+# gem 'jbuilder'
+
+# Use unicorn as the app server
+# gem 'unicorn'
+
+# Deploy with Capistrano
+# gem 'capistrano'
+
+# To use debugger
+# gem 'debugger'

data/spec/support/stubbed_rails_app/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require 'fileutils'
+
+namespace :assets do
+  task :precompile do
+    rails_root = File.expand_path('..', __FILE__)
+    asset_root = File.join(rails_root, 'public', 'assets')
+    FileUtils.mkdir_p(File.join(asset_root))
+    File.open(File.join(asset_root, 'manifest.yml'), 'w+') do |file|
+      file.write('list of compiled assets...')
+    end
+  end
+end
+

data/spec/support/stubbed_rails_app/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/spec/support/stubbed_rails_app/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: pipefitter
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Lee Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-03-24 00:00:00 Z
+dependencies: []
+
+description: A command-line tool that avoids unnecessary compiles when using the Rails Asset Pipeline.
+email: 
+- scribblethink@gmail.com
+executables: 
+- pipefitter
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/pipefitter
+- lib/pipefitter.rb
+- lib/pipefitter/checksum.rb
+- lib/pipefitter/cli.rb
+- lib/pipefitter/compiler.rb
+- lib/pipefitter/compressor.rb
+- lib/pipefitter/error.rb
+- lib/pipefitter/inventory.rb
+- lib/pipefitter/logger.rb
+- lib/pipefitter/version.rb
+- pipefitter.gemspec
+- spec/pipefitter/checksum_spec.rb
+- spec/pipefitter/cli_spec.rb
+- spec/pipefitter/compiler_spec.rb
+- spec/pipefitter/inventory_spec.rb
+- spec/pipefitter_spec.rb
+- spec/spec_helper.rb
+- spec/support/stubbed_rails_app/Gemfile
+- spec/support/stubbed_rails_app/Rakefile
+- spec/support/stubbed_rails_app/app/assets/images/rails.png
+- spec/support/stubbed_rails_app/app/assets/javascripts/application.js
+- spec/support/stubbed_rails_app/app/assets/stylesheets/application.css
+- spec/support/stubbed_rails_app/lib/assets/.gitkeep
+- spec/support/stubbed_rails_app/public/.gitkeep
+- spec/support/stubbed_rails_app/vendor/assets/javascripts/.gitkeep
+- spec/support/stubbed_rails_app/vendor/assets/stylesheets/.gitkeep
+- spec/support/stubbed_rails_app/vendor/plugins/.gitkeep
+homepage: https://github.com/leejones/pipefitter
+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.24
+signing_key: 
+specification_version: 3
+summary: Pipefitter answers the age old question of "To compile or not to compile?"
+test_files: 
+- spec/pipefitter/checksum_spec.rb
+- spec/pipefitter/cli_spec.rb
+- spec/pipefitter/compiler_spec.rb
+- spec/pipefitter/inventory_spec.rb
+- spec/pipefitter_spec.rb
+- spec/spec_helper.rb
+- spec/support/stubbed_rails_app/Gemfile
+- spec/support/stubbed_rails_app/Rakefile
+- spec/support/stubbed_rails_app/app/assets/images/rails.png
+- spec/support/stubbed_rails_app/app/assets/javascripts/application.js
+- spec/support/stubbed_rails_app/app/assets/stylesheets/application.css
+- spec/support/stubbed_rails_app/lib/assets/.gitkeep
+- spec/support/stubbed_rails_app/public/.gitkeep
+- spec/support/stubbed_rails_app/vendor/assets/javascripts/.gitkeep
+- spec/support/stubbed_rails_app/vendor/assets/stylesheets/.gitkeep
+- spec/support/stubbed_rails_app/vendor/plugins/.gitkeep