Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 746d1fff1d
Fetching contributors…

Octocat-spinner-32-eaf2f5

Cannot retrieve contributors at this time

file 180 lines (155 sloc) 6.646 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
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.digest_files = digest_files
            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.uniq.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.uniq.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 a 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 a 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 a 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 digest_files
          ::Rails.application.config.assets.digest_files
        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, :digest_files, :compile_assets, :digest_assets

          class AssetNotPrecompiledError < StandardError; end

          # Retrieve the asset path on disk, for processed files +ext+ should
          # contain the final extension (e.g. +js+ for <tt>*.js.coffee</tt>).
          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 && digest_files && (digest = digest_files[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
              if digest_assets && options[:digest] != false
                source = digest_for(source)
              end
              source = File.join(dir, source)
              source = "/#{source}" unless source =~ /^\//
              source
            end
          end

          def rewrite_extension(source, dir, ext)
            source_ext = File.extname(source)
            if ext && source_ext != ".#{ext}"
              if !source_ext.empty? && (asset = asset_environment[source]) &&
                    asset.pathname.to_s =~ /#{source}\Z/
                source
              else
                "#{source}.#{ext}"
              end
            else
              source
            end
          end
        end
      end
    end
  end
end
Something went wrong with that request. Please try again.