daq_flow 1.0.4

data/lib/flash_flow/cmd_runner.rb

@@ -0,0 +1,54 @@
+require 'logger'
+require 'open3'
+
+module FlashFlow
+  class CmdRunner
+    LOG_NONE = :log_none
+    LOG_CMD = :log_cmd
+
+    attr_reader :dry_run, :last_command, :last_stderr, :last_stdout
+    attr_accessor :dir
+
+    def initialize(opts={})
+      @dir = opts[:dir] || `pwd`.strip
+      @dry_run = opts[:dry_run]
+      @logger = opts[:logger] || Logger.new('/dev/null')
+    end
+
+    def run(cmd, opts={})
+      @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
+        log(cmd, opts[:log])
+      end
+    end
+
+    def last_success?
+      @success
+    end
+
+    private
+
+    def log(cmd, log_what)
+      log_what = nil
+      if log_what == LOG_NONE
+          # Do nothing
+      else
+          @logger.debug("#{dir}$ #{cmd}")
+        unless log_what == LOG_CMD
+          last_stdout.split("\n").each { |line| @logger.debug(line) }
+          last_stderr.split("\n").each { |line| @logger.debug(line) }
+        end
+      end
+    end
+  end
+end

data/lib/flash_flow/config.rb

@@ -0,0 +1,84 @@
+require 'logger'
+require 'singleton'
+require 'yaml'
+require 'erb'
+require 'fileutils'
+
+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, :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, get_logger(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.get_logger(log_file)
+      if log_file.to_s.empty?
+        log_file = '/dev/null'
+      elsif log_file.to_s.upcase == 'STDOUT'
+        log_file = STDOUT
+      else
+        dir = File.dirname(log_file)
+        FileUtils.mkdir_p(dir)
+      end
+      Logger.new(log_file)
+
+    end
+
+    def self.defaults
+      {
+          branch_info_file: 'README.rdoc',
+          log_file: 'log/flash_flow.log',
+          notifier: 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,89 @@
+require 'json'
+require 'flash_flow/time_helper'
+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, :successes, :removals, :set_resolutions,
+                     :to_a, :code_reviewed?, :branch_link
+
+      attr_reader :collection
+
+      def initialize(branch_config, filename, git, opts={})
+        @git = git
+        @store = Store.new(filename, git, opts)
+        @collection = initialize_collection(branch_config)
+      end
+
+      def initialize_collection(branch_config)
+        stored_collection = Collection.from_hash(stored_branches)
+
+        if branch_config && !branch_config.empty?
+          collection = Collection.fetch(branch_config)
+          # Order matters. We are marking the PRs as current, not the branches stored in the json
+          collection.mark_all_as_current
+          collection = collection.reverse_merge(stored_collection)
+
+        else
+          collection = stored_collection
+          collection.mark_all_as_current
+        end
+
+        collection.branches.delete_if { |k, v|  TimeHelper.massage_time(v.updated_at) < Time.now - TimeHelper.two_weeks  }
+
+        collection
+      end
+
+      def version
+        stored_data['version']
+      end
+
+      def save!
+        @store.write(to_hash)
+      end
+
+      def to_hash
+        {
+            'version'  => FlashFlow::VERSION,
+            'branches' => @collection.to_hash,
+            'releases' => releases
+        }
+      end
+
+      def stored_branches
+        @stored_branches ||= stored_data['branches'] || {}
+      end
+
+      def releases
+        @releases ||= stored_data['releases'] || []
+      end
+
+      def merged_branches
+        @collection.reverse_merge(Collection.from_hash({}, stored_branches))
+      end
+
+      def stored_data
+        @stored_data ||= @store.get
+      end
+
+      def saved_branches
+        Collection.from_hash(stored_branches).to_a
+      end
+
+      def pending_release
+        releases.detect { |r| r['status'] == 'Pending' }
+      end
+
+      def ready_to_merge_release
+        releases.detect { |r| r['status'] == 'Ready to merge' }
+      end
+    end
+  end
+end

data/lib/flash_flow/data/bitbucket.rb

@@ -0,0 +1,152 @@
+require 'tinybucket'
+require 'flash_flow/data/branch'
+
+module FlashFlow
+  module Data
+    class Bitbucket
+
+      attr_accessor :repo, :unmergeable_label
+
+      def initialize(config={})
+        initialize_connection!(config['oauth_token'], config['oauth_secret'])
+        @repo_owner = config['repo_owner']
+        @repo = config['repo']
+        @master_branch = config['master_branch'] || 'master'
+        @unmergeable_label = config['unmergeable_label'] || 'Flash Flow -- Unmergeable'
+        @do_not_merge_label = config['do_not_merge_label'] || 'Flash Flow -- Do Not Merge'
+        # @code_reviewed_label = config['code_reviewed_label'] || 'code reviewed'
+        # @shippable_label = config['shippable_label'] || 'shippable'
+      end
+
+      def initialize_connection!(oauth_token, oauth_secret)
+        if oauth_token.nil? || oauth_secret.nil?
+          raise RuntimeError.new("Oauth token and Oauth secret must be set in your flash_flow config file.")
+        end
+        Tinybucket.configure do |config|
+          config.oauth_token = oauth_token
+          config.oauth_secret = oauth_secret
+        end
+      end
+
+      def remove_from_merge(branch)
+        pr = pr_for(branch)
+        if pr && @do_not_merge_label
+          add_labeling(pr, @do_not_merge_label)
+        end
+      end
+
+      def fetch
+        pull_requests.map do |pr|
+          Branch.from_hash(
+              'ref' => pr.source['branch']['name'],
+              'status' => status_from_labeling(pr),
+              'metadata' => metadata(pr),
+              'sha' => pr.source['commit']['hash']
+          )
+        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_labeling(pr, @do_not_merge_label)
+        end
+      end
+
+      def mark_success(branch)
+        remove_labeling(pr_for(branch), @unmergeable_label)
+      end
+
+      def mark_failure(branch)
+        add_labeling(pr_for(branch), @unmergeable_label)
+      end
+
+      def code_reviewed?(branch)
+        is_labeled?(pr_for(branch), @code_reviewed_label)
+      end
+
+      def can_ship?(branch)
+        is_labeled?(pr_for(branch), @shippable_label)
+      end
+
+      def branch_link(branch)
+        branch.metadata['pr_url']
+      end
+
+      private
+
+      def status_from_labeling(pr)
+        case
+        when is_labeled?(pr, @do_not_merge_label)
+            'removed'
+          when is_labeled?(pr, @unmergeable_label)
+            'fail'
+          else
+            nil
+        end
+      end
+
+      def pr_for(branch)
+        pull_requests.detect { |pr| branch.ref == pr.source['branch']['name'] }
+      end
+
+      def create_pr(branch, title, body)
+        pr_resource = Tinybucket::Resource::PullRequests.new(repo_obj, [])
+        pr = pr_resource.create(source: { branch: { name: branch }}, title: title, description: body)
+        pull_requests << pr
+        pr
+      end
+
+      def pull_requests
+        @pull_requests ||= repo_obj.pull_requests.sort_by(&:created_on)
+      end
+
+      def labeling_string(label)
+        " ---  #{label}"
+      end
+
+      def labeling_regex(label)
+        /#{Regexp.escape(labeling_string(label))}$/
+      end
+
+      def remove_labeling(pr, label)
+        if is_labeled?(pr, label)
+          pr.title.gsub!(labeling_regex(label), '')
+          pr.update
+        end
+      end
+
+      def add_labeling(pr, label)
+        unless is_labeled?(pr, label)
+          pr.title += labeling_string(label)
+          pr.update
+        end
+      end
+
+      def is_labeled?(pr, label)
+        pr.title =~ labeling_regex(label)
+      end
+
+      def metadata(pr)
+        {
+            'pr_number' => pr.id,
+            'pr_url'    => pr.links['html']['href'],
+            'user_url'  => pr.author['links']['html']['href'],
+            'repo_url'  => repo_obj.links['html']['href']
+        }
+      end
+
+      def repo_obj
+        @repo_obj ||= begin
+          repo = Tinybucket.new.repo(@repo_owner, @repo)
+          repo.load
+          repo
+        end
+      end
+    end
+  end
+end

data/lib/flash_flow/data/branch.rb

@@ -0,0 +1,124 @@
+require 'json'
+require 'flash_flow/time_helper'
+
+module FlashFlow
+  module Data
+
+    class Branch
+      attr_accessor :ref, :sha, :status, :resolutions, :stories, :conflict_sha, :metadata,
+                    :current_record, :merge_order, :updated_at, :created_at
+
+      def initialize(_ref)
+        @ref = _ref
+        @resolutions = {}
+        @stories = []
+        @metadata = {}
+        @updated_at = Time.now
+        @created_at = Time.now
+      end
+
+      def self.from_hash(hash)
+        branch = new(hash['ref'])
+        branch.sha = hash['sha']
+        branch.status = hash['status']
+        branch.merge_order = hash['merge_order']
+        branch.resolutions = hash['resolutions']
+        branch.stories = hash['stories']
+        branch.metadata = hash['metadata']
+        branch.conflict_sha = hash['conflict_sha'] || hash['metadata'].to_h['conflict_sha']
+        branch.updated_at = TimeHelper.massage_time(hash['updated_at'])
+        branch.created_at = TimeHelper.massage_time(hash['created_at'])
+        branch
+      end
+
+      def ==(other)
+        other.ref == ref
+      end
+
+      def to_hash
+        {
+            'ref' => ref,
+            'sha' => sha,
+            'status' => status,
+            'merge_order' => merge_order,
+            'resolutions' => resolutions,
+            'stories' => stories,
+            'conflict_sha' => conflict_sha,
+            '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.merge_order = other.merge_order
+          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)
+        self.conflict_sha = 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