Redmine

  # Content types covered by each icon. The same kind of file can be denoted by

  # several types, depending on whether the type was detected from the file

  # contents or taken from Redmine::MimeType, so list them all rather than

  # deriving the icon name from the type. An entry with no subtype (eg. audio)

  # covers every type of that top level type that is not listed elsewhere.

  ICON_MIME_TYPES = {

    'application-gzip' => %w(application/gzip),

    'application-javascript' => %w(application/javascript text/javascript),

    'application-pdf' => %w(application/pdf),

    'application-zip' => %w(application/zip),

    'file-music' => %w(audio),

    'movie' => %w(video),

    'photo' => %w(image),

    'text-css' => %w(text/css),

    'text-html' => %w(text/html),

    'text-plain' => %w(text application/sql application/x-csh application/x-sh),

    'text-x-c' => %w(text/x-c text/x-c++hdr text/x-c++src),

    'text-x-csharp' => %w(text/x-csharp),

    'text-x-java' => %w(text/x-java text/x-java-source),

    'text-x-php' => %w(text/x-php),

    'text-x-ruby' => %w(text/x-ruby),

    'text-xml' => %w(text/xml application/xml),

    # Microsoft Office Open XML documents

    # Do not add legacy Office formats (.doc, .xls, .ppt) here because

    # Redmine does not provide attachment preview for these formats.

    'file-type-docx' => %w(application/vnd.openxmlformats-officedocument.wordprocessingml.document),

    'file-type-ppt' => %w(application/vnd.openxmlformats-officedocument.presentationml.presentation),

    'file-type-xls' => %w(application/vnd.openxmlformats-officedocument.spreadsheetml.sheet)

  }.freeze

  MIME_TYPE_ICONS = ICON_MIME_TYPES.each_with_object({}) do |(icon, types), map|

    types.each {|type| map[type] = icon}

  end.freeze

  def file_type_icon(mime_type, label = nil, filename: nil, **)

    icon_name = icon_for_mime_type(mime_type, filename)

    sprite_icon(icon_name, label, **)

  def icon_for_mime_type(mime, filename = nil)

    # Content type detection falls back to application/octet-stream when it

    # cannot tell the type from the file contents. In that case only, guess

    # the type from the filename, as AttachmentsController#detect_content_type

    # does.

    if filename.present? && (mime.blank? || mime == 'application/octet-stream')

      mime = Redmine::MimeType.of(filename)

    MIME_TYPE_ICONS[mime] ||

      MIME_TYPE_ICONS[mime.to_s.split('/').first] ||

      'file'

    <%= link_to_attachment attachment, class: 'icon icon-attachment ', icon: icon_for_mime_type(attachment.content_type, attachment.filename) -%>

        <span class="icon icon-attachment"><%= file_type_icon(attachment.content_type_was, attachment.filename_was, filename: attachment.filename_was) %></span>

            <%= file_type_icon(attachment.content_type, filename: attachment.filename, size: 12) %>

    <%= file_type_icon(attachment.content_type, filename: attachment.filename, size: 12) %>

  def test_icon_for_mime_type_should_return_the_same_icon_for_equivalent_mime_types

    # Types detected from the file contents and their Redmine::MimeType counterparts

    {

      'text/javascript' => 'application/javascript',

      'application/xml' => 'text/xml',

      'text/x-c++src' => 'text/x-c',

      'text/x-java-source' => 'text/x-java',

      'text/x-diff' => 'text/plain',

      'application/sql' => 'text/plain'

    }.each do |detected, counterpart|

      assert_equal icon_for_mime_type(counterpart), icon_for_mime_type(detected),

                   "#{detected} should get the same icon as #{counterpart}"

    end

  end

  def test_icon_for_mime_type_should_fall_back_to_filename_only_when_type_is_undetermined

    assert_equal 'text-plain', icon_for_mime_type('application/octet-stream', 'readme.textile')

    assert_equal 'application-pdf', icon_for_mime_type(nil, 'document.pdf')

    # A type detected from the file contents takes precedence over the filename

    assert_equal 'text-html', icon_for_mime_type('text/html', 'not-really-an-image.png')

  end