sprockets 2.1.0 → 2.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be373494a4e64c06e55a9ad11e2c9efae09f1492
+  data.tar.gz: b683ce4b0ed64e683ea98d0b5af268bdeca3f584
+SHA512:
+  metadata.gz: fa430704b4ef87304b8a128cb83fbb64c66e24d0bdae3d9e9e343bbebd56bf8823f65cba4a0ad1eb33204308c814910ebdd9c2b570c33fbbf89a2fadd2383b33
+  data.tar.gz: 785eb7a9f36afa38e6f010a573240768a9620ed216f4b20614835ffe9564d258a0e5340c9e8dbf3b538e8b960d9f7fd22342581b5e597dbbfc4e892bac7f7d3a

data/README.md

@@ -354,9 +354,26 @@ submit a pull request.
 
 ## Version History ##
 
+**2.2.0** (Unreleased)
+
+* Added `sprockets` command line utility.
+* Added rake/sprocketstask.
+* Added json manifest log of compiled assets.
+* Added `stub` directive that allows you to exclude files from the bundle.
+* Added per environment external encoding (Environment#default_external_encoding). Defaults to UTF-8. Fixes issues where LANG is not set correctly and Rubys default external is set to ASCII.
+
+**2.1.2** (November 20, 2011)
+
+* Disabled If-Modified-Since server checks. Fixes some browser caching issues when serving the asset body only. If-None-Match caching is sufficent.
+
+**2.1.1** (November 18, 2011)
+
+* Fix windows absolute path check bug.
+
 **2.1.0** (November 11, 2011)
 
-* Preserve directive whitespace.
+* Directive comment lines are now turned into empty lines instead of removed. This way line numbers in
+  CoffeeScript syntax errors are correct.
 * Performance and caching bug fixes.
 
 **2.0.3** (October 17, 2011)

data/bin/sprockets

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'sprockets'
+require 'optparse'
+require 'shellwords'
+
+unless ARGV.delete("--noenv")
+  if File.exist?(path = "./.sprocketsrc")
+    rcflags = Shellwords.split(File.read(path))
+    ARGV.unshift(*rcflags)
+  end
+end
+
+filenames = []
+environment = Sprockets::Environment.new(Dir.pwd)
+manifest = nil
+
+(ENV['SPROCKETS_PATH'] || "").split(File::PATH_SEPARATOR).each do |path|
+  environment.append_path path
+end
+
+OptionParser.new do |opts|
+  opts.summary_width = 28
+  opts.banner = "Usage: sprockets [options] filename [filename ...]"
+
+  def opts.show_usage
+    puts self
+    exit 1
+  end
+
+  opts.on("-r", "--require LIBRARY", "Require the LIBRARY before doing anything") do |lib|
+    require lib
+  end
+
+  opts.on("-I DIRECTORY", "--include=DIRECTORY", "Adds the directory to the Sprockets load path") do |directory|
+    environment.append_path directory
+  end
+
+  opts.on("-o DIRECTORY", "--output=DIRECTORY", "Copy provided assets into DIRECTORY") do |directory|
+    manifest = Sprockets::Manifest.new(environment, directory)
+  end
+
+  opts.on("--noenv", "Disables .sprocketsrc file") do
+  end
+
+  opts.on_tail("-h", "--help", "Shows this help message") do
+    opts.show_usage
+  end
+
+  opts.on_tail("-v", "--version", "Shows version") do
+    puts Sprockets::VERSION
+    exit
+  end
+
+  opts.show_usage if ARGV.empty?
+
+  begin
+    opts.order(ARGV) do |filename|
+      filenames << File.expand_path(filename)
+    end
+  rescue OptionParser::ParseError => e
+    opts.warn e.message
+    opts.show_usage
+  end
+end
+
+if environment.paths.empty?
+  warn "No load paths given"
+  warn "Usage: sprockets -Ijavascripts/ filename"
+  exit 1
+end
+
+if manifest
+  manifest.compile(filenames)
+elsif filenames.length == 1
+  puts environment.find_asset(filenames.first).to_s
+else
+  warn "Only one file can be compiled to stdout at a time"
+  exit 1
+end

data/lib/rake/sprocketstask.rb

@@ -0,0 +1,140 @@
+require 'rake'
+require 'rake/tasklib'
+
+require 'sprockets'
+require 'logger'
+
+module Rake
+  # Simple Sprockets compilation Rake task macro.
+  #
+  #   Rake::SprocketsTask.new do |t|
+  #     t.environment = Sprockets::Environment.new
+  #     t.output      = "./public/assets"
+  #     t.assets      = %w( application.js application.css )
+  #   end
+  #
+  class SprocketsTask < Rake::TaskLib
+    # Name of the task. Defaults to "assets".
+    #
+    # The name will also be used to suffix the clean and clobber
+    # tasks, "clean_assets" and "clobber_assets".
+    attr_accessor :name
+
+    # `Environment` instance used for finding assets.
+    #
+    # You'll most likely want to reassign `environment` to your own.
+    #
+    #   Rake::SprocketsTask.new do |t|
+    #     t.environment = Foo::Assets
+    #   end
+    #
+    def environment
+      if !@environment.is_a?(Sprockets::Base) && @environment.respond_to?(:call)
+        @environment = @environment.call
+      else
+        @environment
+      end
+    end
+    attr_writer :environment
+
+    # Directory to write compiled assets too. As well as the manifest file.
+    #
+    #   t.output = "./public/assets"
+    #
+    attr_accessor :output
+
+    # Array of asset logical paths to compile.
+    #
+    #   t.assets = %w( application.js jquery.js application.css )
+    #
+    attr_accessor :assets
+
+    # Number of old assets to keep.
+    attr_accessor :keep
+
+    # Logger to use during rake tasks. Defaults to using stderr.
+    #
+    #   t.logger = Logger.new($stdout)
+    #
+    attr_accessor :logger
+
+    # Returns logger level Integer.
+    def log_level
+      @logger.level
+    end
+
+    # Set logger level with constant or symbol.
+    #
+    #   t.log_level = Logger::INFO
+    #   t.log_level = :debug
+    #
+    def log_level=(level)
+      if level.is_a?(Integer)
+        @logger.level = level
+      else
+        @logger.level = Logger.const_get(level.to_s.upcase)
+      end
+    end
+
+    def initialize(name = :assets)
+      @name         = name
+      @environment  = lambda { Sprockets::Environment.new(Dir.pwd) }
+      @logger       = Logger.new($stderr)
+      @logger.level = Logger::INFO
+      @keep         = 2
+
+      yield self if block_given?
+
+      define
+    end
+
+    # Define tasks
+    def define
+      desc name == :assets ? "Compile assets" : "Compile #{name} assets"
+      task name do
+        with_logger do
+          manifest.compile(assets)
+        end
+      end
+
+      desc name == :assets ? "Remove all assets" : "Remove all #{name} assets"
+      task "clobber_#{name}" do
+        with_logger do
+          manifest.clobber
+        end
+      end
+
+      task :clobber => ["clobber_#{name}"]
+
+      desc name == :assets ? "Clean old assets" : "Clean old #{name} assets"
+      task "clean_#{name}" do
+        with_logger do
+          manifest.clean(keep)
+        end
+      end
+
+      task :clean => ["clean_#{name}"]
+    end
+
+    private
+      # Returns cached indexed environment
+      def index
+        @index ||= environment.index
+      end
+
+      # Returns manifest for tasks
+      def manifest
+        @manifest ||= Sprockets::Manifest.new(index, output)
+      end
+
+      # Sub out environment logger with our rake task logger that
+      # writes to stderr.
+      def with_logger
+        old_logger = index.logger
+        index.logger = @logger
+        yield
+      ensure
+        index.logger = old_logger
+      end
+  end
+end

data/lib/sprockets.rb

@@ -6,6 +6,7 @@ module Sprockets
   autoload :Engines,                 "sprockets/engines"
   autoload :Environment,             "sprockets/environment"
   autoload :Index,                   "sprockets/index"
+  autoload :Manifest,                "sprockets/manifest"
 
   # Assets
   autoload :Asset,                   "sprockets/asset"

data/lib/sprockets/asset.rb

@@ -138,6 +138,8 @@ module Sprockets
       # Gzip contents if filename has '.gz'
       options[:compress] ||= File.extname(filename) == '.gz'
 
+      FileUtils.mkdir_p File.dirname(filename)
+
       File.open("#{filename}+", 'wb') do |f|
         if options[:compress]
           # Run contents through `Zlib`

data/lib/sprockets/base.rb

@@ -103,6 +103,12 @@ module Sprockets
       raise NotImplementedError
     end
 
+    if defined? Encoding.default_external
+      # Define `default_external_encoding` accessor on 1.9.
+      # Defaults to UTF-8.
+      attr_accessor :default_external_encoding
+    end
+
     # Works like `Dir.entries`.
     #
     # Subclasses may cache this method.
@@ -149,7 +155,7 @@ module Sprockets
       logical_path = path
       pathname     = Pathname.new(path)
 
-      if pathname.to_s =~ /^\//
+      if pathname.absolute?
         return unless stat(pathname)
         logical_path = attributes_for(pathname).logical_path
       else
@@ -204,13 +210,15 @@ module Sprockets
       nil
     end
 
-    def each_logical_path
-      return to_enum(__method__) unless block_given?
+    def each_logical_path(*args)
+      return to_enum(__method__, *args) unless block_given?
+      filters = args.flatten
       files = {}
       each_file do |filename|
-        logical_path = attributes_for(filename).logical_path
-        yield logical_path unless files[logical_path]
-        files[logical_path] = true
+        if logical_path = logical_path_for_filename(filename, filters)
+          yield logical_path unless files[logical_path]
+          files[logical_path] = true
+        end
       end
       nil
     end
@@ -263,5 +271,37 @@ module Sprockets
       ensure
         Thread.current[:sprockets_circular_calls] = nil if reset
       end
+
+      def logical_path_for_filename(filename, filters)
+        logical_path = attributes_for(filename).logical_path.to_s
+
+        if matches_filter(filters, logical_path)
+          return logical_path
+        end
+
+        # If filename is an index file, retest with alias
+        if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
+          path = logical_path.sub(/\/index\./, '.')
+          if matches_filter(filters, path)
+            return path
+          end
+        end
+
+        nil
+      end
+
+      def matches_filter(filters, filename)
+        return true if filters.empty?
+
+        filters.any? do |filter|
+          if filter.is_a?(Regexp)
+            filter.match(filename)
+          elsif filter.respond_to?(:call)
+            filter.call(filename)
+          else
+            File.fnmatch(filter.to_s, filename)
+          end
+        end
+      end
   end
 end

data/lib/sprockets/cache/file_store.rb

@@ -6,14 +6,11 @@ module Sprockets
   module Cache
     # A simple file system cache store.
     #
-    #     environment.cache = Sprockets::Cache::FileStore.new("tmp/sprockets")
+    #     environment.cache = Sprockets::Cache::FileStore.new("/tmp")
     #
     class FileStore
       def initialize(root)
         @root = Pathname.new(root)
-
-        # Ensure directory exists
-        FileUtils.mkdir_p @root
       end
 
       # Lookup value in cache
@@ -24,6 +21,9 @@ module Sprockets
 
       # Save value to cache
       def []=(key, value)
+        # Ensure directory exists
+        FileUtils.mkdir_p @root.join(key).dirname
+
         @root.join(key).open('w') { |f| Marshal.dump(value, f)}
         value
       end

data/lib/sprockets/context.rb

@@ -11,7 +11,7 @@ module Sprockets
   # helpers by injecting them into `Environment#context_class`. Do not
   # mix them into `Context` directly.
   #
-  #     environment.instance_eval do
+  #     environment.context_class.class_eval do
   #       include MyHelper
   #       def asset_url; end
   #     end
@@ -22,7 +22,8 @@ module Sprockets
   # assets. See `DirectiveProcessor` for an example of this.
   class Context
     attr_reader :environment, :pathname
-    attr_reader :_required_paths, :_dependency_paths, :_dependency_assets
+    attr_reader :_required_paths, :_stubbed_assets
+    attr_reader :_dependency_paths, :_dependency_assets
     attr_writer :__LINE__
 
     def initialize(environment, logical_path, pathname)
@@ -32,6 +33,7 @@ module Sprockets
       @__LINE__     = nil
 
       @_required_paths    = []
+      @_stubbed_assets    = Set.new
       @_dependency_paths  = Set.new
       @_dependency_assets = Set.new([pathname.to_s])
     end
@@ -78,7 +80,7 @@ module Sprockets
       pathname   = Pathname.new(path)
       attributes = environment.attributes_for(pathname)
 
-      if pathname.to_s =~ /^\//
+      if pathname.absolute?
         pathname
 
       elsif content_type = options[:content_type]
@@ -143,6 +145,14 @@ module Sprockets
       nil
     end
 
+    # `stub_asset` blacklists `path` from being included in the bundle.
+    # `path` must be an asset which may or may not already be included
+    # in the bundle.
+    def stub_asset(path)
+      @_stubbed_assets << resolve(path, :content_type => :self).to_s
+      nil
+    end
+
     # Tests if target path is able to be safely required into the
     # current concatenation.
     def asset_requirable?(path)
@@ -168,7 +178,13 @@ module Sprockets
       if options[:data]
         result = options[:data]
       else
-        result = Sprockets::Utils.read_unicode(pathname)
+        if environment.respond_to?(:default_external_encoding)
+          mime_type = environment.mime_types(pathname.extname)
+          encoding  = environment.encoding_for_mime_type(mime_type)
+          result    = Sprockets::Utils.read_unicode(pathname, encoding)
+        else
+          result = Sprockets::Utils.read_unicode(pathname)
+        end
       end
 
       processors.each do |processor|