geet 0.1.0

data/README.md

@@ -0,0 +1,30 @@
+# Geet
+
+Command line interface for performing Git hosting service operations.
+
+The current version supports only creating PRs/issues.
+
+This tool is very similar to [Hub](https://github.com/github/hub), but it supports more complex operations, fully specified via command line.
+
+## Samples
+
+Basic creation of an issue and a PR (both actions will open the pages with the result in the browser):
+
+    $ geet issue 'Issue Title' 'Issue Description'
+    $ geet pr 'PR Title' 'PR Description
+    > 
+    > Closes #1' --label-patterns "code review" --reviewer-patterns john,tom,adrian
+
+Create an issue, adding the label matching `bug`, and assigning it to the collaborators matching `john`, `tom`, `kevin`:
+
+    $ geet issue 'Issue Title' 'Issue Description' --label-patterns "code review" --assignee-patterns john,tom,kevin
+
+Create a PR, adding the label matching `code review`, and requesting reviews from the collaborators matching `john`, `tom`, `adrian`:
+
+    $ geet pr 'PR Title' 'PR Description
+    > 
+    > Closes #1' --label-patterns "code review" --reviewer-patterns john,tom,adrian
+
+For the help:
+
+    $ geet --help

data/bin/geet

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/geet/helpers/configuration_helper.rb'
+require_relative '../lib/geet/git/repository.rb'
+
+include Geet
+
+configuration_helper = Helpers::ConfigurationHelper.new
+
+command, options = configuration_helper.decode_argv || exit
+api_token = configuration_helper.api_token
+
+title, description = options.values_at(:title, :description)
+
+repository = Git::Repository.new(api_token)
+
+case command
+when Helpers::ConfigurationHelper::ISSUE_CREATE_COMMAND
+  Services::CreateIssue.new.execute(repository, title, description, options)
+when Helpers::ConfigurationHelper::ISSUE_LIST_COMMAND
+  Services::ListIssues.new.execute(repository)
+when Helpers::ConfigurationHelper::PR_CREATE_COMMAND
+  Services::CreatePr.new.execute(repository, title, description, options)
+else
+  raise "Internal error - Unrecognized command #{command.inspect}"
+end

data/geet.gemspec

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+$LOAD_PATH << File.expand_path("lib", __dir__)
+
+require "geet/version"
+
+Gem::Specification.new do |s|
+  s.name        = "geet"
+  s.version     = Geet::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Saverio Miroddi"]
+  s.date        = "2017-10-18"
+  s.email       = ["saverio.pub2@gmail.com"]
+  s.homepage    = "https://github.com/saveriomiroddi/geet"
+  s.summary     = "Commandline interface for performing SCM (eg. GitHub) operations (eg. PR creation)."
+  s.description = "Commandline interface for performing SCM (eg. GitHub) operations (eg. PR creation)."
+  s.license     = "GPL-3.0"
+
+  s.add_runtime_dependency "simple_scripting", "~> 0.9.3"
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   << "geet"
+  s.require_paths = ["lib"]
+end

data/lib/geet/git/repository.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+Dir[File.join(__dir__, '../**/remote_repository.rb')].each { |repository_file| require repository_file }
+Dir[File.join(__dir__, '../**/account.rb')].each { |account_file| require account_file }
+Dir[File.join(__dir__, '../**/api_helper.rb')].each { |helper_file| require helper_file }
+Dir[File.join(__dir__, '../services/*.rb')].each { |helper_file| require helper_file }
+
+module Geet
+  module Git
+    # This class represents, for convenience, both the local and the remote repository, but the
+    # remote code is separated in each provider module.
+    class Repository
+      extend Forwardable
+
+      def_delegators :@remote_repository, :collaborators, :labels
+      def_delegators :@remote_repository, :create_issue, :list_issues
+      def_delegators :@remote_repository, :create_pr
+      def_delegators :@account, :authenticated_user
+
+      DOMAIN_PROVIDERS_MAPPING = {
+        'github.com' => Geet::GitHub
+      }.freeze
+
+      # For simplicity, we match any character except the ones the separators.
+      REMOTE_ORIGIN_REGEX = %r{\Agit@([^:]+):([^/]+)/(.*?)(\.git)?\Z}
+
+      def initialize(api_token)
+        the_provider_domain = provider_domain
+        provider_module = DOMAIN_PROVIDERS_MAPPING[the_provider_domain] || raise("Provider not supported for domain: #{provider_domain}")
+
+        api_helper = provider_module::ApiHelper.new(api_token, user, owner, repo)
+
+        @remote_repository = provider_module::RemoteRepository.new(self, api_helper)
+        @account = provider_module::Account.new(api_helper)
+      end
+
+      # METADATA
+
+      def user
+        `git config --get user.email`.strip
+      end
+
+      def provider_domain
+        remote_origin[REMOTE_ORIGIN_REGEX, 1]
+      end
+
+      def owner
+        remote_origin[REMOTE_ORIGIN_REGEX, 2]
+      end
+
+      def repo
+        remote_origin[REMOTE_ORIGIN_REGEX, 3]
+      end
+
+      # DATA
+
+      def current_head
+        `git rev-parse --abbrev-ref HEAD`.strip
+      end
+
+      # OTHER
+
+      private
+
+      # The result is in the format `git@github.com:saveriomiroddi/geet.git`
+      #
+      def remote_origin
+        origin = `git ls-remote --get-url origin`.strip
+
+        if origin !~ REMOTE_ORIGIN_REGEX
+          raise("Unexpected remote reference format: #{origin.inspect}")
+        end
+
+        origin
+      end
+    end
+  end
+end

data/lib/geet/git_hub/abstract_issue.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Geet
+  module GitHub
+    # For clarity, in this class we keep only the identical logic between the subclasses, but
+    # other methods could be moved in here at some complexity cost.
+    class AbstractIssue
+      attr_reader :issue_number
+
+      def initialize(repository, issue_number, api_helper)
+        @repository = repository
+        @issue_number = issue_number
+        @api_helper = api_helper
+      end
+
+      # params:
+      #   users:   String, or Array of strings.
+      #
+      def assign_user(users)
+        request_data = { assignees: Array(users) }
+        request_address = "#{@api_helper.repo_link}/issues/#{@issue_number}/assignees"
+
+        @api_helper.send_request(request_address, data: request_data)
+      end
+
+      def add_labels(labels)
+        request_data = labels
+        request_address = "#{@api_helper.repo_link}/issues/#{@issue_number}/labels"
+
+        @api_helper.send_request(request_address, data: request_data)
+      end
+    end
+  end
+end

data/lib/geet/git_hub/account.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Geet
+  module GitHub
+    class Account
+      def initialize(api_helper)
+        @api_helper = api_helper
+      end
+
+      def authenticated_user
+        request_address = 'https://api.github.com/user'
+
+        response = @api_helper.send_request(request_address)
+
+        response.fetch('login')
+      end
+    end
+  end
+end

data/lib/geet/git_hub/api_helper.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'shellwords'
+
+module Geet
+  module GitHub
+    class ApiHelper
+      def initialize(api_token, user, owner, repo)
+        @api_token = api_token
+        @user = user
+        @owner = owner
+        @repo = repo
+      end
+
+      def repo_link
+        "https://api.github.com/repos/#{@owner}/#{@repo}"
+      end
+
+      # Send a request.
+      #
+      # Returns the parsed response, or an Array, in case of multipage.
+      #
+      # params:
+      #   :data:        (Hash) if present, will generate a POST request
+      #   :multipage:   set true for paged GitHub responses (eg. issues); it will make the method
+      #                 return an array, with the concatenated (parsed) responses
+      #
+      def send_request(address, data: nil, multipage: false)
+        # `--data` implies `-X POST`
+        #
+        if data
+          escaped_request_body = JSON.generate(data).shellescape
+          data_option = "--data #{escaped_request_body}"
+        end
+
+        # filled only on :multipage
+        parsed_responses = []
+
+        loop do
+          command = %(curl --verbose --silent --user "#{@user}:#{@api_token}" #{data_option} #{address})
+          response_metadata, response_body = nil
+
+          Open3.popen3(command) do |_, stdout, stderr, wait_thread|
+            response_metadata = stderr.readlines.join
+            response_body = stdout.readlines.join
+
+            if !wait_thread.value.success?
+              puts response_metadata
+              puts "Error! Command: #{command}"
+              exit
+            end
+          end
+
+          parsed_response = JSON.parse(response_body)
+
+          if error?(response_metadata)
+            formatted_error = decode_and_format_error(parsed_response)
+            raise(formatted_error)
+          end
+
+          return parsed_response if !multipage
+
+          parsed_responses.concat(parsed_response)
+
+          address = link_next_page(response_metadata)
+
+          return parsed_responses if address.nil?
+        end
+      end
+
+      private
+
+      def decode_and_format_error(response)
+        message = response['message']
+
+        if response.key?('errors')
+          message += ':'
+
+          error_details = response['errors'].map do |error_data|
+            error_code = error_data.fetch('code')
+
+            if error_code == 'custom'
+              " #{error_data.fetch('message')}"
+            else
+              " #{error_code} (#{error_data.fetch('field')})"
+            end
+          end
+
+          message += error_details.join(', ')
+        end
+
+        message
+      end
+
+      def error?(response_metadata)
+        status_header = find_header_content(response_metadata, 'Status')
+
+        !!(status_header =~ /^4\d\d/)
+      end
+
+      def link_next_page(response_metadata)
+        link_header = find_header_content(response_metadata, 'Link')
+
+        return nil if link_header.nil?
+
+        link_header[/<(\S+)>; rel="next"/, 1]
+      end
+
+      def find_header_content(response_metadata, header_name)
+        response_metadata.split("\n").each do |header|
+          return Regexp.last_match(1) if header =~ /^< #{header_name}: (.*)/
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/geet/git_hub/issue.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'abstract_issue'
+
+module Geet
+  module GitHub
+    class Issue < AbstractIssue
+      def self.create(repository, title, description, api_helper)
+        request_address = "#{api_helper.repo_link}/issues"
+        request_data = { title: title, body: description, base: 'master' }
+
+        response = api_helper.send_request(request_address, data: request_data)
+
+        issue_number = response.fetch('number')
+
+        new(repository, issue_number, api_helper)
+      end
+
+      # Returns an array of Struct(:number, :title); once this workflow is extended,
+      # the struct will likely be converted to a standard class.
+      #
+      # See https://developer.github.com/v3/issues/#list-issues-for-a-repository
+      #
+      def self.list(repository, api_helper)
+        request_address = "#{api_helper.repo_link}/issues"
+
+        response = api_helper.send_request(request_address, multipage: true)
+        issue_class = Struct.new(:number, :title, :link)
+
+        response.map do |issue_data|
+          number = issue_data.fetch('number')
+          title = issue_data.fetch('title')
+          link = issue_data.fetch('html_url')
+
+          issue_class.new(number, title, link)
+        end
+      end
+
+      def link
+        "https://github.com/#{@repository.owner}/#{@repository.repo}/issues/#{@issue_number}"
+      end
+    end
+  end
+end

data/lib/geet/git_hub/pr.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'abstract_issue'
+
+module Geet
+  module GitHub
+    class PR < AbstractIssue
+      def self.create(repository, title, description, head, api_helper)
+        request_address = "#{api_helper.repo_link}/pulls"
+        request_data = { title: title, body: description, head: head, base: 'master' }
+
+        response = api_helper.send_request(request_address, data: request_data)
+
+        issue_number = response.fetch('number')
+
+        new(repository, issue_number, api_helper)
+      end
+
+      def link
+        "https://github.com/#{@repository.owner}/#{@repository.repo}/pull/#{@issue_number}"
+      end
+
+      def request_review(reviewers)
+        request_data = { reviewers: reviewers }
+        request_address = "#{@api_helper.repo_link}/pulls/#{@issue_number}/requested_reviewers"
+
+        @api_helper.send_request(request_address, data: request_data)
+      end
+    end
+  end
+end

data/lib/geet/git_hub/remote_repository.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'api_helper.rb'
+require_relative 'issue'
+require_relative 'pr.rb'
+
+module Geet
+  module GitHub
+    class RemoteRepository
+      def initialize(local_repository, api_helper)
+        @local_repository = local_repository
+        @api_helper = api_helper
+      end
+
+      def collaborators
+        url = "https://api.github.com/repos/#{@local_repository.owner}/#{@local_repository.repo}/collaborators"
+        response = @api_helper.send_request(url, multipage: true)
+
+        response.map { |user_entry| user_entry.fetch('login') }
+      end
+
+      def labels
+        url = "https://api.github.com/repos/#{@local_repository.owner}/#{@local_repository.repo}/labels"
+        response = @api_helper.send_request(url, multipage: true)
+
+        response.map { |label_entry| label_entry['name'] }
+      end
+
+      def create_issue(title, description)
+        Geet::GitHub::Issue.create(@local_repository, title, description, @api_helper)
+      end
+
+      def list_issues
+        Geet::GitHub::Issue.list(@local_repository, @api_helper)
+      end
+
+      def create_pr(title, description, head: @local_repository.current_head)
+        Geet::GitHub::PR.create(@local_repository, title, description, head, @api_helper)
+      end
+    end
+  end
+end