summaryrefslogtreecommitdiff
path: root/lib/mime/types/_columnar.rb
blob: 3a52d30365f4f3eb7fcff406231eabba67b610e7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
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
128
129
130
131
132
133
134
135
136
137
# frozen_string_literal: true

require "mime/type/columnar"

# MIME::Types::Columnar is used to extend a MIME::Types container to load data
# by columns instead of from JSON or YAML. Column loads of MIME types loaded
# through the columnar store are synchronized with a Mutex.
#
# MIME::Types::Columnar is not intended to be used directly, but will be added
# to an instance of MIME::Types when it is loaded with
# MIME::Types::Loader#load_columnar.
module MIME::Types::Columnar
  LOAD_MUTEX = Mutex.new # :nodoc:

  def self.extended(obj) # :nodoc:
    super
    obj.instance_variable_set(:@__mime_data__, [])
    obj.instance_variable_set(:@__files__, Set.new)
  end

  # Load the first column data file (type and extensions).
  def load_base_data(path) #:nodoc:
    @__root__ = path

    each_file_line("content_type", false) do |line|
      line = line.split
      content_type = line.shift
      extensions = line
      # content_type, *extensions = line.split

      type = MIME::Type::Columnar.new(self, content_type, extensions)
      @__mime_data__ << type
      add(type)
    end

    self
  end

  private

  def each_file_line(name, lookup = true)
    LOAD_MUTEX.synchronize do
      next if @__files__.include?(name)

      i = -1
      column = File.join(@__root__, "mime.#{name}.column")

      IO.readlines(column, encoding: "UTF-8").each do |line|
        line.chomp!

        if lookup
          (type = @__mime_data__[i += 1]) || next
          yield type, line
        else
          yield line
        end
      end

      @__files__ << name
    end
  end

  def load_encoding
    each_file_line("encoding") do |type, line|
      pool ||= {}
      type.instance_variable_set(:@encoding, (pool[line] ||= line))
    end
  end

  def load_docs
    each_file_line("docs") do |type, line|
      type.instance_variable_set(:@docs, opt(line))
    end
  end

  def load_preferred_extension
    each_file_line("pext") do |type, line|
      type.instance_variable_set(:@preferred_extension, opt(line))
    end
  end

  def load_flags
    each_file_line("flags") do |type, line|
      line = line.split
      type.instance_variable_set(:@obsolete, flag(line.shift))
      type.instance_variable_set(:@registered, flag(line.shift))
      type.instance_variable_set(:@signature, flag(line.shift))
      type.instance_variable_set(:@provisional, flag(line.shift))
    end
  end

  def load_xrefs
    each_file_line("xrefs") { |type, line|
      type.instance_variable_set(:@xrefs, dict(line, array: true))
    }
  end

  def load_friendly
    each_file_line("friendly") { |type, line|
      type.instance_variable_set(:@friendly, dict(line))
    }
  end

  def load_use_instead
    each_file_line("use_instead") do |type, line|
      type.instance_variable_set(:@use_instead, opt(line))
    end
  end

  def dict(line, array: false)
    if line == "-"
      {}
    else
      line.split("|").each_with_object({}) { |l, h|
        k, v = l.split("^")
        v = nil if v.empty?
        h[k] = array ? Array(v) : v
      }
    end
  end

  def arr(line)
    if line == "-"
      []
    else
      line.split("|").flatten.compact.uniq
    end
  end

  def opt(line)
    line unless line == "-"
  end

  def flag(line)
    line == "1"
  end
end