module ActionView::Helpers::AssetTagHelper

def self.register_javascript_expansion(expansions)
  expansions.each do |key, values|
    @@javascript_expansions[key] = (@@javascript_expansions[key] || []) | Array(values)
  end
end

def self.register_javascript_include_default(*args)
  ActiveSupport::Deprecation.warn "register_javascript_include_default is deprecated. Please " \
    "manipulate config.action_view.javascript_expansions[:defaults] directly", caller
  self.javascript_expansions[:defaults].concat args
end

def self.register_stylesheet_expansion(expansions)
  expansions.each do |key, values|
    @@stylesheet_expansions[key] = (@@stylesheet_expansions[key] || []) | Array(values)
  end
end

def self.reset_javascript_include_default
  ActiveSupport::Deprecation.warn "reset_javascript_include_default is deprecated. Please manipulate " \
    "config.action_view.javascript_expansions[:defaults] directly", caller
  self.javascript_expansions[:defaults] = ['prototype', 'effects', 'dragdrop', 'controls', 'rails']
end

def asset_file_path(path)
  File.join(config.assets_dir, path.split('?').first)
end

def asset_file_path!(path)
  unless is_uri?(path)
    absolute_path = asset_file_path(path)
    raise(Errno::ENOENT, "Asset file not found at '#{absolute_path}'" ) unless File.exist?(absolute_path)
    return absolute_path
  end
end

def audio_path(source)
  compute_public_path(source, 'audios')
end

def audio_tag(source, options = {})
  options.symbolize_keys!
  options[:src] = path_to_audio(source)
  tag("audio", options)
end

def auto_discovery_link_tag(type = :rss, url_options = {}, tag_options = {})
  tag(
    "link",
    "rel"   => tag_options[:rel] || "alternate",
    "type"  => tag_options[:type] || Mime::Type.lookup_by_extension(type.to_s).to_s,
    "title" => tag_options[:title] || type.to_s.upcase,
    "href"  => url_options.is_a?(Hash) ? url_for(url_options.merge(:only_path => false)) : url_options
  )
end

def collect_asset_files(*path)
  dir = path.first
  Dir[File.join(*path.compact)].collect do |file|
    file[-(file.size - dir.size - 1)..-1].sub(/\.\w+$/, '')
  end.sort
end

def compute_asset_host(source)
  if host = config.asset_host
    if host.is_a?(Proc) || host.respond_to?(:call)
      case host.is_a?(Proc) ? host.arity : host.method(:call).arity
      when 2
        request = controller.respond_to?(:request) && controller.request
        host.call(source, request)
      else
        host.call(source)
      end
    else
      (host =~ /%d/) ? host % (source.hash % 4) : host
    end
  end
end

def compute_javascript_paths(*args)
  expand_javascript_sources(*args).collect { |source| compute_public_path(source, 'javascripts', 'js', false) }
end

def compute_public_path(source, dir, ext = nil, include_host = true)
  return source if is_uri?(source)
  source += ".#{ext}" if rewrite_extension?(source, dir, ext)
  source  = "/#{dir}/#{source}" unless source[0] == ?/
  source = rewrite_asset_path(source, config.asset_path)
  has_request = controller.respond_to?(:request)
  if has_request && include_host && source !~ %r{^#{controller.config.relative_url_root}/}
    source = "#{controller.config.relative_url_root}#{source}"
  end
  source = rewrite_host_and_protocol(source, has_request) if include_host
  source
end

def compute_stylesheet_paths(*args)
  expand_stylesheet_sources(*args).collect { |source| compute_public_path(source, 'stylesheets', 'css', false) }
end

def determine_source(source, collection)
  case source
  when Symbol
    collection[source] || raise(ArgumentError, "No expansion found for #{source.inspect}")
  else
    source
  end
end

def ensure_javascript_sources!(sources)
  sources.each do |source|
    asset_file_path!(compute_public_path(source, 'javascripts', 'js', false))
  end
  return sources
end

def ensure_stylesheet_sources!(sources)
  sources.each do |source|
    asset_file_path!(compute_public_path(source, 'stylesheets', 'css', false))
  end
  return sources
end

def expand_javascript_sources(sources, recursive = false)
  if sources.include?(:all)
    all_javascript_files = (collect_asset_files(config.javascripts_dir, ('**' if recursive), '*.js') - ['application']) << 'application'
    ((determine_source(:defaults, @@javascript_expansions).dup & all_javascript_files) + all_javascript_files).uniq
  else
    expanded_sources = sources.collect do |source|
      determine_source(source, @@javascript_expansions)
    end.flatten
    expanded_sources << "application" if sources.include?(:defaults) && File.exist?(File.join(config.javascripts_dir, "application.js"))
    expanded_sources
  end
end

def expand_stylesheet_sources(sources, recursive)
  if sources.first == :all
    collect_asset_files(config.stylesheets_dir, ('**' if recursive), '*.css')
  else
    sources.collect do |source|
      determine_source(source, @@stylesheet_expansions)
    end.flatten
  end
end

def favicon_link_tag(source='/favicon.ico', options={})
  tag('link', {
    :rel  => 'shortcut icon',
    :type => 'image/vnd.microsoft.icon',
    :href => path_to_image(source)
  }.merge(options.symbolize_keys))
end

def image_path(source)
  compute_public_path(source, 'images')
end

def image_tag(source, options = {})

image_tag("mouse.png", :mouseover => image_path("mouse_over.png")) # =>

image_tag("mouse.png", :mouseover => "/images/mouse_over.png") # =>

image_tag("/icons/icon.gif", :class => "menu_icon") # =>

image_tag("/icons/icon.gif", :height => '32', :width => '32') # =>

image_tag("/icons/icon.gif", :size => "16x16") # =>

image_tag("icon.png", :size => "16x10", :alt => "Edit Entry") # =>

image_tag("icon.png") # =>

image_tag("icon") # =>
==== Examples

This can be used to implement an easy image toggle that fires on onmouseover.
event is fired, and sets the original image to be replaced onmouseout.
* :mouseover - Set an alternate image to be used when the onmouseover
value is not in the correct format.
width="30" and height="45". :size will be ignored if the
* :size - Supplied as "{Width}x{Height}", so "30x45" becomes
+source+ is used (capitalized and without the extension)
* :alt - If no alt text is given, the file name part of the

three additional keys for convenience and conformance:
You can add HTML attributes using the +options+. The +options+ supports
==== Options

path or a file that exists in your public images directory.
Returns an html image tag for the +source+. The +source+ can be a full

def image_tag(source, options = {})
  options.symbolize_keys!
  src = options[:src] = path_to_image(source)
  unless src =~ /^cid:/
    options[:alt] = options.fetch(:alt){ File.basename(src, '.*').capitalize }
  end
  if size = options.delete(:size)
    options[:width], options[:height] = size.split("x") if size =~ %r{^\d+x\d+$}
  end
  if mouseover = options.delete(:mouseover)
    options[:onmouseover] = "this.src='#{path_to_image(mouseover)}'"
    options[:onmouseout]  = "this.src='#{src}'"
  end
  tag("img", options)
end

def is_uri?(path)
  path =~ %r{^[-a-z]+://|^cid:}
end

def javascript_include_tag(*sources)
  options = sources.extract_options!.stringify_keys
  concat  = options.delete("concat")
  cache   = concat || options.delete("cache")
  recursive = options.delete("recursive")
  if concat || (config.perform_caching && cache)
    joined_javascript_name = (cache == true ? "all" : cache) + ".js"
    joined_javascript_path = File.join(joined_javascript_name[/^#{File::SEPARATOR}/] ? config.assets_dir : config.javascripts_dir, joined_javascript_name)
    unless config.perform_caching && File.exists?(joined_javascript_path)
      write_asset_file_contents(joined_javascript_path, compute_javascript_paths(sources, recursive))
    end
    javascript_src_tag(joined_javascript_name, options)
  else
    sources = expand_javascript_sources(sources, recursive)
    ensure_javascript_sources!(sources) if cache
    sources.collect { |source| javascript_src_tag(source, options) }.join("\n").html_safe
  end
end

def javascript_path(source)
  compute_public_path(source, 'javascripts', 'js')
end

def javascript_src_tag(source, options)
  content_tag("script", "", { "type" => Mime::JS, "src" => path_to_javascript(source) }.merge(options))
end

def join_asset_file_contents(paths)
  paths.collect { |path| File.read(asset_file_path!(path)) }.join("\n\n")
end

def rails_asset_id(source)
  if asset_id = ENV["RAILS_ASSET_ID"]
    asset_id
  else
    if @@cache_asset_timestamps && (asset_id = @@asset_timestamps_cache[source])
      asset_id
    else
      path = File.join(config.assets_dir, source)
      asset_id = File.exist?(path) ? File.mtime(path).to_i.to_s : ''
      if @@cache_asset_timestamps
        @@asset_timestamps_cache_guard.synchronize do
          @@asset_timestamps_cache[source] = asset_id
        end
      end
      asset_id
    end
  end
end

def rewrite_asset_path(source, path = nil)
  if path && path.respond_to?(:call)
    return path.call(source)
  elsif path && path.is_a?(String)
    return path % [source]
  end
  asset_id = rails_asset_id(source)
  if asset_id.blank?
    source
  else
    source + "?#{asset_id}"
  end
end

def rewrite_extension?(source, dir, ext)
  source_ext = File.extname(source)[1..-1]
  ext && (source_ext.blank? || (ext != source_ext && File.exist?(File.join(config.assets_dir, dir, "#{source}.#{ext}"))))
end

def rewrite_host_and_protocol(source, has_request)
  host = compute_asset_host(source)
  if has_request && host.present? && !is_uri?(host)
    host = "#{controller.request.protocol}#{host}"
  end
  "#{host}#{source}"
end

def stylesheet_link_tag(*sources)
  options = sources.extract_options!.stringify_keys
  concat  = options.delete("concat")
  cache   = concat || options.delete("cache")
  recursive = options.delete("recursive")
  if concat || (config.perform_caching && cache)
    joined_stylesheet_name = (cache == true ? "all" : cache) + ".css"
    joined_stylesheet_path = File.join(joined_stylesheet_name[/^#{File::SEPARATOR}/] ? config.assets_dir : config.stylesheets_dir, joined_stylesheet_name)
    unless config.perform_caching && File.exists?(joined_stylesheet_path)
      write_asset_file_contents(joined_stylesheet_path, compute_stylesheet_paths(sources, recursive))
    end
    stylesheet_tag(joined_stylesheet_name, options)
  else
    sources = expand_stylesheet_sources(sources, recursive)
    ensure_stylesheet_sources!(sources) if cache
    sources.collect { |source| stylesheet_tag(source, options) }.join("\n").html_safe
  end
end

def stylesheet_path(source)
  compute_public_path(source, 'stylesheets', 'css')
end

def stylesheet_tag(source, options)
  tag("link", { "rel" => "stylesheet", "type" => Mime::CSS, "media" => "screen", "href" => html_escape(path_to_stylesheet(source)) }.merge(options), false, false)
end

def video_path(source)
  compute_public_path(source, 'videos')
end

def video_tag(sources, options = {})
  options.symbolize_keys!
  options[:poster] = path_to_image(options[:poster]) if options[:poster]
  if size = options.delete(:size)
    options[:width], options[:height] = size.split("x") if size =~ %r{^\d+x\d+$}
  end
  if sources.is_a?(Array)
    content_tag("video", options) do
      sources.map { |source| tag("source", :src => source) }.join.html_safe
    end
  else
    options[:src] = path_to_video(sources)
    tag("video", options)
  end
end

def write_asset_file_contents(joined_asset_path, asset_paths)
  FileUtils.mkdir_p(File.dirname(joined_asset_path))
  File.atomic_write(joined_asset_path) { |cache| cache.write(join_asset_file_contents(asset_paths)) }
  # Set mtime to the latest of the combined files to allow for
  # consistent ETag without a shared filesystem.
  mt = asset_paths.map { |p| File.mtime(asset_file_path(p)) }.max
  File.utime(mt, mt, joined_asset_path)
end