class Sprockets::Context

assets. See ‘DirectiveProcessor` for an example of this.
The `Context` also collects dependencies declared by
<%= asset_url “foo.png” %>
end
def asset_url; end
include MyHelper
environment.context_class.class_eval do
`Context` directly.
by injecting them into `Environment#context_class`. Do not mix them into
They are typically accessed by ERB templates. You can mix in custom helpers
Deprecated: `Context` provides helper methods to all processors.

def asset_data_uri(path)


$('').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')

#logo { background: url(<%= asset_data_uri 'logo.png' %>) }

Use `asset_data_uri` from ERB with CSS or JavaScript assets:

of the current file.
asset at the specified path, and marks that path as a dependency
Returns a Base64-encoded `data:` URI with the contents of the 
def asset_data_uri(path)
  asset = depend_on_asset(path)
  data = EncodingUtils.base64(asset.source)
  "data:#{asset.content_type};base64,#{Rack::Utils.escape(data)}"
end

def asset_path(path, options = {})

are required to be overridden.
basics implemention may be provided with different methods that
customized by the application. Though, in the future, some
NOTE: This helper is currently not implemented and should be

Expands logical path to full url to asset. 
def asset_path(path, options = {})
  message = <<-EOS
om asset_path helper is not implemented
nd your environment context with a custom method.
environment.context_class.class_eval do
  def asset_path(path, options = {})
  end
end
  EOS
  raise NotImplementedError, message
end

def audio_path(path)

Expand logical audio asset path. 
def audio_path(path)
  asset_path(path, type: :audio)
end

def depend_on(path)

source file.
the dependency file with invalidate the cache of the
This is used for caching purposes. Any changes made to

including it.
`depend_on` allows you to state a dependency on a file without 
def depend_on(path)
  path = path.to_s if path.is_a?(Pathname)
  if environment.absolute_path?(path) && environment.stat(path)
    @dependencies << environment.build_file_digest_uri(path)
  else
    resolve(path, compat: false)
  end
  nil
end

def depend_on_asset(path)

the target asset's dependencies.
file. Unlike `depend_on`, this will include recursively include
invalidate the dependency asset will invalidate the source
This is used for caching purposes. Any changes that would

without including it.
`depend_on_asset` allows you to state an asset dependency 
def depend_on_asset(path)
  load(resolve(path, compat: false))
end

def font_path(path)

Expand logical font asset path. 
def font_path(path)
  asset_path(path, type: :font)
end

def image_path(path)

Expand logical image asset path. 
def image_path(path)
  asset_path(path, type: :image)
end

def initialize(input) 

def initialize(input)
  @environment  = input[:environment]
  @metadata     = input[:metadata]
  @load_path    = input[:load_path]
  @logical_path = input[:name]
  @filename     = input[:filename]
  @dirname      = File.dirname(@filename)
  @pathname     = Pathname.new(@filename)
  @content_type = input[:content_type]
  @required     = Set.new(@metadata[:required])
  @stubbed      = Set.new(@metadata[:stubbed])
  @links        = Set.new(@metadata[:links])
  @dependencies = Set.new(input[:metadata][:dependencies])
end

def javascript_path(path)

Expand logical javascript asset path. 
def javascript_path(path)
  asset_path(path, type: :javascript)
end

def link_asset(path)

Returns an Asset or nil.

easy to construct a link to it.
including it. The target asset is returned from this function making it
`link_asset` declares an external dependency on an asset without directly 
def link_asset(path)
  asset = depend_on_asset(path)
  @links << asset.uri
  asset
end

def load(uri)

Returns Asset.

uri - AssetURI

Public: Load Asset by AssetURI and track it as a dependency. 
def load(uri)
  asset = environment.load(uri)
  @dependencies.merge(asset.metadata[:dependencies])
  asset
end

def metadata 

def metadata
  { required: @required,
    stubbed: @stubbed,
    links: @links,
    dependencies: @dependencies }
end

def require_asset(path)


<%= require_asset "#{framework}.js" %>

require assets.
If ERB processing is enabled, you can use it to dynamically

included once.
dependency will be inserted before the file and will only be
`require_asset` declares `path` as a dependency of the file. The 
def require_asset(path)
  @required << resolve(path, accept: @content_type, pipeline: :self, compat: false)
  nil
end

def resolve(path, options = {})

Returns an Asset URI String.

accept - String content accept type
options
path - String logical or absolute path

# => "file:///path/to/app/javascripts/bar.js?type=application/javascript"
resolve("./bar.js")

# => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
resolve("foo.js")

restrict the search.
Relative paths will also be resolved. An accept type maybe given to
Public: Given a logical path, `resolve` will find and return an Asset URI. 
def resolve(path, options = {})
  uri, deps = environment.resolve!(path, options.merge(base_path: @dirname))
  @dependencies.merge(deps)
  uri
end

def resolve_with_compat(path, options = {})


# => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
resolve("foo.js")

4.x

# => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
resolve("foo.js", compat: false)

# => "/path/to/app/javascripts/foo.js"
resolve("foo.js", compat: true)

# => "/path/to/app/javascripts/foo.js"
resolve("foo.js")

3.x

# => "/path/to/app/javascripts/foo.js"
resolve("foo.js")

2.x

compatible plain filename String. 4.x will always return an Asset URI.
Deprecated: Change default return type of resolve() to return 2.x 
def resolve_with_compat(path, options = {})
  options = options.dup
  # Support old :content_type option, prefer :accept going forward
  if type = options.delete(:content_type)
    type = self.content_type if type == :self
    options[:accept] ||= type
  end
  if options.delete(:compat) { true }
    uri = resolve_without_compat(path, options)
    path, _ = environment.parse_asset_uri(uri)
    path
  else
    resolve_without_compat(path, options)
  end
end

def stub_asset(path)

in the bundle.
`path` must be an asset which may or may not already be included
`stub_asset` blacklists `path` from being included in the bundle. 
def stub_asset(path)
  @stubbed << resolve(path, accept: @content_type, pipeline: :self, compat: false)
  nil
end

def stylesheet_path(path)

Expand logical stylesheet asset path. 
def stylesheet_path(path)
  asset_path(path, type: :stylesheet)
end

def video_path(path)

Expand logical video asset path. 
def video_path(path)
  asset_path(path, type: :video)
end