aboutsummaryrefslogtreecommitdiffstats
path: root/Library/Homebrew/extend/ARGV.rb
blob: 25d19e2e7ff62e39e84cd6d190b87394bf711497 (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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
require 'bottles'

module HomebrewArgvExtension
  def named
    @named ||= reject{|arg| arg[0..0] == '-'}
  end

  def options_only
    select {|arg| arg[0..0] == '-'}
  end

  def formulae
    require 'formula'
    @formulae ||= downcased_unique_named.map{ |name| Formula.factory name }
    return @formulae
  end

  def kegs
    require 'keg'
    require 'formula'
    @kegs ||= downcased_unique_named.collect do |name|
      canonical_name = Formula.canonical_name(name)
      rack = HOMEBREW_CELLAR + if canonical_name.include? "/"
        # canonical_name returns a path if it was a formula installed via a
        # URL. And we only want the name. FIXME that function is insane.
        Pathname.new(canonical_name).stem
      else
        canonical_name
      end
      dirs = rack.children.select{ |pn| pn.directory? } rescue []
      raise NoSuchKegError.new(name) if not rack.directory? or dirs.length == 0

      linked_keg_ref = HOMEBREW_REPOSITORY/"Library/LinkedKegs"/name

      if not linked_keg_ref.symlink?
        if dirs.length == 1
          Keg.new(dirs.first)
        else
          prefix = Formula.factory(canonical_name).prefix
          if prefix.directory?
            Keg.new(prefix)
          else
            raise MultipleVersionsInstalledError.new(name)
          end
        end
      else
        Keg.new(linked_keg_ref.realpath)
      end
    end
  end

  # self documenting perhaps?
  def include? arg
    @n=index arg
  end
  def next
    at @n+1 or raise UsageError
  end

  def force?
    flag? '--force'
  end
  def verbose?
    flag? '--verbose' or ENV['HOMEBREW_VERBOSE']
  end
  def debug?
    flag? '--debug' or ENV['HOMEBREW_DEBUG']
  end
  def quieter?
    flag? '--quieter'
  end
  def interactive?
    flag? '--interactive'
  end
  def one?
    flag? '--1'
  end

  def build_head?
    flag? '--HEAD'
  end

  def build_devel?
    include? '--devel'
  end

  def build_universal?
    include? '--universal'
  end

  # Request a 32-bit only build.
  # This is needed for some use-cases though we prefer to build Universal
  # when a 32-bit version is needed.
  def build_32_bit?
    include? '--32-bit'
  end

  def build_bottle?
    bottles_supported? and include? '--build-bottle'
  end

  def build_from_source?
    flag? '--build-from-source' or ENV['HOMEBREW_BUILD_FROM_SOURCE'] \
      or not bottles_supported? or not options_only.empty?
  end

  def flag? flag
    options_only.each do |arg|
      return true if arg == flag
      next if arg[1..1] == '-'
      return true if arg.include? flag[2..2]
    end
    return false
  end

  # eg. `foo -ns -i --bar` has three switches, n, s and i
  def switch? switch_character
    return false if switch_character.length > 1
    options_only.each do |arg|
      next if arg[1..1] == '-'
      return true if arg.include? switch_character
    end
    return false
  end

  def usage
    require 'cmd/help'
    Homebrew.help_s
  end

  def filter_for_dependencies
    # Clears some flags that affect installation, yields to a block, then
    # restores to original state.
    old_args = clone

    flags_to_clear = %w[
      --debug -d
      --devel
      --fresh
      --interactive -i
      --HEAD
    ]
    flags_to_clear.concat %w[--verbose -v] if quieter?
    flags_to_clear.each {|flag| delete flag}

    yield

    replace old_args
  end

  private

  def downcased_unique_named
    # Only lowercase names, not paths or URLs
    @downcased_unique_named ||= named.map do |arg|
      arg.include?("/") ? arg : arg.downcase
    end.uniq
  end
end