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".freeze

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.


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

def self.create(formula, compiler, stdlib)
  build = formula.build
  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" => formula.runtime_dependencies.map do |dep|
      f = dep.to_formula
      { "full_name" => f.full_name, "version" => f.version.to_s }
    end,
    "source" => {
      "path" => formula.specified_path.to_s,
      "tap" => formula.tap ? formula.tap.name : nil,
      "spec" => formula.active_spec_sym.to_s,
      "versions" => {
        "stable" => formula.stable ? formula.stable.version.to_s : nil,
        "devel" => formula.devel ? formula.devel.version.to_s : nil,
        "head" => formula.head ? formula.head.version.to_s : nil,
        "version_scheme" => formula.version_scheme,
      },
    },
  }

  new(attributes)
end

.empty ⇒ Object 


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

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" => [],
    "source" => {
      "path" => nil,
      "tap" => nil,
      "spec" => "stable",
      "versions" => {
        "stable" => nil,
        "devel" => nil,
        "head" => nil,
        "version_scheme" => 0,
      },
    },
  }

  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.


130
131
132
133
134
135
136
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
 
# File 'Library/Homebrew/tab.rb', line 130

def self.for_formula(f)
  paths = []

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

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

  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 ? f.tap.name : f.tap,
      "spec" => f.active_spec_sym.to_s,
      "versions" => {
        "stable" => f.stable ? f.stable.version.to_s : nil,
        "devel" => f.devel ? f.devel.version.to_s : nil,
        "head" => f.head ? f.head.version.to_s : nil,
        "version_scheme" => f.version_scheme,
      },
    }
  end

  tab
end

.for_keg(keg) ⇒ Object 


99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'Library/Homebrew/tab.rb', line 99

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.


114
115
116
 
# File 'Library/Homebrew/tab.rb', line 114

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.


57
58
59
 
# File 'Library/Homebrew/tab.rb', line 57

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.


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

def self.from_file_content(content, path)
  attributes = JSON.parse(content)
  attributes["tabfile"] = path
  attributes["source_modified_time"] ||= 0
  attributes["source"] ||= {}

  tapped_from = attributes["tapped_from"]
  unless 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("/")[-2]
    if version.head?
      attributes["source"]["spec"] = "head"
    else
      attributes["source"]["spec"] = "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 


118
119
120
121
122
123
124
125
126
 
# File 'Library/Homebrew/tab.rb', line 118

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

Instance Method Details

#bottle? ⇒ Boolean 


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

def bottle?
  built_as_bottle
end

#build_bottle? ⇒ Boolean 


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

def build_bottle?
  built_as_bottle && !poured_from_bottle
end

#compiler ⇒ Object 


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

def compiler
  super || DevelopmentTools.default_compiler
end

#cxx11? ⇒ Boolean 


225
226
227
 
# File 'Library/Homebrew/tab.rb', line 225

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

#cxxstdlib ⇒ Object 


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

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 


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

def devel?
  spec == :devel
end

#devel_version ⇒ Object 


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

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

#head? ⇒ Boolean 


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

def head?
  spec == :head
end

#head_version ⇒ Object 


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

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

#include?(opt) ⇒ Boolean 


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

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

#parsed_homebrew_version ⇒ Object 


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

def parsed_homebrew_version
  return Version::NULL if homebrew_version.nil?
  Version.new(homebrew_version)
end

#runtime_dependencies ⇒ Object 


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

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 


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

def source_modified_time
  Time.at(super)
end

#spec ⇒ Object 


288
289
290
 
# File 'Library/Homebrew/tab.rb', line 288

def spec
  source["spec"].to_sym
end

#stable? ⇒ Boolean 


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

def stable?
  spec == :stable
end

#stable_version ⇒ Object 


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

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

#tap ⇒ Object 


278
279
280
281
 
# File 'Library/Homebrew/tab.rb', line 278

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

#tap=(tap) ⇒ Object 


283
284
285
286
 
# File 'Library/Homebrew/tab.rb', line 283

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

#to_json ⇒ Object 


316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'Library/Homebrew/tab.rb', line 316

def to_json
  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 if stdlib),
    "compiler" => (compiler.to_s if compiler),
    "aliases" => aliases,
    "runtime_dependencies" => runtime_dependencies,
    "source" => source,
  }

  JSON.generate(attributes)
end

#to_s ⇒ Object 


348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
 
# File 'Library/Homebrew/tab.rb', line 348

def to_s
  s = []
  if poured_from_bottle
    s << "Poured from bottle"
  else
    s << "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 


221
222
223
 
# File 'Library/Homebrew/tab.rb', line 221

def universal?
  include?("universal")
end

#unused_options ⇒ Object 


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

def unused_options
  Options.create(super)
end

#used_options ⇒ Object 


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

def used_options
  Options.create(super)
end

#version_scheme ⇒ Object 


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

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

#versions ⇒ Object 


292
293
294
 
# File 'Library/Homebrew/tab.rb', line 292

def versions
  source["versions"]
end

#with?(val) ⇒ Boolean 


205
206
207
208
209
210
211
 
# File 'Library/Homebrew/tab.rb', line 205

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 


213
214
215
 
# File 'Library/Homebrew/tab.rb', line 213

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

#write ⇒ Object 


339
340
341
342
343
344
345
346
 
# File 'Library/Homebrew/tab.rb', line 339

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