sprockets-rails 1.0.0 → 2.0.0.backport1

data/lib/sprockets-rails.rb

@@ -1,7 +0,0 @@
-require 'sprockets'
-require 'sprockets/rails/railtie'
-
-module Sprockets
-  module Rails
-  end
-end

data/lib/sprockets/rails/bootstrap.rb

@@ -1,41 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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.rb

@@ -1,8 +0,0 @@
-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/helpers/isolated_helper.rb

@@ -1,15 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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/railtie.rb

@@ -1,64 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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