daq_flow 1.0.4

data/lib/flash_flow/install.rb

@@ -0,0 +1,19 @@
+require 'fileutils'
+
+module FlashFlow
+  class Install
+    def self.install
+      FileUtils.mkdir 'config' unless Dir.exists?('config')
+      dest_file = 'config/flash_flow.yml.erb'
+
+      FileUtils.cp example_file, dest_file
+
+      puts "Flash flow config file is in #{dest_file}"
+    end
+
+    def self.example_file
+      "#{File.dirname(__FILE__)}/../../flash_flow.yml.erb.example"
+    end
+
+  end
+end

data/lib/flash_flow/lock.rb

@@ -0,0 +1,23 @@
+module FlashFlow
+  module Lock
+    class Error < RuntimeError; end
+
+    class Base
+      def initialize(config=nil)
+        lock_class_name = config && config['class'] && config['class']['name']
+        return unless lock_class_name
+
+        lock_class = Object.const_get(lock_class_name)
+        @lock = lock_class.new(config['class'])
+      end
+
+      def with_lock(&block)
+        if @lock
+          @lock.with_lock(&block)
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/flash_flow/merge.rb

@@ -0,0 +1,6 @@
+module FlashFlow
+  module Merge
+  end
+end
+
+require 'flash_flow/merge/acceptance'

data/lib/flash_flow/merge/acceptance.rb

@@ -0,0 +1,154 @@
+require 'flash_flow/merge/base'
+require 'flash_flow/time_helper'
+
+module FlashFlow
+  module Merge
+    class Acceptance < Base
+
+      def initialize(opts={})
+        super(opts)
+
+        @data = Data::Base.new(Config.configuration.branches, Config.configuration.branch_info_file, @git, logger: logger)
+
+        @do_not_merge = opts[:do_not_merge]
+        @force = opts[:force]
+        @rerere_forget = opts[:rerere_forget]
+        @stories = [opts[:stories]].flatten.compact
+      end
+
+      def run
+        # check_version
+        check_git_version
+        check_repo
+        puts "Building #{@local_git.merge_branch}... Log can be found in #{FlashFlow::Config.configuration.log_file}"
+        logger.info "\n\n### Beginning #{@local_git.merge_branch} merge ###\n\n"
+
+        begin
+          open_pull_request
+
+          @lock.with_lock do
+            @git.in_original_merge_branch do
+              @git.initialize_rerere(@local_git.working_dir)
+            end
+
+            @git.reset_temp_merge_branch
+            @git.in_temp_merge_branch do
+              merge_branches(@data.mergeable) do |branch, merger|
+                # Do not merge the master branch or the merge branch
+                next if [@git.merge_branch, @git.master_branch].include?(branch.ref)
+                process_result(branch, merger)
+              end
+              commit_branch_info
+              commit_rerere
+            end
+
+            @git.copy_temp_to_branch(@git.merge_branch, commit_message)
+            @git.delete_temp_merge_branch
+            @git.push(@git.merge_branch)
+          end
+
+          raise OutOfSyncWithRemote.new("#{@git.merge_branch} is out of sync with the remote.") unless @git.last_success?
+          print_errors
+          logger.info "### Finished #{@local_git.merge_branch} merge ###"
+        rescue Lock::Error, OutOfSyncWithRemote => e
+          puts 'Failure!'
+          puts e.message
+        ensure
+          @local_git.run("checkout #{@local_git.working_branch}")
+        end
+      end
+
+      def commit_branch_info
+        @stories.each do |story_id|
+          @data.add_story(@git.working_branch, story_id)
+        end
+        @data.save!
+      end
+
+      def commit_rerere
+        current_branches = @data.to_a.select { |branch| !@git.master_branch_contains?(branch.sha) && (Time.now - branch.updated_at < TimeHelper.two_weeks) }
+        current_rereres = current_branches.map { |branch| branch.resolutions.to_h.values }.flatten
+
+        @git.commit_rerere(current_rereres)
+      end
+
+      def process_result(branch, merger)
+        case merger.result
+          when :deleted
+            @data.mark_deleted(branch)
+            @notifier.deleted_branch(branch) unless is_working_branch(branch)
+
+          when :success
+            branch.sha = merger.sha
+            @data.mark_success(branch)
+            @data.set_resolutions(branch, merger.resolutions)
+
+          when :conflict
+            if is_working_branch(branch)
+              @data.mark_failure(branch, merger.conflict_sha)
+            else
+              @data.mark_failure(branch, nil)
+              @notifier.merge_conflict(branch)
+            end
+        end
+      end
+
+      def is_working_branch(branch)
+        branch.ref == @git.working_branch
+      end
+
+      def open_pull_request
+        return false if [@local_git.master_branch, @local_git.merge_branch].include?(@local_git.working_branch)
+
+        @local_git.push(@local_git.working_branch, @force)
+        raise OutOfSyncWithRemote.new("Your branch is out of sync with the remote. If you want to force push, run 'flash_flow -f'") unless @local_git.last_success?
+
+        if @do_not_merge
+          @data.remove_from_merge(@local_git.working_branch)
+        else
+          @data.add_to_merge(@local_git.working_branch)
+        end
+      end
+
+      def print_errors
+        puts format_errors
+      end
+
+      def format_errors
+        errors = []
+        branch_not_merged = nil
+        @data.failures.each do |branch|
+          if branch.ref == @local_git.working_branch
+            branch_not_merged = "ERROR: Your branch did not merge to #{@local_git.merge_branch}. Run 'flash_flow --resolve', fix the merge conflict(s) and then re-run this script\n"
+          else
+            errors << "WARNING: Unable to merge branch #{@local_git.remote}/#{branch.ref} to #{@local_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
+
+      def commit_message
+        message =<<-EOS
+Flash Flow run from branch: #{@local_git.working_branch}
+
+Merged branches:
+#{@data.successes.empty? ? 'None' : @data.successes.sort_by(&:merge_order).map(&:ref).join("\n")}
+
+Failed branches:
+#{@data.failures.empty? ? 'None' : @data.failures.map(&:ref).join("\n")}
+
+Removed branches:
+#{@data.removals.empty? ? 'None' : @data.removals.map(&:ref).join("\n")}
+        EOS
+        message.gsub(/'/, '')
+      end
+
+    end
+  end
+end

data/lib/flash_flow/merge/base.rb

@@ -0,0 +1,116 @@
+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
+      class NothingToMergeError < 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 check_git_version
+        git_version = @local_git.version
+        return if git_version.nil?
+
+        running_version = git_version.split(".").map(&:to_i)
+        expected_version = FlashFlow::GIT_VERSION.split(".").map(&:to_i)
+
+        if running_version[0] < expected_version[0] ||
+          (running_version[0] == expected_version[0] && running_version[1] < expected_version[1]) # Ignore the point release number
+          puts "Warning: Your version of git (#{git_version}) is behind the version that is tested (#{FlashFlow::GIT_VERSION}). We recommend to upgrade to at least #{expected_version[0]}.#{expected_version[1]}.0"
+        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
+
+          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
+
+      def pending_release
+        @data.pending_release
+      end
+
+      def ready_to_merge_release
+        @data.ready_to_merge_release
+      end
+
+      def release_ahead_of_master?
+        @git.ahead_of_master?("#{@git.remote}/#{@git.release_branch}")
+      end
+
+      def write_data(commit_msg)
+        @git.in_temp_merge_branch do
+          @git.run("reset --hard #{@git.remote}/#{@git.merge_branch}")
+        end
+        @git.in_merge_branch do
+          @git.run("reset --hard #{@git.remote}/#{@git.merge_branch}")
+        end
+
+        @data.save!
+
+        @git.copy_temp_to_branch(@git.merge_branch, commit_msg)
+        @git.delete_temp_merge_branch
+        @git.push(@git.merge_branch, false)
+      end
+
+    end
+  end
+end

data/lib/flash_flow/merge_order.rb

@@ -0,0 +1,27 @@
+module FlashFlow
+  class MergeOrder
+
+    def initialize(git, branches)
+      @git = git
+      @branches = branches
+    end
+
+    def get_order
+      new_branches, old_branches = @branches.partition { |branch| branch.merge_order.nil? }
+      branches = old_branches.sort_by(&:merge_order) + new_branches
+
+      unchanged, changed = branches.partition { |branch| current_sha(branch) == branch.sha }
+      my_branch_index = changed.find_index { |branch| branch.ref == @git.working_branch }
+      my_branch_changed = my_branch_index ? changed.delete_at(my_branch_index) : nil
+
+      [unchanged, changed, my_branch_changed].flatten.compact
+    end
+
+    private
+
+    def current_sha(branch)
+      @git.get_sha("#{@git.remote}/#{branch.ref}")
+    end
+
+  end
+end

data/lib/flash_flow/notifier.rb

@@ -0,0 +1,23 @@
+require 'flash_flow/data'
+
+module FlashFlow
+  module Notifier
+    class Base
+      def initialize(config=nil)
+        notifier_class_name = config && config['class'] && config['class']['name']
+        return unless notifier_class_name
+
+        @notifier_class = Object.const_get(notifier_class_name)
+        @notifier = @notifier_class.new(config['class'])
+      end
+
+      def merge_conflict(branch)
+        @notifier.merge_conflict(branch) if @notifier.respond_to?(:merge_conflict)
+      end
+
+      def deleted_branch(branch)
+        @notifier.deleted_branch(branch) if @notifier.respond_to?(:deleted_branch)
+      end
+    end
+  end
+end

data/lib/flash_flow/options.rb

@@ -0,0 +1,34 @@
+require 'optparse'
+
+module FlashFlow
+  class Options
+    def self.parse
+      options = {}
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: flash_flow [options]'
+        opts.separator ''
+
+        opts.on('--install', 'Copy flash_flow.yml.erb to your repo and exit') { |v| options[:install] = true }
+        opts.on('-v', '--version', 'Print the current version of flash flow and exit') { |v| options[:version] = true }
+        opts.on('-n', '--no-merge', 'Run flash flow, but do not merge this branch') { |v| options[:do_not_merge] = true }
+        opts.on('--rerere-forget', 'Delete the saved patch for this branch and let the merge fail if there is a conflict') { |v| options[:rerere_forget] = true }
+        opts.on('-f', '--force-push', 'Force push your branch') { |v| options[:force] = v }
+        opts.on('-c', '--config-file FILE_PATH', 'The path to your config file. Defaults to config/flash_flow.yml.erb') { |v| options[:config_file] = v }
+        opts.on('--resolve', 'Launch a bash shell to save your conflict resolutions') { |v| options[:resolve] = true }
+        opts.on('--resolve-manual', 'Print instructions to use git to resolve conflicts') { |v| options[:resolve_manual] = true }
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+      end
+
+      opt_parser.parse!
+
+      options[:stories] ||= []
+      options[:config_file] ||= './config/flash_flow.yml.erb'
+
+      options
+    end
+  end
+end

data/lib/flash_flow/resolve.rb

@@ -0,0 +1,143 @@
+require 'logger'
+
+require 'flash_flow/git'
+require 'flash_flow/data'
+
+module FlashFlow
+  class Resolve
+
+    class NothingToResolve < StandardError; end
+
+    def initialize(git_config, branch_info_file, opts={})
+      @logger = opts[:logger]
+      @branch_info_file = branch_info_file
+      @cmd_runner = CmdRunner.new(logger: @logger)
+      @git = ShadowGit.new(git_config, @logger)
+    end
+
+    def manual_instructions
+      check_for_conflict
+      puts manual_not_merged_instructions
+    end
+
+    def start
+      check_for_conflict
+
+      in_working_branch do
+        merge_conflicted
+
+        if unresolved_conflicts.empty?
+          puts "You have already resolved all conflicts."
+        else
+          launch_bash
+
+          rerere
+
+          unless unresolved_conflicts.empty?
+            puts "There are still unresolved conflicts in these files:\n#{unresolved_conflicts.join("\n")}\n\n"
+          end
+        end
+
+        git_reset
+      end
+    end
+
+    def unresolved_conflicts
+      @git.unresolved_conflicts
+    end
+
+    def merge_conflicted
+      @git.run("checkout #{branch.conflict_sha}")
+      @git.run("merge #{@git.remote}/#{working_branch}")
+    end
+
+    def git_reset
+      @git.run("reset --hard HEAD")
+    end
+
+    def rerere
+      @git.run("rerere")
+    end
+
+    def bash_message
+      puts "\nNote: You are in a special flash_flow directory (#{Dir.pwd}). The files still open in your editor will not reflect the merge conflicts, open them from this shell to get the conflicted versions.\n\nPlease fix the following conflicts and then 'exit':\n#{unresolved_conflicts.join("\n")}\n\n"
+    end
+
+    def launch_bash
+      bash_message
+
+      with_init_file do |file|
+        system("bash --init-file #{file} -i")
+      end
+    end
+
+    def with_init_file
+      filename = '.flash_flow_init'
+      File.open(filename, 'w') do |f|
+        f.puts(init_file_contents)
+      end
+
+      yield filename
+
+      File.delete(filename)
+    end
+
+    def manual_not_merged_instructions
+      <<-EOS
+
+Run the following commands to fix the merge conflict and then re-run flash_flow:
+  pushd #{flash_flow_directory}
+  git checkout #{branch.conflict_sha}
+  git merge #{working_branch}
+  # Resolve the conflicts
+  git add <conflicted files>
+  git commit --no-edit
+  popd
+
+      EOS
+    end
+
+    private
+
+    def data
+      @data ||= Data::Base.new({}, @branch_info_file, @git, logger: @logger)
+    end
+
+    def branch
+      @branch ||= data.saved_branches.detect { |branch| branch.ref == working_branch }
+    end
+
+    def working_branch
+      @git.working_branch
+    end
+
+    def in_working_branch
+      @git.in_dir do
+        @git.in_branch(working_branch) do
+          yield
+        end
+      end
+    end
+
+    def flash_flow_directory
+      @git.flash_flow_dir
+    end
+
+    def init_file_contents
+      <<-EOS
+        # Commented this one out because it was causing lots of spurious "saving session..." type messages
+        # [[ -s /etc/profile ]] && source /etc/profile
+        [[ -s ~/.bash_profile ]] && source ~/.bash_profile
+        [[ -s ~/.bash_login ]] && source ~/.bash_login
+        [[ -s ~/.profile ]] && source ~/.profile
+        [[ -s ~/.bashrc ]] && source ~/.bashrc
+
+        PS1='flash_flow resolve: (type "exit" after your conflicts are resolved)$ '
+      EOS
+    end
+
+    def check_for_conflict
+      raise NothingToResolve.new("The current branch (#{working_branch}) does not appear to be in conflict.") unless branch.conflict_sha
+    end
+  end
+end