zenflow 0.8.0

data/lib/zenflow/commands/deploy.rb

@@ -0,0 +1,33 @@
+module Zenflow
+
+  def self.Deploy(to, opts={})
+    Branch.push(to)
+    if opts[:migrations]
+      Log("Deploying with migrations to #{to}")
+      Shell["cap #{to} deploy:migrations"]
+    else
+      Log("Deploying to #{to}")
+      Shell["cap #{to} deploy"]
+    end
+  end
+
+  class Deploy < Thor
+    class_option :migrations, type: :boolean, desc: "Run migrations during deployment", aliases: :m
+
+    desc "qa", "Deploy to qa."
+    def qa
+      Zenflow::Deploy("qa", options)
+    end
+
+    desc "staging", "Deploy to staging."
+    def staging
+      Zenflow::Deploy("staging", options)
+    end
+
+    desc "production", "Deploy to production."
+    def production
+      Zenflow::Deploy("production", options)
+    end
+  end
+
+end

data/lib/zenflow/commands/feature.rb

@@ -0,0 +1,10 @@
+module Zenflow
+  class Feature < BranchCommand
+
+    flow "feature"
+
+    branch source: Zenflow::Config[:development_branch]
+    branch deploy: Zenflow::Config[:qa_branch]
+
+  end
+end

data/lib/zenflow/commands/hotfix.rb

@@ -0,0 +1,15 @@
+module Zenflow
+  class Hotfix < BranchCommand
+
+    flow "hotfix"
+
+    branch source: Zenflow::Config[:release_branch]
+    branch deploy: Zenflow::Config[:staging_branch]
+    branch deploy: Zenflow::Config[:qa_branch]
+
+    changelog :rotate
+    version :patch
+    tag true
+
+  end
+end

data/lib/zenflow/commands/release.rb

@@ -0,0 +1,16 @@
+module Zenflow
+  class Release < BranchCommand
+
+    flow "release"
+
+    branch source: Zenflow::Config[:development_branch]
+    branch deploy: Zenflow::Config[:staging_branch]
+    branch deploy: Zenflow::Config[:qa_branch]
+    branch destination: Zenflow::Config[:release_branch]
+
+    changelog :rotate
+    version :minor
+    tag true
+
+  end
+end

data/lib/zenflow/commands/reviews.rb

@@ -0,0 +1,12 @@
+module Zenflow
+  class Reviews < Thor
+
+    desc "list", "Show all open reviews."
+    def list
+      Zenflow::Log(Terminal::Table.new(rows: Zenflow::PullRequest.list.map {|request|
+        [request["number"], request["head"]["ref"]]
+      }).to_s, indent: false, arrows: false, color: false)
+    end
+
+  end
+end

data/lib/zenflow/helpers/ask.rb

@@ -0,0 +1,66 @@
+module Zenflow
+
+  def self.Ask(question, options={})
+    response = Zenflow::Query.ask_question(question, options)
+    Zenflow::Query.handle_response(response, options)
+  rescue StandardError => e
+    puts e.message
+    options[:response] = nil
+    retry
+  rescue Interrupt => e
+    puts
+    puts "-----> Exiting...".cyan
+    LogToFile("-----> Received interrupt. Exiting...")
+    exit(1)
+  end
+
+  class Query
+    def self.ask_question(question, options={})
+      if options[:response].to_s.strip != ""
+        response = options[:response]
+      else
+        response = Zenflow::Query.prompt_for_answer(question, options)
+      end
+      Zenflow::LogToFile("Response: #{response}")
+      response
+    end
+
+    def self.prompt_for_answer(question, options={})
+      prompt = ">> #{question} "
+      prompt << "[#{options[:options].join('/')}] " if options[:options]
+      prompt << "[#{options[:default]}] " if options[:default] && !options[:options]
+      Zenflow::LogToFile("Asked: #{prompt}")
+      print prompt
+      $stdin.gets.chomp
+    end
+
+    def self.handle_response(response, options={})
+      if !Zenflow::Query.valid_response?(response, options)
+        raise Zenflow::Query.build_error_message(response, options)
+      end
+
+      return options[:default].downcase if response == ""
+      return response.downcase if response == "Y" || response == "N"
+      response
+    end
+
+    def self.valid_response?(response, options={})
+      return false if options[:options] && !options[:options].include?(response)
+      return false if options[:validate] && options[:validate].is_a?(Regexp) && !response[options[:validate]]
+      return false if options[:required] && response == ""
+      true
+    end
+
+    def self.build_error_message(response, options={})
+      if options[:required]
+        message = "You must respond to this prompt."
+      elsif options[:error_message]
+        message = options[:error_message]
+      else
+        message = %{"#{response}" is not a valid response.}
+      end
+      "-----> #{message} Try again.".red
+    end
+  end
+
+end

data/lib/zenflow/helpers/branch.rb

@@ -0,0 +1,80 @@
+module Zenflow
+  module Branch
+    class << self
+
+      def list(prefix)
+        branches = Zenflow::Shell.run "git branch | grep #{prefix}", :silent => true
+        return ['!! NONE !!'] if branches.empty?
+        branches.split("\n").map{|branch| branch.sub(/.*#{prefix}\/?/, "") }
+      end
+
+      def current(prefix)
+        branch = Zenflow::Shell.run("git branch | grep '* #{prefix}'", :silent => true)
+        branch.chomp.sub(/\* #{prefix}\/?/, "") unless branch.empty?
+      end
+
+      def update(name)
+        Zenflow::Log("Updating the #{name} branch")
+        Zenflow::Shell["git checkout #{name} && git pull"]
+      end
+
+      def create(name, base)
+        Zenflow::Log("Creating the #{name} branch based on #{base}")
+        Zenflow::Shell["git checkout -b #{name} #{base}"]
+      end
+
+      def push(name)
+        Zenflow::Log("Pushing the #{name} branch to #{Zenflow::Config[:remote] || 'origin'}")
+        Zenflow::Shell["git push #{Zenflow::Config[:remote] || 'origin'} #{name}"]
+        if Zenflow::Config[:backup_remote]
+          Zenflow::Log("Pushing the #{name} branch to #{Zenflow::Config[:backup_remote]}")
+          Zenflow::Shell["git push #{Zenflow::Config[:backup_remote]} #{name}"]
+        end
+      end
+
+      def push_tags
+        Zenflow::Log("Pushing tags to #{Zenflow::Config[:remote] || 'origin'}")
+        Zenflow::Shell["git push #{Zenflow::Config[:remote] || 'origin'} --tags"]
+        if Zenflow::Config[:backup_remote]
+          Zenflow::Log("Pushing tags to #{Zenflow::Config[:backup_remote]}")
+          Zenflow::Shell["git push #{Zenflow::Config[:backup_remote]} --tags"]
+        end
+      end
+
+      def track(name)
+        Zenflow::Log("Tracking the #{name} branch against #{Zenflow::Config[:remote] || 'origin'}/#{name}")
+        Zenflow::Shell["git branch --set-upstream-to=#{Zenflow::Config[:remote] || 'origin'}/#{name} #{name}"]
+      end
+
+      def checkout(name)
+        Zenflow::Log("Switching to the #{name} branch")
+        Zenflow::Shell["git checkout #{name}"]
+      end
+
+      def merge(name)
+        Zenflow::Log("Merging in the #{name} branch")
+        Zenflow::Shell["git merge --no-ff #{name}"]
+      end
+
+      def tag(name=nil, description=nil)
+        Zenflow::Log("Tagging the release")
+        Zenflow::Shell["git tag -a '#{name || Zenflow::Ask('Name of the tag:', :required => true)}' -m '#{Zenflow::Shell.shell_escape_for_single_quoting((description || Zenflow::Ask('Tag message:', :required => true)).to_s)}'"]
+      end
+
+      def delete_remote(name)
+        Zenflow::Log("Removing the remote branch from #{Zenflow::Config[:remote] || 'origin'}")
+        Zenflow::Shell["git branch -r | grep #{Zenflow::Config[:remote] || 'origin'}/#{name} && git push #{Zenflow::Config[:remote] || 'origin'} :#{name} || echo ''"]
+        if Zenflow::Config[:backup_remote]
+          Zenflow::Log("Removing the remote branch from #{Zenflow::Config[:backup_remote]}")
+          Zenflow::Shell["git branch -r | grep #{Zenflow::Config[:backup_remote]}/#{name} && git push #{Zenflow::Config[:backup_remote]} :#{name} || echo ''"]
+        end
+      end
+
+      def delete_local(name, options={})
+        Zenflow::Log("Removing the local branch")
+        Zenflow::Shell["git branch -#{options[:force] ? 'D' : 'd'} #{name}"]
+      end
+
+    end
+  end
+end

data/lib/zenflow/helpers/branch_command.rb

@@ -0,0 +1,95 @@
+module Zenflow
+  class BranchCommand < Thor
+
+    include Zenflow::BranchCommands::Abort
+    include Zenflow::BranchCommands::Branches
+    include Zenflow::BranchCommands::Compare
+    include Zenflow::BranchCommands::Deploy
+    include Zenflow::BranchCommands::Diff
+    include Zenflow::BranchCommands::Finish
+    include Zenflow::BranchCommands::Review
+    include Zenflow::BranchCommands::Start
+    include Zenflow::BranchCommands::Update
+
+    no_commands do
+      def flow
+        self.class.flow
+      end
+
+      def branch(key)
+        val = all_branches(key)
+        if val.size == 1
+          val.first
+        else
+          val
+        end
+      end
+
+      def all_branches(key)
+        self.class.branch[key]
+      end
+
+      def version
+        self.class.version
+      end
+
+      def changelog
+        self.class.changelog
+      end
+
+      def tag
+        self.class.tag
+      end
+
+      def delete_branches
+        Zenflow::Branch.delete_remote("#{flow}/#{branch_name}") if !options[:offline]
+        Zenflow::Branch.delete_local("#{flow}/#{branch_name}", force: true)
+      end
+
+    end
+
+
+  protected
+
+    def branch_name
+      @branch_name ||= Zenflow::Branch.current(flow) ||
+                       Zenflow::Ask("Name of the #{flow}:",
+                           required:      true,
+                           validate:      /^[-0-9a-z]+$/,
+                           error_message: "Names can only contain dashes, 0-9, and a-z").downcase
+    end
+
+
+    # DSL METHODS
+
+    def self.flow(flow=nil)
+      @flow = flow if flow
+      @flow
+    end
+
+    def self.branch(branch={})
+      @branch ||= {}
+      branch.keys.each do |key|
+        @branch[key] ||= []
+        @branch[key] << branch[key]
+      end
+      @branch
+    end
+
+    def self.version(version=nil)
+      @version = version if version
+      @version
+    end
+
+    def self.changelog(changelog=nil)
+      @changelog = changelog if changelog
+      @changelog
+    end
+
+    def self.tag(tag=nil)
+      @tag = tag if tag
+      @tag
+    end
+
+  end
+end

data/lib/zenflow/helpers/branch_commands/abort.rb

@@ -0,0 +1,21 @@
+module Zenflow
+  module BranchCommands
+    module Abort
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "abort", "Aborts the branch and cleans up"
+          option :offline, type: :boolean, desc: "Runs in offline mode"
+          def abort
+            branch_name
+            Zenflow::Branch.checkout(branch(:source))
+            delete_branches
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/zenflow/helpers/branch_commands/branches.rb

@@ -0,0 +1,21 @@
+module Zenflow
+  module BranchCommands
+    module Branches
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "branches", "List branches"
+          def branches
+            Zenflow::Log("Available #{flow} branches:")
+            Zenflow::Branch.list(flow).each do |branch|
+              Zenflow::Log("* #{branch}", indent: true, color: false)
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/zenflow/helpers/branch_commands/compare.rb

@@ -0,0 +1,20 @@
+module Zenflow
+  module BranchCommands
+    module Compare
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "compare", "Launch GitHub compare view against the latest code"
+          def compare
+            branch_name
+            Zenflow::Log("Opening GitHub compare view for #{branch(:source)}...#{flow}/#{branch_name}")
+            Zenflow::Shell["open https://github.com/#{Zenflow::Repo.slug}/compare/#{branch(:source)}...#{flow}/#{branch_name}"]
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/zenflow/helpers/branch_commands/deploy.rb

@@ -0,0 +1,29 @@
+module Zenflow
+  module BranchCommands
+    module Deploy
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "deploy [OPTIONS]", "Deploy"
+          option :migrations, type: :boolean, desc: "Run migrations during deployment", aliases: :m
+          def deploy
+            branch_name
+            if !Zenflow::Config[:deployable]
+              Zenflow::Log("This project is not deployable right now", color: :red)
+              exit(1)
+            end
+            all_branches(:deploy).each do |branch|
+              Zenflow::Branch.update(branch)
+              Zenflow::Branch.merge("#{flow}/#{branch_name}")
+              Zenflow::Deploy(branch, options)
+            end
+            Zenflow::Branch.checkout("#{flow}/#{branch_name}")
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/zenflow/helpers/branch_commands/diff.rb

@@ -0,0 +1,19 @@
+module Zenflow
+  module BranchCommands
+    module Diff
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "diff", "Launch a diff against the latest code"
+          def diff
+            Zenflow::Log("Displaying diff with #{branch(:source)}")
+            Zenflow::Shell["git difftool #{branch(:source)}"]
+          end
+
+        end
+      end
+
+    end
+  end
+end