flash_flow 1.0.0

data/lib/flash_flow/data/github.rb

@@ -0,0 +1,129 @@
+require 'octokit'
+require 'flash_flow/data/branch'
+
+module FlashFlow
+  module Data
+    class Github
+
+      attr_accessor :repo, :unmergeable_label
+
+      def initialize(config={})
+        initialize_connection!(config['token'])
+        @repo = config['repo']
+        @master_branch = config['master_branch'] || master
+        @unmergeable_label = config['unmergeable_label'] || 'unmergeable'
+        @do_not_merge_label = config['do_not_merge_label'] || 'do not merge'
+      end
+
+      def initialize_connection!(token)
+        if token.nil?
+          raise RuntimeError.new("Github token must be set in your flash_flow config file.")
+        end
+        octokit.configure do |c|
+          c.access_token = token
+        end
+      end
+
+      def remove_from_merge(branch)
+        pr = pr_for(branch)
+        if pr && @do_not_merge_label
+          add_label(pr.number, @do_not_merge_label)
+        end
+      end
+
+      def fetch
+        pull_requests.map do |pr|
+          Branch.from_hash(
+              'remote_url' => pr.head.repo.ssh_url,
+              'ref' => pr.head.ref,
+              'status' => status_from_labels(pr),
+              'metadata' => metadata(pr)
+          )
+        end
+      end
+
+      def add_to_merge(branch)
+        pr = pr_for(branch)
+
+        pr ||= create_pr(branch.ref, branch.ref, branch.ref)
+        branch.add_metadata(metadata(pr))
+
+        if pr && @do_not_merge_label
+          remove_label(pr.number, @do_not_merge_label)
+        end
+      end
+
+      def mark_success(branch)
+        remove_label(branch.metadata['pr_number'], @unmergeable_label)
+      end
+
+      def mark_failure(branch)
+        add_label(branch.metadata['pr_number'], @unmergeable_label)
+      end
+
+      private
+
+      def status_from_labels(pull_request)
+        case
+          when has_label?(pull_request.number, @do_not_merge_label)
+            'removed'
+          when has_label?(pull_request.number, @unmergeable_label)
+            'fail'
+          else
+            nil
+        end
+      end
+
+      def pr_for(branch)
+        pull_requests.detect { |p| branch.remote_url == p.head.repo.ssh_url && branch.ref == p.head.ref }
+      end
+
+      def update_pr(pr_number)
+        octokit.update_pull_request(repo, pr_number, {})
+      end
+
+      def create_pr(branch, title, body)
+        pr = octokit.create_pull_request(repo, @master_branch, branch, title, body)
+        pull_requests << pr
+        pr
+      end
+
+      def pull_requests
+        @pull_requests ||= octokit.pull_requests(repo).sort_by(&:updated_at)
+      end
+
+      def remove_label(pull_request_number, label)
+        if has_label?(pull_request_number, label)
+          octokit.remove_label(repo, pull_request_number, label)
+        end
+      end
+
+      def add_label(pull_request_number, label)
+        unless has_label?(pull_request_number, label)
+          octokit.add_labels_to_an_issue(repo, pull_request_number, [label])
+        end
+      end
+
+      def has_label?(pull_request_number, label_name)
+        labels(pull_request_number).detect { |label| label.name == label_name }
+      end
+
+      def labels(pull_request_number)
+        @labels ||= {}
+        @labels[pull_request_number] ||= octokit.labels_for_issue(repo, pull_request_number)
+      end
+
+      def metadata(pr)
+        {
+            'pr_number' => pr.number,
+            'user_url' => pr.user.html_url,
+            'repo_url' => pr.head.repo.html_url
+        }
+      end
+
+      def octokit
+        Octokit
+      end
+    end
+  end
+end

data/lib/flash_flow/data/store.rb

@@ -0,0 +1,33 @@
+require 'json'
+require 'flash_flow/data'
+
+module FlashFlow
+  module Data
+    class Store
+      def initialize(filename, git, opts={})
+        @filename = filename
+        @git = git
+        @logger = opts[:logger] || Logger.new('/dev/null')
+      end
+
+      def get
+        file_contents = @git.read_file_from_merge_branch(@filename)
+        JSON.parse(file_contents)
+
+      rescue JSON::ParserError, Errno::ENOENT
+        @logger.error "Unable to read branch info from file: #{@filename}"
+        {}
+      end
+
+      def write(branches, file=nil)
+        @git.in_temp_merge_branch do
+          file ||= File.open(@filename, 'w')
+          file.puts JSON.pretty_generate(branches)
+          file.close
+
+          @git.add_and_commit(@filename, 'Branch Info', add: { force: true })
+        end
+      end
+    end
+  end
+end

data/lib/flash_flow/deploy.rb

@@ -0,0 +1,184 @@
+require 'logger'
+
+require 'flash_flow/git'
+require 'flash_flow/data'
+require 'flash_flow/lock'
+require 'flash_flow/notifier'
+require 'flash_flow/branch_merger'
+
+module FlashFlow
+  class Deploy
+
+    class OutOfSyncWithRemote < RuntimeError ; end
+
+    def initialize(opts={})
+      @do_not_merge = opts[:do_not_merge]
+      @force = opts[:force]
+      @rerere_forget = opts[:rerere_forget]
+      @stories = [opts[:stories]].flatten.compact
+
+      @git = Git.new(Config.configuration.git, logger)
+      @lock = Lock::Base.new(Config.configuration.lock)
+      @notifier = Notifier::Base.new(Config.configuration.notifier)
+      @data = Data::Base.new(Config.configuration.branches, Config.configuration.branch_info_file, @git, logger: logger)
+    end
+
+    def logger
+      @logger ||= FlashFlow::Config.configuration.logger
+    end
+
+    def run
+      check_version
+      check_repo
+      puts "Building #{@git.merge_branch}... Log can be found in #{FlashFlow::Config.configuration.log_file}"
+      logger.info "\n\n### Beginning #{@git.merge_branch} merge ###\n\n"
+
+      fetch(@git.merge_remote)
+      @git.in_original_merge_branch do
+        @git.initialize_rerere
+      end
+
+      begin
+        @lock.with_lock do
+          open_pull_request
+
+          @git.reset_temp_merge_branch
+          @git.in_temp_merge_branch do
+            merge_branches
+            commit_branch_info
+            commit_rerere
+          end
+
+          @git.copy_temp_to_merge_branch
+          @git.delete_temp_merge_branch
+          @git.push_merge_branch
+        end
+
+        print_errors
+        logger.info "### Finished #{@git.merge_branch} merge ###"
+      rescue Lock::Error, OutOfSyncWithRemote => e
+        puts 'Failure!'
+        puts e.message
+      ensure
+        @git.run("checkout #{@git.working_branch}")
+      end
+    end
+
+    def check_repo
+      if @git.staged_and_working_dir_files.any?
+        raise RuntimeError.new('You have changes in your working directory. Please stash and try again')
+      end
+    end
+
+    def check_version
+      data_version = @data.version
+      return if data_version.nil?
+
+      written_version = data_version.split(".").map(&:to_i)
+      running_version = FlashFlow::VERSION.split(".").map(&:to_i)
+
+      unless written_version[0] < running_version[0] ||
+          (written_version[0] == running_version[0] && written_version[1] <= running_version[1]) # Ignore the point release number
+        raise RuntimeError.new("Your version of flash flow (#{FlashFlow::VERSION}) is behind the version that was last used (#{data_version}) by a member of your team. Please upgrade to at least #{written_version[0]}.#{written_version[1]}.0 and try again.")
+      end
+    end
+
+    def commit_branch_info
+      @stories.each do |story_id|
+        @data.add_story(@git.merge_remote, @git.working_branch, story_id)
+      end
+      @data.save!
+    end
+
+    def commit_rerere
+      current_branches = @data.merged_branches.to_a.select { |branch| !@git.master_branch_contains?(branch.sha) && (Time.now - branch.updated_at < two_weeks) }
+      current_rereres = current_branches.map { |branch| branch.resolutions.to_h.values }.flatten
+
+      @git.commit_rerere(current_rereres)
+    end
+
+    def two_weeks
+      60 * 60 * 24 * 14
+    end
+
+    def merge_branches
+      @data.mergeable.each do |branch|
+        remote = @git.fetch_remote_for_url(branch.remote_url)
+        if remote.nil?
+          raise RuntimeError.new("No remote found for #{branch.remote_url}. Please run 'git remote add *your_remote_name* #{branch.remote_url}' and try again.")
+        end
+
+        fetch(branch.remote)
+        git_merge(branch, branch.ref == @git.working_branch)
+      end
+    end
+
+    def git_merge(branch, is_working_branch)
+      merger = BranchMerger.new(@git, branch)
+      forget_rerere = is_working_branch && @rerere_forget
+
+      case merger.do_merge(forget_rerere)
+        when :deleted
+          @data.mark_deleted(branch)
+          @notifier.deleted_branch(branch) unless is_working_branch
+
+        when :success
+          branch.sha = merger.sha
+          @data.mark_success(branch)
+          @data.set_resolutions(branch, merger.resolutions)
+
+        when :conflict
+          @data.mark_failure(branch, merger.conflict_sha)
+          @notifier.merge_conflict(branch) unless is_working_branch
+      end
+    end
+
+    def open_pull_request
+      return false if [@git.master_branch, @git.merge_branch].include?(@git.working_branch)
+
+      # TODO - This should use the actual remote for the branch we're on
+      @git.push(@git.working_branch, force: @force)
+      raise OutOfSyncWithRemote.new("Your branch is out of sync with the remote. If you want to force push, run 'flash_flow -f'") unless @git.last_success?
+
+      # TODO - This should use the actual remote for the branch we're on
+      if @do_not_merge
+        @data.remove_from_merge(@git.merge_remote, @git.working_branch)
+      else
+        @data.add_to_merge(@git.merge_remote, @git.working_branch)
+      end
+    end
+
+    def print_errors
+      puts format_errors
+    end
+
+    def format_errors
+      errors = []
+      branch_not_merged = nil
+      @data.failures.each do |full_ref, failure|
+        if failure.ref == @git.working_branch
+          branch_not_merged = "\nERROR: Your branch did not merge to #{@git.merge_branch}. Run the following commands to fix the merge conflict and then re-run this script:\n\n  git checkout #{failure.metadata['conflict_sha']}\n  git merge #{@git.working_branch}\n  # Resolve the conflicts\n  git add <conflicted files>\n  git commit --no-edit"
+        else
+          errors << "WARNING: Unable to merge branch #{failure.remote}/#{failure.ref} to #{@git.merge_branch} due to conflicts."
+        end
+      end
+      errors << branch_not_merged if branch_not_merged
+
+      if errors.empty?
+        "Success!"
+      else
+        errors.join("\n")
+      end
+    end
+
+    private
+
+    def fetch(remote)
+      @fetched_remotes ||= {}
+      unless @fetched_remotes[remote]
+        @git.fetch(remote)
+        @fetched_remotes[remote] = true
+      end
+    end
+  end
+end

data/lib/flash_flow/git.rb

@@ -0,0 +1,248 @@
+require 'flash_flow/cmd_runner'
+
+module FlashFlow
+  class Git
+    ATTRIBUTES = [:merge_remote, :merge_branch, :master_branch, :use_rerere]
+    attr_reader *ATTRIBUTES
+    attr_reader :working_branch
+
+    UNMERGED_STATUSES = %w{DD AU UD UA DU AA UU}
+
+    def initialize(config, logger=nil)
+      @cmd_runner = CmdRunner.new(logger: logger)
+
+      ATTRIBUTES.each do |attr|
+        unless config.has_key?(attr.to_s)
+          raise RuntimeError.new("git configuration missing. Required config parameters: #{ATTRIBUTES}")
+        end
+
+        instance_variable_set("@#{attr}", config[attr.to_s])
+      end
+
+      @working_branch = current_branch
+    end
+
+    def last_stdout
+      @cmd_runner.last_stdout
+    end
+
+    def last_command
+      @cmd_runner.last_command
+    end
+
+    def last_success?
+      @cmd_runner.last_success?
+    end
+
+    def run(cmd)
+      @cmd_runner.run("git #{cmd}")
+    end
+
+    def add_and_commit(files, message, opts={})
+      files = [files].flatten
+      run("add #{'-f ' if opts[:add] && opts[:add][:force]}#{files.join(' ')}")
+      run("commit -m '#{message}'")
+    end
+
+    def push(branch, options)
+      run("push #{'-f' if options[:force]} #{merge_remote} #{branch}")
+    end
+
+    def merge(branch)
+      run("merge #{branch}")
+    end
+
+    def fetch(remote)
+      run("fetch #{remote}")
+    end
+
+    def master_branch_contains?(ref)
+      run("branch --contains #{ref}")
+      last_stdout.split("\n").detect { |str| str[2..-1] == master_branch }
+    end
+
+    def in_original_merge_branch
+      begin
+        starting_branch = current_branch
+        run("checkout #{merge_remote}/#{merge_branch}")
+
+        yield
+      ensure
+        run("checkout #{starting_branch}")
+      end
+    end
+
+    def read_file_from_merge_branch(filename)
+      run("show #{merge_remote}/#{merge_branch}:#{filename}")
+      last_stdout
+    end
+
+    def initialize_rerere
+      return unless use_rerere
+
+      @cmd_runner.run('mkdir .git/rr-cache')
+      @cmd_runner.run('cp -R rr-cache/* .git/rr-cache/')
+    end
+
+    def commit_rerere(current_rereres)
+      return unless use_rerere
+      @cmd_runner.run('mkdir rr-cache')
+      @cmd_runner.run('rm -rf rr-cache/*')
+      current_rereres.each do |rerere|
+        @cmd_runner.run("cp -R .git/rr-cache/#{rerere} rr-cache/")
+      end
+
+      run('add rr-cache/')
+      run("commit -m 'Update rr-cache'")
+    end
+
+    def rerere_resolve!
+      return false unless use_rerere
+
+      merging_files = staged_and_working_dir_files.select { |s| UNMERGED_STATUSES.include?(s[0..1]) }.map { |s| s[3..-1] }
+
+      conflicts = merging_files.map do |file|
+        File.open(file) { |f| f.grep(/>>>>/) }
+      end
+
+      if conflicts.all? { |c| c.empty? }
+        run("add #{merging_files.join(" ")}")
+        run('commit --no-edit')
+
+        resolutions(merging_files)
+      else
+        false
+      end
+    end
+
+    def resolutions(files)
+      {}.tap do |hash|
+        files.map do |file|
+          hash[file] = resolution_candidates(file)
+        end.flatten
+      end
+    end
+
+    # git rerere doesn't give you a deterministic way to determine which resolution was used
+    def resolution_candidates(file)
+      @cmd_runner.run("diff -q --from-file #{file} .git/rr-cache/*/postimage")
+      different_files = split_diff_lines(@cmd_runner.last_stdout)
+
+      @cmd_runner.run('ls -la .git/rr-cache/*/postimage')
+      all_files = split_diff_lines(@cmd_runner.last_stdout)
+
+      all_files - different_files
+    end
+
+    def split_diff_lines(arr)
+      arr.split("\n").map { |s| s.split(".git/rr-cache/").last.split("/postimage").first }
+    end
+
+    def remotes
+      run('remote -v')
+      last_stdout.split("\n")
+    end
+
+    def remotes_hash
+      return @remotes_hash if @remotes_hash
+
+      @remotes_hash = {}
+      remotes.each do |r|
+        name = r.split[0]
+        url = r.split[1]
+        @remotes_hash[name] ||= url
+      end
+      @remotes_hash
+    end
+
+    def fetch_remote_for_url(url)
+      fetch_remotes = remotes.grep(Regexp.new(url)).grep(/ \(fetch\)/)
+      fetch_remotes.map { |remote| remote.to_s.split("\t").first }.first
+    end
+
+    def staged_and_working_dir_files
+      run("status --porcelain")
+      last_stdout.split("\n").reject { |line| line[0..1] == '??' }
+    end
+
+    def current_branch
+      run("rev-parse --abbrev-ref HEAD")
+      last_stdout.strip
+    end
+
+    def most_recent_commit
+      run("show -s --format=%cd head")
+    end
+
+    def reset_temp_merge_branch
+      in_branch(master_branch) do
+        run("fetch #{merge_remote}")
+        run("branch -D #{temp_merge_branch}")
+        run("checkout -b #{temp_merge_branch}")
+        run("reset --hard #{merge_remote}/#{master_branch}")
+      end
+    end
+
+    def push_merge_branch
+      run("push -f #{merge_remote} #{merge_branch}")
+    end
+
+    def copy_temp_to_merge_branch
+      run("checkout #{temp_merge_branch}")
+      run("merge --strategy=ours --no-edit #{merge_branch}")
+      run("checkout #{merge_branch}")
+      run("merge #{temp_merge_branch}")
+
+      squash_commits
+    end
+
+    def commit_message(log)
+      "Flash Flow run from branch: #{working_branch}\n\n#{log}".gsub(/'/, '')
+    end
+
+    def delete_temp_merge_branch
+      in_merge_branch do
+        run("branch -d #{temp_merge_branch}")
+      end
+    end
+
+    def in_temp_merge_branch(&block)
+      in_branch(temp_merge_branch, &block)
+    end
+
+    def in_merge_branch(&block)
+      in_branch(merge_branch, &block)
+    end
+
+    private
+
+    def squash_commits
+      # There are three commits created by flash flow that we don't need in the message
+      run("log #{merge_remote}/#{merge_branch}..#{merge_branch}~3")
+      log = last_stdout
+
+      # Get all the files that differ between existing acceptance and new acceptance
+      run("diff --name-only #{merge_remote}/#{merge_branch} #{merge_branch}")
+      files = last_stdout.split("\n")
+      run("reset #{merge_remote}/#{merge_branch}")
+      run("add #{files.map { |f| "'#{f}'" }.join(" ")}")
+
+      run("commit -m '#{commit_message(log)}'")
+    end
+
+    def temp_merge_branch
+      "flash_flow/#{merge_branch}"
+    end
+
+    def in_branch(branch)
+      begin
+        starting_branch = current_branch
+        run("checkout #{branch}")
+
+        yield
+      ensure
+        run("checkout #{starting_branch}")
+      end
+    end
+  end
+end