multi_repo 0.1.0

data/lib/multi_repo/helpers/pull_request_blaster_outer.rb

@@ -0,0 +1,129 @@
+require 'pathname'
+
+module MultiRepo::Helpers
+  class PullRequestBlasterOuter
+    attr_reader :repo, :base, :head, :script, :dry_run, :message, :title
+
+    def initialize(repo, base:, head:, script:, dry_run:, message:, title: nil, **)
+      @repo    = repo
+      @base    = base
+      @head    = head
+      @script  = begin
+        s = Pathname.new(script)
+        s = Pathname.new(Dir.pwd).join(script) if s.relative?
+        raise "File not found #{s}" unless s.exist?
+        s.to_s
+      end
+      @dry_run = dry_run
+      @message = message
+      @title   = (title || message)[0, 72]
+    end
+
+    def blast
+      puts "+++ blasting #{repo.name}..."
+
+      repo.git.fetch
+
+      unless repo.git.remote_branch?("origin", base)
+        puts "!!! Skipping #{repo.name}: 'origin/#{base}' not found"
+        return
+      end
+
+      repo.git.hard_checkout(head, "origin/#{base}")
+      run_script
+
+      result = false
+      if !commit_changes
+        puts "!!! Failed to commit changes. Perhaps the script is wrong or #{repo.name} is already updated."
+      elsif dry_run
+        result = "Committed but is dry run"
+      else
+        puts "Do you want to open a pull request on #{repo.name} with the above changes? (Y/N)"
+        answer = $stdin.gets.chomp
+        if answer.upcase.start_with?("Y")
+          fork_repo unless forked?
+          push_branch
+          result = open_pull_request
+        end
+      end
+      puts "--- blasting #{repo.name} complete"
+      result
+    end
+
+    private
+
+    def github
+      @github ||= MultiRepo::Service::Github.new(dry_run: dry_run)
+    end
+
+    def forked?
+      github.client.repos(github.client.login).any? { |m| m.name == repo.name }
+    end
+
+    def fork_repo
+      github.client.fork(repo.name)
+      until forked?
+        print "."
+        sleep 3
+      end
+    end
+
+    def run_script
+      repo.chdir do
+        parts = []
+        parts << "GITHUB_REPO=#{repo.name}"
+        parts << "DRY_RUN=true" if dry_run
+        parts << script
+        cmd = parts.join(" ")
+
+        unless system(cmd)
+          puts "!!! Script execution failed."
+          exit $?.exitstatus
+        end
+      end
+    end
+
+    def commit_changes
+      repo.chdir do
+        begin
+          repo.git.client.add("-v", ".")
+          repo.git.client.commit("-m", message)
+          repo.git.client.show
+          if dry_run
+            puts "!!! --dry-run enabled: If the above commit in #{repo.path} looks good, run again without dry run to fork the repo, push the branch and open a pull request."
+          end
+          true
+        rescue MiniGit::GitError => e
+          e.status.exitstatus == 0
+        end
+      end
+    end
+
+    def origin_remote
+      "pr_blaster_outer"
+    end
+
+    def origin_url
+      "git@github.com:#{github.client.login}/#{repo.name}.git"
+    end
+
+    def pr_head
+      "#{github.client.login}:#{head}"
+    end
+
+    def push_branch
+      repo.chdir do
+        repo.git.client.remote("add", origin_remote, origin_url) unless repo.git.remote?(origin_remote)
+        repo.git.client.push("-f", origin_remote, "#{head}:#{head}")
+      end
+    end
+
+    def open_pull_request
+      pr = github.client.create_pull_request(repo.name, base, pr_head, title, title)
+      pr.html_url
+    rescue => err
+      raise unless err.message.include?("A pull request already exists")
+      puts "!!! Skipping.  #{err.message}"
+    end
+  end
+end

data/lib/multi_repo/helpers/readme_badges.rb

@@ -0,0 +1,84 @@
+require "active_support/core_ext/object/deep_dup"
+
+module MultiRepo::Helpers
+  class ReadmeBadges
+    attr_reader :repo, :dry_run
+    attr_accessor :badges
+
+    def initialize(repo, dry_run: false, **)
+      @repo    = repo
+      @dry_run = dry_run
+
+      if repo.dry_run != dry_run
+        raise ArgumentError, "expected repo.dry_run (#{repo.dry_run}) to match dry_run (#{dry_run})"
+      end
+
+      reload
+    end
+
+    def save!
+      lines = content.lines
+
+      apply_badges!(lines)
+      save_contents!(lines.join)
+
+      if dry_run
+        reload(lines)
+      else
+        reload
+      end
+
+      true
+    end
+
+    def content
+      return "" unless @file
+      File.read(repo.path.join(@file))
+    end
+
+    private
+
+    def reload(lines = nil)
+      @file = repo.detect_readme_file if lines.nil?
+
+      reload_badges(lines)
+    end
+
+    def reload_badges(lines)
+      lines ||= content.lines
+      @badges = extract_badges(lines)
+      @original_badges = @badges.deep_dup
+      @original_badge_indexes = @badges.map { |b| b["index"] }
+    end
+
+    def extract_badges(lines)
+      lines.each.with_index.select do |l, _i|
+        l.to_s.start_with?("[![")
+      end.map do |l, i|
+        match = l.match(/\A\[!\[(?<description>[^\]]+)\]\((?<image>[^\)]+)\)\]\((?<url>[^\)]+)\)/)
+        match.named_captures.merge("index" => i)
+      end
+    end
+
+    def build_badge_string(badge)
+      "[![#{badge["description"]}](#{badge["image"]})](#{badge["url"]})\n"
+    end
+
+    def apply_badges!(lines)
+      return if badges == @original_badges
+
+      lines.reject!.with_index { |_l, i| @original_badge_indexes.include?(i) }
+
+      start_index = @original_badge_indexes[0] || 2
+      @badges.reverse_each do |b|
+        lines.insert(start_index, build_badge_string(b))
+      end
+    end
+
+    def save_contents!(contents)
+      repo.rm_file("README")
+      repo.rm_file("README.txt")
+      repo.write_file("README.md", contents)
+    end
+  end
+end

data/lib/multi_repo/helpers/rename_labels.rb

@@ -0,0 +1,26 @@
+module MultiRepo::Helpers
+  class RenameLabels
+    attr_reader :repo_name, :rename_hash, :github
+
+    def initialize(repo_name, rename_hash, dry_run: false, **)
+      @repo_name   = repo_name
+      @rename_hash = rename_hash
+      @github      = MultiRepo::Service::Github.new(dry_run: dry_run)
+    end
+
+    def run
+      rename_hash.each do |old_name, new_name|
+        github_label = existing_labels.detect { |l| l.name == old_name }
+
+        if github_label
+          puts "Renaming label #{old_name.inspect} to #{new_name.inspect}"
+          github.update_label(repo_name, old_name, name: new_name)
+        end
+      end
+    end
+
+    private def existing_labels
+      @existing_labels ||= github.labels(repo_name)
+    end
+  end
+end

data/lib/multi_repo/helpers/update_branch_protection.rb

@@ -0,0 +1,24 @@
+module MultiRepo::Helpers
+  class UpdateBranchProtection
+    attr_reader :repo_name, :branch, :dry_run, :github
+
+    def initialize(repo_name, branch:, dry_run: false, **)
+      @repo_name = repo_name
+      @branch    = branch
+      @github    = MultiRepo::Service::Github.new(dry_run: dry_run)
+    end
+
+    def run
+      puts "Protecting #{branch} branch"
+
+      settings = {
+        :enforce_admins                => nil,
+        :required_status_checks        => nil,
+        :required_pull_request_reviews => nil,
+        :restrictions                  => nil
+      }
+
+      github.protect_branch(repo_name, branch, settings)
+    end
+  end
+end

data/lib/multi_repo/helpers/update_labels.rb

@@ -0,0 +1,34 @@
+module MultiRepo::Helpers
+  class UpdateLabels
+    attr_reader :repo_name, :expected_labels, :github
+
+    def initialize(repo_name, dry_run: false, **)
+      @repo_name       = repo_name
+      @expected_labels = MultiRepo::Labels[repo_name]
+      @github          = MultiRepo::Service::Github.new(dry_run: dry_run)
+    end
+
+    def run
+      if expected_labels.nil?
+        puts "!! No labels defined for #{repo_name}"
+        return
+      end
+
+      expected_labels.each do |label, color|
+        github_label = existing_labels.detect { |l| l.name == label }
+
+        if !github_label
+          puts "Creating #{label.inspect} with #{color.inspect}"
+          github.create_label(repo_name, label, color)
+        elsif github_label.color.downcase != color.downcase
+          puts "Updating #{label.inspect} to #{color.inspect}"
+          github.update_label(repo_name, label, color: color)
+        end
+      end
+    end
+
+    private def existing_labels
+      @existing_labels ||= github.client.labels(repo_name)
+    end
+  end
+end

data/lib/multi_repo/helpers/update_milestone.rb

@@ -0,0 +1,33 @@
+
+
+module MultiRepo::Helpers
+  class UpdateMilestone
+    attr_reader :repo_name, :title, :due_on, :close, :github
+
+    def initialize(repo_name, title:, due_on:, close:, dry_run: false, **)
+      raise ArgumentError, "due_on must be specified" if due_on.nil? && !close
+
+      @repo_name = repo_name
+      @title     = title
+      @due_on    = MultiRepo::Service::Github.parse_milestone_date(due_on) if due_on
+      @close     = close
+      @github    = MultiRepo::Service::Github.new(dry_run: dry_run)
+    end
+
+    def run
+      existing = github.find_milestone_by_title(repo_name, title)
+      if close
+        if existing
+          puts "Closing milestone #{title.inspect} (#{existing.number})"
+          github.close_milestone(repo.name, title, existing.number)
+        end
+      elsif existing
+        puts "Updating milestone #{title.inspect} (#{existing.number}) with due date #{due_on_str.inspect}"
+        github.update_milestone(repo.name, existing.number, due_on)
+      else
+        puts "Creating milestone #{title.inspect} with due date #{due_on_str.inspect}"
+        github.create_milestone(repo.name, title, due_on)
+      end
+    end
+  end
+end

data/lib/multi_repo/helpers/update_repo_settings.rb

@@ -0,0 +1,23 @@
+module MultiRepo::Helpers
+  class UpdateRepoSettings
+    attr_reader :repo_name, :github
+
+    def initialize(repo_name, dry_run: false, **)
+      @repo_name = repo_name
+      @github    = MultiRepo::Service::Github.new(dry_run: dry_run)
+    end
+
+    def run
+      settings = {
+        :has_wiki           => false,
+        :has_projects       => false,
+        :allow_merge_commit => true,
+        :allow_rebase_merge => false,
+        :allow_squash_merge => false,
+      }
+
+      puts "Editing #{repo_name}"
+      github.edit_repository(repo_name, settings)
+    end
+  end
+end

data/lib/multi_repo/labels.rb

@@ -0,0 +1,31 @@
+module MultiRepo
+  class Labels
+    def self.config_file
+      MultiRepo.config_dir.join("labels.yml")
+    end
+
+    def self.config
+      @config ||= YAML.unsafe_load_file(config_file)
+    end
+
+    def self.[](repo)
+      all[repo]
+    end
+
+    def self.all
+      @all ||= begin
+        require "more_core_extensions/core_ext/hash/nested"
+
+        Array(config["orgs"]).each do |org, options|
+          MultiRepo::Service::Github.org_repo_names(org).each do |repo_name|
+            next if config.key_path?("repos", repo_name)
+            next if options["except"].include?(repo_name)
+
+            config.store_path("repos", repo_name, options["labels"])
+          end
+        end
+        config["repos"].sort.to_h
+      end
+    end
+  end
+end

data/lib/multi_repo/repo.rb

@@ -0,0 +1,56 @@
+require 'ostruct'
+
+module MultiRepo
+  class Repo
+    attr_reader :name, :config, :path
+    attr_accessor :dry_run
+
+    def initialize(name, config: nil, dry_run: false)
+      @name    = name
+      @dry_run = dry_run
+      @config  = OpenStruct.new(config || {})
+      @path    = MultiRepo.repos_dir.join(name)
+    end
+
+    alias to_s inspect
+
+    def git
+      @git ||= MultiRepo::Service::Git.new(path: path, clone_source: config.clone_source || "git@github.com:#{name}.git", dry_run: dry_run)
+    end
+
+    def chdir
+      git # Ensures the clone exists
+      Dir.chdir(path) { yield }
+    end
+
+    def short_name
+      name.split("/").last
+    end
+
+    def write_file(file, content, **kwargs)
+      if dry_run
+        puts "** dry-run: Writing #{path.join(file).expand_path}".light_black
+      else
+        chdir { File.write(file, content) }
+      end
+    end
+
+    def rm_file(file)
+      return unless path.join(file).exist?
+
+      if dry_run
+        puts "** dry-run: Removing #{path.join(file).expand_path}".light_black
+      else
+        chdir { FileUtils.rm_f(file) }
+      end
+    end
+
+    def detect_readme_file
+      chdir do
+        %w[README.md README README.txt].detect do |f|
+          File.exist?(f)
+        end
+      end
+    end
+  end
+end

data/lib/multi_repo/repo_set.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+
+module MultiRepo
+  class RepoSet
+    def self.config_files
+      Dir.glob(MultiRepo.config_dir.join("repos*.yml")).sort
+    end
+
+    def self.config
+      @config ||= config_files.each_with_object({}) do |f, h|
+        h.merge!(YAML.unsafe_load_file(f))
+      end
+    end
+
+    def self.[](set_name)
+      all[set_name]
+    end
+
+    def self.all
+      @all ||= config.transform_values do |repo_set|
+        repo_set.map do |repo, config|
+          Repo.new(repo, config: config)
+        end
+      end
+    end
+  end
+end

data/lib/multi_repo/service/artifactory.rb

@@ -0,0 +1,122 @@
+module MultiRepo::Service
+  class Artifactory
+    def self.api_token
+      @api_token ||= ENV.fetch("ARTIFACTORY_API_TOKEN")
+    end
+
+    def self.api_token=(token)
+      @api_token = token
+    end
+
+    def self.api_endpoint
+      @api_endpoint ||= ENV.fetch("ARTIFACTORY_API_ENDPOINT")
+    end
+
+    def self.api_endpoint=(endpoint)
+      @api_endpoint = endpoint
+    end
+
+    def self.auth_header
+      {"X-JFrog-Art-Api" => api_token}
+    end
+
+    attr_accessor :dry_run, :cache
+
+    def initialize(dry_run: false, cache: true)
+      require "rest-client"
+      require "json"
+
+      @dry_run = dry_run
+      @cache   = cache
+    end
+
+    def clear_cache
+      FileUtils.rm_f(Dir.glob("/tmp/artifactory-*"))
+    end
+
+    # https://www.jfrog.com/confluence/display/JFROG/RPM+Repositories
+    def get(path, **kwargs)
+      path = path.to_s
+      request(:get, path, **kwargs)
+    end
+
+    def list(folder, cache: @cache, **kwargs)
+      folder = folder.to_s
+      cache_file = "/tmp/artifactory-#{folder.tr("/", "_")}-#{Date.today}.txt"
+      if cache && File.exist?(cache_file)
+        File.readlines(cache_file, :chomp => true)
+      else
+        data = raw_list(folder, cache: cache, **kwargs)
+        uri  = data["uri"]
+
+        data["files"].map { |d| File.join(uri, d["uri"]) }.tap do |d|
+          File.write(cache_file, d.join("\n")) if cache
+        end
+      end
+    end
+
+    def raw_list(folder, cache: @cache, **kwargs)
+      folder = folder.to_s
+      cache_file = "/tmp/artifactory-#{folder.tr("/", "_")}-raw-#{Date.today}.json"
+      if cache && File.exist?(cache_file)
+        JSON.parse(File.read(cache_file))
+      else
+        get("/api/storage/#{folder}?list&deep=1", **kwargs).tap do |d|
+          File.write(cache_file, JSON.pretty_generate(d)) if cache
+        end
+      end
+    end
+
+    def delete(file, **kwargs)
+      file = file.to_s
+      request(:delete, strip_api_prefix(file), **kwargs)
+    rescue RestClient::NotFound => err
+      # Ignore deletes on a 404 because it's already deleted
+      raise unless err.http_code == 404
+    end
+
+    def move(file, to, **kwargs)
+      file = file.to_s
+      to = to.to_s
+      request(:post, File.join("/api/move", "#{strip_api_prefix(file)}?to=/#{strip_api_prefix(to)}"), **kwargs)
+    end
+
+    def copy(file, to, **kwargs)
+      file = file.to_s
+      to = to.to_s
+      request(:post, File.join("/api/copy", "#{strip_api_prefix(file)}?to=/#{strip_api_prefix(to)}"), **kwargs)
+    end
+
+    private
+
+    def request(verb, path, body: nil, headers: nil, verbose: true)
+      headers ||= self.class.auth_header.merge(
+        "Accept"       => "application/json",
+        "Content-Type" => "application/json"
+      )
+      path = File.join(self.class.api_endpoint, path)
+
+      puts "+ #{verb.to_s.upcase} #{path}".light_black if verbose
+      if dry_run && %i[delete put post patch].include?(verb)
+        puts "+ dry_run: #{verb.to_s.upcase} #{path}".light_black if verbose
+        {}
+      else
+        response =
+          if %i[put post patch].include?(verb)
+            RestClient.send(verb, path, body, headers)
+          else
+            RestClient.send(verb, path, headers)
+          end
+        response.empty? ? {} : JSON.parse(response)
+      end
+    end
+
+    def api_file_prefix
+      File.join(self.class.api_endpoint, "api/storage")
+    end
+
+    def strip_api_prefix(path)
+      path.start_with?(api_file_prefix) ? path.sub(api_file_prefix, "") : path
+    end
+  end
+end