Class: Mime::Type

### Home Classes Methods

### In Files

- lib/action_dispatch/http/mime_type.rb

### Parent

Object

### Methods

- ::lookup
- ::lookup_by_extension
- ::new
- ::parse
- ::parse_data_with_trailing_star
- ::register
- ::register_alias
- ::unregister
- #==
- #===
- #=~
- #html?
- #ref
- #to_s
- #to_str
- #to_sym
- #verify_request?

### Class/Module Index

Quicksearch

- ActionDispatch
- ActionDispatch::Assertions
- ActionDispatch::Assertions::DomAssertions
- ActionDispatch::Assertions::ResponseAssertions
- ActionDispatch::Assertions::RoutingAssertions
- ActionDispatch::Assertions::SelectorAssertions
- ActionDispatch::Assertions::TagAssertions
- ActionDispatch::BestStandardsSupport
- ActionDispatch::BodyProxy
- ActionDispatch::Callbacks
- ActionDispatch::Cookies
- ActionDispatch::Cookies::CookieOverflow
- ActionDispatch::DebugExceptions
- ActionDispatch::ExceptionWrapper
- ActionDispatch::FileHandler
- ActionDispatch::Flash
- ActionDispatch::Flash::FlashHash
- ActionDispatch::Head
- ActionDispatch::Http
- ActionDispatch::Http::Cache
- ActionDispatch::Http::Cache::Request
- ActionDispatch::Http::Cache::Response
- ActionDispatch::Http::FilterParameters
- ActionDispatch::Http::Headers
- ActionDispatch::Http::MimeNegotiation
- ActionDispatch::Http::ParameterFilter
- ActionDispatch::Http::Parameters
- ActionDispatch::Http::URL
- ActionDispatch::Http::Upload
- ActionDispatch::Http::UploadedFile
- ActionDispatch::Integration
- ActionDispatch::Integration::RequestHelpers
- ActionDispatch::Integration::Runner
- ActionDispatch::Integration::Session
- ActionDispatch::IntegrationTest
- ActionDispatch::MiddlewareStack
- ActionDispatch::MiddlewareStack::Middleware
- ActionDispatch::ParamsParser
- ActionDispatch::PerformanceTest
- ActionDispatch::PublicExceptions
- ActionDispatch::RailsEntityStore
- ActionDispatch::RailsMetaStore
- ActionDispatch::Railtie
- ActionDispatch::Reloader
- ActionDispatch::RemoteIp
- ActionDispatch::RemoteIp::GetIp
- ActionDispatch::RemoteIp::IpSpoofAttackError
- ActionDispatch::Request
- ActionDispatch::RequestId
- ActionDispatch::Rescue
- ActionDispatch::Response
- ActionDispatch::Routing
- ActionDispatch::Routing::Mapper
- ActionDispatch::Routing::Mapper::Base
- ActionDispatch::Routing::Mapper::HttpHelpers
- ActionDispatch::Routing::Mapper::Resources
- ActionDispatch::Routing::Mapper::Scoping
- ActionDispatch::Routing::PolymorphicRoutes
- ActionDispatch::Routing::Redirection
- ActionDispatch::Routing::RouteSet
- ActionDispatch::Routing::RouteSet::MountedHelpers
- ActionDispatch::Routing::UrlFor
- ActionDispatch::Session
- ActionDispatch::Session::AbstractStore
- ActionDispatch::Session::CacheStore
- ActionDispatch::Session::Compatibility
- ActionDispatch::Session::CookieStore
- ActionDispatch::Session::DestroyableSession
- ActionDispatch::Session::MemCacheStore
- ActionDispatch::Session::StaleSessionCheck
- ActionDispatch::ShowExceptions
- ActionDispatch::Static
- ActionDispatch::TestProcess
- ActionDispatch::TestRequest
- ActionDispatch::TestResponse
- ActionController
- ActionController::Base
- ActionController::Caching
- ActionController::Caching::Actions
- ActionController::Caching::Actions::ActionCachePath
- ActionController::Caching::Actions::ClassMethods
- ActionController::Caching::ConfigMethods
- ActionController::Caching::Fragments
- ActionController::Caching::Pages
- ActionController::Caching::Pages::ClassMethods
- ActionController::Caching::Sweeping
- ActionController::Compatibility
- ActionController::ConditionalGet
- ActionController::Cookies
- ActionController::DataStreaming
- ActionController::Flash
- ActionController::ForceSSL
- ActionController::ForceSSL::ClassMethods
- ActionController::Head
- ActionController::Helpers
- ActionController::Helpers::ClassMethods
- ActionController::HideActions
- ActionController::HideActions::ClassMethods
- ActionController::HttpAuthentication
- ActionController::HttpAuthentication::Basic
- ActionController::HttpAuthentication::Basic::ControllerMethods
- ActionController::HttpAuthentication::Basic::ControllerMethods::ClassMethods
- ActionController::HttpAuthentication::Digest
- ActionController::HttpAuthentication::Digest::ControllerMethods
- ActionController::HttpAuthentication::Token
- ActionController::HttpAuthentication::Token::ControllerMethods
- ActionController::ImplicitRender
- ActionController::Instrumentation
- ActionController::Instrumentation::ClassMethods
- ActionController::LogSubscriber
- ActionController::Metal
- ActionController::Middleware
- ActionController::Middleware::ActionMiddleware
- ActionController::MimeResponds
- ActionController::MimeResponds::ClassMethods
- ActionController::ParamsWrapper
- ActionController::ParamsWrapper::ClassMethods
- ActionController::RackDelegation
- ActionController::Railtie
- ActionController::Railties
- ActionController::Railties::Paths
- ActionController::RecordIdentifier
- ActionController::Redirecting
- ActionController::Renderers
- ActionController::Renderers::All
- ActionController::Renderers::ClassMethods
- ActionController::Rendering
- ActionController::RequestForgeryProtection
- ActionController::RequestForgeryProtection::ClassMethods
- ActionController::Rescue
- ActionController::Responder
- ActionController::SessionManagement
- ActionController::SessionManagement::ClassMethods
- ActionController::Streaming
- ActionController::TemplateAssertions
- ActionController::TestCase
- ActionController::TestCase::Behavior
- ActionController::TestCase::Behavior::ClassMethods
- ActionController::TestCase::RaiseActionExceptions
- ActionController::TestResponse
- ActionController::Testing
- ActionController::Testing::ClassMethods
- ActionController::UrlFor
- ActionView
- ActionView::Base
- ActionView::Context
- ActionView::FileSystemResolver
- ActionView::FixtureResolver
- ActionView::Helpers
- ActionView::Helpers::ActiveModelHelper
- ActionView::Helpers::ActiveModelInstanceTag
- ActionView::Helpers::AssetPaths
- ActionView::Helpers::AssetTagHelper
- ActionView::Helpers::AssetTagHelper::AssetIncludeTag
- ActionView::Helpers::AssetTagHelper::JavascriptIncludeTag
- ActionView::Helpers::AssetTagHelper::JavascriptTagHelpers
- ActionView::Helpers::AssetTagHelper::JavascriptTagHelpers::ClassMethods
- ActionView::Helpers::AssetTagHelper::StylesheetIncludeTag
- ActionView::Helpers::AssetTagHelper::StylesheetTagHelpers
- ActionView::Helpers::AssetTagHelper::StylesheetTagHelpers::ClassMethods
- ActionView::Helpers::AtomFeedHelper
- ActionView::Helpers::AtomFeedHelper::AtomBuilder
- ActionView::Helpers::AtomFeedHelper::AtomFeedBuilder
- ActionView::Helpers::CacheHelper
- ActionView::Helpers::CaptureHelper
- ActionView::Helpers::CsrfHelper
- ActionView::Helpers::DateHelper
- ActionView::Helpers::DateHelperInstanceTag
- ActionView::Helpers::DebugHelper
- ActionView::Helpers::FormBuilder
- ActionView::Helpers::FormHelper
- ActionView::Helpers::FormOptionsHelper
- ActionView::Helpers::FormTagHelper
- ActionView::Helpers::InstanceTag
- ActionView::Helpers::JavaScriptHelper
- ActionView::Helpers::OutputSafetyHelper
- ActionView::Helpers::RecordTagHelper
- ActionView::Helpers::RenderingHelper
- ActionView::Helpers::SanitizeHelper
- ActionView::Helpers::TagHelper
- ActionView::Helpers::TextHelper
- ActionView::Helpers::TranslationHelper
- ActionView::Helpers::UrlHelper
- ActionView::LogSubscriber
- ActionView::LookupContext
- ActionView::LookupContext::DetailsCache
- ActionView::LookupContext::ViewPaths
- ActionView::NullResolver
- ActionView::PartialRenderer
- ActionView::Railtie
- ActionView::Renderer
- ActionView::Resolver
- ActionView::Resolver::Path
- ActionView::Template
- ActionView::Template::Handlers
- ActionView::Template::Handlers::Builder
- ActionView::Template::Handlers::ERB
- ActionView::Template::Handlers::Erubis
- ActionView::TestCase
- ActionView::TestCase::Behavior
- ActionView::TestCase::Behavior::ClassMethods
- ActionView::TestCase::Behavior::Locals
- ActionView::TestCase::TestController
- AbstractController
- AbstractController::ActionNotFound
- AbstractController::AssetPaths
- AbstractController::Base
- AbstractController::Callbacks
- AbstractController::Callbacks::ClassMethods
- AbstractController::Collector
- AbstractController::DoubleRenderError
- AbstractController::Error
- AbstractController::Helpers
- AbstractController::Helpers::ClassMethods
- AbstractController::Layouts
- AbstractController::Layouts::ClassMethods
- AbstractController::Layouts::ClassMethods::LayoutConditions
- AbstractController::Logger
- AbstractController::Railties
- AbstractController::Railties::RoutesHelpers
- AbstractController::Rendering
- AbstractController::Rendering::ClassMethods
- AbstractController::Translation
- AbstractController::UrlFor
- AbstractController::UrlFor::ClassMethods
- AbstractController::ViewPaths
- AbstractController::ViewPaths::ClassMethods
- Sprockets
- Sprockets::Bootstrap
- Sprockets::Compressors
- Sprockets::Helpers
- Sprockets::Helpers::IsolatedHelper
- Sprockets::Helpers::RailsHelper
- Sprockets::Helpers::RailsHelper::AssetPaths
- Sprockets::Helpers::RailsHelper::AssetPaths::AssetNotPrecompiledError
- Sprockets::Railtie
- Sprockets::StaticCompiler
- HTML
- HTML::FullSanitizer
- HTML::LinkSanitizer
- HTML::Sanitizer
- HTML::Selector
- HTML::Tag
- HTML::WhiteListSanitizer
- Mime
- Mime::Mimes
- Mime::Type
- ActionPack
- Object
- Rack

No matching classes.

# Mime::Type

Encapsulates the notion of a mime type. Can be used at render time, for example, with:

    class PostsController < ActionController::Base
      def show
        @post = Post.find(params[:id])

        respond_to do |format|
          format.html
          format.ics { render :text => post.to_ics, :mime_type => Mime::Type["text/calendar"]  }
          format.xml { render :xml => @people.to_xml }
        end
      end
    end

### Constants

Q_SEPARATOR_REGEXP
TRAILING_STAR_REGEXP

### Attributes

symbol[R]

### Public Class Methods

lookup(string) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 87
    def lookup(string)
      LOOKUP[string]
    end

lookup_by_extension(extension) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 91
    def lookup_by_extension(extension)
      EXTENSION_LOOKUP[extension.to_s]
    end

new(string, symbol = nil, synonyms = []) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 207
    def initialize(string, symbol = nil, synonyms = [])
      @symbol, @synonyms = symbol, synonyms
      @string = string
    end

parse(accept_header) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 110
    def parse(accept_header)
      if accept_header !~ /,/
        accept_header = accept_header.split(Q_SEPARATOR_REGEXP).first
        if accept_header =~ TRAILING_STAR_REGEXP
          parse_data_with_trailing_star($1)
        else
          [Mime::Type.lookup(accept_header)]
        end
      else
        # keep track of creation order to keep the subsequent sort stable
        list, index = [], 0
        accept_header.split(/,/).each do |header|
          params, q = header.split(Q_SEPARATOR_REGEXP)
          if params.present?
            params.strip!

            if params =~ TRAILING_STAR_REGEXP
              parse_data_with_trailing_star($1).each do |m|
                list << AcceptItem.new(index, m.to_s, q)
                index += 1
              end
            else
              list << AcceptItem.new(index, params, q)
              index += 1
            end
          end
        end
        list.sort!

        # Take care of the broken text/xml entry by renaming or deleting it
        text_xml = list.index("text/xml")
        app_xml = list.index(Mime::XML.to_s)

        if text_xml && app_xml
          # set the q value to the max of the two
          list[app_xml].q = [list[text_xml].q, list[app_xml].q].max

          # make sure app_xml is ahead of text_xml in the list
          if app_xml > text_xml
            list[app_xml], list[text_xml] = list[text_xml], list[app_xml]
            app_xml, text_xml = text_xml, app_xml
          end

          # delete text_xml from the list
          list.delete_at(text_xml)

        elsif text_xml
          list[text_xml].name = Mime::XML.to_s
        end

        # Look for more specific XML-based types and sort them ahead of app/xml

        if app_xml
          idx = app_xml
          app_xml_type = list[app_xml]

          while(idx < list.length)
            type = list[idx]
            break if type.q < app_xml_type.q
            if type.name =~ /\+xml$/
              list[app_xml], list[idx] = list[idx], list[app_xml]
              app_xml = idx
            end
            idx += 1
          end
        end

        list.map! { |i| Mime::Type.lookup(i.name) }.uniq!
        list
      end
    end

parse_data_with_trailing_star(input) click to toggle source

input: 'text' returned value: [Mime::JSON, Mime::XML, Mime::ICS, Mime::HTML, Mime::CSS, Mime::CSV, Mime::JS, Mime::YAML, Mime::TEXT]

input: 'application' returned value: [Mime::HTML, Mime::JS, Mime::XML, Mime::YAML, Mime::ATOM, Mime::JSON, Mime::RSS, Mime::URL_ENCODED_FORM]

    # File lib/action_dispatch/http/mime_type.rb, line 187
    def parse_data_with_trailing_star(input)
      Mime::SET.select { |m| m =~ input }
    end

register(string, symbol, mime_type_synonyms = [], extension_synonyms = [], skip_lookup = false) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 101
    def register(string, symbol, mime_type_synonyms = [], extension_synonyms = [], skip_lookup = false)
      Mime.const_set(symbol.to_s.upcase, Type.new(string, symbol, mime_type_synonyms))

      SET << Mime.const_get(symbol.to_s.upcase)

      ([string] + mime_type_synonyms).each { |str| LOOKUP[str] = SET.last } unless skip_lookup
      ([symbol] + extension_synonyms).each { |ext| EXTENSION_LOOKUP[ext.to_s] = SET.last }
    end

register_alias(string, symbol, extension_synonyms = []) click to toggle source

Registers an alias that's not used on mime type lookup, but can be referenced directly. Especially useful for rendering different HTML versions depending on the user agent, like an iPhone.

    # File lib/action_dispatch/http/mime_type.rb, line 97
    def register_alias(string, symbol, extension_synonyms = [])
      register(string, symbol, [], extension_synonyms, true)
    end

unregister(symbol) click to toggle source

This method is opposite of register method.

Usage:

Mime::Type.unregister(:mobile)

    # File lib/action_dispatch/http/mime_type.rb, line 196
    def unregister(symbol)
      symbol = symbol.to_s.upcase
      mime = Mime.const_get(symbol)
      Mime.instance_eval { remove_const(symbol) }

      SET.delete_if { |v| v.eql?(mime) }
      LOOKUP.delete_if { |k,v| v.eql?(mime) }
      EXTENSION_LOOKUP.delete_if { |k,v| v.eql?(mime) }
    end

### Public Instance Methods

==(mime_type) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 236
    def ==(mime_type)
      return false if mime_type.blank?
      (@synonyms + [ self ]).any? do |synonym|
        synonym.to_s == mime_type.to_s || synonym.to_sym == mime_type.to_sym
      end
    end

===(list) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 228
    def ===(list)
      if list.is_a?(Array)
        (@synonyms + [ self ]).any? { |synonym| list.include?(synonym) }
      else
        super
      end
    end

=~(mime_type) click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 243
    def =~(mime_type)
      return false if mime_type.blank?
      regexp = Regexp.new(Regexp.quote(mime_type.to_s))
      (@synonyms + [ self ]).any? do |synonym|
        synonym.to_s =~ regexp
      end
    end

html?() click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 257
    def html?
      @@html_types.include?(to_sym) || @string =~ /html/
    end

ref() click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 224
    def ref
      to_sym || to_s
    end

to_s() click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 212
    def to_s
      @string
    end

to_str() click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 216
    def to_str
      to_s
    end

to_sym() click to toggle source

    # File lib/action_dispatch/http/mime_type.rb, line 220
    def to_sym
      @symbol
    end

verify_request?() click to toggle source

Returns true if Action Pack should check requests using this Mime Type for possible request forgery. See ActionController::RequestForgeryProtection.

    # File lib/action_dispatch/http/mime_type.rb, line 253
    def verify_request?
      @@browser_generated_types.include?(to_sym)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.