daq_flow 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33db5905fd00b05127ee7fb761b6e7c0fe7b89f099f1afe916a5dfe0b6200530
+  data.tar.gz: b13fc8564da32777578df3574300292eae18f921a386041ecd78540272c5d5b0
+SHA512:
+  metadata.gz: b0b1c21344c05c378027335209a898bbf584455184b35c77b037fad4db90ebd3fdd083aa0c6b2ae7cd1a1378de8c8128a5973463cca64aea76a07b7f9b8e3e33
+  data.tar.gz: 153b426a3577f8dc3648135fb1299229e824e86865ff4fc90638129036c7e024410a00857c4ed04a8907628d945c7c45296f0d1606913832bd61b53be84233d7

data/.gitignore

@@ -0,0 +1,11 @@
+*.gem
+coverage
+/.bundle
+.env
+/log/*.log
+/tmp
+/doc
+public/*
+vendor/bundle
+.DS_Store
+.idea/

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    daq_flow (1.0.0)
+      octokit (~> 4.1)
+      tb-bjb (>= 1.6.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    concurrent-ruby (1.1.5)
+    faraday (0.15.4)
+      multipart-post (>= 1.2, < 3)
+    faraday-http-cache (1.3.1)
+      faraday (~> 0.8)
+    faraday_middleware (0.13.1)
+      faraday (>= 0.7.4, < 1.0)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.3.5)
+    minitest-stub_any_instance (1.0.1)
+    multipart-post (2.0.0)
+    octokit (4.14.0)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    public_suffix (3.0.3)
+    rake (10.4.2)
+    sawyer (0.8.1)
+      addressable (>= 2.3.5, < 2.6)
+      faraday (~> 0.8, < 1.0)
+    simple_oauth (0.3.1)
+    tb-bjb (1.6.2)
+      activemodel (>= 4.1.6)
+      activesupport (>= 4.1.6)
+      faraday (~> 0.9)
+      faraday-http-cache (~> 1.2)
+      faraday_middleware (~> 0.10)
+      simple_oauth (~> 0.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  daq_flow!
+  minitest (> 0)
+  minitest-stub_any_instance (> 0)
+  rake (> 0)
+
+BUNDLED WITH
+   1.17.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 FlashFunders
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,165 @@
+# Flash Flow
+
+Flash Flow is a ruby gem that helps your team keep your acceptance environment up to date. Check out
+[this gist](https://gist.github.com/bradleyjucsc/bfbb8742889edf1b423a) for a detailed explanation of
+how it works.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'flash_flow'
+
+And then run:
+
+    $ bundle install
+    $ bundle exec flash_flow --install
+
+Or install it yourself as:
+
+    $ gem install flash_flow
+
+And then run:
+
+    $ flash_flow --install
+
+After "installing" flash_flow, you'll have a file "config/flash_flow.yml.erb". If your remote is origin,
+your master branch is master, and you're fine using "acceptance" as the branch that flash_flow owns, you
+are ready to go for flash_flow basic. If not, edit that file and change branch and remote names accordingly.
+
+## Usage
+flash_flow is a ruby script which, in the simplest case, can just be run by calling `flash_flow`.
+What that will do (once your application is properly configured) is:
+
+1. Push your branch to the `remote`
+2. Reset your `merge_branch` to be the same as your `master_branch`
+3. Get your list of pull requests from github (or use the saved list, more on that later)
+4. Filter out any "removed" branches
+5. Merge the rest into the newly created `merge_branch`
+6. Push the `merge_branch` to the `remote`
+7. The `merge_branch` is now a merge of your master branch plus all of your pull requests.
+
+### Notes
+
+1. Step 1 will not push your branch if you're on either the `merge_branch` or `master_branch`, but it will
+still merge all the other branches and push the result.
+2. flash_flow creates a copy of your local git repo. The copy lives in /your/repo/dir/../.flash_flow/.
+That's where it merges all the code and pushes to the remote from. This "shadow" directory is used so
+that your local git repository is still available for your use while flash flow is running.
+
+
+### Configuring a lock
+We use the "lock" configuration in flash_flow.yml. The lock ensures that no one else is running flash_flow
+while you are so that you don't inadvertently have your newly pushed branch overwritten. The way we lock you
+out is super janky, we open an issue on github when flash_flow starts and close it when flash_flow is done.
+To configure the lock you need to specify the class name, your github token, your github repo, and the issue_id
+that you want to open and close each time. The email alerts you get from github about this issue are annoying
+and should be ignored.
+
+### Configuring branches
+We use github to track our branches that we want to merge, and there are a few things about that worth noting.
+In step 1 after your branch is pushed, a pull request into `master_branch` will be created on github.  If you
+add the "do not merge" label to a pull request, it will be excluded from the `merge_branch`. This is extremely
+useful whenever one of your co-workers breaks the build, you can either run `flash_flow --no-merge` from their
+branch, or go directly to github and add the "do not merge" label and then re-run flash_flow from your branch.
+
+To use github as your source of merge branches you have to configure it with the class name, github token and
+repo, your master branch name and both the unmergeable label and do not merge label, which must exist on github.
+The unmergeable label is added to a pull request that has a conflict that can't be resolved and is therefore
+excluded from the merge branch.
+
+### Configuring an issue tracker
+We use Pivotal Tracker. When we have finished work for a story on a particular branch we run
+`flash_flow --story <story_id>`, which will transition all of those stories to "finished" if they were previously
+"started".
+
+When code deploys to our review environment, our deploy script runs `flash_flow --review-deploy`, which transitions
+stories associated with merged branches from "finished" to "delivered". At the same time, for a branch that has been
+removed ("--no-merge"), if the story is "delivered" it will transition back to "finished". This means that the only
+buttons that have to be manually clicked in tracker are "Start" and "Accept/Reject".
+
+In addition, as part of our production deploy script, we run `flash_flow --prod-deploy`, which takes all the stories
+that are newly in the `master_branch` and adds a comment "Deployed to production on 12/25/2015 at 11:11pm". Tracker
+doesn't support a real state for "In production", so for us this comment serves as that state.
+
+### Runtime options
+
+#### -v, --version
+Print the current version of flash flow and exit.
+
+#### -n, --no-merge
+Runs flash_flow, but excludes the branch that you're on from the merge branch. If the branch you're on has breaking
+tests, you may want to get it out of your `merge_branch`, and this will do that and ensure that the next times
+flash_flow is run by anyone else it will not be included. It will add the "do not merge" label to your github pull
+request if you're using that. Anytime you run flash_flow without this option, the branch you're running from will
+be included in the `merge_branch` even if it has previously been set to "do not merge".
+
+#### --rerere-forget
+If you've resolved a merge conflict the wrong way, run with this option on the problem branch. The remembered
+resolution will be deleted and you'll get to re-resolve your conflict.
+
+#### --story <story_id>
+Associates a story id with this branch. See "configuring an issue tracker" for why this can be useful.
+
+#### --stories <story_id1,storyid2...>
+Same as --story, but a comma-separated list so you can pass more than one story at a time.
+
+#### -f, --force-push
+Forces pushes your branch. All it does is add "-f" to the git push command, so you'd better make sure you know what
+you're doing if you use this. The `merge_branch` always gets force pushed at the end, this option has nothing to do
+with that.
+
+#### --release-notes <hours>
+Lists all the stories that have been deployed to production in the last <hours> hours. Only relevant if you run
+--prod-deploy when you deploy.
+
+#### --config-file FILE_PATH
+This tells flash_flow how to find the configuration file. If you just put the file in config/flash_flow.yml you will
+never need this option.
+
+#### --prod-deploy
+If you have Pivotal Tracker configured it will look at all stories associated with branches, and if that branch is
+deployed to `master_branch` it will add a comment to those stories that says
+"Deployed to production on MM/DD/YY at XX:XX". This is meant to be used right after every deploy to your production
+environment. The acceptance branch will not be re-built in this case.
+
+#### --review-deploy
+If you have Pivotal Tracker configured it will look at all stories associated with branches, and if that branch is
+deployed to `acceptance_branch` it will mark any finished stories as delivered. This is best used right after every
+deploy to your acceptance environment. The acceptance branch will not be re-built in this case.
+
+#### --resolve
+Launch a bash shell to save your conflict resolutions. If your branch didn't merge the last time you ran flash flow
+you'll run this command. This drops you into bash where you can save your resolved conflicts, then those resolutions
+will be remembered the next time you run flash flow.
+
+#### --resolve-manual
+Print instructions that will show you how to resolve your merge conflicts without using flash flow's version of the
+shell. If you don't use bash, or flash flow does odd things to your bash config, this is the way to go.
+
+### A note about merge conflicts
+When we first started using flash_flow, if your branch had a merge conflict you were out of luck. You had to wait for
+the branch that you were conflicting with to be merged to master, merge master into your branch, and then try again to
+get your code into the merge branch.
+
+Then we discovered `git rerere`, which is [the coolest feature of git that almost no one seems to have heard of](https://git-scm.com/blog/2010/03/08/rerere.html). Basically
+what rerere does is remember how you resolved conflicts and auto-apply those patches when it notices the same conflicts.
+
+If your branch has a conflict with the `merge_branch` flash_flow will look for a rerere patch and apply that if it
+exists. If it doesn't, flash_flow will not merge your branch (but will continue merging all the others), and it will
+spit out instructions for how to make your branch merge successfully. Once you follow those instructions (which involve
+resolving the merge conflicts and saving the resolution), the next time you run flash_flow it will use that resolution
+and everything will be sunshine and ponies.
+
+In addition, flash_flow takes all your patches and copies them into the `merge_branch` where they are saved. Every time
+flash_flow is run, those patches are first copied out of the `merge_branch` into your local rerere cache. The result of
+this is that every time flash_flow is run all previous resolutions are available so once you've merged your branch and
+flash_flow'ed it, it will merge successfully for everyone else too. rerere ftwftwftw.
+
+## Contributing
+
+1. Fork it ( https://github.com/flashfunders/flash_flow/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb', 'test/**/test*.rb']
+  t.verbose = true
+end
+
+task :default => [:test]

data/bin/daq_flow

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'flash_flow'
+
+options = FlashFlow::Options.parse
+
+if options[:install]
+  FlashFlow::Install.install
+  exit(0)
+elsif options[:version]
+  puts "Flash flow version #{FlashFlow::VERSION}\n"
+  exit(0)
+end
+
+FlashFlow::Config.configure!(options[:config_file])
+case
+  when options[:resolve]
+    FlashFlow::Resolve.new(FlashFlow::Config.configuration.git, FlashFlow::Config.configuration.branch_info_file, logger: FlashFlow::Config.configuration.logger).start
+  when options[:resolve_manual]
+    FlashFlow::Resolve.new(FlashFlow::Config.configuration.git, FlashFlow::Config.configuration.branch_info_file, logger: FlashFlow::Config.configuration.logger).manual_instructions
+  else
+    FlashFlow::Merge::Acceptance.new(options).run
+end

data/flash_flow.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flash_flow/version'
+Gem::Specification.new do |spec|
+  spec.name          = "daq_flow"
+  spec.version       = FlashFlow::VERSION
+  spec.authors       = ["Brad Bennett"]
+  spec.email         = ["bradleyjaybennett@gmail.com"]
+  spec.summary       = %q{Merge your open prs together}
+  spec.description   = %q{Flash flow is a command line tool for keeping your acceptance environment up to date}
+  spec.homepage      = "https://github.com/bradleyjucsc/flash_flow"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'octokit', "~> 4.1"
+  spec.add_dependency 'tb-bjb', ">= 1.6.2"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "> 0"
+  spec.add_development_dependency "minitest", "> 0"
+  # spec.add_development_dependency "byebug", "> 0"
+  spec.add_development_dependency 'minitest-stub_any_instance', "> 0"
+end

data/flash_flow.yml.erb.example

@@ -0,0 +1,42 @@
+## The basic settings for your app
+
+git:
+  # This is what allows you to resolve merge conflicts using flash_flow, rerere is amazing. There's
+  # more description elsewhere about how this works.
+  use_rerere: true
+
+  # Which remote your branches use
+  remote: origin
+
+  # This branch is owned by flash_flow, and will be overwritten. Don't use a branch to which you make
+  # commits. Treat this as 100% ephemeral, this is the branch that you should deploy automatically to
+  # your review/staging env.
+  merge_branch: acceptance
+
+  # This is your mainline production branch that is the basis for the merge branch
+  master_branch: master
+
+# An arbitrary file that flash_flow will write to in the merge branch and use to store branch information.
+# Make sure it doesn't collide with a file you actually need in your application. You don't need to look at
+# this file in general.
+branch_info_file: 'flash_flow.json'
+
+
+
+### Everything below here is optional and should be deleted or remain commented out if you don't need it
+
+## We use Bitbucket as our source of truth for which branches to merge. All open pull requests that don't
+## have the "do not merge" label on them get merged. If you configure this flash_flow will automatically
+## create a PR for your branch when it runs. If your branch can't merge, it will still be PR'ed, but it
+## will have the "unmergeable" label on it (that label is strictly informational, no functionality is
+## affected at all).
+
+#branches:
+#  class:
+#    name: 'FlashFlow::Data::Bitbucket'
+#    token: <%= ENV['GH_TOKEN'] %>
+#    repo: # Your github repo. For example, the flash_flow repo is 'flashfunders/flash_flow'
+#    master_branch: master
+#    unmergeable_label: unmergeable
+#    do_not_merge_label: 'do not merge'
+#    shippable_label: 'shippable'

data/lib/flash_flow.rb

@@ -0,0 +1,7 @@
+module FlashFlow; end
+
+require 'flash_flow/options'
+require 'flash_flow/install'
+require 'flash_flow/config'
+require 'flash_flow/resolve'
+require 'flash_flow/merge'

data/lib/flash_flow/branch_merger.rb

@@ -0,0 +1,55 @@
+module FlashFlow
+  class BranchMerger
+
+    attr_reader :conflict_sha, :resolutions, :result
+
+    def initialize(git, branch)
+      @git = git
+      @branch = branch
+    end
+
+    def do_merge(rerere_forget)
+      if sha.nil?
+        @result = :deleted
+        return
+      end
+
+      @git.run("merge --no-ff #{@git.remote}/#{@branch.ref}")
+
+      if @git.last_success? || try_rerere(rerere_forget)
+        @result = :success
+      else
+        @conflict_sha = merge_rollback
+        @result = :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 #{@git.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
+