Class: Reporter

Inherits:

Object

• Object
• Reporter

Defined in:

cmd/update-report.rb

Defined Under Namespace

Classes: ReporterRevisionUnsetError

Instance Attribute Summary

• #current_revision ⇒ Object readonly

  Returns the value of attribute current_revision.

• #initial_revision ⇒ Object readonly

  Returns the value of attribute initial_revision.

• #tap ⇒ Object readonly

  Returns the value of attribute tap.

Instance Method Summary

• #initialize(tap) ⇒ Reporter constructor

  A new instance of Reporter.

• #migrate_formula_rename(force:, verbose:) ⇒ Object
• #migrate_tap_migration ⇒ Object
• #report(preinstall: false) ⇒ Object
• #updated? ⇒ Boolean

Constructor Details

#initialize(tap) ⇒ Reporter

Returns a new instance of Reporter.

Raises:

• (ReporterRevisionUnsetError)

# File 'cmd/update-report.rb', line 244

def initialize(tap)
  @tap = tap

  initial_revision_var = "HOMEBREW_UPDATE_BEFORE#{tap.repo_var}"
  @initial_revision = ENV[initial_revision_var].to_s
  raise ReporterRevisionUnsetError, initial_revision_var if @initial_revision.empty?

  current_revision_var = "HOMEBREW_UPDATE_AFTER#{tap.repo_var}"
  @current_revision = ENV[current_revision_var].to_s
  raise ReporterRevisionUnsetError, current_revision_var if @current_revision.empty?
end

Instance Attribute Details

#current_revision ⇒ Object (readonly)

Returns the value of attribute current_revision.

# File 'cmd/update-report.rb', line 242

def current_revision
  @current_revision
end

#initial_revision ⇒ Object (readonly)

Returns the value of attribute initial_revision.

# File 'cmd/update-report.rb', line 242

def initial_revision
  @initial_revision
end

#tap ⇒ Object (readonly)

Returns the value of attribute tap.

# File 'cmd/update-report.rb', line 242

def tap
  @tap
end

Instance Method Details

#migrate_formula_rename(force:, verbose:) ⇒ Object

# File 'cmd/update-report.rb', line 445

def migrate_formula_rename(force:, verbose:)
  Formula.installed.each do |formula|
    next unless Migrator.needs_migration?(formula)

    oldname = formula.oldname
    oldname_rack = HOMEBREW_CELLAR/oldname

    if oldname_rack.subdirs.empty?
      oldname_rack.rmdir_if_possible
      next
    end

    new_name = tap.formula_renames[oldname]
    next unless new_name

    new_full_name = "#{tap}/#{new_name}"

    begin
      f = Formulary.factory(new_full_name)
    rescue Exception => e # rubocop:disable Lint/RescueException
      onoe "#{e.message}\n#{e.backtrace.join "\n"}" if Homebrew::EnvConfig.developer?
      next
    end

    Migrator.migrate_if_needed(f, force: force)
  end
end

#migrate_tap_migration ⇒ Object

# File 'cmd/update-report.rb', line 366

def migrate_tap_migration
  (report[:D] + report[:DC]).each do |full_name|
    name = full_name.split("/").last
    new_tap_name = tap.tap_migrations[name]
    next if new_tap_name.nil? # skip if not in tap_migrations list.

    new_tap_user, new_tap_repo, new_tap_new_name = new_tap_name.split("/")
    new_name = if new_tap_new_name
      new_full_name = new_tap_new_name
      new_tap_name = "#{new_tap_user}/#{new_tap_repo}"
      new_tap_new_name
    else
      new_full_name = "#{new_tap_name}/#{name}"
      name
    end

    # This means it is a cask
    if report[:DC].include? full_name
      next unless (HOMEBREW_PREFIX/"Caskroom"/new_name).exist?

      new_tap = Tap.fetch(new_tap_name)
      new_tap.install unless new_tap.installed?
      ohai_stdout_or_stderr "#{name} has been moved to Homebrew.", <<~EOS
        To uninstall the cask, run:
          brew uninstall --cask --force #{name}
      EOS
      next if (HOMEBREW_CELLAR/new_name.split("/").last).directory?

      ohai_stdout_or_stderr "Installing #{new_name}..."
      system HOMEBREW_BREW_FILE, "install", new_full_name
      begin
        unless Formulary.factory(new_full_name).keg_only?
          system HOMEBREW_BREW_FILE, "link", new_full_name, "--overwrite"
        end
      rescue Exception => e # rubocop:disable Lint/RescueException
        onoe "#{e.message}\n#{e.backtrace.join "\n"}" if Homebrew::EnvConfig.developer?
      end
      next
    end

    next unless (dir = HOMEBREW_CELLAR/name).exist? # skip if formula is not installed.

    tabs = dir.subdirs.map { |d| Tab.for_keg(Keg.new(d)) }
    next unless tabs.first.tap == tap # skip if installed formula is not from this tap.

    new_tap = Tap.fetch(new_tap_name)
    # For formulae migrated to cask: Auto-install cask or provide install instructions.
    if new_tap_name.start_with?("homebrew/cask")
      if new_tap.installed? && (HOMEBREW_PREFIX/"Caskroom").directory?
        ohai_stdout_or_stderr "#{name} has been moved to Homebrew Cask."
        ohai_stdout_or_stderr "brew unlink #{name}"
        system HOMEBREW_BREW_FILE, "unlink", name
        ohai_stdout_or_stderr "brew cleanup"
        system HOMEBREW_BREW_FILE, "cleanup"
        ohai_stdout_or_stderr "brew install --cask #{new_name}"
        system HOMEBREW_BREW_FILE, "install", "--cask", new_name
        ohai <<~EOS
          #{name} has been moved to Homebrew Cask.
          The existing keg has been unlinked.
          Please uninstall the formula when convenient by running:
            brew uninstall --force #{name}
        EOS
      else
        ohai_stdout_or_stderr "#{name} has been moved to Homebrew Cask.", <<~EOS
          To uninstall the formula and install the cask, run:
            brew uninstall --force #{name}
            brew tap #{new_tap_name}
            brew install --cask #{new_name}
        EOS
      end
    else
      new_tap.install unless new_tap.installed?
      # update tap for each Tab
      tabs.each { |tab| tab.tap = new_tap }
      tabs.each(&:write)
    end
  end
end

#report(preinstall: false) ⇒ Object

# File 'cmd/update-report.rb', line 256

def report(preinstall: false)
  return @report if @report

  @report = Hash.new { |h, k| h[k] = [] }
  return @report unless updated?

  diff.each_line do |line|
    status, *paths = line.split
    src = Pathname.new paths.first
    dst = Pathname.new paths.last

    next unless dst.extname == ".rb"

    if paths.any? { |p| tap.cask_file?(p) }
      case status
      when "A"
        # Have a dedicated report array for new casks.
        @report[:AC] << tap.formula_file_to_name(src)
      when "D"
        # Have a dedicated report array for deleted casks.
        @report[:DC] << tap.formula_file_to_name(src)
      when "M"
        # Report updated casks
        @report[:MC] << tap.formula_file_to_name(src)
      end
    end

    next unless paths.any? { |p| tap.formula_file?(p) }

    case status
    when "A", "D"
      full_name = tap.formula_file_to_name(src)
      name = full_name.split("/").last
      new_tap = tap.tap_migrations[name]
      @report[status.to_sym] << full_name unless new_tap
    when "M"
      name = tap.formula_file_to_name(src)

      # Skip reporting updated formulae to speed up automatic updates.
      if preinstall
        @report[:M] << name
        next
      end

      begin
        formula = Formulary.factory(tap.path/src)
        new_version = formula.pkg_version
        old_version = FormulaVersions.new(formula).formula_at_revision(@initial_revision, &:pkg_version)
        next if new_version == old_version
      rescue FormulaUnavailableError
        # Don't care if the formula isn't available right now.
        nil
      rescue Exception => e # rubocop:disable Lint/RescueException
        onoe "#{e.message}\n#{e.backtrace.join "\n"}" if Homebrew::EnvConfig.developer?
      end

      @report[:M] << name
    when /^R\d{0,3}/
      src_full_name = tap.formula_file_to_name(src)
      dst_full_name = tap.formula_file_to_name(dst)
      # Don't report formulae that are moved within a tap but not renamed
      next if src_full_name == dst_full_name

      @report[:D] << src_full_name
      @report[:A] << dst_full_name
    end
  end

  renamed_formulae = Set.new
  @report[:D].each do |old_full_name|
    old_name = old_full_name.split("/").last
    new_name = tap.formula_renames[old_name]
    next unless new_name

    new_full_name = if tap.core_tap?
      new_name
    else
      "#{tap}/#{new_name}"
    end

    renamed_formulae << [old_full_name, new_full_name] if @report[:A].include? new_full_name
  end

  @report[:A].each do |new_full_name|
    new_name = new_full_name.split("/").last
    old_name = tap.formula_renames.key(new_name)
    next unless old_name

    old_full_name = if tap.core_tap?
      old_name
    else
      "#{tap}/#{old_name}"
    end

    renamed_formulae << [old_full_name, new_full_name]
  end

  unless renamed_formulae.empty?
    @report[:A] -= renamed_formulae.map(&:last)
    @report[:D] -= renamed_formulae.map(&:first)
    @report[:R] = renamed_formulae.to_a
  end

  @report
end

#updated? ⇒ Boolean

Returns:

• (Boolean)

# File 'cmd/update-report.rb', line 362

def updated?
  initial_revision != current_revision
end