Class: Libis::Format::TypeDatabase

Inherits:
Object
  • Object
show all
Includes:
Tools::Logger, Singleton
Defined in:
lib/libis/format/type_database.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#types ⇒ Object (readonly)

Returns the value of attribute types.



158
159
160
 
# File 'lib/libis/format/type_database.rb', line 158

def types
  @types
end

Class Method Details

.enrich(info, map_keys = {}) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/libis/format/type_database.rb', line 23

def self.enrich(info, map_keys = {})
  return {} unless info.is_a? Hash
  mapper = Hash.new {|hash,key| hash[key] = key}
  mapper.merge! map_keys
  unless (puid = info[mapper[:PUID]]).blank?
    info[mapper[:TYPE]] ||= puid_infos(puid).first[:TYPE] rescue nil
  end
  unless (mime = info[mapper[:MIME]]).blank?
    info[mapper[:TYPE]] ||= mime_infos(mime).first[:TYPE] rescue nil
  end
  unless (type_name = info[mapper[:TYPE]]).nil?
    mapper.keys.each do |key|
      info[mapper[key]] = get(type_name, key) || info[mapper[key]]
    end
    info[mapper[:GROUP]] = self.type_group(type_name)
  end
  info
end

.ext_infos(ext) ⇒ Object 



130
131
132
133
134
135
 
# File 'lib/libis/format/type_database.rb', line 130

def self.ext_infos(ext)
  ext = ext.gsub /^\./, ''
  self.instance.types.select do |_, v|
    v[:EXTENSIONS].include?(ext) rescue false
  end.values
end

.ext_types(ext) ⇒ Object 



137
138
139
140
141
142
 
# File 'lib/libis/format/type_database.rb', line 137

def self.ext_types(ext)
  ext = ext.gsub /^\./, ''
  self.instance.types.select do |_, v|
    v[:EXTENSIONS].include?(ext) rescue false
  end.keys
end

.get(type_name, key) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/libis/format/type_database.rb', line 59

def self.get(type_name, key)
  case key
    when :MIME
      type_mimetypes(type_name).first
    when :PUID
      type_puids(type_name).first
    when :EXTENSION
      type_extentions(type_name).first
    else
      self.typeinfo(type_name)[key]
  end
end

.group_types(group) ⇒ Object 



88
89
90
91
92
 
# File 'lib/libis/format/type_database.rb', line 88

def self.group_types(group)
  self.instance.types.select do |_, v|
    v[:GROUP] == group.to_sym
  end.keys
end

.known_mime?(mime) ⇒ Boolean

Returns:

  • (Boolean) 


151
152
153
154
155
156
 
# File 'lib/libis/format/type_database.rb', line 151

def self.known_mime?(mime)
  self.instance.types.each do |_, v|
    return true if v[:MIME].include? mime
  end
  false
end

.mime_groups(mime) ⇒ Object 



124
125
126
127
128
 
# File 'lib/libis/format/type_database.rb', line 124

def self.mime_groups(mime)
  mime_types(mime).map do |t|
    type_group t
  end
end

.mime_infos(mime) ⇒ Object 



112
113
114
115
116
 
# File 'lib/libis/format/type_database.rb', line 112

def self.mime_infos(mime)
  self.instance.types.select do |_, v|
    v[:MIME].include? mime rescue false
  end.values
end

.mime_types(mime) ⇒ Object 



118
119
120
121
122
 
# File 'lib/libis/format/type_database.rb', line 118

def self.mime_types(mime)
  self.instance.types.select do |_, v|
    v[:MIME].include? mime rescue false
  end.keys
end

.normalize(info, map_keys = {}) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/libis/format/type_database.rb', line 42

def self.normalize(info, map_keys = {})
  return {} unless info.is_a? Hash
  mapper = Hash.new {|hash,key| hash[key] = key}
  mapper.merge! map_keys
  unless (puid = info[mapper[:PUID]]).blank?
    info[mapper[:TYPE]] ||= self.puid_infos(puid).first[:TYPE] rescue nil
  end
  unless (mime = info[mapper[:MIME]]).blank?
    info[mapper[:TYPE]] ||= self.mime_infos(mime).first[:TYPE] rescue nil
  end
  unless (type_name = info[mapper[:TYPE]]).nil?
    info[mapper[:MIME]] = self.type_mimetypes(type_name).first if self.type_mimetypes(type_name).first
    info[mapper[:GROUP]] = self.type_group(type_name)
  end
  info
end

.puid_groups(puid) ⇒ Object 



106
107
108
109
110
 
# File 'lib/libis/format/type_database.rb', line 106

def self.puid_groups(puid)
  puid_types(puid).map do |t|
    type_group t
  end
end

.puid_infos(puid) ⇒ Object 



94
95
96
97
98
 
# File 'lib/libis/format/type_database.rb', line 94

def self.puid_infos(puid)
  self.instance.types.select do |_, v|
    v[:PUID].include? puid rescue false
  end.values
end

.puid_typeinfo(puid) ⇒ Object 



144
145
146
147
148
149
 
# File 'lib/libis/format/type_database.rb', line 144

def self.puid_typeinfo(puid)
  self.instance.types.each do |_, v|
    return v if v[:PUID] and v[:PUID].include?(puid)
  end
  nil
end

.puid_types(puid) ⇒ Object 



100
101
102
103
104
 
# File 'lib/libis/format/type_database.rb', line 100

def self.puid_types(puid)
  self.instance.types.select do |_, v|
    v[:PUID].include? puid rescue false
  end.keys
end

.type_extentions(t) ⇒ Object 



84
85
86
 
# File 'lib/libis/format/type_database.rb', line 84

def self.type_extentions(t)
  typeinfo(t)[:EXTENSIONS] || []
end

.type_group(t) ⇒ Object 



72
73
74
 
# File 'lib/libis/format/type_database.rb', line 72

def self.type_group(t)
  typeinfo(t)[:GROUP]
end

.type_mimetypes(t) ⇒ Object 



76
77
78
 
# File 'lib/libis/format/type_database.rb', line 76

def self.type_mimetypes(t)
  typeinfo(t)[:MIME] || []
end

.type_puids(t) ⇒ Object 



80
81
82
 
# File 'lib/libis/format/type_database.rb', line 80

def self.type_puids(t)
  typeinfo(t)[:PUID] || []
end

.typeinfo(t) ⇒ Object 



19
20
21
 
# File 'lib/libis/format/type_database.rb', line 19

def self.typeinfo(t)
  self.instance.types[t.to_sym] || {}
end

Instance Method Details

#load_types(file_or_hash = {}, append = true) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/libis/format/type_database.rb', line 160

def load_types(file_or_hash = {}, append = true)
  hash = file_or_hash.is_a?(Hash) ? file_or_hash : YAML::load_file(file_or_hash)
  # noinspection RubyResolve
  hash.each do |group, type_info|
    type_info.each do |type_name, info|
      type_key = type_name.to_sym
      info.symbolize_keys!
      info[:TYPE] = type_key
      info[:GROUP] = group.to_sym
      info[:MIME] = info[:MIME].strip.split(/[\s,]+/).map { |v| v.strip } rescue []
      info[:EXTENSIONS] = info[:EXTENSIONS].strip.split(/[\s,]+/).map { |v| v.strip } rescue []
      info[:PUID] = info[:PUID].strip.split(/[\s,]+/).map { |v| v.strip } if info[:PUID]
      if @types.has_key?(type_key)
        warn 'Type %s already defined; merging with info from %s.', type_name.to_s, file_or_hash
        info.merge!(@types[type_key]) do |_,v_new,v_old|
          case v_old
            when Array
              append ? v_old + v_new : v_new + v_old
            when Hash
              append ? v_new.merge(v_old) : v_old.merge(v_new)
            else
              append ? v_old : v_new
          end
        end
      end
      @types[type_key] = info
    end
  end
end