intello-shipit-cli 0.6.0.rc1

data/lib/shipit/cli/configuration.rb

@@ -0,0 +1,81 @@
+require "uri"
+
+module Shipit
+  module Cli
+    # This class maintains all system-wide configuration for *shipit*. It properly
+    # applies the correct source of configuration values based on the different contexts and
+    # also makes sure that compulsory data are not missing.
+    #
+    class Configuration
+      # List of all the configuration attributes stored for use within the gem
+      ATTRIBUTES = [:endpoint, :private_token, :protected_branches]
+
+      attr_accessor :endpoint, :private_token, :protected_branches
+
+      # Apply a configuration hash to a configuration instance
+      #
+      # @example Override one of the configuration attributes
+      #   config = Shipit::Cli::Configuration.new
+      #   config.apply(private_token: 'supersecret')
+      #   config.private_token #=> "supersecret"
+      #
+      # @param attributes [Hash] list of key/values to apply to the configuration
+      # @return [Object] the configuration object
+      #
+      def apply(attributes = {})
+        prepared_attributes = prepare_attributes attributes
+        prepared_attributes.each_pair do |attribute, value|
+          send("#{attribute}=", value)
+        end
+        self
+      end
+
+      # The configuration instance formatted as a stringified hash
+      #
+      # @example Override one of the configuration attributes
+      #   config = Shipit::Cli::Configuration.new
+      #   config.to_hash
+      #   #=> { "endpoint" => "https://gitlab.example.com/api/v3", "private_token" => "supersecret" }
+      #
+      # @return [Hash] the configuration object as a Hash
+      #
+      def to_hash
+        config_hash = ATTRIBUTES.inject({}) do |hash, attr|
+          hash["#{attr}"] = instance_variable_get("@#{attr}")
+          hash
+        end
+        Shipit::Cli::Sanitizer.symbolize config_hash
+      end
+
+      # Write a configuration summary to STDOUT, useful for output in the CLI
+      #
+      def to_stdout
+        to_hash.each_pair do |attribute, value|
+          puts format("%-20s %-50s", "#{attribute}:", value)
+        end
+        nil
+      end
+
+      def motd_list
+        File.readlines(File.expand_path('../../motd', __FILE__)).map(&:chomp)
+      end
+
+      private
+
+      # Symbolize keys and remove nil or duplicate attributes
+      # The attributes usually passed to our configuration class by the CLI
+      # are usually full of duplicates and unconsistant keys, we make sure
+      # to clean up that input, before doing any configuration work.
+      #
+      # @param attributes [Hash] list of key/values
+      # @return [Hash] a clean list of key/values
+      #
+      def prepare_attributes(attributes)
+        # Convert string keys to symbols
+        symboled_attributes = Shipit::Cli::Sanitizer.symbolize attributes
+        # Clean up user_attributes from unwanted, nil and duplicate options
+        symboled_attributes.select { |key, _| ATTRIBUTES.include? key }.delete_if { |_, v| v.nil? }
+      end
+    end
+  end
+end

data/lib/shipit/cli/configuration_file.rb

@@ -0,0 +1,58 @@
+require "yaml"
+
+module Shipit
+  module Cli
+    class ConfigurationFile
+      ATTR_READER = [:endpoint, :private_token, :protected_branches]
+      attr_reader(*ATTR_READER)
+
+      def initialize(path, configuration = nil)
+        @path = path
+        @file = load_file
+        @configuration = configuration || load_configuration
+      end
+
+      def exist?
+        File.exist?(@path)
+      end
+
+      def to_hash
+        config_hash = ATTR_READER.inject({}) do |hash, attr|
+          hash["#{attr}"] = instance_variable_get("@#{attr}")
+          hash
+        end
+        Shipit::Cli::Sanitizer.symbolize config_hash
+      end
+
+      def persist
+        File.open(@path, "w") do |f|
+          f.write @configuration.to_yaml
+        end
+        reload!
+      end
+
+      def reload!
+        @file = load_file
+        @configuration = load_configuration
+      end
+
+      private
+
+      def load_file
+        if exist?
+          Shipit::Cli::Sanitizer.symbolize YAML.load_file(@path)
+        else
+          {}
+        end
+      end
+
+      def load_configuration
+        if @file
+          ATTR_READER.each do |attr|
+            instance_variable_set "@#{attr}", @file[attr]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shipit/cli/git.rb

@@ -0,0 +1,58 @@
+module Shipit
+  module Cli
+    class Git
+      GIT     = ENV["SHIPIT_GIT"] || "git"
+      ORIGIN  = ENV["SHIPIT_ORIGIN"] || "origin"
+      VERBOSE = ENV["SHIPIT_GIT_VERBOSE"] ? "--verbose" : "--quiet"
+
+      COMMANDS = {
+        new: {
+          desc: "create new branch `branch`",
+          commands: [
+            '"#{GIT} push #{origin} #{current_branch}:refs/heads/#{branch} --no-verify #{VERBOSE}"',
+            '"#{GIT} fetch #{origin} #{VERBOSE}"',
+            '"#{GIT} branch --track #{branch} #{origin}/#{branch} #{VERBOSE}"',
+            '"#{GIT} checkout #{branch} #{VERBOSE}"',
+            '"#{GIT} commit --allow-empty -m \"#{message}\" #{VERBOSE}"',
+            '"#{GIT} push --no-verify #{VERBOSE}"'
+          ]
+        }
+      }
+
+      # Ex: Shipit::Cli::Git.run(command: :new, target_branch: "master", branch: "my-new-branch", message: "empty commit")
+      def self.run(opt)
+        if COMMANDS.keys.include?(opt[:command].to_sym)
+          current_branch = opt[:target_branch]
+          branch = opt[:branch]
+          origin = ORIGIN
+          message = opt.fetch(:message, "").gsub("`", "'")
+          dry_run = opt.fetch(:dry_run, false)
+          grepped_protected_branches = Array(Shipit::Cli.config.protected_branches)
+            .push("master")
+            .push("develop")
+            .push(get_current_branch)
+            .uniq.map{ |b| "| grep -v #{b} " }.join
+          COMMANDS[opt[:command].to_sym][:commands].map do |x|
+            command = exec_cmd(eval(x), dry_run)
+            exit_now!("There was an error running the last Git command. See the trace for more info.") if dry_run == false && command == false
+          end
+        else
+          false
+        end
+      end
+
+      def self.get_current_branch
+        (`#{GIT} branch 2> /dev/null | grep '^\*'`).gsub(/[\*\s]/, "")
+      end
+
+      def self.exec_cmd(str, dry_run = false)
+        return true unless str
+        if dry_run
+          puts "    - #{str}"
+        else
+          system("#{str}")
+        end
+      end
+    end
+  end
+end

data/lib/shipit/cli/sanitizer.rb

@@ -0,0 +1,18 @@
+module Shipit
+  module Cli
+    class Sanitizer
+      def self.symbolize(obj)
+        return obj.inject({}) do |memo, (k, v)|
+          memo.tap { |m| m[k.to_sym] = symbolize(v) }
+        end if obj.is_a? Hash
+
+        return obj.inject([]) do |memo, v|
+          memo << symbolize(v)
+          memo
+        end if obj.is_a? Array
+
+        obj
+      end
+    end
+  end
+end

data/lib/shipit/cli/server.rb

@@ -0,0 +1,48 @@
+require "json"
+require "uri"
+require "net/http"
+require "net/https"
+
+module Shipit
+  module Cli
+    class Server
+      def initialize(url, options = {})
+        @uri = URI(url)
+        @scheme = @uri.scheme || "https"
+        @method = options[:method] || :get
+        @body = options[:body]
+        @private_token = options[:private_token] || Shipit::Cli.config.private_token
+        @authorization_header = "Token #{@private_token}"
+        @http = set_http(@uri, @scheme)
+      end
+
+      def request
+        case @method
+        when :post
+          @request = Net::HTTP::Post.new(@uri.request_uri, initheader = { "Content-Type" => "application/json" })
+          @request.body = @body.to_json
+        else
+          @request = Net::HTTP::Get.new(@uri.request_uri)
+        end
+
+        @request["authorization"] = @authorization_header
+        @request
+      end
+
+      def response
+        @response ||= @http.request(request)
+      end
+
+      private
+
+      def set_http(uri, scheme)
+        http = Net::HTTP.new(uri.host, uri.port)
+        if scheme == "https"
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+        http
+      end
+    end
+  end
+end

data/lib/shipit/cli/version.rb

@@ -0,0 +1,5 @@
+module Shipit
+  module Cli
+    VERSION = "0.6.0.rc1".freeze
+  end
+end

data/lib/shipit/cli/work.rb

@@ -0,0 +1,138 @@
+require "active_support/all"
+
+module Shipit
+  module Cli
+    class Work
+      attr_reader :client, :issue_id, :global_options
+
+      # @param issue_id [Integer] The issue GitLab IID
+      # @param target_branch [String] "master", "develop"...
+      # @param global_options [Hash] A hash of options
+      #   - dry_run : If true will not perform the commands
+      #   - client : an instance of the GitLab client
+      def initialize(issue_id, global_options)
+        @issue_id       = issue_id
+        @global_options = global_options
+        @client = global_options.fetch(:client)
+      end
+
+      # 1. Get issue : https://docs.gitlab.com/ee/api/issues.html#single-issue
+      # 2. Validate issue properties
+      # 3. Create branch : https://docs.gitlab.com/ee/api/branches.html#create-repository-branch
+      # 4. First commit : https://docs.gitlab.com/ee/api/commits.html#create-a-commit-with-multiple-files-and-actions
+      # 5. New merge request : https://docs.gitlab.com/ee/api/merge_requests.html#create-mr
+      def perform(target_branch)
+        # 1. Load issue
+        issue = fetch_remote_issue(issue_id).to_hash
+        # 2. Validate issue
+        validate_issue(issue)
+        # 3. Add additional issue attributes
+        enhanced_issue = enhance_issue(issue, target_branch)
+        # 4. Create remote branch & checkout
+        create_source_branch(enhanced_issue)
+        # 5. Create merge request
+        create_merge_request(enhanced_issue)
+        # 6. Motivation!
+        puts ""
+        Shipit::Cli.ascii
+      rescue => e
+        exit_now! e
+      end
+
+      # @return [Boolean]
+      def dry_run?
+        global_options["dry_run"] == true
+      end
+
+      private
+
+      # @param id [Integer] The issue IID to fetch from GitLab
+      def fetch_remote_issue(id)
+        client.issue(project_path, id)
+      rescue Gitlab::Error::NotFound => e
+        exit_now! "Issue #{id} not found for project #{project_name} on the remote GitLab server."
+      end
+
+      def create_source_branch(issue)
+        commands = Shipit::Cli::Git.run(command: :new,
+                                        branch: issue["source_branch"],
+                                        message: issue["first_commit_message"],
+                                        target_branch: issue["target_branch"],
+                                        dry_run: global_options["dry_run"])
+        raise "There was an error creating your working branch.\nPROTIP: Review the previous trace and fix the errors before retrying." if !dry_run? && commands.any? { |c| c == false }
+      end
+
+      def create_merge_request(issue)
+        return if dry_run?
+        opts = issue.slice("source_branch", "target_branch", "assignee_id", "labels", "milestone_id", "remove_source_branch")
+        client.create_merge_request(project_path,
+                                    issue["merge_request_title"],
+                                    opts)
+      rescue Gitlab::Error => e
+        exit_now! "There was a problem creating your merge request on the GitLab server. Please do it manually.\nError : #{e.message}"
+      end
+
+      # @param issue [Hash] A hash of properties
+      # @return true if issue if valid
+      def validate_issue(issue)
+        errors = []
+        errors << "Assignee missing" if issue["assignees"].empty? # returns an array of assignees (Array of hash)
+        errors << "Milestone missing" if issue["milestone"].to_s.empty? # returns a hash with the milestone properties
+        errors << "Labels missing" if issue["labels"].empty? # returns an array of strings
+        exit_now!("Invalid remote GitLab issue. Please fix the following warnings : #{errors.join(", ")}") if errors.any?
+      end
+
+      def enhance_issue(issue, target_branch)
+        # 1. Build properties
+        issue_id = issue["iid"]
+        labels = issue["labels"].join(", ")
+        assignee = issue["assignees"].first
+        sane_title = issue["title"].gsub(/[^0-9A-Za-z ,.]/, '').strip
+        assignee_initials = assignee["name"].split.map(&:first).join.downcase.gsub(/[^a-z]/, '').strip
+        assignee_id = assignee["id"]
+        issue_title = sane_title.parameterize[0..20]
+        first_commit_message = "[#{labels}] Fixes ##{issue_id} - #{sane_title}"
+        mr_title = "[WIP] [#{labels}] ##{issue_id} - #{sane_title}"
+
+        # 2. Add to issue properties
+        issue["source_branch"] = [issue["labels"].first, assignee_initials, issue_id, issue_title].compact.join("-")
+        issue["first_commit_message"] = first_commit_message
+        issue["target_branch"] = target_branch
+        issue["merge_request_title"] = mr_title
+        issue["assignee_id"] = assignee_id
+        issue["milestone_id"] = issue["milestone"]["id"]
+        issue["remove_source_branch"] = true
+        issue["labels"] = labels
+        issue
+      end
+
+      # Branch names are constructed like so :
+      # {label}-{assignee initials}-{issue id}-{issue title}
+      #
+      # @return [String]
+      def define_source_branch_name
+        [first_label, assignee_initials, @id, issue_title].compact.join("-")
+      end
+
+      # @return [String]
+      def project_git_url
+        @project_git_url ||= `git config --local remote.origin.url`.chomp
+      end
+
+      # @return [String]
+      def project_name
+        @project_name ||= project_git_url.split("/").last.gsub(".git", "")
+      end
+
+      # @return [String]
+      def project_namespace
+        @project_namespace ||= project_git_url.split(":").last.split("/").first
+      end
+
+      # @return [String]
+      def project_path
+        @project_path ||= [project_namespace, project_name].join("/")
+      end
+    end
+  end
+end

data/lib/shipit/cli.rb

@@ -0,0 +1,45 @@
+require "shipit/cli/configuration"
+require "shipit/cli/configuration_file"
+require "shipit/cli/sanitizer"
+require "shipit/cli/git"
+require "shipit/cli/server"
+require "shipit/cli/version"
+require "shipit/cli/work"
+
+module Shipit
+  module Cli
+    class << self
+      # Keep track of the configuration values set after a configuration
+      # has been applied
+      #
+      # @example Return a configuration value
+      #   Shipit::Cli.config.foo #=> "bar"
+      #
+      # @return [Object] the configuration object
+      #
+      def config
+        @config ||= Shipit::Cli::Configuration.new
+      end
+
+      def configure(attributes = {})
+        config.apply attributes
+      end
+
+      def ascii
+        label = "*" + @config.motd_list.sample[0..37].upcase.center(38) + "*"
+
+        puts "****************************************"
+        puts label
+        puts "*                                      *"
+        puts "*             |    |    |              *"
+        puts "*            )_)  )_)  )_)             *"
+        puts "*           )___))___))___)\\           *"
+        puts "*          )____)____)_____)\\          *"
+        puts "*        _____|____|____|____\\__       *"
+        puts "*--------\\                   /---------*"
+        puts "*       ^^^^^^^^^^^^^^^^^^^^^^         *"
+        puts "****************************************"
+      end
+    end
+  end
+end

data/lib/shipit/motd

@@ -0,0 +1,15 @@
+F*CK IT, SHIP IT
+FAILURE IS ALWAYS AN OPTION
+I can haz Ship It?
+I dare you to ship. I dare you!
+It's hip to ship
+Keep it simple, ship it fast
+NEVER GIVE UP, NEVER SURRENDER
+REAL ARTISTS SHIP
+Ship it baby!
+TO ERR IS HUMAN BUT TO ARR IS PIRATE
+IT'S GOING TO BE ALL RIGHT
+IT'S GONNA BLOW THEM ALL AWAY
+Smurferation, Smurferation, Smurf
+All boundaries are conventions
+Ship it or die trying

data/script/bootstrap

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Usage: script/bootstrap
+set -e
+
+echo "* Install the project gems"
+gem install bundler --conservative
+bundle check || bundle install
+
+echo "* Bootstrap finished."

data/script/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "shipit/cli"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/script/package

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Usage: script/package
+# Updates the gemspec and builds a new gem in the pkg directory.
+
+mkdir -p pkg
+bundle exec gem build *.gemspec
+mv *.gem pkg

data/script/release

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# Usage: script/release
+# Build the package, tag a commit, push it to origin, and then release the
+# package to our private gem repository.
+
+# Let's source required ENV variables
+source .rbenv-vars
+set -e
+
+# Get latest tag
+
+# http://git-scm.com/docs/git-fetch
+# `-t`: Fetch all tags from the remote
+echo "Fetching origin with all remote tags..."
+git fetch -t origin
+
+latest_tag=$(git describe --always origin/master --abbrev=0 --match="v*")
+latest_release=${latest_tag:1}
+echo "Did you update the VERSION in lib/shipit-cli/version.rb ?"
+read -p "It should be > $latest_release [y/N]: " response
+
+if [[ $response =~ ^(y|Y)$ ]]; then
+  # Build the gem
+  echo "Preparing the gem package in pkg/*"
+  # Output format: intello-shipit-cli 1.0.2 built to pkg/intello-shipit-cli-1.0.2.gem.
+  version="$(script/package | grep Version: | awk '{print $2}')"
+  # Did we get a version?
+  if [ -z "$version" ]; then echo "You have to give me a semantic tag, like 1.0.0"; exit 1; fi
+  echo "Tagging your code to v$version"
+  echo ""
+
+  echo "Make sure you are GPG ready."
+  echo "You should have run this at one point:"
+  echo "$ git config --global user.signingkey [gpg-key-id]"
+  git tag -s "v$version" -m "Release v$version"
+  git push origin
+  git push origin "v$version"
+  echo ""
+  echo "Publishing to remote gem repository."
+  gem push pkg/intello-shipit-cli-${version}.gem
+else
+  echo "You canceled the operation, nothing was done."
+fi

data/script/test

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -e
+
+echo "===> Running specs..."
+bundle exec rspec

data/shipit-cli.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "shipit/cli/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "intello-shipit-cli"
+  spec.version       = Shipit::Cli::VERSION
+  spec.authors       = ["Benjamin Thouret"]
+  spec.email         = ["benjamin.thouret@intello.com"]
+
+  spec.summary       = %w{Designed to simplify working with Gitlab,
+                          its main purpose is to kickstart working on an issue.}
+  spec.homepage      = "https://gitlab.com/intello/shipit-cli"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "gli", "~> 2.13"
+  spec.add_dependency "gitlab", "~> 4.3.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0.1"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-ctags-bundler"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-rubocop"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "simplecov"
+end