sprockets-rails 0.0.1 → 1.0.0

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Sam Stephenson
+Copyright (c) 2012 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -0,0 +1,3 @@
+= sprockets-rails
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -1,40 +1,24 @@
-require 'rubygems'
-require 'rake'
+#!/usr/bin/env rake
 require 'rake/testtask'
-require 'rake/rdoctask'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "sprockets-rails"
-    gem.summary = %Q{Sprockets JavaScript dependency management and concatenation support for Rails applications}
-    gem.description = %Q{Sprockets JavaScript dependency management and concatenation support for Rails applications}
-    gem.email = "jeff@80beans.com"
-    gem.homepage = "http://github.com/80beans/sprockets-rails"
-    gem.authors = ["Sam Stephenson","Jeff Kreeftmeijer"]
-    gem.add_dependency 'sprockets', ">= 1.0.2"
+namespace :test do
+  task :isolated do
+    Dir["test/assets*_test.rb"].each do |file|
+      dash_i = [
+        'test',
+        'lib',
+      ]
+      ruby "-I#{dash_i.join ':'}", file
+    end
   end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the sprockets plugin.'
-Rake::TestTask.new(:test) do |t|
+Rake::TestTask.new("test:regular") do |t|
   t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
+  t.libs << 'test'
+  t.pattern = 'test/**/sprockets*_test.rb'
   t.verbose = true
 end
 
-desc 'Generate documentation for the sprockets plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Sprockets'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-Jeweler::GemcutterTasks.new
+task :test => ['test:isolated', 'test:regular']
+task :default => :test

data/lib/sprockets/rails/bootstrap.rb

@@ -0,0 +1,41 @@
+module Sprockets
+  module Rails
+    class Bootstrap
+      def initialize(app)
+        @app = app
+      end
+
+      # TODO: Get rid of config.assets.enabled
+      def run
+        app, config = @app, @app.config
+        return unless app.assets
+
+        config.assets.paths.each { |path| app.assets.append_path(path) }
+
+        if config.assets.compress
+          # temporarily hardcode default JS compressor to uglify. Soon, it will work
+          # the same as SCSS, where a default plugin sets the default.
+          unless config.assets.js_compressor == false
+            js_compressor = config.assets.js_compressor || :uglifier
+            app.assets.js_compressor = LazyCompressor.new { Sprockets::Rails::Compressors.registered_js_compressor(js_compressor) }
+          end
+
+          unless config.assets.css_compressor == false
+            css_compressor = config.assets.css_compressor
+            app.assets.css_compressor = LazyCompressor.new { Sprockets::Rails::Compressors.registered_css_compressor(css_compressor) }
+          end
+        end
+
+        if config.assets.compile
+          app.routes.prepend do
+            mount app.assets => config.assets.prefix
+          end
+        end
+
+        if config.assets.digest
+          app.assets = app.assets.index
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/rails/compressors.rb

@@ -0,0 +1,87 @@
+module Sprockets
+  module Rails
+    module Compressors
+      extend self
+
+      @@css_compressors = {}
+      @@js_compressors = {}
+      @@default_css_compressor = nil
+      @@default_js_compressor = nil
+
+      def register_css_compressor(name, klass, options = {})
+        @@default_css_compressor = name.to_sym if options[:default] || @@default_css_compressor.nil?
+        @@css_compressors[name.to_sym] = { :klass => klass.to_s, :require => options[:require] }
+      end
+
+      def register_js_compressor(name, klass, options = {})
+        @@default_js_compressor = name.to_sym if options[:default] || @@default_js_compressor.nil?
+        @@js_compressors[name.to_sym] = { :klass => klass.to_s, :require => options[:require] }
+      end
+
+      def registered_css_compressor(name)
+        find_registered_compressor name, @@css_compressors, @@default_css_compressor
+      end
+
+      def registered_js_compressor(name)
+        find_registered_compressor name, @@js_compressors, @@default_js_compressor
+      end
+
+      # The default compressors must be registered in default plugins (ex. Sass-Rails)
+      register_css_compressor(:scss, 'Sass::Rails::Compressor', :require => 'sass/rails/compressor', :default => true)
+      register_js_compressor(:uglifier, 'Uglifier', :require => 'uglifier', :default => true)
+
+      # Automaticaly register some compressors
+      register_css_compressor(:yui, 'YUI::CssCompressor', :require => 'yui/compressor')
+      register_js_compressor(:closure, 'Closure::Compiler', :require => 'closure-compiler')
+      register_js_compressor(:yui, 'YUI::JavaScriptCompressor', :require => 'yui/compressor')
+
+      private
+
+      def find_registered_compressor(name, compressors_hash, default_compressor_name)
+        if name.respond_to?(:to_sym)
+          compressor = compressors_hash[name.to_sym] || compressors_hash[default_compressor_name]
+          require compressor[:require] if compressor[:require]
+          compressor[:klass].constantize.new
+        else
+          name
+        end
+      end
+    end
+
+    # An asset compressor which does nothing.
+    #
+    # This compressor simply returns the asset as-is, without any compression
+    # whatsoever. It is useful in development mode, when compression isn't
+    # needed but using the same asset pipeline as production is desired.
+    class NullCompressor #:nodoc:
+      def compress(content)
+        content
+      end
+    end
+
+    # An asset compressor which only initializes the underlying compression
+    # engine when needed.
+    #
+    # This postpones the initialization of the compressor until
+    # <code>#compress</code> is called the first time.
+    class LazyCompressor #:nodoc:
+      # Initializes a new LazyCompressor.
+      #
+      # The block should return a compressor when called, i.e. an object
+      # which responds to <code>#compress</code>.
+      def initialize(&block)
+        @block = block
+      end
+
+      def compress(content)
+        compressor.compress(content)
+      end
+
+      private
+
+      def compressor
+        @compressor ||= (@block.call || NullCompressor.new)
+      end
+    end
+  end
+end

data/lib/sprockets/rails/helpers/isolated_helper.rb

@@ -0,0 +1,15 @@
+module Sprockets
+  module Rails
+    module Helpers
+      module IsolatedHelper
+        def controller
+          nil
+        end
+
+        def config
+          ::Rails.application.config.action_controller
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/rails/helpers/rails_helper.rb

@@ -0,0 +1,169 @@
+require "action_view"
+
+module Sprockets
+  module Rails
+    module Helpers
+      module RailsHelper
+        extend ActiveSupport::Concern
+        include ActionView::Helpers::AssetTagHelper
+
+        def asset_paths
+          @asset_paths ||= begin
+            paths = RailsHelper::AssetPaths.new(config, controller)
+            paths.asset_environment = asset_environment
+            paths.asset_digests     = asset_digests
+            paths.compile_assets    = compile_assets?
+            paths.digest_assets     = digest_assets?
+            paths
+          end
+        end
+
+        def javascript_include_tag(*sources)
+          options = sources.extract_options!
+          debug   = options.delete(:debug)  { debug_assets? }
+          body    = options.delete(:body)   { false }
+          digest  = options.delete(:digest) { digest_assets? }
+
+          sources.collect do |source|
+            if debug && asset = asset_paths.asset_for(source, 'js')
+              asset.to_a.map { |dep|
+                super(dep.pathname.to_s, { :src => path_to_asset(dep, :ext => 'js', :body => true, :digest => digest) }.merge!(options))
+              }
+            else
+              super(source.to_s, { :src => path_to_asset(source, :ext => 'js', :body => body, :digest => digest) }.merge!(options))
+            end
+          end.join("\n").html_safe
+        end
+
+        def stylesheet_link_tag(*sources)
+          options = sources.extract_options!
+          debug   = options.delete(:debug)  { debug_assets? }
+          body    = options.delete(:body)   { false }
+          digest  = options.delete(:digest) { digest_assets? }
+
+          sources.collect do |source|
+            if debug && asset = asset_paths.asset_for(source, 'css')
+              asset.to_a.map { |dep|
+                super(dep.pathname.to_s, { :href => path_to_asset(dep, :ext => 'css', :body => true, :protocol => :request, :digest => digest) }.merge!(options))
+              }
+            else
+              super(source.to_s, { :href => path_to_asset(source, :ext => 'css', :body => body, :protocol => :request, :digest => digest) }.merge!(options))
+            end
+          end.join("\n").html_safe
+        end
+
+        def asset_path(source, options = {})
+          source = source.logical_path if source.respond_to?(:logical_path)
+          path = asset_paths.compute_public_path(source, asset_prefix, options.merge(:body => true))
+          options[:body] ? "#{path}?body=1" : path
+        end
+        alias_method :path_to_asset, :asset_path # aliased to avoid conflicts with an asset_path named route
+
+        def image_path(source)
+          path_to_asset(source)
+        end
+        alias_method :path_to_image, :image_path # aliased to avoid conflicts with an image_path named route
+
+        def font_path(source)
+          path_to_asset(source)
+        end
+        alias_method :path_to_font, :font_path # aliased to avoid conflicts with an font_path named route
+
+        def javascript_path(source)
+          path_to_asset(source, :ext => 'js')
+        end
+        alias_method :path_to_javascript, :javascript_path # aliased to avoid conflicts with an javascript_path named route
+
+        def stylesheet_path(source)
+          path_to_asset(source, :ext => 'css')
+        end
+        alias_method :path_to_stylesheet, :stylesheet_path # aliased to avoid conflicts with an stylesheet_path named route
+
+      private
+        def debug_assets?
+          compile_assets? && (::Rails.application.config.assets.debug || params[:debug_assets])
+        rescue NameError
+          false
+        end
+
+        # Override to specify an alternative prefix for asset path generation.
+        # When combined with a custom +asset_environment+, this can be used to
+        # implement themes that can take advantage of the asset pipeline.
+        #
+        # If you only want to change where the assets are mounted, refer to
+        # +config.assets.prefix+ instead.
+        def asset_prefix
+          ::Rails.application.config.assets.prefix
+        end
+
+        def asset_digests
+          ::Rails.application.config.assets.digests
+        end
+
+        def compile_assets?
+          ::Rails.application.config.assets.compile
+        end
+
+        def digest_assets?
+          ::Rails.application.config.assets.digest
+        end
+
+        # Override to specify an alternative asset environment for asset
+        # path generation. The environment should already have been mounted
+        # at the prefix returned by +asset_prefix+.
+        def asset_environment
+          ::Rails.application.assets
+        end
+
+        class AssetPaths < ::ActionView::AssetPaths #:nodoc:
+          attr_accessor :asset_environment, :asset_prefix, :asset_digests, :compile_assets, :digest_assets
+
+          class AssetNotPrecompiledError < StandardError; end
+
+          def asset_for(source, ext)
+            source = source.to_s
+            return nil if is_uri?(source)
+            source = rewrite_extension(source, nil, ext)
+            asset_environment[source]
+          rescue Sprockets::FileOutsidePaths
+            nil
+          end
+
+          def digest_for(logical_path)
+            if digest_assets && asset_digests && (digest = asset_digests[logical_path])
+              return digest
+            end
+
+            if compile_assets
+              if digest_assets && asset = asset_environment[logical_path]
+                return asset.digest_path
+              end
+              return logical_path
+            else
+              raise AssetNotPrecompiledError.new("#{logical_path} isn't precompiled")
+            end
+          end
+
+          def rewrite_asset_path(source, dir, options = {})
+            if source[0] == ?/
+              source
+            else
+              source = digest_for(source) unless options[:digest] == false
+              source = File.join(dir, source)
+              source = "/#{source}" unless source =~ /^\//
+              source
+            end
+          end
+
+          def rewrite_extension(source, dir, ext)
+            if ext && File.extname(source) != ".#{ext}"
+              "#{source}.#{ext}"
+            else
+              source
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/rails/helpers.rb

@@ -0,0 +1,8 @@
+module Sprockets
+  module Rails
+    module Helpers
+      autoload :RailsHelper,    "sprockets/rails/helpers/rails_helper"
+      autoload :IsolatedHelper, "sprockets/rails/helpers/isolated_helper"
+    end
+  end
+end

data/lib/sprockets/rails/railtie.rb

@@ -0,0 +1,64 @@
+require "action_controller/railtie"
+
+module Sprockets
+  module Rails
+    autoload :Bootstrap,      "sprockets/rails/bootstrap"
+    autoload :Helpers,        "sprockets/rails/helpers"
+    autoload :Compressors,    "sprockets/rails/compressors"
+    autoload :LazyCompressor, "sprockets/rails/compressors"
+    autoload :NullCompressor, "sprockets/rails/compressors"
+    autoload :StaticCompiler, "sprockets/rails/static_compiler"
+
+    # TODO: Get rid of config.assets.enabled
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load "tasks/assets.rake"
+      end
+
+      initializer "sprockets.environment", :group => :all do |app|
+        config = app.config
+        next unless config.assets.enabled
+
+        require 'sprockets'
+
+        app.assets = Sprockets::Environment.new(app.root.to_s) do |env|
+          env.version = ::Rails.env + "-#{config.assets.version}"
+
+          if config.assets.logger != false
+            env.logger = config.assets.logger || ::Rails.logger
+          end
+
+          if config.assets.cache_store != false
+            env.cache = ActiveSupport::Cache.lookup_store(config.assets.cache_store) || ::Rails.cache
+          end
+        end
+
+        if config.assets.manifest
+          path = File.join(config.assets.manifest, "manifest.yml")
+        else
+          path = File.join(::Rails.public_path, config.assets.prefix, "manifest.yml")
+        end
+
+        if File.exist?(path)
+          config.assets.digests = YAML.load_file(path)
+        end
+
+        ActiveSupport.on_load(:action_view) do
+          include ::Sprockets::Rails::Helpers::RailsHelper
+          app.assets.context_class.instance_eval do
+            include ::Sprockets::Rails::Helpers::IsolatedHelper
+            include ::Sprockets::Rails::Helpers::RailsHelper
+          end
+        end
+      end
+
+      # We need to configure this after initialization to ensure we collect
+      # paths from all engines. This hook is invoked exactly before routes
+      # are compiled, and so that other Railties have an opportunity to
+      # register compressors.
+      config.after_initialize do |app|
+        Sprockets::Rails::Bootstrap.new(app).run
+      end
+    end
+  end
+end

data/lib/sprockets/rails/static_compiler.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+
+module Sprockets
+  module Rails
+    class StaticCompiler
+      attr_accessor :env, :target, :paths
+
+      def initialize(env, target, paths, options = {})
+        @env = env
+        @target = target
+        @paths = paths
+        @digest = options.fetch(:digest, true)
+        @manifest = options.fetch(:manifest, true)
+        @manifest_path = options.delete(:manifest_path) || target
+        @zip_files = options.delete(:zip_files) || /\.(?:css|html|js|svg|txt|xml)$/
+      end
+
+      def compile
+        manifest = {}
+        env.each_logical_path do |logical_path|
+          next unless compile_path?(logical_path)
+          if asset = env.find_asset(logical_path)
+            manifest[logical_path] = write_asset(asset)
+          end
+        end
+        write_manifest(manifest) if @manifest
+      end
+
+      def write_manifest(manifest)
+        FileUtils.mkdir_p(@manifest_path)
+        File.open("#{@manifest_path}/manifest.yml", 'wb') do |f|
+          YAML.dump(manifest, f)
+        end
+      end
+
+      def write_asset(asset)
+        path_for(asset).tap do |path|
+          filename = File.join(target, path)
+          FileUtils.mkdir_p File.dirname(filename)
+          asset.write_to(filename)
+          asset.write_to("#{filename}.gz") if filename.to_s =~ @zip_files
+        end
+      end
+
+      def compile_path?(logical_path)
+        paths.each do |path|
+          case path
+          when Regexp
+            return true if path.match(logical_path)
+          when Proc
+            return true if path.call(logical_path)
+          else
+            return true if File.fnmatch(path.to_s, logical_path)
+          end
+        end
+        false
+      end
+
+      def path_for(asset)
+        @digest ? asset.digest_path : asset.logical_path
+      end
+    end
+  end
+end

data/lib/sprockets/rails/version.rb

@@ -0,0 +1,5 @@
+module Sprockets
+  module Rails
+    VERSION = "1.0.0"
+  end
+end

data/lib/sprockets-rails.rb

@@ -1,8 +1,7 @@
-require "sprockets"
-require "sprockets_helper"
-require "sprocket"
-require "sprockets_application"
+require 'sprockets'
+require 'sprockets/rails/railtie'
 
-class ActionController::Base
-  helper :sprockets
+module Sprockets
+  module Rails
+  end
 end

data/lib/tasks/assets.rake

@@ -0,0 +1,105 @@
+require "fileutils"
+
+namespace :assets do
+  def ruby_rake_task(task, fork = true)
+    env    = ENV['RAILS_ENV'] || 'production'
+    groups = ENV['RAILS_GROUPS'] || 'assets'
+    args   = [$0, task,"RAILS_ENV=#{env}","RAILS_GROUPS=#{groups}"]
+    args << "--trace" if Rake.application.options.trace
+    if $0 =~ /rake\.bat\Z/i
+      Kernel.exec $0, *args
+    else
+      fork ? ruby(*args) : Kernel.exec(FileUtils::RUBY, *args)
+    end
+  end
+
+  # We are currently running with no explicit bundler group
+  # and/or no explicit environment - we have to reinvoke rake to
+  # execute this task.
+  def invoke_or_reboot_rake_task(task)
+    if ENV['RAILS_GROUPS'].to_s.empty? || ENV['RAILS_ENV'].to_s.empty?
+      ruby_rake_task task
+    else
+      Rake::Task[task].invoke
+    end
+  end
+
+  desc "Compile all the assets named in config.assets.precompile"
+  task :precompile do
+    invoke_or_reboot_rake_task "assets:precompile:all"
+  end
+
+  namespace :precompile do
+    def internal_precompile(digest=nil)
+      unless ::Rails.application.config.assets.enabled
+        warn "Cannot precompile assets if sprockets is disabled. Please set config.assets.enabled to true"
+        exit
+      end
+
+      # Ensure that action view is loaded and the appropriate
+      # sprockets hooks get executed
+      _ = ActionView::Base
+
+      config = ::Rails.application.config
+      config.assets.compile = true
+      config.assets.digest  = digest unless digest.nil?
+      config.assets.digests = {}
+
+      env      = ::Rails.application.assets
+      target   = File.join(::Rails.public_path, config.assets.prefix)
+      compiler = Sprockets::Rails::StaticCompiler.new(env,
+                                                      target,
+                                                      config.assets.precompile,
+                                                      :manifest_path => config.assets.manifest,
+                                                      :digest => config.assets.digest,
+                                                      :manifest => digest.nil?)
+      compiler.compile
+    end
+
+    task :all do
+      Rake::Task["assets:precompile:primary"].invoke
+      # We need to reinvoke in order to run the secondary digestless
+      # asset compilation run - a fresh Sprockets environment is
+      # required in order to compile digestless assets as the
+      # environment has already cached the assets on the primary
+      # run.
+      ruby_rake_task("assets:precompile:nondigest", false) if ::Rails.application.config.assets.digest
+    end
+
+    task :primary => ["assets:cache:clean"] do
+      internal_precompile
+    end
+
+    task :nondigest => ["assets:cache:clean"] do
+      internal_precompile(false)
+    end
+  end
+
+  desc "Remove compiled assets"
+  task :clean do
+    invoke_or_reboot_rake_task "assets:clean:all"
+  end
+
+  namespace :clean do
+    task :all => ["assets:cache:clean"] do
+      config = ::Rails.application.config
+      public_asset_path = File.join(::Rails.public_path, config.assets.prefix)
+      rm_rf public_asset_path, :secure => true
+    end
+  end
+
+  namespace :cache do
+    task :clean => ["assets:environment"] do
+      ::Rails.application.assets.cache.clear
+    end
+  end
+
+  task :environment do
+    if ::Rails.application.config.assets.initialize_on_precompile
+      Rake::Task["environment"].invoke
+    else
+      ::Rails.application.initialize!(:assets)
+      Sprockets::Rails::Bootstrap.new(Rails.application).run
+    end
+  end
+end