flash_flow 1.3.2.1 → 1.4.0

data/lib/flash_flow/merge/base.rb

@@ -0,0 +1,81 @@
+require 'logger'
+
+require 'flash_flow/git'
+require 'flash_flow/data'
+require 'flash_flow/lock'
+require 'flash_flow/notifier'
+require 'flash_flow/branch_merger'
+require 'flash_flow/merge_order'
+require 'flash_flow/shadow_repo'
+
+module FlashFlow
+  module Merge
+    class Base
+
+      class VersionError < RuntimeError; end
+      class OutOfSyncWithRemote < RuntimeError; end
+      class UnmergeableBranch < RuntimeError; end
+
+      def initialize(opts={})
+        @local_git = Git.new(Config.configuration.git, logger)
+        @git = ShadowGit.new(Config.configuration.git, logger)
+        @lock = Lock::Base.new(Config.configuration.lock)
+        @notifier = Notifier::Base.new(Config.configuration.notifier)
+      end
+
+      def logger
+        @logger ||= FlashFlow::Config.configuration.logger
+      end
+
+      def check_repo
+        if @local_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 merge_branches(branches)
+        ordered_branches = MergeOrder.new(@git, branches).get_order
+        ordered_branches.each_with_index do |branch, index|
+          branch.merge_order = index + 1
+
+          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
+
+          @git.fetch(branch.remote)
+          merger = git_merge(branch)
+
+          yield(branch, merger)
+        end
+      end
+
+      def git_merge(branch)
+        merger = BranchMerger.new(@git, branch)
+        forget_rerere = is_working_branch(branch) && @rerere_forget
+
+        merger.do_merge(forget_rerere)
+
+        merger
+      end
+
+      def is_working_branch(branch)
+        branch.ref == @git.working_branch
+      end
+
+    end
+  end
+end

data/lib/flash_flow/merge/master.rb

@@ -0,0 +1,126 @@
+require 'flash_flow/merge/base'
+
+module FlashFlow
+  module Merge
+    class Master < Base
+
+      class PendingReleaseError < RuntimeError; end
+      class NothingToMergeError < RuntimeError; end
+      class GitPushFailure < RuntimeError; end
+
+      def initialize(opts={})
+        super(opts)
+
+        @release_branches = parse_branches(opts[:release_branches])
+
+        @data = Data::Base.new({}, Config.configuration.branch_info_file, @git, logger: logger)
+      end
+
+      def run
+        begin
+          check_version
+          check_branches
+          puts "Merging these branches into #{@git.release_branch}:\n  #{@release_branches.map(&:ref).join("\n  ")}"
+          logger.info "\n\n### Beginning #{@local_git.merge_branch} merge ###\n\n"
+
+          mergers, errors = [], []
+
+          @lock.with_lock do
+            release = @data.releases.detect { |r| r['status'] == 'Pending' }
+            if release
+              raise PendingReleaseError.new("There is already a pending release: #{release}")
+            elsif @git.branch_exists?("#{@git.merge_remote}/#{@git.release_branch}") &&
+                !@git.branch_contains?(@git.master_branch, @git.get_sha("#{@git.merge_remote}/#{@git.release_branch}"))
+              raise PendingReleaseError.new("The release branch '#{@git.release_branch}' has commits that are not in master")
+            end
+
+            @git.fetch(@git.merge_remote)
+            @git.in_original_merge_branch do
+              @git.initialize_rerere
+            end
+
+            @git.reset_temp_merge_branch
+            @git.in_temp_merge_branch do
+              merge_branches(@release_branches) do |branch, merger|
+                mergers << [branch, merger]
+              end
+            end
+
+            errors = mergers.select { |m| m.last.result != :success }
+
+            if errors.empty?
+              unless @git.push("#{@git.temp_merge_branch}:#{@git.release_branch}", true)
+                raise GitPushFailure.new("Unable to push to #{@git.release_branch}. See log for details.")
+              end
+
+              release_sha = @git.get_sha(@git.temp_merge_branch)
+
+              @data.releases.unshift({ created_at: Time.now, sha: release_sha, status: 'Pending' })
+
+              @git.in_temp_merge_branch do
+                @git.run("reset --hard #{@git.merge_remote}/#{@git.merge_branch}")
+              end
+              @git.in_merge_branch do
+                @git.run("reset --hard #{@git.merge_remote}/#{@git.merge_branch}")
+              end
+
+              @data.save!
+
+              @git.copy_temp_to_branch(@git.merge_branch, 'Release data updated [ci skip]')
+              @git.delete_temp_merge_branch
+              @git.push(@git.merge_branch, false)
+            end
+          end
+
+          if errors.empty?
+            puts 'Success!'
+          else
+            raise UnmergeableBranch.new("The following branches didn't merge successfully:\n  #{errors.map { |e| e.first.ref }.join("\n  ")}")
+          end
+
+          logger.info "### Finished #{@git.release_branch} merge ###"
+        rescue Lock::Error, OutOfSyncWithRemote, UnmergeableBranch, GitPushFailure, NothingToMergeError, VersionError, PendingReleaseError => e
+          puts 'Failure!'
+          puts e.message
+        ensure
+          @local_git.run("checkout #{@local_git.working_branch}")
+        end
+      end
+
+      def branch_data
+
+      end
+
+      def parse_branches(user_branches)
+        branch_list = user_branches == ['ready'] ? shippable_branch_names : [user_branches].flatten.compact
+
+        branch_list.map { |b| Data::Branch.new('origin', @git.remotes_hash['origin'], b) }
+      end
+
+      def check_branches
+        raise NothingToMergeError.new("Nothing to merge") if @release_branches.empty?
+
+        requested_not_ready_branches = (@release_branches.map(&:ref) - shippable_branch_names)
+        raise RuntimeError.new("The following branches are not ready to ship:\n#{requested_not_ready_branches.join("\n")}") unless requested_not_ready_branches.empty?
+      end
+
+      def shippable_branch_names
+        @shippable_branch_names ||= begin
+          status = Merge::Status.new(Config.configuration.issue_tracker, Config.configuration.branches, Config.configuration.branch_info_file, Config.configuration.git, logger: logger)
+
+          all_branches = status.branches
+          all_branches.values.select { |b| b[:shippable?] }.map { |b| b[:name] }
+        end
+      end
+
+      def commit_message
+        message =<<-EOS
+Flash Flow merged these branches:
+#{@release_branches.map(&:ref).join("\n")}
+        EOS
+        message.gsub(/'/, '')
+      end
+
+    end
+  end
+end

data/lib/flash_flow/{merge_master → merge}/release_graph.rb

@@ -1,7 +1,7 @@
 require 'graphviz'
 
 module FlashFlow
-  module MergeMaster
+  module Merge
     class ReleaseGraph
       attr_accessor :branches, :issue_tracker
 

data/lib/flash_flow/{merge_master → merge}/status.rb

@@ -1,13 +1,13 @@
-require 'flash_flow/merge_master/release_graph'
+require 'flash_flow/merge/release_graph'
 
 module FlashFlow
-  module MergeMaster
+  module Merge
     class Status
       attr_reader :issue_tracker, :collection, :stories, :releases
 
       def initialize(issue_tracker_config, branches_config, branch_info_file, git_config, opts={})
         @issue_tracker = IssueTracker::Base.new(issue_tracker_config)
-        @collection = Data::Base.new(branches_config, branch_info_file, ShadowGit.new(git_config)).merged_branches
+        @collection = Data::Base.new(branches_config, branch_info_file, ShadowGit.new(git_config)).collection
       end
 
       def status

data/lib/flash_flow/merge_order.rb

@@ -20,8 +20,7 @@ module FlashFlow
     private
 
     def current_sha(branch)
-      @git.run("rev-parse #{branch.remote}/#{branch.ref}")
-      @git.last_stdout.strip if @git.last_success?
+      @git.get_sha("#{branch.remote}/#{branch.ref}")
     end
 
   end

data/lib/flash_flow/notifier/hipchat.rb

@@ -14,14 +14,12 @@ module FlashFlow
           user_name = branch.metadata['user_url'].split('/').last
           user_url_link = %{<a href="#{branch.metadata['user_url']}">#{user_name}</a>}
           ref_link = %{<a href="#{branch.metadata['repo_url']}/tree/#{branch.ref}">#{branch.ref}</a>}
-        rescue => e
-          puts "An error occurred in the hipchat notifier: #{e.message}."
-          user_url_link = 'Unknown'
-          ref_link = branch.ref
-        end
 
-        message = %{#{user_url_link}'s branch (#{ref_link}) did not merge successfully}
-        @client[@room].send("FlashFlow", message)
+          message = %{#{user_url_link}'s branch (#{ref_link}) did not merge successfully}
+          @client[@room].send("FlashFlow", message)
+        rescue HipChat::UnknownResponseCode => e
+          puts e.message
+        end
       end
 
       private

data/lib/flash_flow/release.rb

@@ -0,0 +1,20 @@
+require 'flash_flow/release/percy_client'
+
+module FlashFlow
+  module Release
+    class Base
+      def initialize(config=nil)
+        release_class_name = config && config['class'] && config['class']['name']
+        return unless release_class_name
+
+        @release_class = Object.const_get(release_class_name)
+        @release = @release_class.new(config['class'])
+      end
+
+      def find_latest_by_sha(sha)
+        @release.find_latest_by_sha(sha) if @release.respond_to?(:find_latest_by_sha)
+      end
+
+    end
+  end
+end

data/lib/flash_flow/release/percy_client.rb

@@ -0,0 +1,67 @@
+require 'percy'
+
+module FlashFlow
+  module Release
+    class PercyClient
+
+      def initialize(config={})
+        @client = initialize_connection!(config['token'])
+      end
+
+      def find_latest_by_sha(sha)
+        response = get_builds
+        commit = find_commit_by_sha(response, sha)
+        build = find_build_by_commit_id(response, commit['id'])
+
+        { url: build['web-url'], approved: !build['approved-at'].nil? }
+      end
+
+      private
+
+      def initialize_connection!(token)
+        if token.nil?
+          raise RuntimeError.new("Percy token must be set in your flash flow config.")
+        end
+
+        Percy.client.config.access_token = token
+        percy_client
+      end
+
+      def percy_client
+        Percy.client
+      end
+
+      def get_builds
+        @client.get("#{Percy.config.api_url}/repos/#{Percy.config.repo}/builds/")
+      end
+
+      def find_commit_by_sha(response, sha)
+        commits_data(response).detect { |h| h.dig('attributes', 'sha') == sha }
+      end
+
+      def find_build_by_commit_id(response, commit_id)
+        builds = builds_collection(response)
+        return if builds.nil?
+
+        latest_build = builds
+          .select { |b| b.dig('relationships', 'commit', 'data', 'id') == commit_id }
+          .sort_by { |b| DateTime.parse(b.dig('attributes', 'created-at')) }.last
+
+        latest_build['attributes']
+      end
+
+      def builds_collection(response)
+        response['data'].select do |h|
+          h['type'] == 'builds' &&
+            h.dig('attributes', 'web-url') &&
+            h.dig('relationships', 'commit', 'data', 'type') == 'commits'
+        end
+      end
+
+      def commits_data(response)
+        response['included'].select { |data| data['type'] == 'commits' }
+      end
+
+    end
+  end
+end

data/lib/flash_flow/shadow_repo.rb

@@ -13,6 +13,7 @@ module FlashFlow
 
       run("clean -x -f")
       fetch(merge_remote)
+      run("remote prune #{merge_remote}")
       run("reset --hard HEAD")
     end
 

data/lib/flash_flow/version.rb

@@ -1,3 +1,3 @@
 module FlashFlow
-  VERSION = "1.3.2.1"
+  VERSION = "1.4.0"
 end

data/test/lib/merge/test_acceptance.rb

@@ -0,0 +1,191 @@
+require 'minitest_helper'
+require 'minitest/stub_any_instance'
+
+module FlashFlow
+  module Merge
+    class TestAcceptance < Minitest::Test
+
+      def setup
+        reset_config!
+        config!(git:
+                    {
+                        'merge_branch' => 'test_acceptance',
+                        'merge_remote' => 'test_remote',
+                        'master_branch' => 'test_master',
+                        'remotes' => ['fake_origin'],
+                        'use_rerere' => true
+                    },
+                branches: {}
+        )
+
+        @branch = Data::Branch.from_hash({'ref' => 'pushing_branch', 'remote' => 'origin', 'status' => 'fail', 'stories' => []})
+        @deploy = Acceptance.new
+      end
+
+      def test_version_is_nil
+        with_versions('1.1.1', nil) do
+          assert_nil(@deploy.check_version)
+        end
+      end
+
+      def test_check_version_greater
+        with_versions('2.0.0', '1.1.1') do
+          assert_nil(@deploy.check_version)
+        end
+
+        with_versions('1.2.0', '1.1.1') do
+          assert_nil(@deploy.check_version)
+        end
+      end
+
+      def test_check_version_less_raises
+        with_versions('1.1.1', '2.1.0') do
+          assert_raises(RuntimeError) { @deploy.check_version }
+        end
+
+        with_versions('1.2.0', '2.1.0') do
+          assert_raises(RuntimeError) { @deploy.check_version }
+        end
+      end
+
+      def test_check_version_equal
+
+      end
+
+      def test_print_errors_with_no_errors
+        data.expect(:failures, [])
+        assert_equal(@deploy.format_errors, 'Success!')
+      end
+
+      def test_print_errors_when_current_branch_cant_merge
+        data.expect(:failures, [@branch])
+        @branch.fail!('some_random_sha')
+
+        current_branch_error = "ERROR: Your branch did not merge to test_acceptance. Run 'flash_flow --resolve', fix the merge conflict(s) and then re-run this script\n"
+
+        @deploy.instance_variable_get('@local_git'.to_sym).stub(:working_branch, 'pushing_branch') do
+          assert_equal(current_branch_error, @deploy.format_errors)
+        end
+      end
+
+      def test_print_errors_when_another_branch_cant_merge
+        data.expect(:failures, [@branch])
+
+        other_branch_error = "WARNING: Unable to merge branch origin/pushing_branch to test_acceptance due to conflicts."
+
+        assert_equal(@deploy.format_errors, other_branch_error)
+      end
+
+      def test_check_out_to_working_branch
+        @deploy.stub(:check_repo, true) do
+          @deploy.stub(:check_version, true) do
+            Lock::Base.stub_any_instance(:with_lock, -> { raise Lock::Error }) do
+              assert_output(/Failure!/) { @deploy.run }
+            end
+          end
+        end
+      end
+
+      def test_deleted_branch
+        data.expect(:mark_deleted, true, [@branch])
+
+        notifier.expect(:deleted_branch, true, [@branch])
+
+        merger.expect(:result, :deleted)
+
+        @deploy.process_result(@branch, merger)
+
+        notifier.verify
+        data.verify
+        merger.verify
+      end
+
+      def test_merge_conflict
+        data.expect(:mark_failure, true, [@branch, nil])
+
+        notifier.expect(:merge_conflict, true, [@branch])
+
+        merger.expect(:result, :conflict)
+
+        @deploy.process_result(@branch, merger)
+
+        notifier.verify
+        data.verify
+        merger.verify
+      end
+
+      def test_successful_merge
+        data.expect(:mark_success, true, [@branch])
+        data.expect(:set_resolutions, true, [@branch, {'filename' => ["resolution_sha"]}])
+
+        merger.
+            expect(:result, :success).
+            expect(:sha, 'sha').
+            expect(:resolutions, {'filename' => ["resolution_sha"]})
+
+        @deploy.process_result(@branch, merger)
+
+        data.verify
+        merger.verify
+        assert_equal(@branch.sha, 'sha')
+      end
+
+      def test_ignore_pushing_master_or_acceptance
+        ['test_master', 'test_acceptance'].each do |branch|
+          @deploy.instance_variable_get('@local_git'.to_sym).stub(:working_branch, branch) do
+            refute(@deploy.open_pull_request)
+          end
+        end
+      end
+
+      def test_commit_message_ordering
+        data
+            .expect(:successes, ['data_successes'])
+            .expect(:successes, sample_branches)
+            .expect(:failures, [])
+            .expect(:removals, [])
+
+        expected_message = sample_branches.sort_by(&:merge_order).map(&:ref).join("\n")
+        assert_output(/#{expected_message}/) { print @deploy.commit_message }
+        data.verify
+      end
+
+      private
+
+      def with_versions(current, written)
+        original_version = FlashFlow::VERSION
+        FlashFlow.send(:remove_const, :VERSION)
+        FlashFlow.const_set(:VERSION, current)
+        data.expect(:version, written)
+        yield
+        data.verify
+        FlashFlow.send(:remove_const, :VERSION)
+        FlashFlow.const_set(:VERSION, original_version)
+      end
+
+      def merger
+        @merger ||= Minitest::Mock.new
+      end
+
+      def notifier
+        return @notifier if @notifier
+
+        @notifier = Minitest::Mock.new
+        @deploy.instance_variable_set('@notifier'.to_sym, @notifier)
+      end
+
+      def data
+        return @data if @data
+
+        @data = Minitest::Mock.new
+        @deploy.instance_variable_set('@data'.to_sym, @data)
+      end
+
+      def sample_branches
+        @sample_branches ||= [Data::Branch.from_hash({'ref' => 'branch3', 'merge_order' => 2}),
+                              Data::Branch.from_hash({'ref' => 'branch1', 'merge_order' => 3}),
+                              Data::Branch.from_hash({'ref' => 'branch2', 'merge_order' => 1})]
+      end
+    end
+  end
+end