Class: MIME::Type

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/mime/type.rb

Overview

The definition of one MIME content-type.

Usage

require 'mime/types'

plaintext = MIME::Types['text/plain'].first
# returns [text/plain, text/plain]
text = plaintext.first
print text.media_type           # => 'text'
print text.sub_type             # => 'plain'

puts text.extensions.join(" ")  # => 'asc txt c cc h hh cpp'

puts text.encoding              # => 8bit
puts text.binary?               # => false
puts text.ascii?                # => true
puts text == 'text/plain'       # => true
puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'

puts MIME::Types.any? { |type|
  type.content_type == 'text/plain'
}                               # => true
puts MIME::Types.all?(&:registered?)
                                # => false

Direct Known Subclasses

Columnar

Defined Under Namespace

Classes: Columnar, InvalidContentType, InvalidEncoding

Constant Summary collapse

VERSION =

The released version of the mime-types library.

'2.6.2'

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(content_type) {|_self| ... } ⇒ Type

Builds a MIME::Type object from the content_type, a MIME Content Type value (e.g., ‘text/plain’ or ‘applicaton/x-eruby’). The constructed object is yielded to an optional block for additional configuration, such as associating extensions and encoding information.

  • When provided a Hash or a MIME::Type, the MIME::Type will be constructed with #init_with.

  • When provided an Array, the MIME::Type will be constructed only using the first two elements of the array as the content type and extensions.

  • Otherwise, the content_type will be used as a string.

Yields the newly constructed self object.

Yields:

  • (_self)

Yield Parameters:

  • _self (MIME::Type) —

    the object that the method was called on



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/mime/type.rb', line 97

def initialize(content_type) # :yields self:
  @friendly = {}
  self.system = nil
  self.obsolete = false
  self.registered = nil
  self.use_instead = nil
  self.signature = nil

  case content_type
  when Hash
    init_with(content_type)
  when Array
    self.content_type = content_type[0]
    self.extensions = content_type[1] || []
  when MIME::Type
    init_with(content_type.to_h)
  else
    self.content_type = content_type
  end

  self.extensions ||= []
  self.docs ||= []
  self.encoding ||= :default
  # This value will be deprecated in the future, as it will be an
  # alternative view on #xrefs. Silence an unnecessary warning for now by
  # assigning directly to the instance variable.
  @references ||= []
  self.xrefs ||= {}

  yield self if block_given?
end

Instance Attribute Details

#content_type ⇒ Object

Returns the whole MIME content-type string.

The content type is a presentation value from the MIME type registry and should not be used for comparison. The case of the content type is preserved, and extension markers (x-) are kept.

text/plain        => text/plain
x-chemical/x-pdb  => x-chemical/x-pdb
audio/QCELP       => audio/QCELP



209
210
211
 
# File 'lib/mime/type.rb', line 209

def content_type
  @content_type
end

#docs ⇒ Object

The documentation for this MIME::Type.



340
341
342
 
# File 'lib/mime/type.rb', line 340

def docs
  @docs
end

#encoding ⇒ Object

Returns the value of attribute encoding.



280
281
282
 
# File 'lib/mime/type.rb', line 280

def encoding
  @encoding
end

#extensions ⇒ Object

The list of extensions which are known to be used for this MIME::Type. Non-array values will be coerced into an array with #to_a. Array values will be flattened, nil values removed, and made unique.



242
243
244
 
# File 'lib/mime/type.rb', line 242

def extensions
  @extensions
end

#i18n_key ⇒ Object (readonly)

A key suitable for use as a lookup key for translations, such as with the I18n library.

call-seq:

text_plain.i18n_key # => "text.plain"
3gpp_xml.i18n_key   # => "application.vnd-3gpp-bsf-xml"
  # from application/vnd.3gpp.bsf+xml
x_msword.i18n_key   # => "application.word"
  # from application/x-msword



371
372
373
 
# File 'lib/mime/type.rb', line 371

def i18n_key
  @i18n_key
end

#media_type ⇒ Object (readonly)

Returns the media type of the simplified MIME::Type.

text/plain        => text
x-chemical/x-pdb  => chemical



222
223
224
 
# File 'lib/mime/type.rb', line 222

def media_type
  @media_type
end

#raw_media_type ⇒ Object (readonly)

Returns the media type of the unmodified MIME::Type.

text/plain        => text
x-chemical/x-pdb  => x-chemical



227
228
229
 
# File 'lib/mime/type.rb', line 227

def raw_media_type
  @raw_media_type
end

#raw_sub_type ⇒ Object (readonly)

Returns the media type of the unmodified MIME::Type.

text/plain        => plain
x-chemical/x-pdb  => x-pdb



237
238
239
 
# File 'lib/mime/type.rb', line 237

def raw_sub_type
  @raw_sub_type
end

#simplified ⇒ Object (readonly)

A simplified form of the MIME content-type string, suitable for case-insensitive comparison, with any extension markers (<tt>x-</tt) removed and converted to lowercase.

text/plain        => text/plain
x-chemical/x-pdb  => chemical/pdb
audio/QCELP       => audio/qcelp



217
218
219
 
# File 'lib/mime/type.rb', line 217

def simplified
  @simplified
end

#sub_type ⇒ Object (readonly)

Returns the sub-type of the simplified MIME::Type.

text/plain        => plain
x-chemical/x-pdb  => pdb



232
233
234
 
# File 'lib/mime/type.rb', line 232

def sub_type
  @sub_type
end

#use_instead ⇒ Object 



322
323
324
325
 
# File 'lib/mime/type.rb', line 322

def use_instead
  return nil unless obsolete?
  @use_instead
end

#xrefs ⇒ Object

Returns the value of attribute xrefs.



423
424
425
 
# File 'lib/mime/type.rb', line 423

def xrefs
  @xrefs
end

Class Method Details

.from_array(*args) ⇒ Object

Creates a MIME::Type from an args array in the form of:

[ type-name, [ extensions ], encoding, system ]

extensions, encoding, and system are optional.

MIME::Type.from_array('application/x-ruby', %w(rb), '8bit')
MIME::Type.from_array([ 'application/x-ruby', [ 'rb' ], '8bit' ])

These are equivalent to:

MIME::Type.new('application/x-ruby') do |t|
  t.extensions  = %w(rb)
  t.encoding    = '8bit'
end

It will yield the type (t) if a block is given.

This method is deprecated and will be removed in mime-types 3.



734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
 
# File 'lib/mime/type.rb', line 734

def from_array(*args) # :yields t:
  MIME::Types.deprecated(self, __method__)

  # Dereferences the array one level, if necessary.
  args = args.first if args.first.kind_of? Array

  unless args.size.between?(1, 8)
    fail ArgumentError,
         'Array provided must contain between one and eight elements.'
  end

  MIME::Type.new(args.shift) do |t|
    t.extensions, t.encoding, t.system, t.obsolete, t.docs, t.references,
      t.registered = *args
    yield t if block_given?
  end
end

.from_hash(hash) ⇒ Object

Creates a MIME::Type from a hash. Keys are case-insensitive, dashes may be replaced with underscores, and the internal Symbol of the lowercase-underscore version can be used as well. That is, Content-Type can be provided as content-type, Content_Type, content_type, or :content_type.

Known keys are Content-Type, Content-Transfer-Encoding, Extensions, and System.

MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
                     'Content-Transfer-Encoding' => '8bit',
                     'System' => 'linux',
                     'Extensions' => ['yaml', 'yml'])

This is equivalent to:

MIME::Type.new('text/x-yaml') do |t|
  t.encoding    = '8bit'
  t.system      = 'linux'
  t.extensions  = ['yaml', 'yml']
end

It will yield the constructed type t if a block has been provided.

This method is deprecated and will be removed in mime-types 3.



779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
 
# File 'lib/mime/type.rb', line 779

def from_hash(hash) # :yields t:
  MIME::Types.deprecated(self, __method__)
  type = {}
  hash.each_pair do |k, v|
    type[k.to_s.tr('A-Z', 'a-z').gsub(/-/, '_').to_sym] = v
  end

  MIME::Type.new(type[:content_type]) do |t|
    t.extensions  = type[:extensions]
    t.encoding    = type[:content_transfer_encoding]
    t.system      = type[:system]
    t.obsolete    = type[:obsolete]
    t.docs        = type[:docs]
    t.url         = type[:url]
    t.registered  = type[:registered]

    yield t if block_given?
  end
end

.from_mime_type(mime_type) ⇒ Object

Essentially a copy constructor for mime_type.

MIME::Type.from_mime_type(plaintext)

is equivalent to:

MIME::Type.new(plaintext.content_type.dup) do |t|
  t.extensions  = plaintext.extensions.dup
  t.system      = plaintext.system.dup
  t.encoding    = plaintext.encoding.dup
end

It will yield the type (t) if a block is given.

This method is deprecated and will be removed in mime-types 3.



814
815
816
817
 
# File 'lib/mime/type.rb', line 814

def from_mime_type(mime_type) # :yields the new MIME::Type:
  MIME::Types.deprecated(self, __method__)
  new(mime_type)
end

.i18n_key(content_type) ⇒ Object

Converts a provided content_type into a translation key suitable for use with the I18n library.



698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
 
# File 'lib/mime/type.rb', line 698

def i18n_key(content_type)
  matchdata = case content_type
              when MatchData
                content_type
              else
                MEDIA_TYPE_RE.match(content_type)
              end

  return unless matchdata

  matchdata.captures.map { |e|
    e.downcase!
    e.gsub!(UNREGISTERED_RE, ''.freeze)
    e.gsub!(I18N_RE, '-'.freeze)
    e
  }.join('.'.freeze)
end

.simplified(content_type) ⇒ Object

The MIME types main- and sub-label can both start with x-, which indicates that it is a non-registered name. Of course, after registration this flag may disappear, adds to the confusing proliferation of MIME types. The simplified content_type string has the x- removed and is translated to lowercase.



679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
 
# File 'lib/mime/type.rb', line 679

def simplified(content_type)
  matchdata = case content_type
              when MatchData
                content_type
              else
                MEDIA_TYPE_RE.match(content_type)
              end

  return unless matchdata

  matchdata.captures.map { |e|
    e.downcase!
    e.gsub!(UNREGISTERED_RE, ''.freeze)
    e
  }.join('/'.freeze)
end

Instance Method Details

#<=>(other) ⇒ Object

Compares the other MIME::Type against the exact content type or the simplified type (the simplified type will be used if comparing against something that can be treated as a String with #to_s). In comparisons, this is done against the lowercase version of the MIME::Type.



142
143
144
145
146
147
148
 
# File 'lib/mime/type.rb', line 142

def <=>(other)
  if other.respond_to?(:content_type)
    @content_type.downcase <=> other.content_type.downcase
  elsif other.respond_to?(:to_s)
    @simplified <=> MIME::Type.simplified(other.to_s)
  end
end

#add_extensions(*extensions) ⇒ Object

Merge the extensions provided into this MIME::Type. The extensions added will be merged uniquely.



251
252
253
 
# File 'lib/mime/type.rb', line 251

def add_extensions(*extensions)
  self.extensions = self.extensions + extensions
end

#ascii? ⇒ Boolean

MIME types can be specified to be sent across a network in particular formats. This method returns false when the MIME::Type encoding is set to base64.

Returns:

  • (Boolean) 


539
540
541
 
# File 'lib/mime/type.rb', line 539

def ascii?
  !binary?
end

#binary? ⇒ Boolean

MIME types can be specified to be sent across a network in particular formats. This method returns true when the MIME::Type encoding is set to base64.

Returns:

  • (Boolean) 


532
533
534
 
# File 'lib/mime/type.rb', line 532

def binary?
  BINARY_ENCODINGS.include?(@encoding)
end

#complete? ⇒ Boolean

Returns true if the MIME::Type specifies an extension list, indicating that it is a complete MIME::Type.

Returns:

  • (Boolean) 


572
573
574
 
# File 'lib/mime/type.rb', line 572

def complete?
  !@extensions.empty?
end

#default_encoding ⇒ Object

Returns the default encoding for the MIME::Type based on the media type.



310
311
312
 
# File 'lib/mime/type.rb', line 310

def default_encoding
  (@media_type == 'text') ? 'quoted-printable' : 'base64'
end

#encode_with(coder) ⇒ Object

Populates the coder with attributes about this record for serialization. The structure of coder should match the structure used with #init_with.

This method should be considered a private implementation detail.



633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
 
# File 'lib/mime/type.rb', line 633

def encode_with(coder)
  coder['content-type']   = @content_type
  coder['docs']           = @docs unless @docs.nil? or @docs.empty?
  coder['friendly']       = @friendly unless @friendly.empty?
  coder['encoding']       = @encoding
  coder['extensions']     = @extensions unless @extensions.empty?
  if obsolete?
    coder['obsolete']     = obsolete?
    coder['use-instead']  = use_instead if use_instead
  end
  coder['references']     = references(true) unless references(true).empty?
  coder['xrefs']          = xrefs unless xrefs.empty?
  coder['registered']     = registered?
  coder['signature']      = signature? if signature?
  coder['system']         = @system if @system
  coder
end

#eql?(other) ⇒ Boolean

Returns true if the other object is a MIME::Type and the content types match.

Returns:

  • (Boolean) 


196
197
198
 
# File 'lib/mime/type.rb', line 196

def eql?(other)
  other.kind_of?(MIME::Type) and self == other
end

#friendly(lang = 'en'.freeze) ⇒ Object

A friendly short description for this MIME::Type.

call-seq:

text_plain.friendly         # => "Text File"
text_plain.friendly('en')   # => "Text File"



347
348
349
350
351
352
353
354
355
356
357
358
359
360
 
# File 'lib/mime/type.rb', line 347

def friendly(lang = 'en'.freeze)
  @friendly ||= {}

  case lang
  when String
    @friendly[lang]
  when Array
    @friendly.merge!(Hash[*lang])
  when Hash
    @friendly.merge!(lang)
  else
    fail ArgumentError
  end
end

#init_with(coder) ⇒ Object

Initialize an empty object from coder, which must contain the attributes necessary for initializing an empty object.

This method should be considered a private implementation detail.



655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
 
# File 'lib/mime/type.rb', line 655

def init_with(coder)
  self.content_type = coder['content-type']
  self.docs         = coder['docs'] || []
  friendly(coder['friendly'] || {})
  self.encoding     = coder['encoding']
  self.extensions   = coder['extensions'] || []
  self.obsolete     = coder['obsolete']
  # This value will be deprecated in the future, as it will be an
  # alternative view on #xrefs. Silence an unnecessary warning for now by
  # assigning directly to the instance variable.
  @references       = Array(coder['references']).flatten.compact.uniq
  self.registered   = coder['registered']
  self.signature    = coder['signature']
  self.system       = coder['system']
  self.xrefs        = coder['xrefs'] || {}
  self.use_instead  = coder['use-instead']
end

#like?(other) ⇒ Boolean

Returns true if the other simplified type matches the current type.

Returns:

  • (Boolean) 


130
131
132
133
134
135
136
 
# File 'lib/mime/type.rb', line 130

def like?(other)
  if other.respond_to?(:simplified)
    @simplified == other.simplified
  else
    @simplified == MIME::Type.simplified(other)
  end
end

#obsolete=(v) ⇒ Object

:nodoc:



335
336
337
 
# File 'lib/mime/type.rb', line 335

def obsolete=(v) # :nodoc:
  @obsolete = !!v
end

#obsolete? ⇒ Boolean

Returns true if the media type is obsolete.

Returns:

  • (Boolean) 


331
332
333
 
# File 'lib/mime/type.rb', line 331

def obsolete?
  !!@obsolete
end

#platform?(__internal__ = false) ⇒ Boolean

Returns true if the MIME::Type is specific to the current operating system as represented by RUBY_PLATFORM.

This method is deprecated and will be removed in mime-types 3.

Returns:

  • (Boolean) 


565
566
567
568
 
# File 'lib/mime/type.rb', line 565

def platform?(__internal__ = false)
  MIME::Types.deprecated(self, __method__) unless __internal__
  system?(__internal__) and (RUBY_PLATFORM =~ @system)
end

#preferred_extension ⇒ Object 



261
262
263
 
# File 'lib/mime/type.rb', line 261

def preferred_extension
  extensions.first
end

#priority_compare(other) ⇒ Object

Compares the other MIME::Type based on how reliable it is before doing a normal <=> comparison. Used by MIME::Types#[] to sort types. The comparisons involved are:

  1. self.simplified <=> other.simplified (ensures that we don’t try to compare different types)

  2. IANA-registered definitions < other definitions.

  3. Generic definitions < platform definitions.

  4. Complete definitions < incomplete definitions.

  5. Current definitions < obsolete definitions.

  6. Obselete with use-instead references < obsolete without.

  7. Obsolete use-instead definitions are compared.

While this method is public, its use is strongly discouraged by consumers of mime-types. In mime-types 3, this method is likely to see substantial revision and simplification to ensure current registered content types sort before unregistered or obsolete content types.



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/mime/type.rb', line 167

def priority_compare(other)
  pc = simplified <=> other.simplified
  if pc.zero?
    pc = if (reg = registered?) != other.registered?
           reg ? -1 : 1 # registered < unregistered
         elsif (plat = platform?(true)) != other.platform?(true)
           plat ? 1 : -1 # generic < platform
         elsif (comp = complete?) != other.complete?
           comp ? -1 : 1 # complete < incomplete
         elsif (obs = obsolete?) != other.obsolete?
           obs ? 1 : -1 # current < obsolete
         elsif obs and ((ui = use_instead) != (oui = other.use_instead))
           if ui.nil?
             1
           elsif oui.nil?
             -1
           else
             ui <=> oui
           end
         else
           0
         end
  end

  pc
end

#references(__internal__ = false) ⇒ Object 



385
386
387
388
 
# File 'lib/mime/type.rb', line 385

def references(__internal__ = false)
  MIME::Types.deprecated(self, __method__) unless __internal__
  @references
end

#references=(r) ⇒ Object

:nodoc:



391
392
393
394
 
# File 'lib/mime/type.rb', line 391

def references=(r) # :nodoc:
  MIME::Types.deprecated(self, __method__)
  @references = Array(r).flatten.compact.uniq
end

#registered=(v) ⇒ Object

:nodoc:



525
526
527
 
# File 'lib/mime/type.rb', line 525

def registered=(v) # :nodoc:
  @registered = v.nil? ? v : !!v
end

#registered? ⇒ Boolean

Prior to BCP 178 (RFC 6648), it could be assumed that MIME content types that start with x- were unregistered MIME. Per this BCP, this assumption is no longer being made by default in this library.

There are three possible registration states for a MIME::Type:

  • Explicitly registered, like application/x-www-url-encoded.

  • Explicitly not registered, like image/webp.

  • Unspecified, in which case the media-type and the content-type will be scanned to see if they start with x-, indicating that they are assumed unregistered.

In mime-types 3, only a MIME content type that is explicitly registered will be used; there will be assumption that x- types are unregistered.

Returns:

  • (Boolean) 


516
517
518
519
520
521
522
523
 
# File 'lib/mime/type.rb', line 516

def registered?
  if @registered.nil?
    (@raw_media_type !~ UNREGISTERED_RE) and
      (@raw_sub_type !~ UNREGISTERED_RE)
  else
    !!@registered
  end
end

#signature=(v) ⇒ Object

:nodoc:



549
550
551
 
# File 'lib/mime/type.rb', line 549

def signature=(v) # :nodoc:
  @signature = !!v
end

#signature? ⇒ Boolean

Returns true when the simplified MIME::Type is one of the known digital signature types.

Returns:

  • (Boolean) 


545
546
547
 
# File 'lib/mime/type.rb', line 545

def signature?
  !!@signature
end

#system ⇒ Object

If the MIME::Type is a system-specific MIME::Type, returns the regular expression for the operating system indicated.

This information about MIME content types is deprecated and will be removed in mime-types 3.



296
297
298
299
 
# File 'lib/mime/type.rb', line 296

def system
  MIME::Types.deprecated(self, __method__)
  @system
end

#system=(os) ⇒ Object

:nodoc:



301
302
303
304
305
306
307
 
# File 'lib/mime/type.rb', line 301

def system=(os) # :nodoc:
  if os.nil? or os.kind_of?(Regexp)
    @system = os
  else
    @system = %r{#{os}}
  end
end

#system?(__internal__ = false) ⇒ Boolean

Returns true if the MIME::Type is specific to an operating system.

This method is deprecated and will be removed in mime-types 3.

Returns:

  • (Boolean) 


556
557
558
559
 
# File 'lib/mime/type.rb', line 556

def system?(__internal__ = false)
  MIME::Types.deprecated(self, __method__) unless __internal__
  !@system.nil?
end

#to_a ⇒ Object

Returns the MIME::Type as an array suitable for use with MIME::Type.from_array.

This method is deprecated and will be removed in mime-types 3.



593
594
595
596
597
 
# File 'lib/mime/type.rb', line 593

def to_a
  MIME::Types.deprecated(self, __method__)
  [ @content_type, @extensions, @encoding, @system, obsolete?, @docs,
    @references, registered? ]
end

#to_h ⇒ Object

Converts the MIME::Type to a hash suitable for use in JSON. The output of this method can also be used to initialize a MIME::Type.



624
625
626
 
# File 'lib/mime/type.rb', line 624

def to_h
  encode_with({})
end

#to_hash ⇒ Object

Returns the MIME::Type as an array suitable for use with MIME::Type.from_hash.

This method is deprecated and will be removed in mime-types 3.



603
604
605
606
607
608
609
610
611
612
613
614
 
# File 'lib/mime/type.rb', line 603

def to_hash
  MIME::Types.deprecated(self, __method__)
  { 'Content-Type'              => @content_type,
    'Content-Transfer-Encoding' => @encoding,
    'Extensions'                => @extensions,
    'System'                    => @system,
    'Obsolete'                  => obsolete?,
    'Docs'                      => @docs,
    'URL'                       => @references,
    'Registered'                => registered?,
  }
end

#to_json(*args) ⇒ Object

Converts the MIME::Type to a JSON string.



617
618
619
620
 
# File 'lib/mime/type.rb', line 617

def to_json(*args)
  require 'json'
  to_h.to_json(*args)
end

#to_s ⇒ Object

Returns the MIME::Type as a string.



577
578
579
 
# File 'lib/mime/type.rb', line 577

def to_s
  content_type
end

#to_str ⇒ Object

Returns the MIME::Type as a string for implicit conversions. This allows MIME::Type objects to appear on either side of a comparison.

'text/plain' == MIME::Type.new('text/plain')



585
586
587
 
# File 'lib/mime/type.rb', line 585

def to_str
  content_type
end

#url ⇒ Object 



406
407
408
409
 
# File 'lib/mime/type.rb', line 406

def url
  MIME::Types.deprecated(self, __method__)
  references(true)
end

#url=(r) ⇒ Object

:nodoc:



412
413
414
415
 
# File 'lib/mime/type.rb', line 412

def url=(r) # :nodoc:
  MIME::Types.deprecated(self, __method__)
  self.references = r
end

#urls ⇒ Object

The decoded URL list for this MIME::Type.

The special URL value IANA will be translated into:

http://www.iana.org/assignments/media-types/<mediatype>/<subtype>

The special URL value RFC### will be translated into:

http://www.rfc-editor.org/rfc/rfc###.txt

The special URL value DRAFT:name will be translated into:

https://datatracker.ietf.org/public/idindex.cgi?
    command=id_detail&filename=<name>

The special URL value [token] will be translated into:

http://www.iana.org/assignments/contact-people.htm#<token>

These values will be accessible through #urls, which always returns an array.

This method is deprecated and will be removed in mime-types 3.



451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/mime/type.rb', line 451

def urls
  MIME::Types.deprecated(self, __method__)
  references(true).map do |el|
    case el
    when %r{^IANA$}
      IANA_URL % [ @media_type, @sub_type ]
    when %r{^RFC(\d+)$}
      RFC_URL % $1
    when %r{^DRAFT:(.+)$}
      DRAFT_URL % $1
    when %r{^\{([^=]+)=([^\}]+)\}}
      [$1, $2]
    when %r{^\[([^=]+)=([^\]]+)\]}
      [$1, CONTACT_URL % $2]
    when %r{^\[([^\]]+)\]}
      CONTACT_URL % $1
    else
      el
    end
  end
end

#xref_urls ⇒ Object

The decoded cross-reference URL list for this MIME::Type.



474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
 
# File 'lib/mime/type.rb', line 474

def xref_urls
  xrefs.flat_map { |(type, values)|
    case type
    when 'rfc'.freeze
      values.map { |data| 'http://www.iana.org/go/%s'.freeze % data }
    when 'draft'.freeze
      values.map { |data|
        'http://www.iana.org/go/%s'.freeze % data.sub(/\ARFC/, 'draft')
      }
    when 'rfc-errata'.freeze
      values.map { |data|
        'http://www.rfc-editor.org/errata_search.php?eid=%s'.freeze % data
      }
    when 'person'.freeze
      values.map { |data|
        'http://www.iana.org/assignments/media-types/media-types.xhtml#%s'.freeze % data # rubocop:disable Metrics/LineLength
      }
    when 'template'.freeze
      values.map { |data|
        'http://www.iana.org/assignments/media-types/%s'.freeze % data
      }
    else # 'uri', 'text', etc.
      values
    end
  }
end