Class: Tab

Inherits:
OpenStruct
  • Object
show all
Extended by:
Cachable
Defined in:
Library/Homebrew/tab.rb

Overview

Inherit from OpenStruct to gain a generic initialization method that takes a hash and creates an attribute for each key and value. Tab.new probably should not be called directly, instead use one of the class methods like Tab.create.

Constant Summary collapse

FILENAME = 
"INSTALL_RECEIPT.json"

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Cachable

cache, clear_cache

Class Method Details

.create(formula, compiler, stdlib) ⇒ Object

Instantiates a Tab for a new installation of a formula.


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
 
# File 'Library/Homebrew/tab.rb', line 20

def self.create(formula, compiler, stdlib)
  build = formula.build
  runtime_deps = formula.runtime_dependencies(undeclared: false)
  attributes = {
    "homebrew_version"        => HOMEBREW_VERSION,
    "used_options"            => build.used_options.as_flags,
    "unused_options"          => build.unused_options.as_flags,
    "tabfile"                 => formula.prefix/FILENAME,
    "built_as_bottle"         => build.bottle?,
    "installed_as_dependency" => false,
    "installed_on_request"    => true,
    "poured_from_bottle"      => false,
    "time"                    => Time.now.to_i,
    "source_modified_time"    => formula.source_modified_time.to_i,
    "HEAD"                    => HOMEBREW_REPOSITORY.git_head,
    "compiler"                => compiler,
    "stdlib"                  => stdlib,
    "aliases"                 => formula.aliases,
    "runtime_dependencies"    => Tab.runtime_deps_hash(runtime_deps),
    "arch"                    => Hardware::CPU.arch,
    "source"                  => {
      "path"     => formula.specified_path.to_s,
      "tap"      => formula.tap&.name,
      "spec"     => formula.active_spec_sym.to_s,
      "versions" => {
        "stable"         => formula.stable&.version.to_s,
        "devel"          => formula.devel&.version.to_s,
        "head"           => formula.head&.version.to_s,
        "version_scheme" => formula.version_scheme,
      },
    },
    "built_on"                => DevelopmentTools.build_system_info,
  }

  new(attributes)
end

.empty ⇒ Object 


176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'Library/Homebrew/tab.rb', line 176

def self.empty
  attributes = {
    "homebrew_version"        => HOMEBREW_VERSION,
    "used_options"            => [],
    "unused_options"          => [],
    "built_as_bottle"         => false,
    "installed_as_dependency" => false,
    "installed_on_request"    => true,
    "poured_from_bottle"      => false,
    "time"                    => nil,
    "source_modified_time"    => 0,
    "HEAD"                    => nil,
    "stdlib"                  => nil,
    "compiler"                => DevelopmentTools.default_compiler,
    "aliases"                 => [],
    "runtime_dependencies"    => nil,
    "source"                  => {
      "path"     => nil,
      "tap"      => nil,
      "spec"     => "stable",
      "versions" => {
        "stable"         => nil,
        "devel"          => nil,
        "head"           => nil,
        "version_scheme" => 0,
      },
    },
    "built_on"                => DevelopmentTools.generic_build_system_info,
  }

  new(attributes)
end

.for_formula(f) ⇒ Object

Returns a Tab for an already installed formula, or a fake one if the formula is not installed.


137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'Library/Homebrew/tab.rb', line 137

def self.for_formula(f)
  paths = []

  paths << f.opt_prefix.resolved_path if f.opt_prefix.symlink? && f.opt_prefix.directory?

  paths << f.linked_keg.resolved_path if f.linked_keg.symlink? && f.linked_keg.directory?

  if (dirs = f.installed_prefixes).length == 1
    paths << dirs.first
  end

  paths << f.installed_prefix

  path = paths.map { |pn| pn/FILENAME }.find(&:file?)

  if path
    tab = from_file(path)
    used_options = remap_deprecated_options(f.deprecated_options, tab.used_options)
    tab.used_options = used_options.as_flags
  else
    # Formula is not installed. Return a fake tab.
    tab = empty
    tab.unused_options = f.options.as_flags
    tab.source = {
      "path"     => f.specified_path.to_s,
      "tap"      => f.tap&.name,
      "spec"     => f.active_spec_sym.to_s,
      "versions" => {
        "stable"         => f.stable&.version.to_s,
        "devel"          => f.devel&.version.to_s,
        "head"           => f.head&.version.to_s,
        "version_scheme" => f.version_scheme,
      },
    }
  end

  tab
end

.for_keg(keg) ⇒ Object 


105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'Library/Homebrew/tab.rb', line 105

def self.for_keg(keg)
  path = keg/FILENAME

  tab = if path.exist?
    from_file(path)
  else
    empty
  end

  tab["tabfile"] = path
  tab
end

.for_name(name) ⇒ Object

Returns a tab for the named formula's installation, or a fake one if the formula is not installed.


120
121
122
 
# File 'Library/Homebrew/tab.rb', line 120

def self.for_name(name)
  for_formula(Formulary.factory(name))
end

.from_file(path) ⇒ Object

Returns the Tab for an install receipt at path. Results are cached.


59
60
61
 
# File 'Library/Homebrew/tab.rb', line 59

def self.from_file(path)
  cache.fetch(path) { |p| cache[p] = from_file_content(File.read(p), p) }
end

.from_file_content(content, path) ⇒ Object

Like Tab.from_file, but bypass the cache.


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
 
# File 'Library/Homebrew/tab.rb', line 64

def self.from_file_content(content, path)
  attributes = begin
    JSON.parse(content)
  rescue JSON::ParserError => e
    raise e, "Cannot parse #{path}: #{e}", e.backtrace
  end
  attributes["tabfile"] = path
  attributes["source_modified_time"] ||= 0
  attributes["source"] ||= {}

  tapped_from = attributes["tapped_from"]
  if !tapped_from.nil? && tapped_from != "path or URL"
    attributes["source"]["tap"] = attributes.delete("tapped_from")
  end

  if attributes["source"]["tap"] == "mxcl/master" ||
     attributes["source"]["tap"] == "Homebrew/homebrew"
    attributes["source"]["tap"] = "homebrew/core"
  end

  if attributes["source"]["spec"].nil?
    version = PkgVersion.parse path.to_s.split("/").second_to_last
    attributes["source"]["spec"] = if version.head?
      "head"
    else
      "stable"
    end
  end

  if attributes["source"]["versions"].nil?
    attributes["source"]["versions"] = {
      "stable"         => nil,
      "devel"          => nil,
      "head"           => nil,
      "version_scheme" => 0,
    }
  end

  new(attributes)
end

.remap_deprecated_options(deprecated_options, options) ⇒ Object 


124
125
126
127
128
129
130
131
132
133
 
# File 'Library/Homebrew/tab.rb', line 124

def self.remap_deprecated_options(deprecated_options, options)
  deprecated_options.each do |deprecated_option|
    option = options.find { |o| o.name == deprecated_option.old }
    next unless option

    options -= [option]
    options << Option.new(deprecated_option.current, option.description)
  end
  options
end

.runtime_deps_hash(deps) ⇒ Object 


209
210
211
212
213
214
 
# File 'Library/Homebrew/tab.rb', line 209

def self.runtime_deps_hash(deps)
  deps.map do |dep|
    f = dep.to_formula
    { "full_name" => f.full_name, "version" => f.version.to_s }
  end
end

Instance Method Details

#any_args_or_options? ⇒ Boolean

Returns:

  • (Boolean) 

216
217
218
 
# File 'Library/Homebrew/tab.rb', line 216

def any_args_or_options?
  !used_options.empty? || !unused_options.empty?
end

#bottle? ⇒ Boolean

Returns:

  • (Boolean) 

290
291
292
 
# File 'Library/Homebrew/tab.rb', line 290

def bottle?
  built_as_bottle
end

#built_bottle? ⇒ Boolean

Returns:

  • (Boolean) 

286
287
288
 
# File 'Library/Homebrew/tab.rb', line 286

def built_bottle?
  built_as_bottle && !poured_from_bottle
end

#compiler ⇒ Object 


264
265
266
 
# File 'Library/Homebrew/tab.rb', line 264

def compiler
  super || DevelopmentTools.default_compiler
end

#cxx11? ⇒ Boolean

Returns:

  • (Boolean) 

240
241
242
 
# File 'Library/Homebrew/tab.rb', line 240

def cxx11?
  include?("c++11")
end

#cxxstdlib ⇒ Object 


280
281
282
283
284
 
# File 'Library/Homebrew/tab.rb', line 280

def cxxstdlib
  # Older tabs won't have these values, so provide sensible defaults
  lib = stdlib.to_sym if stdlib
  CxxStdlib.create(lib, compiler.to_sym)
end

#devel? ⇒ Boolean

Returns:

  • (Boolean) 

248
249
250
 
# File 'Library/Homebrew/tab.rb', line 248

def devel?
  spec == :devel
end

#devel_version ⇒ Object 


316
317
318
 
# File 'Library/Homebrew/tab.rb', line 316

def devel_version
  Version.create(versions["devel"]) if versions["devel"]
end

#head? ⇒ Boolean

Returns:

  • (Boolean) 

244
245
246
 
# File 'Library/Homebrew/tab.rb', line 244

def head?
  spec == :head
end

#head_version ⇒ Object 


320
321
322
 
# File 'Library/Homebrew/tab.rb', line 320

def head_version
  Version.create(versions["head"]) if versions["head"]
end

#include?(opt) ⇒ Boolean

Returns:

  • (Boolean) 

232
233
234
 
# File 'Library/Homebrew/tab.rb', line 232

def include?(opt)
  used_options.include? opt
end

#parsed_homebrew_version ⇒ Object 


268
269
270
271
272
 
# File 'Library/Homebrew/tab.rb', line 268

def parsed_homebrew_version
  return Version::NULL if homebrew_version.nil?

  Version.new(homebrew_version)
end

#runtime_dependencies ⇒ Object 


274
275
276
277
278
 
# File 'Library/Homebrew/tab.rb', line 274

def runtime_dependencies
  # Homebrew versions prior to 1.1.6 generated incorrect runtime dependency
  # lists.
  super unless parsed_homebrew_version < "1.1.6"
end

#source_modified_time ⇒ Object 


328
329
330
 
# File 'Library/Homebrew/tab.rb', line 328

def source_modified_time
  Time.at(super)
end

#spec ⇒ Object 


304
305
306
 
# File 'Library/Homebrew/tab.rb', line 304

def spec
  source["spec"].to_sym
end

#stable? ⇒ Boolean

Returns:

  • (Boolean) 

252
253
254
 
# File 'Library/Homebrew/tab.rb', line 252

def stable?
  spec == :stable
end

#stable_version ⇒ Object 


312
313
314
 
# File 'Library/Homebrew/tab.rb', line 312

def stable_version
  Version.create(versions["stable"]) if versions["stable"]
end

#tap ⇒ Object 


294
295
296
297
 
# File 'Library/Homebrew/tab.rb', line 294

def tap
  tap_name = source["tap"]
  Tap.fetch(tap_name) if tap_name
end

#tap=(tap) ⇒ Object 


299
300
301
302
 
# File 'Library/Homebrew/tab.rb', line 299

def tap=(tap)
  tap_name = tap.respond_to?(:name) ? tap.name : tap
  source["tap"] = tap_name
end

#to_json(options = nil) ⇒ Object 


332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'Library/Homebrew/tab.rb', line 332

def to_json(options = nil)
  attributes = {
    "homebrew_version"        => homebrew_version,
    "used_options"            => used_options.as_flags,
    "unused_options"          => unused_options.as_flags,
    "built_as_bottle"         => built_as_bottle,
    "poured_from_bottle"      => poured_from_bottle,
    "installed_as_dependency" => installed_as_dependency,
    "installed_on_request"    => installed_on_request,
    "changed_files"           => changed_files&.map(&:to_s),
    "time"                    => time,
    "source_modified_time"    => source_modified_time.to_i,
    "HEAD"                    => self.HEAD,
    "stdlib"                  => stdlib&.to_s,
    "compiler"                => compiler&.to_s,
    "aliases"                 => aliases,
    "runtime_dependencies"    => runtime_dependencies,
    "source"                  => source,
    "built_on"                => built_on,
  }

  JSON.generate(attributes, options)
end

#to_s ⇒ Object 


365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
 
# File 'Library/Homebrew/tab.rb', line 365

def to_s
  s = []
  s << if poured_from_bottle
    "Poured from bottle"
  else
    "Built from source"
  end

  s << Time.at(time).strftime("on %Y-%m-%d at %H:%M:%S") if time

  unless used_options.empty?
    s << "with:"
    s << used_options.to_a.join(" ")
  end
  s.join(" ")
end

#universal? ⇒ Boolean

Returns:

  • (Boolean) 

236
237
238
 
# File 'Library/Homebrew/tab.rb', line 236

def universal?
  include?("universal")
end

#unused_options ⇒ Object 


260
261
262
 
# File 'Library/Homebrew/tab.rb', line 260

def unused_options
  Options.create(super)
end

#used_options ⇒ Object 


256
257
258
 
# File 'Library/Homebrew/tab.rb', line 256

def used_options
  Options.create(super)
end

#version_scheme ⇒ Object 


324
325
326
 
# File 'Library/Homebrew/tab.rb', line 324

def version_scheme
  versions["version_scheme"] || 0
end

#versions ⇒ Object 


308
309
310
 
# File 'Library/Homebrew/tab.rb', line 308

def versions
  source["versions"]
end

#with?(val) ⇒ Boolean

Returns:

  • (Boolean) 

220
221
222
223
224
225
226
 
# File 'Library/Homebrew/tab.rb', line 220

def with?(val)
  option_names = val.respond_to?(:option_names) ? val.option_names : [val]

  option_names.any? do |name|
    include?("with-#{name}") || unused_options.include?("without-#{name}")
  end
end

#without?(val) ⇒ Boolean

Returns:

  • (Boolean) 

228
229
230
 
# File 'Library/Homebrew/tab.rb', line 228

def without?(val)
  !with?(val)
end

#write ⇒ Object 


356
357
358
359
360
361
362
363
 
# File 'Library/Homebrew/tab.rb', line 356

def write
  # If this is a new installation, the cache of installed formulae
  # will no longer be valid.
  Formula.clear_installed_formulae_cache unless tabfile.exist?

  self.class.cache[tabfile] = self
  tabfile.atomic_write(to_json)
end