zenflow 0.8.0

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

@@ -0,0 +1,68 @@
+module Zenflow
+  module BranchCommands
+    module Finish
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "finish", "Finish the branch and close the code review"
+          option :offline, type: :boolean, desc: "Runs in offline mode"
+          def finish
+            branch_name
+            confirm(:confirm_staging, "Has this been tested in a staging environment first?",
+                                      "Sorry, deploy to a staging environment first")
+            confirm(:confirm_review, "Has this been code reviewed yet?",
+                                     "Please have someone look at this first")
+            update_branch_from_destination
+            update_version_and_changelog(version, changelog)
+            merge_branch_into_destination
+            create_tag
+            delete_branches
+          end
+
+          no_commands do
+            def confirm(confirmation, question, failure_response)
+              return unless Zenflow::Config[confirmation]
+              if Zenflow::Ask(question, options: ["Y", "n"], default: "Y") == "n"
+                Zenflow::Log(failure_response, color: :red)
+                exit(1)
+              end
+            end
+
+            def update_version_and_changelog(version, changelog)
+              if version
+                Zenflow::Version.update(version)
+              end
+              if changelog
+                @change = Zenflow::Changelog.update(rotate: (changelog == :rotate), name: branch_name)
+              end
+            end
+
+            def create_tag
+              return unless tag
+              Zenflow::Branch.tag(Zenflow::Version.current.to_s, @change)
+              Zenflow::Branch.push(:tags) if !options[:offline]
+            end
+
+            def update_branch_from_destination
+              destination = (branch(:destination) || branch(:source))
+              Zenflow::Branch.update(destination) if !options[:offline]
+              Zenflow::Branch.checkout("#{flow}/#{branch_name}")
+              Zenflow::Branch.merge(destination)
+            end
+
+            def merge_branch_into_destination
+              [branch(:source), branch(:destination)].compact.each do |finish|
+                Zenflow::Branch.checkout(finish)
+                Zenflow::Branch.merge("#{flow}/#{branch_name}")
+                Zenflow::Branch.push(finish) if !options[:offline]
+              end
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Zenflow
+  module BranchCommands
+    module Review
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "review", "Start a code review."
+          def review
+            branch_name
+            create_pull_request
+          end
+
+          no_commands do
+            def create_pull_request
+              already_created?(Zenflow::PullRequest.find_by_ref("#{flow}/#{branch_name}"))
+
+              pull = Zenflow::PullRequest.create(
+                base:  branch(:source),
+                head:  "#{flow}/#{branch_name}",
+                title: "#{flow}: #{branch_name}",
+                body:  Zenflow::Ask("Describe this #{flow}:", required: true)
+              )
+
+              return handle_invalid_pull_request(pull) unless pull.valid?
+
+              Zenflow::Log("Pull request was created!")
+              Zenflow::Log(pull["html_url"], indent: true, color: false)
+              Zenflow::Shell["open #{pull['html_url']}"]
+            end
+
+            def already_created?(pull)
+              return unless pull
+              Zenflow::Log("A pull request for #{flow}/#{branch_name} already exists", color: :red)
+              Zenflow::Log(pull[:html_url], indent: true, color: false)
+              exit(1)
+            end
+
+            def handle_invalid_pull_request(pull)
+              Zenflow::Log("There was a problem creating the pull request:", color: :red)
+              if pull["errors"]
+                pull["errors"].each do |error|
+                  Zenflow::Log("* #{error['message'].gsub(/^base\s*/,'')}", indent: true, color: :red)
+                end
+              elsif pull["message"]
+                Zenflow::Log("* #{pull['message']}", indent: true, color: :red)
+              else
+                Zenflow::Log(" * unexpected failure, both 'errors' and 'message' were empty in the response")
+              end
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Zenflow
+  module BranchCommands
+    module Start
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "start [NAME]", "Start a branch"
+          option :offline, type: :boolean, desc: "Runs in offline mode"
+          def start(name=nil)
+            @branch_name = Zenflow::Ask("Name of the #{flow}:",
+                                        required:      true,
+                                        validate:      /^[-0-9a-z]+$/,
+                                        error_message: "Names can only contain dashes, 0-9, and a-z",
+                                        response:      name).downcase
+
+            create_new_branch(options[:offline])
+          end
+
+          no_commands do
+            def create_new_branch(offline=false)
+              if !offline
+                Zenflow::Branch.update(branch(:source))
+                Zenflow::Branch.create("#{flow}/#{branch_name}", branch(:source))
+                Zenflow::Branch.push("#{flow}/#{branch_name}")
+                Zenflow::Branch.track("#{flow}/#{branch_name}")
+              else
+                Zenflow::Branch.checkout(branch(:source))
+                Zenflow::Branch.create("#{flow}/#{branch_name}", branch(:source))
+              end
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Zenflow
+  module BranchCommands
+    module Update
+
+      def self.included(thor)
+        thor.class_eval do
+
+          desc "update", "Update the branch to the latest code"
+          option :offline, type: :boolean, desc: "Runs in offline mode"
+          def update
+            branch_name
+            Zenflow::Branch.update(branch(:source)) if !options[:offline]
+            Zenflow::Branch.checkout("#{flow}/#{branch_name}")
+            Zenflow::Branch.merge(branch(:source))
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/zenflow/helpers/changelog.rb

@@ -0,0 +1,100 @@
+module Zenflow
+  module Changelog
+    class << self
+
+      def exist?
+        File.exist?("CHANGELOG.md")
+      end
+
+      def update(options={})
+        return unless exist?
+        change = prompt_for_change(options)
+        if change
+          prepend_change_to_changelog(change, options)
+        else
+          rotate(:commit => true) if options[:rotate]
+        end
+        change
+      end
+
+      def prompt_for_change(options={})
+        required = ' (optional)' if options[:required] == false
+        Zenflow::Ask("Add one line to the changelog#{required}:", :required => !(options[:required] == false))
+      end
+
+      def prepend_change_to_changelog(change, options={})
+        return unless exist?
+        new_changes = Zenflow::Shell.shell_escape_for_single_quoting(change)
+        File.open("CHANGELOG.md", "w") do |f|
+          f.write prepended_changelog(new_changes)
+        end
+        rotate(:name => options[:name]) if options[:rotate]
+        Zenflow::Shell["git add . && git commit -a -m 'Adding line to CHANGELOG: #{new_changes}'"]
+      end
+
+      def prepended_changelog(new_changes)
+        existing_changes, changelog = get_changes
+
+        <<-EOS
+#{new_changes}
+#{existing_changes}
+--------------------------------------------------------------------------------
+#{changelog}
+        EOS
+      end
+
+      def rotate(options={})
+        return unless changelog = rotated_changelog(options)
+        Zenflow::Log("Managing changelog for version #{Zenflow::Version.current} / #{Time.now.strftime('%Y-%m-%d')} #{"/ " + options[:name] + " " if options[:name]}")
+
+        File.open("CHANGELOG.md", "w") do |f|
+          f.write changelog
+        end
+        Zenflow::Shell["git add CHANGELOG.md && git commit -a -m 'Rotating CHANGELOG.'"] if options[:commit]
+      end
+
+      def rotated_changelog(options={})
+        changes, changelog = get_changes
+        return if changes.nil?
+        <<-EOS
+#{changelog}
+
+#{row_name(options[:name])}
+#{changes}
+        EOS
+      end
+
+      def get_changes
+        return unless exist?
+        changelog = File.read("CHANGELOG.md").strip
+        changes = changelog.split("--------------------------------------------------------------------------------")[0]
+        return if changes.strip.empty?
+        changelog = changelog.sub(changes, "")
+        return changes.strip, changelog
+      end
+
+      def row_name(name=nil)
+        formatted_name = "/ #{name} " if name
+        "---- #{Zenflow::Version.current} / #{Time.now.strftime('%Y-%m-%d')} #{formatted_name}".ljust(80, "-")
+      end
+
+      def create
+        File.open("CHANGELOG.md", "w") do |f|
+          f.write changelog_template
+        end
+      end
+
+      def changelog_template
+        <<-EOS
+--------------------------------------------------------------------------------
+                        ^ ADD NEW CHANGES ABOVE ^
+--------------------------------------------------------------------------------
+
+CHANGELOG
+=========
+
+        EOS
+      end
+    end
+  end
+end

data/lib/zenflow/helpers/config.rb

@@ -0,0 +1,36 @@
+module Zenflow
+  class Config
+    class << self
+      attr_accessor :config
+
+      CONFIG_FILE = "#{Dir.pwd}/.zenflow"
+
+      def load!
+        @config = {}
+        @config = YAML.load_file(CONFIG_FILE) if configured?
+      end
+
+      def save!
+        File.open(CONFIG_FILE, "w") do |out|
+          YAML.dump(@config, out)
+        end
+      end
+
+      def [](key)
+        load!
+        @config[key.to_s]
+      end
+
+      def []=(key, value)
+        load!
+        @config[key.to_s] = value
+        save!
+      end
+
+      def configured?
+        File.exist?(CONFIG_FILE)
+      end
+
+    end
+  end
+end

data/lib/zenflow/helpers/github.rb

@@ -0,0 +1,40 @@
+module Zenflow
+
+  module Github
+    def self.user
+      Zenflow::Shell.run('git config --get github.user', silent: true).chomp
+    end
+
+    def self.zenflow_token
+      zenflow_token = Zenflow::Shell.run('git config --get zenflow.token', silent: true).chomp
+      zenflow_token = nil if zenflow_token.to_s.strip == ''
+      zenflow_token
+    end
+
+    def self.authorize
+      Zenflow::Log("Authorizing with GitHub... Enter your GitHub password.")
+      oauth_response = JSON.parse(Zenflow::Shell.run(%{curl -u "#{Zenflow::Github.user}" https://api.github.com/authorizations -d '{"scopes":["repo"], "note":"Zenflow"}' --silent}, silent: true))
+      if oauth_response['token']
+        Zenflow::Shell.run("git config --global zenflow.token #{oauth_response['token']}", silent: true)
+        Zenflow::Log("Authorized!")
+      else
+        Zenflow::Log("Something went wrong. Error from GitHub was: #{oauth_response['message']}")
+        return
+      end
+    end
+  end
+
+  def self.set_user
+    username = Zenflow::Ask("What is your Github username?")
+    Zenflow::Shell.run("git config --global github.user #{username}", silent: true)
+  end
+
+  class GithubRequest
+    include HTTParty
+    base_uri "https://api.github.com/repos/#{Zenflow::Repo.slug}"
+    format :json
+    headers "Authorization" => "token #{Zenflow::Github.zenflow_token}"
+    headers "User-Agent" => "Zencoder/Zenflow-#{VERSION}"
+  end
+
+end

data/lib/zenflow/helpers/help.rb

@@ -0,0 +1,37 @@
+module Zenflow
+
+  def self.Help(options={})
+    Zenflow::Help.new(options)
+  end
+
+  class Help
+    attr_accessor :options
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def title(text)
+      "- #{text} ".ljust(40, "-").cyan
+    end
+
+    def banner
+      help = []
+      help << "#{title("Summary")}\n#{options[:summary]}" if options[:summary]
+      help << "#{title("Usage")}\n#{options[:usage]}" if options[:usage]
+      help << "#{title("Available Commands")}\n#{options[:commands]}" if options[:commands]
+      help << "#{title("Options")}"
+      help.join("\n\n")
+    end
+
+    def unknown_command
+      if options[:command].nil?
+        Zenflow::Log("Missing command", :color => :red)
+      else
+        Zenflow::Log("Unknown command #{options[:command].inspect}", :color => :red)
+      end
+      exit(1)
+    end
+  end
+
+end

data/lib/zenflow/helpers/log.rb

@@ -0,0 +1,21 @@
+module Zenflow
+
+  LOG_PATH = File.join(Dir.pwd, ".zenflow-log")
+
+  def self.Log(message, options={})
+    output = ""
+    output << "       " if options[:indent]
+    output << "-----> " if !(options[:arrows] === false)
+    output << message
+    LogToFile(output)
+    output = output.send(options[:color] || :cyan) unless options[:color] == false
+    puts output
+  end
+
+  def self.LogToFile(message)
+    File.open(LOG_PATH, "a") do |f|
+      f.write(message+"\n")
+    end
+  end
+
+end

data/lib/zenflow/helpers/pull_request.rb

@@ -0,0 +1,68 @@
+module Zenflow
+  class PullRequest
+
+    class << self
+      def list
+        response = Zenflow::GithubRequest.get("/pulls").parsed_response
+        response.map{ |pull| new(pull) }
+      end
+
+      def find(number)
+        new(Zenflow::GithubRequest.get("/pulls/#{number}").parsed_response["pull"])
+      end
+
+      def find_by_ref(ref, options={})
+        Zenflow::Log("Looking up pull request for #{ref}") unless options[:silent]
+        if !list.nil?
+          pull = list.detect do |p|
+            p["head"]["ref"] == ref
+          end
+          if pull
+            new(pull)
+          end
+        end
+      end
+
+      def find_by_ref!(ref)
+        if pull = find_by_ref(ref)
+          new(pull)
+        else
+          Zenflow::Log("No open pull request was found for #{ref}", color: :red)
+          exit(1)
+        end
+      end
+
+      def exist?(ref)
+        !!find_by_ref(ref)
+      end
+
+      def create(options={})
+        response = Zenflow::GithubRequest.post("/pulls",
+          body: {
+            "base"  => options[:base],
+            "head"  => options[:head],
+            "title" => options[:title],
+            "body"  => options[:body]
+          }.to_json
+        )
+        new(response.parsed_response)
+      end
+    end
+
+
+    attr_reader :pull
+
+    def initialize(pull)
+      @pull = pull || {}
+    end
+
+    def valid?
+      !pull["errors"] && pull['html_url']
+    end
+
+    def [](key)
+      pull[key.to_s]
+    end
+
+  end
+end