flash_flow 1.0.0

data/lib/flash_flow/branch_merger.rb

@@ -0,0 +1,52 @@
+module FlashFlow
+  class BranchMerger
+
+    attr_reader :conflict_sha, :resolutions
+
+    def initialize(git, branch)
+      @git = git
+      @branch = branch
+    end
+
+    def do_merge(rerere_forget)
+      return :deleted if sha.nil?
+
+      @git.run("merge --no-ff #{@branch.remote}/#{@branch.ref}")
+
+      if @git.last_success? || try_rerere(rerere_forget)
+        return :success
+      else
+        @conflict_sha = merge_rollback
+        return :conflict
+      end
+    end
+
+    def sha
+      @sha if defined?(@sha)
+      @sha = get_sha
+    end
+
+    private
+
+    def try_rerere(rerere_forget)
+      if rerere_forget
+        @git.run('rerere forget')
+        false
+      else
+        @resolutions = @git.rerere_resolve!
+      end
+    end
+
+    def get_sha
+      @git.run("rev-parse #{@branch.remote}/#{@branch.ref}")
+      @git.last_stdout.strip if @git.last_success?
+    end
+
+    def merge_rollback
+      @git.run("reset --hard HEAD")
+      @git.run("rev-parse HEAD")
+      @git.last_stdout.strip
+    end
+  end
+end
+

data/lib/flash_flow/cmd_runner.rb

@@ -0,0 +1,37 @@
+require 'logger'
+require 'open3'
+
+module FlashFlow
+  class CmdRunner
+    attr_reader :dry_run, :dir, :last_command, :last_stderr, :last_stdout
+
+    def initialize(opts={})
+      @dir = opts[:dir] || '.'
+      @dry_run = opts[:dry_run]
+      @logger = opts[:logger] || Logger.new('/dev/null')
+    end
+
+    def run(cmd)
+      @last_command = cmd
+      if dry_run
+        puts "#{dir}$ #{cmd}"
+        ''
+      else
+        Dir.chdir(dir) do
+          Open3.popen3(cmd) do |_, stdout, stderr, wait_thr|
+            @last_stdout = stdout.read
+            @last_stderr = stderr.read
+            @success = wait_thr.value.success?
+          end
+        end
+        @logger.debug("#{dir}$ #{cmd}")
+        last_stdout.split("\n").each { |line| @logger.debug(line) }
+        last_stderr.split("\n").each { |line| @logger.debug(line) }
+      end
+    end
+
+    def last_success?
+      @success
+    end
+  end
+end

data/lib/flash_flow/config.rb

@@ -0,0 +1,71 @@
+require 'logger'
+require 'singleton'
+require 'yaml'
+require 'erb'
+
+module FlashFlow
+  class Config
+
+    class AlreadyConfigured < StandardError ; end
+    class NotYetConfigured < StandardError ; end
+    class IncompleteConfiguration < StandardError ; end
+
+    include Singleton
+    class << self
+      private :instance
+    end
+
+    ATTRIBUTES = [
+        :git, :branch_info_file, :log_file, :notifier, :issue_tracker, :lock, :branches
+    ]
+
+    attr_reader *ATTRIBUTES
+    attr_reader :logger
+
+    def self.configuration
+      raise NotYetConfigured unless instance.instance_variable_get(:@configured)
+      instance
+    end
+
+    def self.configure!(config_file)
+      raise AlreadyConfigured if instance.instance_variable_get(:@configured)
+
+      template = ERB.new File.read(config_file)
+      yaml = YAML.load template.result(binding)
+      config = defaults.merge(symbolize_keys!(yaml))
+
+      missing_attrs = []
+      ATTRIBUTES.each do |attr_name|
+        missing_attrs << attr_name unless config.has_key?(attr_name)
+        instance.instance_variable_set("@#{attr_name}", config[attr_name])
+      end
+
+      instance.instance_variable_set(:@logger, Logger.new(instance.log_file))
+
+      raise IncompleteConfiguration.new("Missing attributes:\n #{missing_attrs.join("\n ")}") unless missing_attrs.empty?
+
+      instance.instance_variable_set(:@configured, true)
+    end
+
+    def self.defaults
+      {
+          branch_info_file: 'README.rdoc',
+          log_file: 'log/flash_flow.log',
+          notifier: nil,
+          issue_tracker: nil,
+          lock: nil,
+          branches: nil,
+      }
+    end
+
+    def self.symbolize_keys!(hash)
+      hash.keys.each do |k|
+        unless k.is_a?(Symbol)
+          hash[k.to_sym] = hash[k]
+          hash.delete(k)
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/flash_flow/data.rb

@@ -0,0 +1,6 @@
+require 'flash_flow/data/base'
+
+module FlashFlow
+  module Data
+  end
+end

data/lib/flash_flow/data/base.rb

@@ -0,0 +1,58 @@
+require 'json'
+require 'flash_flow/version'
+require 'flash_flow/data/branch'
+require 'flash_flow/data/collection'
+require 'flash_flow/data/store'
+
+module FlashFlow
+  module Data
+    class Base
+      extend Forwardable
+
+      def_delegators :@collection, :add_story, :mergeable, :mark_deleted, :mark_success,
+                     :mark_failure, :remove_from_merge, :add_to_merge, :failures, :set_resolutions
+
+      def initialize(branch_config, filename, git, opts={})
+        @git = git
+        @store = Store.new(filename, git, opts)
+        @collection = initialize_collection(branch_config, git.remotes_hash)
+      end
+
+      def initialize_collection(branch_config, remotes)
+        Collection.fetch(remotes, branch_config) ||
+            Collection.from_hash(remotes, backwards_compatible_store['branches'])
+      end
+
+      def version
+        backwards_compatible_store['version']
+      end
+
+      def save!
+        @store.write(to_hash)
+      end
+
+      def to_hash
+        {
+            'version'  => FlashFlow::VERSION,
+            'branches' => merged_branches.to_hash
+        }
+      end
+
+      def merged_branches
+        @collection.reverse_merge(Collection.from_hash({}, backwards_compatible_store['branches']))
+      end
+
+      def backwards_compatible_store
+        @backwards_compatible_store ||= begin
+          hash = @store.get
+          hash.has_key?('branches') ? hash : { 'branches' => hash }
+        end
+      end
+
+      def saved_branches
+        Collection.from_hash(@git.remotes, backwards_compatible_store['branches']).to_a
+      end
+
+    end
+  end
+end

data/lib/flash_flow/data/branch.rb

@@ -0,0 +1,131 @@
+require 'json'
+
+module FlashFlow
+  module Data
+
+    class Branch
+      attr_accessor :remote, :remote_url, :ref, :sha, :status, :resolutions, :stories, :metadata, :updated_at, :created_at
+
+      def initialize(_remote, _remote_url, _ref)
+        @remote = _remote
+        @remote_url = _remote_url
+        @ref = _ref
+        @resolutions = {}
+        @stories = []
+        @updated_at = Time.now
+        @created_at = Time.now
+      end
+
+      def self.from_hash(hash)
+        branch = new(hash['remote'], hash['remote_url'], hash['ref'])
+        branch.sha = hash['sha']
+        branch.status = hash['status']
+        branch.resolutions = hash['resolutions']
+        branch.stories = hash['stories']
+        branch.metadata = hash['metadata']
+        branch.updated_at = massage_time(hash['updated_at'])
+        branch.created_at = massage_time(hash['created_at'])
+        branch
+      end
+
+      def self.massage_time(time)
+        case time
+          when Time
+            time
+          when NilClass
+            Time.now
+          else
+            Time.parse(time)
+        end
+      end
+
+      def ==(other)
+        other.remote_url == remote_url && other.remote == remote && other.ref == ref
+      end
+
+      def to_hash
+        {
+            'remote' => remote,
+            'remote_url' => remote_url,
+            'ref' => ref,
+            'sha' => sha,
+            'status' => status,
+            'resolutions' => resolutions,
+            'stories' => stories,
+            'metadata' => metadata,
+            'updated_at' => updated_at,
+            'created_at' => created_at,
+        }
+      end
+      alias :to_h :to_hash
+
+      def to_json(_)
+        JSON.pretty_generate(to_hash)
+      end
+
+      def merge(other)
+        unless other.nil?
+          self.sha = other.sha
+          self.status = other.status
+          self.resolutions = other.resolutions
+          self.stories = self.stories.to_a | other.stories.to_a
+          self.updated_at = Time.now
+          self.created_at = [(self.created_at || Time.now), (other.created_at || Time.now)].min
+        end
+
+        self
+      end
+
+      def add_metadata(data)
+        self.metadata ||= {}
+        self.metadata.merge!(data)
+      end
+
+      def set_resolutions(_resolutions)
+        self.resolutions = _resolutions
+      end
+
+      def success!
+        self.status = 'success'
+      end
+
+      def success?
+        self.status == 'success'
+      end
+
+      def fail!(conflict_sha=nil)
+        add_metadata('conflict_sha' => conflict_sha) if conflict_sha
+        self.status = 'fail'
+      end
+
+      def fail?
+        self.status == 'fail'
+      end
+
+      def removed!
+        self.status = 'removed'
+      end
+
+      def removed?
+        self.status == 'removed'
+      end
+
+      def deleted!
+        self.status = 'deleted'
+      end
+
+      def deleted?
+        self.status == 'deleted'
+      end
+
+      def unknown!
+        self.status = nil
+      end
+
+      def unknown?
+        self.status.nil?
+      end
+    end
+
+  end
+end

data/lib/flash_flow/data/collection.rb

@@ -0,0 +1,181 @@
+require 'flash_flow/data/branch'
+require 'flash_flow/data/github'
+
+module FlashFlow
+  module Data
+
+    class Collection
+
+      attr_accessor :branches, :remotes
+
+      def initialize(remotes, config=nil)
+        @remotes = remotes
+        @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(remotes, config=nil)
+        collection = new(remotes, config)
+        collection.fetch
+        collection
+      end
+
+      def self.from_hash(remotes, hash)
+        collection = new(remotes)
+        collection.branches = branches_from_hash(hash.dup)
+        collection
+      end
+
+      def self.branches_from_hash(hash)
+        hash.each do |key, val|
+          hash[key] = val.is_a?(Branch) ? val : Branch.from_hash(val)
+        end
+      end
+
+      def get(remote_url, ref)
+        @branches[key(remote_url, 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 = branch.resolutions.to_h.merge(info.resolutions.to_h)
+            branch.stories = info.stories.to_a | merged_branches[full_ref].stories.to_a
+          else
+            merged_branches[full_ref] = info
+            merged_branches[full_ref].status = nil
+          end
+        end
+
+        self.class.from_hash(remotes, merged_branches)
+      end
+
+      def to_a
+        @branches.values
+      end
+
+      def each
+        to_a.each
+      end
+
+      def mergeable
+        to_a.select { |branch| branch.success? || branch.fail? || branch.unknown? }
+      end
+
+      def failures
+        @branches.select { |_, v| v.fail? }
+      end
+
+      def fetch
+        return unless @collection_instance.respond_to?(:fetch)
+
+        @collection_instance.fetch.each do |b|
+          update_or_add(b)
+        end
+      end
+
+      def add_to_merge(remote, ref)
+        branch = record(remote, nil, ref)
+        @collection_instance.add_to_merge(branch) if @collection_instance.respond_to?(:add_to_merge)
+        branch
+      end
+
+      def remove_from_merge(remote, ref)
+        branch = record(remote, nil, ref)
+        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(remote, ref, story_id)
+        branch = get(url_from_remote(remote), ref)
+        branch.stories ||= []
+        branch.stories << story_id
+
+        @collection_instance.add_story(branch, story_id) if @collection_instance.respond_to?(:add_story)
+        branch
+      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(remote_url, ref)
+        "#{remote_url}/#{ref}"
+      end
+
+      def remote_from_url(url)
+        remotes.detect { |_, url_val| url_val == url }.first
+      end
+
+      def url_from_remote(remote)
+        remotes[remote]
+      end
+
+      def fixup(branch)
+        branch.remote ||= remote_from_url(branch.remote_url)
+        branch.remote_url ||= url_from_remote(branch.remote)
+      end
+
+      def update_or_add(branch)
+        fixup(branch)
+        old_branch = @branches[key(branch.remote_url, branch.ref)]
+        @branches[key(branch.remote_url, branch.ref)] = old_branch.nil? ? branch : old_branch.merge(branch)
+      end
+
+      def record(remote, remote_url, ref)
+        update_or_add(Branch.new(remote, remote_url, ref))
+      end
+
+    end
+  end
+end