releasinator 0.1.0

data/lib/tasks/releasinator.rake

@@ -0,0 +1,529 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rake'
+require 'colorize'
+require 'json'
+require 'tempfile'
+require_relative '../command_processor'
+require_relative '../config_hash'
+require_relative '../copy_file'
+require_relative '../current_release'
+require_relative '../downstream_repo'
+require_relative '../publisher'
+require_relative '../validator'
+
+include Releasinator
+
+DOWNSTREAM_REPOS = "downstream_repos"
+
+def get_base_dir
+  if @releasinator_config.has_key?(:base_docs_dir)
+    @releasinator_config[:base_docs_dir]
+  else
+    '.'
+  end
+end
+
+def use_git_flow()
+  return @releasinator_config[:use_git_flow] if @releasinator_config.has_key? :use_git_flow
+  false
+end
+
+def full_file_sync(options)
+  return options[:full_file_sync] if options.has_key? :full_file_sync
+  false
+end
+
+def release_to_github(options)
+  return options[:release_to_github] if options.has_key? :release_to_github
+  false
+end
+
+def git_tag(new_tag, changelog)
+  confirm_tag_overwrite(new_tag)
+  puts "tagging with changelog: \n\n#{@currentRelease.changelog}\n".yellow
+  changelog_tempfile = Tempfile.new("#{new_tag}.changelog")
+  changelog_tempfile.write(changelog)
+  changelog_tempfile.close
+  # include changelog in annotated tag
+  CommandProcessor.command("git tag -a -f #{new_tag} -F #{changelog_tempfile.path}")
+  changelog_tempfile.unlink
+end
+
+desc "read and validate the config, adding one if not found"
+task :config do
+  @releasinator_config = ConfigHash.new(verbose == true, Rake.application.options.trace == true)
+  @validator = Validator.new(@releasinator_config)
+  @validator.validate_config
+end
+
+namespace :validate do
+  
+  desc "validate that git is the correct version"
+  task :git_version => :config do
+    @validator.validate_git_version
+  end
+
+  desc "validate that git reports no untracked, unstaged, or uncommitted changes"
+  task :git => :config do
+    @validator.validate_clean_git
+  end
+
+  desc "validate current branch matches the latest on the server and follows naming conventions"
+  task :branch => [:config, :changelog] do
+    current_branch = GitUtil.get_current_branch()
+    @validator.validate_matches_branch(current_branch)
+    if use_git_flow()
+      expected_release_branch = "release/#{@currentRelease.release}"
+      abort("git flow expects the current branch to be either 'develop' or 'release/#{@currentRelease.release}'.  Current branch is '#{current_branch}'".red) unless current_branch == expected_release_branch || current_branch == "develop"
+    else
+      abort("non-git flow expects releases to come from the master branch.  Current branch is '#{current_branch}'".red) unless current_branch == "master"
+    end
+  end
+
+  desc "validate the presence README.md, renaming a similar file if found"
+  task :readme => :config do
+    @validator.validate_exist(get_base_dir(), "README.md", DOWNSTREAM_REPOS)
+  end
+
+  desc "validate the presence LICENSE, renaming a similar file if found - also validates that its referenced from README.md"
+  task :license => :config do
+    @validator.validate_exist(get_base_dir(), "LICENSE", DOWNSTREAM_REPOS)
+    @validator.validate_referenced_in_readme(get_base_dir(), "LICENSE")
+  end
+
+  desc "validate the presence CONTRIBUTING.md, renaming a similar file if found - also validates that its referenced from README.md"
+  task :contributing => :config do
+    @validator.validate_exist(get_base_dir(), "CONTRIBUTING.md", DOWNSTREAM_REPOS)
+    @validator.validate_referenced_in_readme(get_base_dir(), "CONTRIBUTING.md")
+  end
+
+  desc "validate the presence .github/ISSUE_TEMPLATE.md"
+  task :issue_template => :config do
+    @validator.validate_exist(get_base_dir(), ".github/ISSUE_TEMPLATE.md", DOWNSTREAM_REPOS)
+  end
+
+  desc "validate the presence, formatting, and semver sequence of CHANGELOG.md"
+  task :changelog => :config do
+    @currentRelease = @validator.validate_changelog(get_base_dir(), DOWNSTREAM_REPOS)
+  end
+
+  desc "validate the presence of .gitignore, adding it and any appropriate releasinator lines if necessary"
+  task :gitignore => :config do
+    @validator.validate_gitignore("#{DOWNSTREAM_REPOS}/", @releasinator_config.has_key?(:downstream_repos))
+  end
+
+  desc "validate all submodules are on the latest origin/master versions"
+  task :submodules => :config do
+    @validator.validate_submodules
+  end
+
+  desc "validate the current user can push to local repo"
+  task :github_permissions_local => [:config] do
+    @validator.validate_github_permissions(GitUtil.repo_url)
+  end
+
+  desc "validate the current user can push to downstream repos"
+  task :github_permissions_downstream, [:downstream_repo_index] => [:config] do |t, args|
+    if @releasinator_config.has_key?(:downstream_repos)
+      get_downstream_repos(args[:downstream_repo_index]).each do |downstream_repo, index|
+        @validator.validate_github_permissions(downstream_repo.url)
+      end
+    else
+      Printer.success("Not validating permissions of downstream repos.  None found.")
+    end
+  end
+
+  desc "run any configatron.custom_validation_methods"
+  task :custom => :config do
+    if @releasinator_config.has_key?(:custom_validation_methods)
+      @releasinator_config[:custom_validation_methods].each do |validate_method|
+        validate_method.call
+      end
+      Printer.success("All configatron.custom_validation_methods succeeded.")
+    else
+      Printer.success("No configatron.custom_validation_methods found.")
+    end
+  end
+
+  desc "validate all"
+  task :all => 
+    [ 
+      :git_version,
+      :gitignore,
+      :git,
+      :branch,
+      :submodules,
+      :readme,
+      :changelog,
+      :license,
+      :contributing,
+      :issue_template,
+      :github_permissions_local,
+      :github_permissions_downstream,
+      :custom
+    ] do
+    Printer.success("All validations passed.")
+  end
+end
+
+task :default => :release
+
+desc "release all"
+task :release => [:"validate:all",:"local:build",:"pm:all",:"downstream:all",:"local:push",:"docs:all"] do
+  Printer.success("Done releasing.")
+end
+
+def confirm_tag_overwrite(new_tag)
+  tag_results = CommandProcessor.command('git tag -l')
+  tag_results.split.each do |existing_tag|
+    if existing_tag == new_tag
+      Printer.check_proceed("Tag #{existing_tag} already present. Overwrite tag #{existing_tag}?", "Tag #{existing_tag} not overwritten.")
+    end
+  end
+end
+
+desc "iterate over the prerelease_checklist_items, asking the user if each is done"
+task :prerelease_checklist => :config do
+  @releasinator_config[:prerelease_checklist_items].each do |prerelease_item|
+    Printer.check_proceed("#{prerelease_item}", "Then no release for you!")
+  end
+end
+
+namespace :local do
+  desc "ask user whether to proceed with release"
+  task :confirm do
+    Printer.check_proceed("You're about to release #{@currentRelease.release}!", "Then no release for you!")
+  end
+
+  desc "change branch for git flow, if using git flow"
+  task :prepare => [:config, :"validate:changelog"] do
+    if use_git_flow()
+      CommandProcessor.command("git checkout -b release/#{@currentRelease.release} develop") unless GitUtil.get_current_branch() != "develop"
+    end
+  end
+
+  desc "tag the local repo"
+  task :tag => :config do 
+    git_tag(@currentRelease.release, @currentRelease.changelog)
+  end
+
+  desc "build the local repo"
+  task :build => [:config, :"validate:changelog", :prerelease_checklist, :confirm, :prepare, :tag] do
+    puts "building #{@currentRelease.release}" if @releasinator_config[:verbose]
+    @releasinator_config[:build_method].call
+    if @releasinator_config.has_key? :post_build_methods
+      @releasinator_config[:post_build_methods].each do |post_build_method|
+        post_build_method.call(@currentRelease.release)
+      end
+    end
+  end
+
+  desc "run the git flow branch magic (if configured) and push local to remote"
+  task :push => :config do
+    if use_git_flow()
+      CommandProcessor.command("git checkout master")
+      CommandProcessor.command("git pull")
+      CommandProcessor.command("git merge --no-ff release/#{@currentRelease.release}")
+      GitUtil.delete_branch "release/#{@currentRelease.release}"
+      CommandProcessor.command("git checkout develop")
+      CommandProcessor.command("git merge master")
+      CommandProcessor.command("git push origin develop --tags")
+    end
+    CommandProcessor.command("git push origin master --tags")
+    if @releasinator_config[:release_to_github]
+      Publisher.new(@releasinator_config).publish_draft(GitUtil.repo_url, @currentRelease)
+    end
+  end
+end
+
+namespace :pm do
+  desc "publish and wait for package manager"
+  task :all => [:publish, :wait]
+
+  desc "call configured publish_to_package_manager_method"
+  task :publish => [:config, :"validate:changelog"] do
+    @releasinator_config[:publish_to_package_manager_method].call(@currentRelease.release)
+  end
+
+  desc "call configured wait_for_package_manager_method"
+  task :wait => [:config, :"validate:changelog"] do
+    @releasinator_config[:wait_for_package_manager_method].call(@currentRelease.release)
+  end
+end
+
+def copy_the_file(root_dir, copy_file, version=nil)
+  Dir.mkdir(copy_file.target_dir) unless File.exists?(copy_file.target_dir)
+  # use __VERSION__ to auto-substitute the version in any input param
+  source_file_name = copy_file.source_file.gsub("__VERSION__", "#{version}")
+  target_dir_name = copy_file.target_dir.gsub("__VERSION__", "#{version}")
+  destination_file_name = copy_file.target_name.gsub("__VERSION__", "#{version}")
+  CommandProcessor.command("cp -R #{root_dir}/#{source_file_name} #{target_dir_name}/#{destination_file_name}")
+end
+
+def get_new_branch_name(new_branch_name, version)
+  new_branch_name.gsub("__VERSION__", "#{version}")
+end
+
+def reset_repo(branch_name)
+  # resets the repo to a clean state
+  GitUtil.checkout(branch_name)
+  CommandProcessor.command("git fetch origin --prune --recurse-submodules -j9")
+  CommandProcessor.command("git reset --hard origin/#{branch_name}")
+  CommandProcessor.command("git clean -x -d -f")
+end
+
+def get_downstream_repos(downstream_repo_index)
+  repos_to_iterate_over = {}
+  if downstream_repo_index
+    index = Integer(downstream_repo_index) rescue false
+    if !index
+      Printer.fail("downstream_repo_index:#{downstream_repo_index} not a valid integer")
+      abort()
+    end
+    downstream_repo_max_index = @releasinator_config[:downstream_repos].size - 1
+    if index < 0
+      Printer.fail("Index out of bounds downstream_repo_index: #{index} < 0")
+      abort()
+    end
+    if index > downstream_repo_max_index
+      Printer.fail("Index out of bounds downstream_repo_index: #{index} >= #{downstream_repo_max_index}")
+      abort()
+    end
+    # keep original index for printing
+    repos_to_iterate_over[@releasinator_config[:downstream_repos][index]] = index
+  else
+    @releasinator_config[:downstream_repos].each_with_index do |downstream_repo, index|
+      repos_to_iterate_over[downstream_repo] = index
+    end
+  end
+  repos_to_iterate_over
+end
+
+namespace :downstream do
+  desc "build, package, and push all downstream repos"
+  task :all => [:reset,:prepare,:build,:package,:push] do
+    Printer.success("Done with all downstream tasks.")
+  end
+
+  desc "reset the downstream repos to their starting state"
+  task :reset, [:downstream_repo_index] => [:config, :"validate:changelog"] do |t, args|
+    if @releasinator_config.has_key?(:downstream_repos)      
+      get_downstream_repos(args[:downstream_repo_index]).each do |downstream_repo, index|
+        puts "resetting downstream_repo[#{index}]: #{downstream_repo.url}" if @releasinator_config[:verbose]
+        Dir.mkdir(DOWNSTREAM_REPOS) unless File.exists?(DOWNSTREAM_REPOS)
+        Dir.chdir(DOWNSTREAM_REPOS) do
+          CommandProcessor.command("git clone --origin origin #{downstream_repo.url} #{downstream_repo.name}") unless File.exists?(downstream_repo.name)
+          
+          Dir.chdir(downstream_repo.name) do
+            reset_repo(downstream_repo.branch)
+
+            if downstream_repo.options.has_key? :new_branch_name
+              new_branch_name = get_new_branch_name(downstream_repo.options[:new_branch_name], @currentRelease.release)
+              GitUtil.delete_branch new_branch_name
+            end
+          end
+        end
+      end
+      Printer.success("Done resetting downstream repos.")
+    else
+      Printer.success("Not resetting downstream repos.  None found.")
+    end
+  end
+
+  desc "prepare downstream release, copying files from base_docs_dir and any other configured files"
+  task :prepare, [:downstream_repo_index] => [:config, :"validate:changelog", :reset] do |t, args|
+    if @releasinator_config.has_key?(:downstream_repos)
+      get_downstream_repos(args[:downstream_repo_index]).each do |downstream_repo, index|
+        puts "preparing downstream_repo[#{index}]: #{downstream_repo.url}" if @releasinator_config[:verbose]
+
+        root_dir = Dir.pwd.strip
+        copy_from_dir = root_dir + "/" + get_base_dir()
+
+        Dir.chdir(DOWNSTREAM_REPOS) do
+          Dir.chdir(downstream_repo.name) do
+
+            if downstream_repo.options.has_key? :new_branch_name
+              new_branch_name = get_new_branch_name(downstream_repo.options[:new_branch_name], @currentRelease.release)
+              CommandProcessor.command("git checkout -b #{new_branch_name}")
+            end
+
+            if full_file_sync(downstream_repo.options) 
+              # remove old everything
+              CommandProcessor.command("rm -rf *")
+
+              # update all sdk files
+              CommandProcessor.command("rsync -av --exclude='#{DOWNSTREAM_REPOS}' --exclude='.git/' #{copy_from_dir}/* .")
+              CommandProcessor.command("rsync -av --exclude='#{DOWNSTREAM_REPOS}' --exclude='.git/' #{copy_from_dir}/.[!.]* .")
+            end
+
+            # copy custom files
+            if downstream_repo.options.has_key? :files_to_copy
+              downstream_repo.options[:files_to_copy].each do |copy_file|
+                copy_the_file(root_dir, copy_file, @currentRelease.release)
+              end
+            end
+
+            if downstream_repo.options.has_key? :post_copy_methods
+              downstream_repo.options[:post_copy_methods].each do |method|
+                method.call(@currentRelease.release)
+              end
+            end
+
+            if GitUtil.is_clean_git?
+              Printer.fail("Nothing changed in #{downstream_repo.name}!")
+              abort()
+            end
+            # add everything to git and commit
+            CommandProcessor.command("git add .")
+            CommandProcessor.command("git add -u .")
+            if downstream_repo.options.has_key? :new_branch_name
+              commit_message = "Update #{@releasinator_config[:product_name]} to #{@currentRelease.release}"
+            else
+              commit_message = "Release #{@currentRelease.release}"
+            end
+            CommandProcessor.command("git commit -am \"#{commit_message}\"")
+          end
+        end
+      end
+      Printer.success("Done preparing downstream repos.")
+    else
+      Printer.success("Not preparing downstream repos.  None found.")
+    end
+  end
+
+  desc "call all build_methods for each downstream repo"
+  task :build, [:downstream_repo_index] => :config do |t, args|
+    if @releasinator_config.has_key?(:downstream_repos)
+      get_downstream_repos(args[:downstream_repo_index]).each do |downstream_repo, index|
+        puts "building downstream_repo[#{index}]: #{downstream_repo.url}" if @releasinator_config[:verbose]
+        Dir.chdir(DOWNSTREAM_REPOS) do
+          Dir.chdir(downstream_repo.name) do
+            # build any files to verify release
+            if downstream_repo.options.has_key? :build_methods
+              downstream_repo.options[:build_methods].each do |method|
+                method.call
+              end
+            end
+          end
+        end
+      end
+      Printer.success("Done building downstream repos.")
+    else
+      Printer.success("Not building downstream repos.  None found.")
+    end
+  end
+
+  desc "tag all non-branch downstream repos"
+  task :package, [:downstream_repo_index] => [:config,:"validate:changelog"] do |t, args|
+    if @releasinator_config.has_key?(:downstream_repos)
+      get_downstream_repos(args[:downstream_repo_index]).each do |downstream_repo, index|
+        puts "packaging downstream_repo[#{index}]: #{downstream_repo.url}" if @releasinator_config[:verbose]
+        Dir.chdir(DOWNSTREAM_REPOS) do
+          Dir.chdir(downstream_repo.name) do
+            # don't tag those where new branches are created
+            git_tag(@currentRelease.release, @currentRelease.changelog) unless downstream_repo.options.has_key? :new_branch_name
+          end
+        end
+      end
+      Printer.success("Done packaging downstream repos.")
+    else
+      Printer.success("Not packaging downstream repos.  None found.")
+    end
+  end
+
+  desc "push tags and creates draft release, or pushes branch and creates pull request, depending on the presence of new_branch_name"
+  task :push, [:downstream_repo_index] => [:config,:"validate:changelog"] do |t, args|
+    if @releasinator_config.has_key?(:downstream_repos)
+      get_downstream_repos(args[:downstream_repo_index]).each do |downstream_repo, index|
+        puts "pushing downstream_repo[#{index}]: #{downstream_repo.url}" if @releasinator_config[:verbose]
+        Dir.chdir(DOWNSTREAM_REPOS) do
+          Dir.chdir(downstream_repo.name) do
+            if downstream_repo.options.has_key? :new_branch_name
+              new_branch_name = get_new_branch_name(downstream_repo.options[:new_branch_name], @currentRelease.release)
+              CommandProcessor.command("git push -u origin #{new_branch_name}")
+              Publisher.new(@releasinator_config).publish_pull_request(downstream_repo.url, @currentRelease, @releasinator_config[:product_name], downstream_repo.branch, new_branch_name)
+            else
+              CommandProcessor.command("git push origin master --tags")
+              Publisher.new(@releasinator_config).publish_draft(downstream_repo.url, @currentRelease) unless ! release_to_github(downstream_repo.options)
+            end
+          end
+        end
+      end
+      Printer.success("Done pushing downstream repos.")
+    else
+      Printer.success("Not pushing downstream repos.  None found.")
+    end
+  end
+end
+
+namespace :docs do
+  desc "build, copy, and push docs to gh-pages branch"
+  task :all => [:build, :package, :push]
+
+  desc "build docs"
+  task :build => [:config] do
+    if @releasinator_config.has_key?(:doc_build_method)
+      @releasinator_config[:doc_build_method].call
+      Printer.success("doc_build_method done.")
+    else
+      Printer.success("No doc_build_method found.")
+    end
+  end
+
+  desc "copy and commit docs to gh-pages branch"
+  task :package => [:config,:"validate:changelog"] do
+    if @releasinator_config.has_key?(:doc_files_to_copy)
+      root_dir = Dir.pwd.strip
+
+      doc_target_dir = "."
+      doc_target_dir = @releasinator_config[:doc_target_dir] if @releasinator_config.has_key?(:doc_target_dir)
+
+      Dir.chdir(doc_target_dir) do
+        current_branch = GitUtil.get_current_branch()
+
+        GitUtil.init_gh_pages()
+        reset_repo("gh-pages")
+        @releasinator_config[:doc_files_to_copy].each do |copy_file|
+          copy_the_file(root_dir, copy_file)
+        end
+
+        CommandProcessor.command("git add .")
+        CommandProcessor.command("git commit -m \"Update docs for release #{@currentRelease.release}\"")
+
+        # switch back to previous branch
+        CommandProcessor.command("git checkout #{current_branch}")
+      end
+      Printer.success("Doc files copied.")
+    else
+      Printer.success("No doc_files_to_copy found.")
+    end
+  end
+
+  desc "push gh-pages branch"
+  task :push => [:config] do
+    if @releasinator_config.has_key?(:doc_build_method)
+      doc_target_dir = "."
+      doc_target_dir = @releasinator_config[:doc_target_dir] if @releasinator_config.has_key?(:doc_target_dir)
+
+      Dir.chdir(doc_target_dir) do
+        current_branch = GitUtil.get_current_branch()
+        CommandProcessor.command("git checkout gh-pages")
+        CommandProcessor.command("git push origin gh-pages")
+        # switch back to previous branch 
+        CommandProcessor.command("git checkout #{current_branch}")
+      end
+      Printer.success("Docs pushed.")
+    else
+      Printer.success("No docs pushed.")
+    end
+  end
+end
+
+def replace_string(filepath, string_to_replace, new_string)
+  IO.write(filepath,
+    File.open(filepath) do |file|
+      file.read.gsub(string_to_replace, new_string)
+    end
+  )
+end