MuranoCLI 3.2.1.pre.beta.4 → 3.2.1.pre.beta.5

data/Rakefile

@@ -6,7 +6,9 @@
 # Unauthorized copying of this file is strictly prohibited.
 
 require 'bundler/gem_tasks'
+require 'open3'
 require 'shellwords'
+require 'tmpdir'
 
 task default: %i[test]
 
@@ -53,21 +55,6 @@ task :tail do
   sh %(tail -F .trustme.log curldebug.out)
 end
 
-desc 'display remind of how to release'
-task :release_reminder do
-  reminder = %(
-    git flow release start <newversion>
-    gvim lib/MrMurano/version.rb
-    git commit -a -m 'version bump'
-    git flow release finish <newversion>
-    # When editing message for tag, add release notes.
-    #rake git:all
-    # Wait for all tests to complete.
-    # if all passed: rake gemit
-  ).lines.map(&:strip).join("\n")
-  puts reminder
-end
-
 desc 'Prints a cmd to test this in another directory'
 task :testwith do
   pwd = Dir.pwd.sub(Dir.home, '~')
@@ -111,39 +98,415 @@ task :test_clean_up do
   end
 end
 
-###
-# When new tags are pushed to upstream, the CI will kick-in and build the release
-#namespace :git do
-#    desc 'Push only develop, master, and tags to origin'
-#    task :origin do
-#        sh %(git push origin develop)
-#        sh %(git push origin master)
-#        sh %(git push origin --tags)
-#    end
-#
-#    desc 'Push only develop, master, and tags to upstream'
-#    task :upstream do
-#        sh %(git push upstream develop)
-#        sh %(git push upstream master)
-#        sh %(git push upstream --tags)
-#    end
+# ***
+
+def exit_task(msg)
+  require 'rainbow'
+  $stderr.print Rainbow(msg + "\n").red.bright
+  exit 1
+end
+
+# ***
+
+def current_ver
+  Bundler::GemHelper.gemspec.version.version
+end
+
+def verify_semantic_version!(parts, must_beta: nil)
+  msg = nil
+  if must_beta == true && parts.length <= 3
+    msg = 'ERROR: Current version is not pre-release/beta versioned'
+  elsif must_beta == false && parts.length != 3
+    msg = 'ERROR: Current version is not normal-release versioned'
+  elsif parts.length < 3
+    msg = 'ERROR: Not a semantic version'
+  else
+    (parts[0..2] + parts[-1..-1]).each do |number|
+      begin
+        Integer(number)
+      rescue ArgumentError => _err
+        msg = 'ERROR: Contains non-integers'
+      end
+    end
+  end
+  exit_task("#{msg}: #{current_ver}") if msg
+end
+
+def split_version_string(must_beta: nil)
+  parts = current_ver.split('.')
+  verify_semantic_version!(parts, must_beta: must_beta)
+  parts
+end
+
+# ***
+
+def git_working_tree_clean?
+  out, err, status = Open3.capture3(%(git status --short))
+  out == '' && err == '' && status.exitstatus == 0
+end
+
+def git_working_tree_clean!
+  return true if git_working_tree_clean?
+  msg = 'ERROR: Please clean your git working tree!'
+  exit_task(msg)
+end
+
+def git_branchname
+  current_branch, _err, _status = Open3.capture3(%(git rev-parse --abbrev-ref HEAD))
+  current_branch
+end
+
+def git_username
+  git_user, _err, _status = Open3.capture3(%(git config user.name))
+  git_user
+end
+
+# ***
+
+def ff_branch(branch)
+  git_working_tree_clean!
+  sh %(git checkout #{branch})
+  sh %(git fetch --prune --multiple origin upstream)
+  sh %(git merge --ff-only upstream/#{branch})
+  sh %(git push origin #{branch})
+end
+
+def ff_develop
+  ff_branch('develop')
+end
+
+def ff_master
+  ff_branch('master')
+end
+
+desc 'Fast-forward merge upstream/develop into origin/develop'
+task :ff do
+  current_branch = git_branchname
+  ff_develop
+  sh %(git checkout #{current_branch})
+end
+
+# ***
+
+desc 'Start a Pull Request for the current branch in a new browser tab'
+task :pr do
+  # NOTE: On Unity (unity-control-centre), you might need `xdg-open` instead.
+  sh %(sensible-browser "https://github.com/exosite/MuranoCLI/compare/develop...#{git_username}:#{git_branchname}")
+end
+
+# ***
+
+namespace :bump do
+  def bump_version(next_ver)
+    git_working_tree_clean!
+
+    # Change the version number.
+    sh %(/bin/sed \
+          -i "s/^  VERSION = '[a-zA-Z0-9.]\\+'$/  VERSION = '#{next_ver}'/" \
+          lib/MrMurano/version.rb)
+    $stdout.puts
+    # Sanity check.
+    msg = 'INVALID: After editing version, your git working tree is still clean?'
+    exit_task(msg) if git_working_tree_clean?
+
+    # Make a commit.
+    sh %(git add lib/MrMurano/version.rb)
+    $stdout.puts
+    sh %(git commit -m "Version: #{current_ver} → #{next_ver}")
+    $stdout.puts
+    # (lb): Meh. We could push to origin. Or not.
+    #  sh %(git push origin HEAD)
+    require 'rainbow'
+    $stdout.puts Rainbow("Bumped! New version: #{next_ver}").magenta.bright
+  end
+
+  def feature_version(next_ver)
+    bump_version(next_ver)
+  end
+
+  def release_version(next_ver)
+    # Remember what branch the user's on.
+    current_branch = git_branchname
+    # Bring your user's develop branch up to date with upstream.
+    ff_develop
+    # Create a release branch
+    sh %(git checkout develop)
+    $stdout.puts
+    sh %(git checkout -b release/#{next_ver})
+    $stdout.puts
+    # Change the version number.
+    bump_version(next_ver)
+    # Restore the working branch.
+    sh %(git checkout #{current_branch})
+    $stdout.puts
+    # Notify the new version number.
+    require 'rainbow'
+    $stdout.puts Rainbow("Bumped! New version: #{next_ver}\n").magenta.bright
+    # Tell the user what to do next.
+    gh_pr_uri = %(https://github.com/exosite/MuranoCLI/compare/develop...#{git_username}:release/#{next_ver})
+    $stdout.puts %(
+1. Visit GitHub and make a PR.
+
+  #{gh_pr_uri}
+
+2. Approve the PR, merge into develop, and delete the release branch.
+
+3. Run `rake ff` to fast-forward your user's copy of develop.
+
+4. Run `rake publish:develop` or `rake publish:master` to create and
+   upload a pre-release or production Gem.
+    ).strip
+    sh %(sensible-browser "#{gh_pr_uri}")
+  end
+
+  # ***
+
+  desc 'Bump the pre-release (beta) version'
+  task :beta do
+    git_working_tree_clean!
+    parts = split_version_string
+    if parts.length == 3
+      msg = 'ERROR: First start a pre-release version with: `bump major|minor|patch`'
+      exit_task(msg)
+    else
+      parts[-1] = (parts[-1].to_i + 1).to_s
+      next_ver = parts.join('.')
+    end
+    feature_version(next_ver)
+  end
+
+  desc 'Increment the patch version, and add pre-release (beta) postfix'
+  task :patch do
+    git_working_tree_clean!
+    parts = split_version_string
+    parts[2] = (parts[2].to_i + 1).to_s
+    next_ver = parts[0..2].join('.') + '.beta.1'
+    feature_version(next_ver)
+  end
+
+  desc 'Increment the minor version, and add pre-release (beta) postfix'
+  task :minor do
+    git_working_tree_clean!
+    parts = split_version_string
+    minor_num = (parts[1].to_i + 1).to_s
+    next_ver = "#{parts[0]}.#{minor_num}.0.beta.1"
+    feature_version(next_ver)
+  end
+
+  desc 'Increment the major version, and add pre-release (beta) postfix'
+  task :major do
+    git_working_tree_clean!
+    parts = split_version_string
+    major_num = (parts[0].to_i + 1).to_s
+    next_ver = "#{major_num}.0.0.beta.1"
+    feature_version(next_ver)
+  end
+
+  desc 'Drop the beta to make an official release'
+  task :release do
+    git_working_tree_clean!
+    parts = split_version_string(must_beta: true)
+    next_ver = parts[0..2].join('.')
+    release_version(next_ver)
+  end
+end
+
+# ***
+
+namespace :package do
+  GH_OWNER = 'exosite'
+  GH_REPO = 'MuranoCLI'
+
+  def print_next_steps
+    jenkins_job_uri = %(https://jenkins.exosite.com/job/MuranoCLI/job/Murano_CLI_Gem_Release/)
+    $stdout.puts %(
+1. Wait for the Gem release builder to start (or poke it yourself).
+
+    #{jenkins_job_uri}
+
+  The job should start within 5 minutes, per its Jenkins poll config: `H/5 * * * *`.
+
+2. Run `rake package:publish` to download the Jenkins CI-built Gem from
+   GitHub and upload it to rubygems.org.
+    ).strip
+    sh %(sensible-browser "#{jenkins_job_uri}")
+  end
+
+  def tag_version(tag_ver, branch)
+    sh %(git checkout #{branch})
+    sh %(git tag -a "#{tag_ver}" -m "Version: #{tag_ver}" #{branch})
+    sh %(git push upstream "#{tag_ver}")
+  end
+
+  desc 'Publish a pre-release Gem after tagging the develop branch'
+  task :develop do
+    _parts = split_version_string(must_beta: true)
+    current_branch = git_branchname
+    ff_develop
+    tag_version("v#{current_ver}", 'develop')
+    sh %(git checkout #{current_branch})
+    # Tell the user what to do next.
+    print_next_steps
+  end
+
+  desc 'Publish a release Gem after tagging the master branch'
+  task :master do
+    _parts = split_version_string(must_beta: false)
+    current_branch = git_branchname
+    ff_master
+    tag_version("v#{current_ver}", 'master')
+    sh %(git checkout #{current_branch})
+    # Tell the user what to do next.
+    print_next_steps
+  end
+
+  # ***
+
+  def must_env_github_token!
+    return unless ENV['GITHUB_TOKEN'].to_s.empty?
+    $stdout.puts %(
+Please set the GITHUB_TOKEN environ to your user's token. E.g.,
+
+  export GITHUB_TOKEN=XXX
+
+Here's some light reading if you need help:
+
+  https://gist.github.com/Integralist/9482061
+
+  https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/
+
+  https://gist.github.com/maxim/6e15aa45ba010ab030c4
+
+).lstrip
+    exit 1
+  end
+
+  def api_gh_fetch_releases
+    # If the GitHub project was public, we could just `wget https://....gem`,
+    # but the project is private, so we gotta use the GitHub API to fetch it.
+    _out, _err, _status = Open3.capture3(
+      %(
+        curl --header "Authorization: token #{ENV['GITHUB_TOKEN']}" \
+             --header "Accept: application/json" \
+             --remote-name \
+             --location \
+               https://api.github.com/repos/#{GH_OWNER}/#{GH_REPO}/releases
+      )
+    )
+    sh %(cat releases | head -n 14)
+    $stdout.puts %(...\n\n)
+  end
+
+  def api_gh_fetch_asset_id
+    _out, _err, _status = Open3.capture3(
+      %(
+        curl --header "Authorization: token #{ENV['GITHUB_TOKEN']}" \
+             --header "Accept: application/json" \
+             --remote-name \
+             --location \
+               https://api.github.com/repos/#{GH_OWNER}/#{GH_REPO}/releases/tags/v#{current_ver}
+      )
+    )
+    sh %(cat v#{current_ver} | head -n 14)
+    $stdout.puts %(...\n\n)
+
+    asset_id, _err, _status = Open3.capture3(%(cat v#{current_ver} | jq '.assets[0].id'))
+    $stdout.puts %(asset_id: #{asset_id}\n)
+    asset_id
+  end
+
+  def api_gh_fetch_asset(asset_id)
+    gem_name = "MuranoCLI-#{current_ver}.gem"
+    _out, _err, _status = Open3.capture3(
+      %(
+        wget -q --auth-no-challenge \
+          --header='Accept:application/octet-stream' \
+          -O #{gem_name} \
+  https://#{ENV['GITHUB_TOKEN']}:@api.github.com/repos/#{GH_OWNER}/#{GH_REPO}/releases/assets/#{asset_id}
+      )
+    )
+    gem_name
+  end
+
+  def must_gem_downloaded!(gem_name)
+    unless File.exist?(gem_name)
+      msg = 'ERROR: There was a problem downloading the Gem from GitHub!'
+      exit_task(msg)
+    end
+    sh %(/bin/ls -la #{gem_name})
+  end
+
+  TRUTHY_WORDS = %w[1 on t true y yes +].freeze
+
+  def truthy?(text)
+    TRUTHY_WORDS.include? text.to_s.downcase
+  end
+
+  def prompt_user_smoke_test!(gem_name)
+    sh %(gem install -i #{Gem.dir} #{gem_name})
+    $stdout.puts
+    require 'rainbow'
+    $stdout.puts Rainbow('You should run smoke tests on the gem!').green.bright
+    $stdout.puts
+    $stdout.puts %(Type something affirmative when you're satisfied. )
+    $stdout.print %(Upload to rubygems.org? [y/n] )
+    $stdout.flush
+    answer = $stdin.gets.chomp
+    exit_task('Your loss!') unless truthy?(answer)
+    sh %(gem uninstall MuranoCLI --version #{current_ver})
+  end
+
+  def publish_gem(gem_name)
+    sh %(gem push #{gem_name})
+    # To undo:
+    #   gem yank MuranoCLI -v <MuranoCLI Version>
+  end
+
+  def print_test_steps
+    $stdout.puts %(
+Now, smoke test!
+
+  gem uninstall MuranoCLI
+  murano -v
+
+  gem install MuranoCLI
+  murano -v
+
+  gem install MuranoCLI --pre
+  murano -v
+    ).strip
+  end
+
+  desc 'Copy the Gem from GitHub and publish on Rubygems.org'
+  task :publish do
+    # (lb): I don't recall what we do this dance and don't just have
+    # Jenkins publish the Gem. (I know why we don't build the Gem
+    # locally and push that -- because we want all builds to come
+    # from the same, non-developer machine. Perhaps we don't have
+    # Jenkins push the gem so that we can smoke test it first!)
+    must_env_github_token!
+    Dir.mktmpdir do |tmpdir|
+      Dir.chdir(tmpdir)
+      api_gh_fetch_releases
+      asset_id = api_gh_fetch_asset_id
+      gem_name = api_gh_fetch_asset(asset_id)
+      must_gem_downloaded!(gem_name)
+      prompt_user_smoke_test!(gem_name)
+      publish_gem(gem_name)
+      print_test_steps
+      # NOTE: The temporary directory does not get cleaned up
+      # immediately (it gets removed when the OS decides to).
+      # We could remove it now, but it doesn't hurt to leave
+      # it (and we might need it to troubleshoot!).
+    end
+  end
+end
+
+# *** Push tasks (used by Jenkins CI release job).
 #
-#    desc 'Push to origin and upstream'
-#    task all: %i[origin upstream]
-#end
-
-desc 'Build, install locally, and push gem'
-task :gemit do
-  mrt = Bundler::GemHelper.gemspec.version
-  sh %(git checkout v#{mrt})
-  Rake::Task[:build].invoke
-  Rake::Task[:bob].invoke
-  Rake::Task['push:gem'].invoke
-  sh %(git checkout develop)
-end
-
-###########################################
-# Tasks below are largly used by CI systems
+#     NOTE: It is unlikely that you will run these tasks yourself.
+#       See instead: `rake publish:develop` and `rake publish:master`
+
 namespace :push do
   desc 'Push gem up to RubyGems'
   task :gem do
@@ -194,6 +557,9 @@ namespace :push do
   end
 end
 
+# (lb): You can run this task via `rake ReadMe.txt` (the rocket ship
+# operator indicates that that target depends on a file prerequisite).
+#   (Note that this tasks simply translates the readme for Windows.)
 file 'ReadMe.txt' => ['README.markdown'] do |t|
   File.open(t.prerequisites.first) do |rio|
     File.open(t.name, 'w') do |wio|
@@ -202,6 +568,8 @@ file 'ReadMe.txt' => ['README.markdown'] do |t|
   end
 end
 
+# Windows tasks.
+
 if Gem.win_platform?
   desc 'Build as a single windows exe'
   file 'murano.exe' => Dir['lib/**/*.{rb,erb,yaml}'] do