daq_flow 1.0.4

data/lib/flash_flow/data/collection.rb

@@ -0,0 +1,211 @@
+require 'flash_flow/data/branch'
+require 'flash_flow/data/bitbucket'
+require 'flash_flow/data/github'
+
+module FlashFlow
+  module Data
+
+    class Collection
+
+      attr_accessor :branches
+
+      def initialize(config=nil)
+        @branches = {}
+
+        if config && config['class'] && config['class']['name']
+          collection_class = Object.const_get(config['class']['name'])
+          @collection_instance = collection_class.new(config['class'])
+        end
+      end
+
+      def self.fetch(config=nil)
+        collection = new(config)
+        collection.fetch
+        collection
+      end
+
+      def self.from_hash(hash, collection_instance=nil)
+        collection = new
+        collection.branches = branches_from_hash(hash)
+        collection.instance_variable_set(:@collection_instance, collection_instance)
+        collection
+      end
+
+      def self.branches_from_hash(hash)
+        {}.tap do |new_branches|
+          hash.each do |_, val|
+            branch = val.is_a?(Branch) ? val : Branch.from_hash(val)
+            new_branches[branch.ref] = branch
+          end
+        end
+      end
+
+      def self.key(ref)
+        ref
+      end
+
+      def get(ref)
+        @branches[key(ref)]
+      end
+
+      def to_hash
+        {}.tap do |hash|
+          @branches.each do |key, val|
+            hash[key] = val.to_hash
+          end
+        end
+      end
+      alias :to_h :to_hash
+
+      def reverse_merge(old)
+        merged_branches = @branches.dup
+
+        merged_branches.each do |_, info|
+          info.updated_at = Time.now
+          info.created_at ||= Time.now
+        end
+
+        old.branches.each do |full_ref, info|
+          if merged_branches.has_key?(full_ref)
+            branch = merged_branches[full_ref]
+
+            branch.created_at = info.created_at
+            branch.resolutions = info.resolutions.to_h.merge(branch.resolutions.to_h)
+            branch.stories = info.stories.to_a | merged_branches[full_ref].stories.to_a
+            branch.merge_order ||= info.merge_order
+            if branch.fail?
+              branch.conflict_sha ||= info.conflict_sha
+            end
+          else
+            merged_branches[full_ref] = info
+            merged_branches[full_ref].status = nil
+          end
+        end
+
+        self.class.from_hash(merged_branches, @collection_instance)
+      end
+
+      def to_a
+        @branches.values
+      end
+
+      def each
+        to_a.each
+      end
+
+      def current_branches
+        to_a.select { |branch| branch.current_record }
+      end
+
+      def mergeable
+        current_branches.select { |branch| (branch.success? || branch.fail? || branch.unknown?) }
+      end
+
+      def failures
+        current_branches.select { |branch| branch.fail? }
+      end
+
+      def successes
+        current_branches.select { |branch| branch.success? }
+      end
+
+      def removals
+        to_a.select { |branch| branch.removed? }
+      end
+
+      def fetch
+        return unless @collection_instance.respond_to?(:fetch)
+
+        @collection_instance.fetch.each do |b|
+          update_or_add(b)
+        end
+      end
+
+      def mark_all_as_current
+        @branches.each do |_, branch|
+          branch.current_record = true
+        end
+      end
+
+      def add_to_merge(ref)
+        branch = record(ref)
+        branch.current_record = true
+        @collection_instance.add_to_merge(branch) if @collection_instance.respond_to?(:add_to_merge)
+        branch
+      end
+
+      def remove_from_merge(ref)
+        branch = record(ref)
+        branch.current_record = true
+        branch.removed!
+        @collection_instance.remove_from_merge(branch) if @collection_instance.respond_to?(:remove_from_merge)
+        branch
+      end
+
+      def mark_failure(branch, conflict_sha=nil)
+        update_or_add(branch)
+        branch.fail!(conflict_sha)
+        @collection_instance.mark_failure(branch) if @collection_instance.respond_to?(:mark_failure)
+        branch
+      end
+
+      def mark_deleted(branch)
+        update_or_add(branch)
+        branch.deleted!
+        @collection_instance.mark_deleted(branch) if @collection_instance.respond_to?(:mark_deleted)
+        branch
+      end
+
+      def mark_success(branch)
+        update_or_add(branch)
+        branch.success!
+        @collection_instance.mark_success(branch) if @collection_instance.respond_to?(:mark_success)
+        branch
+      end
+
+      def add_story(ref, story_id)
+        branch = get(ref)
+        branch.stories ||= []
+        branch.stories << story_id
+
+        @collection_instance.add_story(branch, story_id) if @collection_instance.respond_to?(:add_story)
+        branch
+      end
+
+      def code_reviewed?(branch)
+        @collection_instance.respond_to?(:code_reviewed?) ? @collection_instance.code_reviewed?(branch) : true
+      end
+
+      def can_ship?(branch)
+        @collection_instance.respond_to?(:can_ship?) ? @collection_instance.can_ship?(branch) : true
+      end
+
+      def branch_link(branch)
+        @collection_instance.branch_link(branch) if @collection_instance.respond_to?(:branch_link)
+      end
+
+      def set_resolutions(branch, resolutions)
+        update_or_add(branch)
+        branch.set_resolutions(resolutions)
+        @collection_instance.set_resolutions(branch) if @collection_instance.respond_to?(:set_resolutions)
+        branch
+      end
+
+      private
+
+      def key(ref)
+        self.class.key(ref)
+      end
+
+      def update_or_add(branch)
+        old_branch = @branches[key(branch.ref)]
+        @branches[key(branch.ref)] = old_branch.nil? ? branch : old_branch.merge(branch)
+      end
+
+      def record(ref)
+        update_or_add(Branch.new(ref))
+      end
+
+    end
+  end
+end

data/lib/flash_flow/data/github.rb

@@ -0,0 +1,140 @@
+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'
+        @code_reviewed_label = config['code_reviewed_label'] || 'code reviewed'
+        @shippable_label = config['shippable_label'] || 'shippable'
+      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(
+              'ref' => pr.head.ref,
+              'status' => status_from_labels(pr),
+              'metadata' => metadata(pr),
+              'sha' => pr.head.sha
+          )
+        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
+
+      def code_reviewed?(branch)
+        has_label?(branch.metadata['pr_number'], @code_reviewed_label)
+      end
+
+      def can_ship?(branch)
+        has_label?(branch.metadata['pr_number'], @shippable_label)
+      end
+
+      def branch_link(branch)
+        branch.metadata['pr_url']
+      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.ref == p.head.ref }
+      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(&:created_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 == label_name }
+      end
+
+      def labels(pull_request_number)
+        @labels ||= {}
+        @labels[pull_request_number] ||= octokit.labels_for_issue(repo, pull_request_number).map(&:name)
+      end
+
+      def metadata(pr)
+        {
+            'pr_number' => pr.number,
+            'pr_url'    => pr.html_url,
+            '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,44 @@
+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_dir do
+          file ||= File.open(@filename, 'w')
+          file.puts JSON.pretty_generate(sort_branches(branches))
+          file.close
+        end
+
+        @git.in_temp_merge_branch do
+          @git.add_and_commit(@filename, 'Branch Info', add: {force: true})
+        end
+      end
+
+      private
+
+      def sort_branches(branches)
+        return branches unless branches.is_a?(Hash)
+        sorted_branches = {}
+        branches.keys.sort.each { |key| sorted_branches[key] = sort_branches(branches[key]) }
+        sorted_branches
+      end
+    end
+  end
+end

data/lib/flash_flow/git.rb

@@ -0,0 +1,267 @@
+require 'flash_flow/cmd_runner'
+require 'shellwords'
+
+module FlashFlow
+  class Git
+    ATTRIBUTES = [:remote, :merge_branch, :master_branch, :release_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)
+
+      config['release_branch'] ||= config['master_branch']
+      config['remote'] ||= config['merge_remote'] # For backwards compatibility
+
+      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 in_dir
+      Dir.chdir(@cmd_runner.dir) do
+        yield
+      end
+    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, opts={})
+      @cmd_runner.run("git #{cmd}", opts)
+    end
+
+    def working_dir
+      @cmd_runner.dir
+    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 merge(branch)
+      run("merge #{branch}")
+    end
+
+    def branch_contains?(branch, ref)
+      run("branch -a --contains #{ref}", log: CmdRunner::LOG_CMD)
+      last_stdout.split("\n").detect { |str| str[2..-1] == branch }
+    end
+
+    def master_branch_contains?(sha)
+      branch_contains?("remotes/#{remote}/#{master_branch}", sha)
+    end
+
+    def in_original_merge_branch
+      in_branch("#{remote}/#{merge_branch}") { yield }
+    end
+
+    def read_file_from_merge_branch(filename)
+      run("show #{remote}/#{merge_branch}:#{filename}", log: CmdRunner::LOG_CMD)
+      last_stdout
+    end
+
+    def initialize_rerere(copy_from_dir=nil)
+      return unless use_rerere
+
+      @cmd_runner.run('mkdir .git/rr-cache')
+      @cmd_runner.run('cp -R rr-cache/* .git/rr-cache/')
+      @cmd_runner.run("cp -R #{File.join(copy_from_dir, '.git/rr-cache/*')} .git/rr-cache/") if copy_from_dir
+    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
+
+      if unresolved_conflicts.empty?
+        merging_files = staged_and_working_dir_files.select { |s| UNMERGED_STATUSES.include?(s[0..1]) }.map { |s| s[3..-1] }
+        conflicts = conflicted_files
+
+        run("add #{merging_files.join(" ")}")
+        run('commit --no-edit')
+
+        resolutions(conflicts)
+      else
+        false
+      end
+    end
+
+    def unresolved_conflicts
+      in_dir do
+        conflicted_files.map do |file|
+          File.open(file) { |f| f.grep(/>>>>/) }.empty? ? nil : file
+        end.compact
+      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*", log: CmdRunner::LOG_CMD)
+      different_files = split_diff_lines(@cmd_runner.last_stdout)
+
+      @cmd_runner.run('ls -la .git/rr-cache/*/postimage*', log: CmdRunner::LOG_CMD)
+      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 staged_and_working_dir_files
+      run("status --porcelain")
+      last_stdout.split("\n").reject { |line| line[0..1] == '??' }
+    end
+
+    def conflicted_files
+      run("diff --name-only --diff-filter=U")
+      last_stdout.split("\n")
+    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 #{remote}")
+        run("branch -D #{temp_merge_branch}")
+        run("checkout -b #{temp_merge_branch}")
+        run("reset --hard #{remote}/#{master_branch}")
+        run("clean -x -f -d")
+      end
+    end
+
+    def push(branch, force=false)
+      run("push #{'-f' if force} #{remote} #{branch}:#{branch}")
+    end
+
+    def copy_temp_to_branch(branch, squash_message = nil)
+      run("checkout #{temp_merge_branch}")
+      run("merge --strategy=ours --no-edit #{branch}")
+      run("checkout #{branch}")
+      run("merge #{temp_merge_branch}")
+
+      squash_commits(branch, squash_message) if squash_message
+    end
+
+    def delete_temp_merge_branch
+      in_branch(master_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
+
+    def in_branch(branch)
+      begin
+        starting_branch = current_branch
+        run("checkout #{branch}")
+
+        yield
+      ensure
+        run("checkout #{starting_branch}")
+      end
+    end
+
+    def temp_merge_branch
+      "flash_flow-#{merge_branch}"
+    end
+
+    def get_sha(branch, opts={})
+      if opts[:short]
+        run("rev-parse --short #{branch}")
+      else
+        run("rev-parse #{branch}")
+      end
+      last_stdout.strip if last_success?
+    end
+
+    def branch_exists?(branch)
+      run("rev-parse --verify #{branch}")
+      last_success?
+    end
+
+    def ahead_of_master?(branch)
+      branch_exists?(branch) && !master_branch_contains?(get_sha(branch))
+    end
+
+    def version
+      run('--version')
+      semver_regex = Regexp.new('.*(\d+\.\d+\.\d+).*')
+      running_version = last_stdout.strip
+      if semver = semver_regex.match(running_version)
+        semver[1]
+      end
+    end
+
+    private
+
+    def squash_commits(branch, commit_message)
+      unless branch_exists?("#{remote}/#{branch}")
+        run("push #{remote} #{master_branch}:#{branch}")
+      end
+
+      # Get all the files that differ between existing acceptance and new acceptance
+      run("diff --name-only #{remote}/#{branch} #{branch}")
+      files = last_stdout.split("\n")
+      run("reset #{remote}/#{branch}")
+
+      run("add -f #{files.map { |f| "\"#{Shellwords.escape(f)}\"" }.join(" ")}")
+
+      run("commit -m '#{commit_message}'")
+    end
+
+  end
+end