Класс: RuboCop::Cop::FormulaCop Абстрактный Приватный

45

# File 'rubocops/extend/formula_cop.rb', line 45

def audit_formula(formula_nodes); end

57
58
59
60
61
62
63
64
65
66
67

# File 'rubocops/extend/formula_cop.rb', line 57

def audit_urls(urls, regex, &_block)
  urls.each_with_index do |url_node, index|
    url_string_node = parameters(url_node).fetch(0)
    url_string = string_content(url_string_node)
    match_object = regex_match_group(url_string_node, regex)
    next unless match_object

    offending_node(url_string_node.parent)
    yield match_object, url_string, index
  end
end

137
138
139
140
141

# File 'rubocops/extend/formula_cop.rb', line 137

def caveats_strings
  return [] if @body.nil?

  find_strings(find_method_def(@body, :caveats)).to_a
end

17

# File 'sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi', line 17

def dependency_name_hash_match?(node, *pattern, **kwargs, &block); end

27

# File 'sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi', line 27

def dependency_type_hash_match?(node, *pattern, **kwargs, &block); end

73
74
75
76
77
78
79
80
81
82
83
84
85
86

# File 'rubocops/extend/formula_cop.rb', line 73

def depends_on?(dependency_name, *types)
  return false if @body.nil?

  types = [:any] if types.empty?
  dependency_nodes = find_every_method_call_by_name(@body, :depends_on)
  idx = dependency_nodes.index do |n|
    types.any? { |type| depends_on_name_type?(n, dependency_name, type) }
  end
  return false if idx.nil?

  @offensive_node = T.let(dependency_nodes[idx], T.nilable(RuboCop::AST::Node))

  true
end

97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

# File 'rubocops/extend/formula_cop.rb', line 97

def depends_on_name_type?(node, name = nil, type = :required)
  name_match = !name # Match only by type when name is nil

  case type
  when :required
    type_match = required_dependency?(node)
    name_match ||= required_dependency_name?(node, name) if type_match
  when :build, :test, :optional, :recommended
    type_match = dependency_type_hash_match?(node, type)
    name_match ||= dependency_name_hash_match?(node, name) if type_match
  when :any
    type_match = true
    name_match ||= required_dependency_name?(node, name) || false
    name_match ||= dependency_name_hash_match?(node, name) || false
  else
    type_match = false
  end

  @offensive_node = node if type_match || name_match
  type_match && name_match
end

186
187
188
189
190

# File 'rubocops/extend/formula_cop.rb', line 186

def formula_tap
  return unless (match_obj = @file_path&.match(%r{(?:/Taps/[\w-]+|^)/(homebrew-[\w-]+)/}))

  match_obj[1]
end

145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

# File 'rubocops/extend/formula_cop.rb', line 145

def get_checksum_node(call)
  return if parameters(call).empty? || parameters(call).nil?

  if parameters(call).fetch(0).str_type?
    parameters(call).first
  # sha256 is passed as a key-value pair in bottle blocks
  elsif parameters(call).fetch(0).hash_type?
    hash_node = T.cast(parameters(call).fetch(0), RuboCop::AST::HashNode)
    if hash_node.keys.first.value == :cellar
      # sha256 :cellar :any, :tag "hexdigest"
      hash_node.values.last
    elsif hash_node.keys.first.is_a?(RuboCop::AST::SymbolNode)
      # sha256 :tag "hexdigest"
      hash_node.values.first
    else
      # Legacy bottle block syntax
      # sha256 "hexdigest" => :tag
      hash_node.keys.first
    end
  end
end

31
32
33
34
35
36
37
38
39
40
41
42

# File 'rubocops/extend/formula_cop.rb', line 31

def on_class(node)
  @file_path = T.let(processed_source.file_path, T.nilable(String))
  return unless file_path_allowed?
  return unless formula_class?(node)

  class_node, parent_class_node, body = *node
  @body = T.let(body, T.nilable(RuboCop::AST::Node))

  @formula_name = T.let(Pathname.new(@file_path).basename(".rb").to_s, T.nilable(String))
  @tap_style_exceptions = T.let(nil, T.nilable(T::Hash[Symbol, T::Array[String]]))
  audit_formula(FormulaNodes.new(node:, class_node:, parent_class_node:, body_node: T.must(@body)))
end

37

# File 'sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi', line 37

def required_dependency?(node, *pattern, **kwargs, &block); end

47

# File 'sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi', line 47

def required_dependency_name?(node, *pattern, **kwargs, &block); end

194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

# File 'rubocops/extend/formula_cop.rb', line 194

def style_exceptions_dir
  file_directory = File.dirname(@file_path) if @file_path
  return unless file_directory

  # if we're in a sharded subdirectory, look below that.
  directory_name = File.basename(file_directory)
  formula_directory = if directory_name.length == 1 || directory_name == "lib"
    File.dirname(file_directory)
  else
    file_directory
  end

  # if we're in a Formula or HomebrewFormula subdirectory, look below that.
  formula_directory_names = ["Formula", "HomebrewFormula"].freeze
  directory_name = File.basename(formula_directory)
  tap_root_directory = if formula_directory_names.include?(directory_name)
    File.dirname(formula_directory)
  else
    formula_directory
  end

  "#{tap_root_directory}/style_exceptions"
end

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

# File 'rubocops/extend/formula_cop.rb', line 221

def tap_style_exception?(list, formula = nil)
  if @tap_style_exceptions.nil? && !formula_tap.nil?
    @tap_style_exceptions = {}

    Pathname.glob("#{style_exceptions_dir}/*.json").each do |exception_file|
      list_name = exception_file.basename.to_s.chomp(".json").to_sym
      list_contents = begin
        JSON.parse exception_file.read
      rescue JSON::ParserError
        nil
      end
      next if list_contents.nil? || list_contents.none?

      @tap_style_exceptions[list_name] = list_contents
    end
  end

  return false if @tap_style_exceptions.nil? || @tap_style_exceptions.none?
  return false unless @tap_style_exceptions.key? list

  T.must(@tap_style_exceptions[list]).include?(formula || @formula_name)
end

178
179
180
181
182

# File 'rubocops/extend/formula_cop.rb', line 178

def versioned_formula?
  return false if @formula_name.nil?

  @formula_name.include?("@")
end