tworingtools 4.7.0 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab98c6a76083beb69e5321318a516f318c978c52fae24bf2cb1a7c4ff0f0da56
-  data.tar.gz: 3e4b33808f476411d426dcc5c01f5cb43769384128f7631b295e0713eccb6626
+  metadata.gz: 220c9e3f2edc649ed5c9a1facfbc5f95d83176c19045b23eb71a36604dc8c536
+  data.tar.gz: 5cff8d57fe3ec27d8a05bde478cd16cb48de72fed0c4a3cddc6e2fcc8228dab7
 SHA512:
-  metadata.gz: c88c9a7ff566bdef41e3201b0871466a760fff3f9faf48c1133fda4a136ba1758bb87cbfa0a955380b4e9c90bc3b8fad2a5c95570c774146436fce7d5885bdcb
-  data.tar.gz: ccec1349aa05d908361c0d35d64b1546748f3d089529a191348c8424facd1e25180adf826bbabfa86d959a377e907e126d692d8c5a0a17dfdd37fceaad4985c8
+  metadata.gz: 95c16050b27aed9526b0404804e6b35db0c3bcbb237066419a4fc56c80d92bb0d58bee741823e64d08e3fceb3eda8962020386ad4814ceb09e3ead2061aeed71
+  data.tar.gz: d19732be9665f152cb9b7d51d5d10519d6bc9de4b3072c2ff26e864a0d29a7c0347edaef3b2f76a17b7b3be09bede3a965ce42a5a86c620c9e87adc7d8495305

data/bin/bumpr

@@ -54,5 +54,5 @@ stdout, stderr, status = Open3.capture3(command)
 
 unless options[:no_commit] then
   echo_and_exec "git add #{version_file}"
-  echo_and_exec "git commit --message \"#{stdout}\""
+  echo_and_exec "git commit --message \"chore: #{stdout}\""
 end

data/bin/sync-git-remotes

@@ -0,0 +1,67 @@
+#! /usr/bin/env ruby
+
+require 'octokit'
+require 'json'
+require 'optparse'
+require_relative '../lib/echoexec'
+require_relative '../lib/git_helpers'
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = <<~BANNER
+
+    Usage: sync-git-remotes [options] <directory>
+
+           For each of your GitHub forks, clone your forked version, then go in and add a remote
+           to the upstream version, and set up local tracking branches for both remotes' default
+           branches. Then fast-forward them both, fetch all tags etc.
+
+           <directory> is the path containing the directories holding your forks, and/or
+           to where those you don't yet have should be cloned.
+
+           Options:
+
+  BANNER
+
+  opts.on('-tTOKEN', '--token=TOKEN', 'GitHub personal access token.') do |t| options[:token] = t end
+  opts.on('-rREPO', '--repo-name=REPO', 'The name of a particular repository to sync.') do |repo| options[:repo] = repo end
+  opts.on('-v', '--verbose', 'Enable verbose logging.') do options[:verbose] = true end
+end
+parser.parse!
+root_dir_path = ARGV[0]
+
+# authenticate the github client, producing a token for callers to use if they try with user/pass, as that is rate limited
+github = nil
+if nil != options[:token] then
+  github = Octokit::Client.new(:access_token => options[:token])
+  puts 'Running with provided token...'
+end
+
+github.auto_paginate = true
+
+repos = github.repos
+
+# sync owned repos
+owned_repos = repos.select {|x| !x.fork}
+if options[:repo] != nil then
+  owned_repos.select! {|x| x.name == options[:repo]}
+end
+owned_repos.each do |owned_repo|
+  puts '---'
+  owned_repo_info = github.repo(owned_repo.id)
+  sync_repo(owned_repo_info, root_dir_path)
+end
+
+# get the list of forks to sync
+forks = repos.select {|x| x.fork}
+if options[:repo] != nil then
+  forks.select! {|x| x.name == options[:repo]}
+end
+
+# sync the forks
+forks.each do |forked_repo|
+  puts '---'
+
+  forked_repo_info = github.repo(forked_repo.id)
+  sync_fork(forked_repo_info, root_dir_path)
+end

data/lib/git_helpers.rb

@@ -0,0 +1,77 @@
+require 'octokit'
+require_relative 'echoexec'
+
+def sync_repo repo_info, root_dir_path
+  name = repo_info.name
+  ssh_url = repo_info.ssh_url
+
+  path = "#{root_dir_path}/#{name}"
+  already_cloned = Dir.exist?(path)
+
+  # clone any forks not already cloned
+  unless already_cloned then
+    echo_and_exec "git clone #{ssh_url} #{path}"
+  end
+
+  # for repos that were cloned previously, update them by fast-forwarding the default branch and fetch all tags
+  if already_cloned then
+    Dir.chdir path do
+      echo_and_exec "git fetch && git fetch --tags && git pull --ff-only"
+    end
+  end
+end
+
+
+def sync_fork forked_repo_info, root_dir_path
+  upstream_ssh_url = forked_repo_info.source.ssh_url
+  original_owner = forked_repo_info.source.owner.login
+  name = forked_repo_info.name
+  fork_ssh_url = forked_repo_info.ssh_url
+
+  upstream_remote_name = 'upstream'
+  fork_remote_name = 'fork'
+  path = "#{root_dir_path}/_Forks/#{original_owner}/#{name}"
+  already_cloned = Dir.exist?(path)
+
+  # clone any forks not already cloned
+  unless already_cloned then
+    echo_and_exec "git clone #{fork_ssh_url} #{path}"
+  end
+
+  Dir.chdir path do
+    # if we just cloned the repo locally, set up both remotes
+    unless already_cloned then
+      echo_and_exec "git remote add #{upstream_remote_name} #{upstream_ssh_url}"
+      echo_and_exec "git remote rename origin #{fork_remote_name}"
+    end
+
+    # get the names of the default branches
+    fork_default_branch_name = `git remote show #{fork_remote_name} | grep "HEAD branch" | cut -d ":" -f 2`.strip
+    fork_default_local_branch_name = "#{fork_remote_name}_#{fork_default_branch_name}"
+    upstream_default_branch_name = `git remote show #{upstream_remote_name} | grep "HEAD branch" | cut -d ":" -f 2`.strip
+    upstream_default_local_branch_name = "#{upstream_remote_name}_#{upstream_default_branch_name}"
+
+    # if we just cloned the repo locally, set local default tracking branches
+    unless already_cloned then
+      # rename the cloned local default branch to reflect that it's tracking the fork remote's version
+      echo_and_exec "git branch -m #{fork_default_branch_name} #{fork_default_local_branch_name}"
+
+      # set up a local branch to track the upstream remote's default branch
+      echo_and_exec "git fetch #{upstream_remote_name}"
+      echo_and_exec "git checkout -b #{upstream_default_local_branch_name} #{upstream_remote_name}/#{upstream_default_branch_name}"
+
+      # push the local upstream default tracking branch to the fork's remote, so it also has a copy alongside it's default branch
+      echo_and_exec "git push #{fork_remote_name} HEAD:#{upstream_default_local_branch_name}"
+    end
+
+    # for repos that were cloned previously, update them by fast-forwarding both default branches and fetch all tags
+    if already_cloned then
+      echo_and_exec "git checkout #{fork_default_local_branch_name}"
+      echo_and_exec "git pull --ff-only #{fork_remote_name}"
+      echo_and_exec "git fetch --tags #{fork_remote_name}"
+
+      echo_and_exec "git checkout #{upstream_default_local_branch_name}"
+      echo_and_exec "git pull --ff-only #{upstream_remote_name}"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tworingtools
 version: !ruby/object:Gem::Version
-  version: 4.7.0
+  version: 6.1.0
 platform: ruby
 authors:
 - Andrew McKnight
@@ -11,19 +11,19 @@ cert_chain: []
 date: 2020-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: github_api
+  name: octokit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: 4.20.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: 4.20.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -40,7 +40,7 @@ dependencies:
         version: '2.1'
 description: |2
     - xcsims: Delete all simulators and recreate one for each compatible platform and device type pairing.
-    - sync-forks: Make sure all your GitHub forks are clones into a given directory, and have “upstream” remotes pointing to the repos that were forked.
+    - sync-git-remotes: Make sure all your GitHub repos are cloned into a given directory and keep them synced with upstream. Forks are maintained with a remote for both the fork and upstream, both remotes' default branches are tracked in local counterparts, and the upstream default branch is also pushed to the fork.
     - changetag: Extract changelog entries to write into git tag annotation messages.
     - prerelease-podspec: Branch and create/push a release candidate tag, modify the podspec to use that version tag, and try linting it.
     - release-podspec: Create a tag with the version and push it to repo origin, push podspec to CocoaPods trunk.
@@ -52,7 +52,7 @@ email: andrew@tworingsoft.com
 executables:
 - clean-rc-tags
 - xcsims
-- sync-forks
+- sync-git-remotes
 - changetag
 - prerelease-podspec
 - release-podspec
@@ -69,11 +69,12 @@ files:
 - bin/prerelease-podspec
 - bin/release-podspec
 - bin/revert-failed-release-tag
-- bin/sync-forks
+- bin/sync-git-remotes
 - bin/xcsims
 - lib/echoexec.rb
 - lib/errors.rb
 - lib/git_check.rb
+- lib/git_helpers.rb
 homepage: https://github.com/TwoRingSoft/tools
 licenses:
 - MIT
@@ -93,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: A collection of command line tools.

data/bin/sync-forks

@@ -1,90 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'github_api'
-require 'json'
-require 'optparse'
-require_relative '../lib/echoexec'
-
-# failure modes
-FURTHER_REQUESTS_REQUIRE_TOKEN = 65
-MISSING_REQUIRED_CREDENTIALS = 66
-
-options = {}
-parser = OptionParser.new do |opts|
-  opts.banner = <<~BANNER
-  
-    Usage: sync-forks [options] <directory>
-           
-           <directory> is the path containing the directories holding your forks, and/or
-           to where those you don't yet have should be cloned.
-           
-           Examples:
-    
-           sync-forks -u/--username <user> -p/--password <pass> [-o/--one-time-pw <otp>] .
-           sync-forks -u/--username <user> -t/--token <token> .
-           sync-forks -u/--username <user> -t/--token -n/--repo-name that-one-repo-I-forked <token> .
-           
-           If you already have a Personal Access Token, provide it in the second form. 
-           Otherwise, use the first form, which will register a new token for you named
-           “sync-forks”. Then use that to invoke the program again. This is because
-           requests using basic authentication (user/pass) are too rate limited.
-           
-           Options:
-           
-  BANNER
-
-  opts.on('-uUSERNAME', '--username=USERNAME', 'GitHub username. Required for all invocations.') do |user| options[:username] = user end
-  opts.on('-tTOKEN', '--token=TOKEN', 'GitHub personal access token. The primary way to use this program.') do |t| options[:token] = t end
-  opts.on('-pPASSWORD', '--password=PASSWORD', 'GitHub password.') do |pass| options[:password] = pass end
-  opts.on('-oOTP', '--one-time-pw=OTP', 'GitHub 2FA token, if you have it enabled.') do |otp| options[:otp] = otp end
-  opts.on('-rREPO', '--repo-name=REPO', 'The name of a particular repository to sync.') do |repo| options[:repo] = repo end
-end
-parser.parse!
-
-github = nil
-if nil != options[:token] && nil != options[:username] then
-  github = Github.new oauth_token: options[:token]
-elsif nil != options[:username] && nil != options[:password]
-  github = Github.new do |config|
-     config.basic_auth = "#{options[:username]}:#{options[:password]}"
-     if nil != options[:otp] then
-       config.connection_options = {headers: {"X-GitHub-OTP" => options[:otp]}}
-     end
-  end
-  token = github.auth.create scopes: ['repo'], note: 'sync-forks3'
-  puts "Created new token, use it to call sync-forks again:"
-  puts
-  puts "\tsync-forks -u #{user} -t #{token.token}"
-  puts
-  exit FURTHER_REQUESTS_REQUIRE_TOKEN
-else
-  puts "Must provide either a username/token or username/password/otp combination to authenticate."
-  puts parser
-  exit MISSING_REQUIRED_CREDENTIALS
-end
-
-repos = github.repos.list user: options[:username], auto_pagination: true
-forks = repos.select {|x| x.fork}
-
-if options[:repo] != nil then
-  forks.select! {|x| x.name == options[:repo]}
-end
-
-current_dir = Dir.new(ARGV[0])
-Dir.chdir current_dir
-forks.each do |forked|
-  info = github.repos(user: options[:username], repo: forked.name).get
-  fork_url = info.source.ssh_url
-  name = forked.name
-  url = forked.ssh_url
-  
-  puts '---'
-  if current_dir.entries.include? name then
-    puts "#{name} already exists."
-  else
-    echo_and_exec "git clone #{url}"
-    Dir.chdir "#{name}"
-    echo_and_exec "git remote add upstream #{fork_url}"
-    Dir.chdir ".."
-  end
-end