class Sprockets::BundledAsset

concatenated with other assets. Use for ‘.js` and `.css` files.
`BundledAsset`s are used for files that need to be processed and

def body

original file.
dependencies but does run any processors or engines on the
Get asset's own processed contents. Excludes any of its required 
def body
  @processed_asset.source
end

def dependencies

Return an `Array` of `Asset` files that are declared dependencies. 
def dependencies
  to_a.reject { |a| a.eql?(@processed_asset) }
end

def encode_with(coder)

Serialize custom attributes in `BundledAsset`. 
def encode_with(coder)
  super
  coder['source'] = source
  coder['required_assets_digest'] = @processed_asset.dependency_digest
end

def fresh?(environment)

digest to the inmemory model.
Checks if Asset is stale by comparing the actual mtime and 
def fresh?(environment)
  @processed_asset.fresh?(environment)
end

def init_with(environment, coder)

Initialize `BundledAsset` from serialized `Hash`. 
def init_with(environment, coder)
  super
  @processed_asset = environment.find_asset(pathname, :bundle => false)
  @required_assets = @processed_asset.required_assets
  if @processed_asset.dependency_digest != coder['required_assets_digest']
    raise UnserializeError, "processed asset belongs to a stale environment"
  end
  @source = coder['source']
end

def initialize(environment, logical_path, pathname) 

def initialize(environment, logical_path, pathname)
  super(environment, logical_path, pathname)
  @processed_asset  = environment.find_asset(pathname, :bundle => false)
  @required_assets  = @processed_asset.required_assets
  @dependency_paths = @processed_asset.dependency_paths
  @source = ""
  # Explode Asset into parts and gather the dependency bodies
  to_a.each { |dependency| @source << dependency.to_s }
  # Run bundle processors on concatenated source
  context = environment.context_class.new(environment, logical_path, pathname)
  @source = context.evaluate(pathname, :data => @source,
              :processors => environment.bundle_processors(content_type))
  @mtime  = (to_a + @dependency_paths).map(&:mtime).max
  @length = Rack::Utils.bytesize(source)
  @digest = environment.digest.update(source).hexdigest
end

def to_a

Expand asset into an `Array` of parts. 
def to_a
  required_assets
end