Class: Homebrew::FormulaAuditor

Inherits:

Object

• Object
• Homebrew::FormulaAuditor

Includes:

FormulaCellarChecks

Defined in:

brew/Library/Homebrew/dev-cmd/audit.rb

Constant Summary

Constants included from FormulaCellarChecks

FormulaCellarChecks::VALID_LIBRARY_EXTENSIONS

Instance Attribute Summary

• #formula ⇒ Object readonly

  Returns the value of attribute formula.

• #new_formula_problems ⇒ Object readonly

  Returns the value of attribute new_formula_problems.

• #problems ⇒ Object readonly

  Returns the value of attribute problems.

• #text ⇒ Object readonly

  Returns the value of attribute text.

Class Method Summary

• .aliases ⇒ Object

Instance Method Summary

• #audit ⇒ Object
• #audit_bitbucket_repository ⇒ Object
• #audit_bottle_disabled ⇒ Object
• #audit_bottle_spec ⇒ Object
• #audit_conflicts ⇒ Object
• #audit_deps ⇒ Object
• #audit_file ⇒ Object
• #audit_formula_name ⇒ Object
• #audit_github_repository ⇒ Object
• #audit_gitlab_repository ⇒ Object
• #audit_homepage ⇒ Object
• #audit_keg_only_style ⇒ Object
• #audit_lines ⇒ Object
• #audit_postgresql ⇒ Object
• #audit_prefix_has_contents ⇒ Object
• #audit_reverse_migration ⇒ Object
• #audit_revision_and_version_scheme ⇒ Object
• #audit_specs ⇒ Object
• #audit_style ⇒ Object
• #audit_text ⇒ Object
• #audit_versioned_keg_only ⇒ Object
• #get_repo_data(regex) ⇒ Object
• #initialize(formula, options = {}) ⇒ FormulaAuditor constructor

  A new instance of FormulaAuditor.

• #line_problems(line, _lineno) ⇒ Object
• #problem_if_output(output) ⇒ Object
• #quote_dep(dep) ⇒ Object

Methods included from FormulaCellarChecks

#audit_installed, #check_easy_install_pth, #check_elisp_dirname, #check_elisp_root, #check_env_path, #check_generic_executables, #check_infopages, #check_jars, #check_linkage, #check_manpages, #check_non_executables, #check_non_libraries, #check_openssl_links, #check_python_framework_links, #check_shadowed_headers, #generic_audit_installed, #generic_valid_library_extension?, #valid_library_extension?

Constructor Details

#initialize(formula, options = {}) ⇒ FormulaAuditor

Returns a new instance of FormulaAuditor

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 216

def initialize(formula, options = {})
  @formula = formula
  @versioned_formula = formula.versioned_formula?
  @new_formula_inclusive = options[:new_formula]
  @new_formula = options[:new_formula] && !@versioned_formula
  @strict = options[:strict]
  @online = options[:online]
  @display_cop_names = options[:display_cop_names]
  @only = options[:only]
  @except = options[:except]
  # Accept precomputed style offense results, for efficiency
  @style_offenses = options[:style_offenses]
  # Allow the formula tap to be set as `core`, for testing purposes
  @core_tap = formula.tap&.core_tap? || options[:core_tap]
  @problems = []
  @new_formula_problems = []
  @text = FormulaText.new(formula.path)
  @specs = %w[stable devel head].map { |s| formula.send(s) }.compact
end

Instance Attribute Details

#formula ⇒ Object (readonly)

Returns the value of attribute formula

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 214

def formula
  @formula
end

#new_formula_problems ⇒ Object (readonly)

Returns the value of attribute new_formula_problems

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 214

def new_formula_problems
  @new_formula_problems
end

#problems ⇒ Object (readonly)

Returns the value of attribute problems

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 214

def problems
  @problems
end

#text ⇒ Object (readonly)

Returns the value of attribute text

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 214

def text
  @text
end

Class Method Details

.aliases ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 333

def self.aliases
  # core aliases + tap alias names + tap alias full name
  @aliases ||= Formula.aliases + Formula.tap_aliases
end

Instance Method Details

#audit ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 994

def audit
  only_audits = @only
  except_audits = @except
  odie "--only and --except cannot be used simultaneously!" if only_audits && except_audits

  methods.map(&:to_s).grep(/^audit_/).each do |audit_method_name|
    name = audit_method_name.gsub(/^audit_/, "")
    if only_audits
      next unless only_audits.include?(name)
    elsif except_audits
      next if except_audits.include?(name)
    end
    send(audit_method_name)
  end
end

#audit_bitbucket_repository ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 608

def audit_bitbucket_repository
  user, repo = get_repo_data(%r{https?://bitbucket\.org/([^/]+)/([^/]+)/?.*})
  return if user.nil?

  api_url = "https://api.bitbucket.org/2.0/repositories/#{user}/#{repo}"
  out, _, status= curl_output("--request", "GET", api_url)
  return unless status.success?

  metadata = JSON.parse(out)
  return if metadata.nil?

  new_formula_problem "Uses deprecated mercurial support in Bitbucket" if metadata["scm"] == "hg"

  new_formula_problem "Bitbucket fork (not canonical repository)" unless metadata["parent"].nil?

  if Date.parse(metadata["created_on"]) >= (Date.today - 30)
    new_formula_problem "Bitbucket repository too new (<30 days old)"
  end

  forks_out, _, forks_status= curl_output("--request", "GET", "#{api_url}/forks")
  return unless forks_status.success?

  watcher_out, _, watcher_status= curl_output("--request", "GET", "#{api_url}/watchers")
  return unless watcher_status.success?

  forks_metadata = JSON.parse(forks_out)
  return if forks_metadata.nil?

  watcher_metadata = JSON.parse(watcher_out)
  return if watcher_metadata.nil?

  return if (forks_metadata["size"] < 30) && (watcher_metadata["size"] < 75)

  new_formula_problem "Bitbucket repository not notable enough (<30 forks and <75 watchers)"
end

#audit_bottle_disabled ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 554

def audit_bottle_disabled
  return unless formula.bottle_disabled?
  return if formula.bottle_unneeded?

  problem "Unrecognized bottle modifier" unless formula.bottle_disable_reason.valid?

  return unless @core_tap

  problem "Formulae should not use `bottle :disabled`"
end

#audit_bottle_spec ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 542

def audit_bottle_spec
  # special case: new versioned formulae should be audited
  return unless @new_formula_inclusive
  return unless @core_tap

  return if formula.bottle_disabled?

  return unless formula.bottle_defined?

  new_formula_problem "New formulae should not have a `bottle do` block"
end

#audit_conflicts ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 435

def audit_conflicts
  formula.conflicts.each do |c|
    Formulary.factory(c.name)
  rescue TapFormulaUnavailableError
    # Don't complain about missing cross-tap conflicts.
    next
  rescue FormulaUnavailableError
    problem "Can't find conflicting formula #{c.name.inspect}."
  rescue TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
    problem "Ambiguous conflicting formula #{c.name.inspect}."
  end
end

#audit_deps ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 362

def audit_deps
  @specs.each do |spec|
    # Check for things we don't like to depend on.
    # We allow non-Homebrew installs whenever possible.
    spec.deps.each do |dep|
      begin
        dep_f = dep.to_formula
      rescue TapFormulaUnavailableError
        # Don't complain about missing cross-tap dependencies
        next
      rescue FormulaUnavailableError
        problem "Can't find dependency #{dep.name.inspect}."
        next
      rescue TapFormulaAmbiguityError
        problem "Ambiguous dependency #{dep.name.inspect}."
        next
      rescue TapFormulaWithOldnameAmbiguityError
        problem "Ambiguous oldname dependency #{dep.name.inspect}."
        next
      end

      if dep_f.oldname && dep.name.split("/").last == dep_f.oldname
        problem "Dependency '#{dep.name}' was renamed; use new name '#{dep_f.name}'."
      end

      if self.class.aliases.include?(dep.name) &&
         (dep_f.core_formula? || !dep_f.versioned_formula?)
        problem "Dependency '#{dep.name}' is an alias; use the canonical name '#{dep.to_formula.full_name}'."
      end

      if @new_formula &&
         dep_f.keg_only_reason&.reason == :provided_by_macos &&
         dep_f.keg_only_reason.valid? &&
         !%w[apr apr-util openblas openssl openssl@1.1].include?(dep.name)
        new_formula_problem(
          "Dependency '#{dep.name}' is provided by macOS; " \
          "please replace 'depends_on' with 'uses_from_macos'.",
        )
      end

      dep.options.each do |opt|
        next if @core_tap
        next if dep_f.option_defined?(opt)
        next if dep_f.requirements.find do |r|
          if r.recommended?
            opt.name == "with-#{r.name}"
          elsif r.optional?
            opt.name == "without-#{r.name}"
          end
        end

        problem "Dependency #{dep} does not define option #{opt.name.inspect}"
      end

      problem "Don't use git as a dependency (it's always available)" if dep.name == "git"

      problem "Dependency '#{dep.name}' is marked as :run. Remove :run; it is a no-op." if dep.tags.include?(:run)

      next unless @core_tap

      if dep.tags.include?(:recommended) || dep.tags.include?(:optional)
        problem "Formulae should not have optional or recommended dependencies"
      end
    end

    next unless @core_tap

    if spec.requirements.map(&:recommended?).any? || spec.requirements.map(&:optional?).any?
      problem "Formulae should not have optional or recommended requirements"
    end
  end
end

#audit_file ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 250

def audit_file
  # Under normal circumstances (umask 0022), we expect a file mode of 644. If
  # the user's umask is more restrictive, respect that by masking out the
  # corresponding bits. (The also included 0100000 flag means regular file.)
  wanted_mode = 0100644 & ~File.umask
  actual_mode = formula.path.stat.mode
  unless actual_mode == wanted_mode
    problem format("Incorrect file permissions (%03<actual>o): chmod %03<wanted>o %<path>s",
                   actual: actual_mode & 0777,
                   wanted: wanted_mode & 0777,
                   path:   formula.path)
  end

  problem "'DATA' was found, but no '__END__'" if text.data? && !text.end?

  problem "'__END__' was found, but 'DATA' is not used" if text.end? && !text.data?

  if text.to_s.match?(/inreplace [^\n]* do [^\n]*\n[^\n]*\.gsub![^\n]*\n\ *end/m)
    problem "'inreplace ... do' was used for a single substitution (use the non-block form instead)."
  end

  problem "File should end with a newline" unless text.trailing_newline?

  if formula.core_formula? && @versioned_formula
    unversioned_formula = begin
      # build this ourselves as we want e.g. homebrew/core to be present
      full_name = if formula.tap
        "#{formula.tap}/#{formula.name}"
      else
        formula.name
      end
      Formulary.factory(full_name.gsub(/@.*$/, "")).path
    rescue FormulaUnavailableError, TapFormulaAmbiguityError,
           TapFormulaWithOldnameAmbiguityError
      Pathname.new formula.path.to_s.gsub(/@.*\.rb$/, ".rb")
    end
    unless unversioned_formula.exist?
      unversioned_name = unversioned_formula.basename(".rb")
      problem "#{formula} is versioned but no #{unversioned_name} formula exists"
    end
  elsif ARGV.build_stable? && formula.stable? &&
        !(versioned_formulae = formula.versioned_formulae).empty?
    versioned_aliases = formula.aliases.grep(/.@\d/)
    _, last_alias_version = versioned_formulae.map(&:name).last.split("@")
    major, minor, = formula.version.to_s.split(".")
    alias_name_major = "#{formula.name}@#{major}"
    alias_name_major_minor = "#{alias_name_major}.#{minor}"
    alias_name = if last_alias_version.split(".").length == 1
      alias_name_major
    else
      alias_name_major_minor
    end
    valid_alias_names = [alias_name_major, alias_name_major_minor]

    unless @core_tap
      versioned_aliases.map! { |a| "#{formula.tap}/#{a}" }
      valid_alias_names.map! { |a| "#{formula.tap}/#{a}" }
    end

    valid_versioned_aliases = versioned_aliases & valid_alias_names
    invalid_versioned_aliases = versioned_aliases - valid_alias_names

    if valid_versioned_aliases.empty?
      if formula.tap
        problem <<~EOS
          Formula has other versions so create a versioned alias:
            cd #{formula.tap.alias_dir}
            ln -s #{formula.path.to_s.gsub(formula.tap.path, "..")} #{alias_name}
        EOS
      else
        problem "Formula has other versions so create an alias named #{alias_name}."
      end
    end

    unless invalid_versioned_aliases.empty?
      problem <<~EOS
        Formula has invalid versioned aliases:
          #{invalid_versioned_aliases.join("\n  ")}
      EOS
    end
  end
end

#audit_formula_name ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 338

def audit_formula_name
  return unless @strict
  return unless @core_tap

  name = formula.name

  problem "'#{name}' is blacklisted." if MissingFormula.blacklisted_reason(name)

  if Formula.aliases.include? name
    problem "Formula name conflicts with existing aliases."
    return
  end

  if oldname = CoreTap.instance.formula_renames[name]
    problem "'#{name}' is reserved as the old name of #{oldname}"
    return
  end

  return if formula.core_formula?
  return unless Formula.core_names.include?(name)

  problem "Formula name conflicts with existing core formula."
end

#audit_github_repository ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 565

def audit_github_repository
  user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*})
  return if user.nil?

  begin
    metadata = GitHub.repository(user, repo)
  rescue GitHub::HTTPNotFoundError
    return
  end

  return if metadata.nil?

  new_formula_problem "GitHub fork (not canonical repository)" if metadata["fork"]
  if (metadata["forks_count"] < 30) && (metadata["subscribers_count"] < 30) &&
     (metadata["stargazers_count"] < 75)
    new_formula_problem "GitHub repository not notable enough (<30 forks, <30 watchers and <75 stars)"
  end

  return if Date.parse(metadata["created_at"]) <= (Date.today - 30)

  new_formula_problem "GitHub repository too new (<30 days old)"
end

#audit_gitlab_repository ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 588

def audit_gitlab_repository
  user, repo = get_repo_data(%r{https?://gitlab\.com/([^/]+)/([^/]+)/?.*})
  return if user.nil?

  out, _, status= curl_output("--request", "GET", "https://gitlab.com/api/v4/projects/#{user}%2F#{repo}")
  return unless status.success?

  metadata = JSON.parse(out)
  return if metadata.nil?

  new_formula_problem "GitLab fork (not canonical repository)" if metadata["fork"]
  if (metadata["forks_count"] < 30) && (metadata["star_count"] < 75)
    new_formula_problem "GitLab repository not notable enough (<30 forks and <75 stars)"
  end

  return if Date.parse(metadata["created_at"]) <= (Date.today - 30)

  new_formula_problem "GitLab repository too new (<30 days old)"
end

#audit_homepage ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 525

def audit_homepage
  homepage = formula.homepage

  return if homepage.nil? || homepage.empty?

  return unless @online

  return unless DevelopmentTools.curl_handles_most_https_certificates?

  if http_content_problem = curl_check_http_content(homepage,
                                                    user_agents:   [:browser, :default],
                                                    check_content: true,
                                                    strict:        @strict)
    problem http_content_problem
  end
end

#audit_keg_only_style ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 448

def audit_keg_only_style
  return unless formula.keg_only?

  whitelist = %w[
    Apple
    macOS
    OS
    Homebrew
    Xcode
    GPG
    GNOME
    BSD
    Firefox
  ].freeze

  reason = formula.keg_only_reason.to_s
  # Formulae names can legitimately be uppercase/lowercase/both.
  name = Regexp.new(formula.name, Regexp::IGNORECASE)
  reason.sub!(name, "")
  first_word = reason.split.first

  if reason =~ /\A[A-Z]/ && !reason.start_with?(*whitelist)
    problem <<~EOS
      '#{first_word}' from the keg_only reason should be '#{first_word.downcase}'.
    EOS
  end

  return unless reason.end_with?(".")

  problem "keg_only reason should not end with a period."
end

#audit_lines ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 896

def audit_lines
  text.without_patch.split("\n").each_with_index do |line, lineno|
    line_problems(line, lineno + 1)
  end
end

#audit_postgresql ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 480

def audit_postgresql
  return unless formula.name == "postgresql"
  return unless @core_tap

  major_version = formula.version
                         .to_s
                         .split(".")
                         .first
                         .to_i
  previous_major_version = major_version - 1
  previous_formula_name = "postgresql@#{previous_major_version}"
  begin
    Formula[previous_formula_name]
  rescue FormulaUnavailableError
    problem "Versioned #{previous_formula_name} must be created for " \
            "`brew-postgresql-upgrade-database` and `pg_upgrade` to work."
  end
end

#audit_prefix_has_contents ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 975

def audit_prefix_has_contents
  return unless formula.prefix.directory?
  return unless Keg.new(formula.prefix).empty_installation?

  problem <<~EOS
    The installation seems to be empty. Please ensure the prefix
    is set correctly and expected files are installed.
    The prefix configure/make argument may be case-sensitive.
  EOS
end

#audit_reverse_migration ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 962

def audit_reverse_migration
  # Only enforce for new formula being re-added to core
  return unless @strict
  return unless @core_tap
  return unless formula.tap.tap_migrations.key?(formula.name)

  problem <<~EOS
    #{formula.name} seems to be listed in tap_migrations.json!
    Please remove #{formula.name} from present tap & tap_migrations.json
    before submitting it to Homebrew/homebrew-#{formula.tap.repo}.
  EOS
end

#audit_revision_and_version_scheme ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 794

def audit_revision_and_version_scheme
  return unless formula.tap # skip formula not from core or any taps
  return unless formula.tap.git? # git log is required
  return if @new_formula

  fv = FormulaVersions.new(formula)

  previous_version_and_checksum = fv.previous_version_and_checksum("origin/master")
  [:stable, :devel].each do |spec_sym|
    next unless spec = formula.send(spec_sym)
    next unless previous_version_and_checksum[spec_sym][:version] == spec.version
    next if previous_version_and_checksum[spec_sym][:checksum] == spec.checksum

    problem(
      "#{spec_sym}: sha256 changed without the version also changing; " \
      "please create an issue upstream to rule out malicious " \
      "circumstances and to find out why the file changed.",
    )
  end

  attributes = [:revision, :version_scheme]
  attributes_map = fv.version_attributes_map(attributes, "origin/master")

  current_version_scheme = formula.version_scheme
  [:stable, :devel].each do |spec|
    spec_version_scheme_map = attributes_map[:version_scheme][spec]
    next if spec_version_scheme_map.empty?

    version_schemes = spec_version_scheme_map.values.flatten
    max_version_scheme = version_schemes.max
    max_version = spec_version_scheme_map.select do |_, version_scheme|
      version_scheme.first == max_version_scheme
    end.keys.max

    if max_version_scheme && current_version_scheme < max_version_scheme
      problem "version_scheme should not decrease (from #{max_version_scheme} to #{current_version_scheme})"
    end

    if max_version_scheme && current_version_scheme >= max_version_scheme &&
       current_version_scheme > 1 &&
       !version_schemes.include?(current_version_scheme - 1)
      problem "version_schemes should only increment by 1"
    end

    formula_spec = formula.send(spec)
    next unless formula_spec

    spec_version = formula_spec.version
    next unless max_version
    next if spec_version >= max_version

    above_max_version_scheme = current_version_scheme > max_version_scheme
    map_includes_version = spec_version_scheme_map.key?(spec_version)
    next if !current_version_scheme.zero? &&
            (above_max_version_scheme || map_includes_version)

    problem "#{spec} version should not decrease (from #{max_version} to #{spec_version})"
  end

  current_revision = formula.revision
  revision_map = attributes_map[:revision][:stable]
  if formula.stable && !revision_map.empty?
    stable_revisions = revision_map[formula.stable.version]
    stable_revisions ||= []
    max_revision = stable_revisions.max || 0

    if current_revision < max_revision
      problem "revision should not decrease (from #{max_revision} to #{current_revision})"
    end

    stable_revisions -= [formula.revision]
    if !current_revision.zero? && stable_revisions.empty? &&
       revision_map.keys.length > 1
      problem "'revision #{formula.revision}' should be removed"
    elsif current_revision > 1 &&
          current_revision != max_revision &&
          !stable_revisions.include?(current_revision - 1)
      problem "revisions should only increment by 1"
    end
  elsif !current_revision.zero? # head/devel-only formula
    problem "'revision #{current_revision}' should be removed"
  end
end

#audit_specs ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 658

def audit_specs
  problem "Head-only (no stable download)" if head_only?(formula)
  problem "Devel-only (no stable download)" if devel_only?(formula)

  %w[Stable Devel HEAD].each do |name|
    spec_name = name.downcase.to_sym
    next unless spec = formula.send(spec_name)

    ra = ResourceAuditor.new(spec, spec_name, online: @online, strict: @strict).audit
    problems.concat ra.problems.map { |problem| "#{name}: #{problem}" }

    spec.resources.each_value do |resource|
      ra = ResourceAuditor.new(resource, spec_name, online: @online, strict: @strict).audit
      problems.concat ra.problems.map { |problem|
        "#{name} resource #{resource.name.inspect}: #{problem}"
      }
    end

    next if spec.patches.empty?
    next unless @new_formula

    new_formula_problem(
      "Formulae should not require patches to build. " \
      "Patches should be submitted and accepted upstream first.",
    )
  end

  %w[Stable Devel].each do |name|
    next unless spec = formula.send(name.downcase)

    version = spec.version
    problem "#{name}: version (#{version}) is set to a string without a digit" if version.to_s !~ /\d/
    if version.to_s.start_with?("HEAD")
      problem "#{name}: non-HEAD version name (#{version}) should not begin with HEAD"
    end
  end

  if formula.stable && formula.devel
    if formula.devel.version < formula.stable.version
      problem "devel version #{formula.devel.version} is older than stable version #{formula.stable.version}"
    elsif formula.devel.version == formula.stable.version
      problem "stable and devel versions are identical"
    end
  end

  return unless @core_tap

  problem "Formulae should not have a `devel` spec" if formula.devel

  if formula.head && @versioned_formula
    head_spec_message = "Formulae should not have a `HEAD` spec"
    versioned_head_spec = %w[
      bash-completion@2
      imagemagick@6
      python@2
    ]
    problem head_spec_message unless versioned_head_spec.include?(formula.name)
  end

  throttled = %w[
    aws-sdk-cpp 10
    awscli 10
    quicktype 10
    vim 50
  ]

  throttled.each_slice(2).to_a.map do |a, b|
    next if formula.stable.nil?

    version = formula.stable.version.to_s.split(".").last.to_i
    if a == formula.name && version.modulo(b.to_i).nonzero?
      problem "should only be updated every #{b} releases on multiples of #{b}"
    end
  end

  unstable_whitelist = %w[
    aalib 1.4rc5
    automysqlbackup 3.0-rc6
    aview 1.3.0rc1
    elm-format 0.6.0-alpha
    ftgl 2.1.3-rc5
    hidapi 0.8.0-rc1
    libcaca 0.99b19
    premake 4.4-beta5
    pwnat 0.3-beta
    recode 3.7-beta2
    speexdsp 1.2rc3
    sqoop 1.4.6
    tcptraceroute 1.5beta7
    tiny-fugue 5.0b8
    vbindiff 3.0_beta4
  ].each_slice(2).to_a.map do |formula, version|
    [formula, version.sub(/\d+$/, "")]
  end

  gnome_devel_whitelist = %w[
    libart 2.3.21
    pygtkglext 1.1.0
    gtk-mac-integration 2.1.3
    gtk-doc 1.31
    gcab 1.3
  ].each_slice(2).to_a.map do |formula, version|
    [formula, version.split(".")[0..1].join(".")]
  end

  stable = formula.stable
  return unless stable
  return unless stable.url

  stable_version_string = stable.version.to_s
  stable_url_version = Version.parse(stable.url)
  _, stable_url_minor_version, = stable_url_version.to_s
                                                   .split(".", 3)
                                                   .map(&:to_i)

  case stable.url
  when /[\d\._-](alpha|beta|rc\d)/
    matched = Regexp.last_match(1)
    version_prefix = stable_version_string.sub(/\d+$/, "")
    return if unstable_whitelist.include?([formula.name, version_prefix])

    problem "Stable version URLs should not contain #{matched}"
  when %r{download\.gnome\.org/sources}, %r{ftp\.gnome\.org/pub/GNOME/sources}i
    version_prefix = stable_version_string.split(".")[0..1].join(".")
    return if gnome_devel_whitelist.include?([formula.name, version_prefix])
    return if stable_url_version < Version.create("1.0")
    return if stable_url_minor_version.even?

    problem "#{stable.version} is a development release"
  when %r{isc.org/isc/bind\d*/}i
    return if stable_url_minor_version.even?

    problem "#{stable.version} is a development release"
  end
end

#audit_style ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 236

def audit_style
  return unless @style_offenses

  @style_offenses.each do |offense|
    if offense.cop_name.start_with?("NewFormulaAudit")
      next if @versioned_formula

      new_formula_problem offense.to_s(display_cop_name: @display_cop_names)
      next
    end
    problem offense.to_s(display_cop_name: @display_cop_names)
  end
end

#audit_text ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 878

def audit_text
  bin_names = Set.new
  bin_names << formula.name
  bin_names += formula.aliases
  [formula.bin, formula.sbin].each do |dir|
    next unless dir.exist?

    bin_names += dir.children.map(&:basename).map(&:to_s)
  end
  bin_names.each do |name|
    ["system", "shell_output", "pipe_output"].each do |cmd|
      if text.to_s.match?(/test do.*#{cmd}[\(\s]+['"]#{Regexp.escape(name)}[\s'"]/m)
        problem %Q(fully scope test #{cmd} calls, e.g. #{cmd} "\#{bin}/#{name}")
      end
    end
  end
end

#audit_versioned_keg_only ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 499

def audit_versioned_keg_only
  return unless @versioned_formula
  return unless @core_tap

  if formula.keg_only?
    return if formula.keg_only_reason.reason == :versioned_formula
    if formula.name.start_with?("openssl", "libressl") &&
       formula.keg_only_reason.reason == :provided_by_macos
      return
    end
  end

  keg_only_whitelist = %w[
    autoconf@2.13
    bash-completion@2
    gnupg@1.4
    lua@5.1
    python@2
    numpy@1.16
  ].freeze

  return if keg_only_whitelist.include?(formula.name) || formula.name.start_with?("gcc@")

  problem "Versioned formulae should use `keg_only :versioned_formula`"
end

#get_repo_data(regex) ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 644

def get_repo_data(regex)
  return unless @core_tap
  return unless @online
  return unless @new_formula

  _, user, repo = *regex.match(formula.stable.url) if formula.stable
  _, user, repo = *regex.match(formula.homepage) unless user
  return if !user || !repo

  repo.gsub!(/.git$/, "")

  [user, repo]
end

#line_problems(line, _lineno) ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 902

def line_problems(line, _lineno)
  # Check for string interpolation of single values.
  if line =~ /(system|inreplace|gsub!|change_make_var!).*[ ,]"#\{([\w.]+)\}"/
    problem "Don't need to interpolate \"#{Regexp.last_match(2)}\" with #{Regexp.last_match(1)}"
  end

  # Check for string concatenation; prefer interpolation
  if line =~ /(#\{\w+\s*\+\s*['"][^}]+\})/
    problem "Try not to concatenate paths in string interpolation:\n   #{Regexp.last_match(1)}"
  end

  # Prefer formula path shortcuts in Pathname+
  if line =~ %r{\(\s*(prefix\s*\+\s*(['"])(bin|include|libexec|lib|sbin|share|Frameworks)[/'"])}
    problem(
      "\"(#{Regexp.last_match(1)}...#{Regexp.last_match(2)})\" should" \
      " be \"(#{Regexp.last_match(3).downcase}+...)\"",
    )
  end

  problem "Use separate make calls" if line.include?("make && make")

  if line =~ /JAVA_HOME/i &&
     [formula.name, *formula.deps.map(&:name)].none? { |name| name.match?(/^openjdk(@|$)/) } &&
     formula.requirements.none? { |req| req.is_a?(JavaRequirement) }
    problem "Use `depends_on :java` to set JAVA_HOME"
  end

  return unless @strict

  problem "`env :userpaths` in formulae is deprecated" if line.include?("env :userpaths")

  if line =~ /system ((["'])[^"' ]*(?:\s[^"' ]*)+\2)/
    bad_system = Regexp.last_match(1)
    unless %w[| < > & ; *].any? { |c| bad_system.include? c }
      good_system = bad_system.gsub(" ", "\", \"")
      problem "Use `system #{good_system}` instead of `system #{bad_system}` "
    end
  end

  problem "`#{Regexp.last_match(1)}` is now unnecessary" if line =~ /(require ["']formula["'])/

  if line.match?(%r{#\{share\}/#{Regexp.escape(formula.name)}[/'"]})
    problem "Use \#{pkgshare} instead of \#{share}/#{formula.name}"
  end

  if !@core_tap && line =~ /depends_on .+ if build\.with(out)?\?\(?["']\w+["']\)?/
    problem "`Use :optional` or `:recommended` instead of `#{Regexp.last_match(0)}`"
  end

  return unless line =~ %r{share(\s*[/+]\s*)(['"])#{Regexp.escape(formula.name)}(?:\2|/)}

  problem "Use pkgshare instead of (share#{Regexp.last_match(1)}\"#{formula.name}\")"

  return unless @core_tap

  return unless line.include?("env :std")

  problem "`env :std` in `core` formulae is deprecated"
end

#problem_if_output(output) ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 990

def problem_if_output(output)
  problem(output) if output
end

#quote_dep(dep) ⇒ Object

# File 'brew/Library/Homebrew/dev-cmd/audit.rb', line 986

def quote_dep(dep)
  dep.is_a?(Symbol) ? dep.inspect : "'#{dep}'"
end