geet 0.3.0 → 0.3.1

data/lib/geet/services/list_issues.rb

@@ -3,12 +3,16 @@
 module Geet
   module Services
     class ListIssues
-      def execute(repository, assignee_pattern: nil, output: $stdout, **)
-        assignee_thread = find_assignee(repository, assignee_pattern, output) if assignee_pattern
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def execute(assignee_pattern: nil, output: $stdout, **)
+        assignee_thread = find_assignee(assignee_pattern, output) if assignee_pattern
 
         assignee = assignee_thread&.join&.value
 
-        issues = repository.issues(assignee: assignee)
+        issues = @repository.issues(assignee: assignee)
 
         issues.each do |issue|
           output.puts "#{issue.number}. #{issue.title} (#{issue.link})"
@@ -17,11 +21,11 @@ module Geet
 
       private
 
-      def find_assignee(repository, assignee_pattern, output)
+      def find_assignee(assignee_pattern, output)
         output.puts 'Finding assignee...'
 
         Thread.new do
-          collaborators = repository.collaborators
+          collaborators = @repository.collaborators
           collaborator = collaborators.find { |collaborator| collaborator =~ /#{assignee_pattern}/i }
           collaborator || raise("No collaborator found for pattern: #{assignee_pattern.inspect}")
         end

data/lib/geet/services/list_labels.rb

@@ -3,8 +3,12 @@
 module Geet
   module Services
     class ListLabels
-      def execute(repository, output: $stdout)
-        labels = repository.labels
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def execute(output: $stdout)
+        labels = @repository.labels
 
         labels.each do |label|
           output.puts "- #{label.name} (##{label.color})"

data/lib/geet/services/list_milestones.rb

@@ -3,9 +3,13 @@
 module Geet
   module Services
     class ListMilestones
-      def execute(repository, output: $stdout)
-        milestones = find_milestones(repository, output)
-        issues_by_milestone_number = find_milestone_issues(repository, milestones, output)
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def execute(output: $stdout)
+        milestones = find_milestones(output)
+        issues_by_milestone_number = find_milestone_issues(milestones, output)
 
         output.puts
 
@@ -30,13 +34,13 @@ module Geet
         description
       end
 
-      def find_milestones(repository, output)
+      def find_milestones(output)
         output.puts 'Finding milestones...'
 
-        repository.milestones
+        @repository.milestones
       end
 
-      def find_milestone_issues(repository, milestones, output)
+      def find_milestone_issues(milestones, output)
         output.puts 'Finding issues...'
 
         # Interestingly, on MRI, concurrent hash access is not a problem without mutex,
@@ -46,7 +50,7 @@ module Geet
 
         issue_threads = milestones.map do |milestone|
           Thread.new do
-            issues = repository.abstract_issues(milestone: milestone.number)
+            issues = @repository.abstract_issues(milestone: milestone.number)
 
             mutex.synchronize do
               issues_by_milestone_number[milestone.number] = issues

data/lib/geet/services/list_prs.rb

@@ -3,8 +3,12 @@
 module Geet
   module Services
     class ListPrs
-      def execute(repository, output: $stdout)
-        prs = repository.prs
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def execute(output: $stdout)
+        prs = @repository.prs
 
         prs.each do |pr|
           output.puts "#{pr.number}. #{pr.title} (#{pr.link})"

data/lib/geet/services/merge_pr.rb

@@ -3,25 +3,32 @@
 module Geet
   module Services
     class MergePr
-      def execute(repository, delete_branch: false, output: $stdout)
-        merge_head = find_merge_head(repository)
-        pr = checked_find_branch_pr(repository, merge_head, output)
+      DEFAULT_GIT_CLIENT = Geet::Utils::GitClient.new
+
+      def initialize(repository, git_client: DEFAULT_GIT_CLIENT)
+        @repository = repository
+        @git_client = git_client
+      end
+
+      def execute(delete_branch: false, output: $stdout)
+        merge_head = find_merge_head
+        pr = checked_find_branch_pr(merge_head, output)
         merge_pr(pr, output)
-        do_delete_branch(repository, output) if delete_branch
+        do_delete_branch(output) if delete_branch
         pr
       end
 
       private
 
-      def find_merge_head(repository)
-        repository.current_branch
+      def find_merge_head
+        @git_client.current_branch
       end
 
       # Expect to find only one.
-      def checked_find_branch_pr(repository, head, output)
+      def checked_find_branch_pr(head, output)
         output.puts "Finding PR with head (#{head})..."
 
-        prs = repository.prs(head: head)
+        prs = @repository.prs(head: head)
 
         raise "Expected to find only one PR for the current branch; found: #{prs.size}" if prs.size != 1
 
@@ -34,10 +41,10 @@ module Geet
         pr.merge
       end
 
-      def do_delete_branch(repository, output)
-        output.puts "Deleting branch #{repository.current_branch}..."
+      def do_delete_branch(output)
+        output.puts "Deleting branch #{@git_client.current_branch}..."
 
-        repository.delete_branch(repository.current_branch)
+        @repository.delete_branch(@git_client.current_branch)
       end
     end
   end

data/lib/geet/utils/git_client.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require_relative '../helpers/os_helper.rb'
+
+module Geet
+  module Utils
+    # Represents the git program interface; used for performing git operations.
+    #
+    class GitClient
+      include Geet::Helpers::OsHelper
+
+      ORIGIN_NAME   = 'origin'
+      UPSTREAM_NAME = 'upstream'
+
+      # For simplicity, we match any character except the ones the separators.
+      REMOTE_ORIGIN_REGEX = %r{
+        \A
+        (?:https://(.+?)/|git@(.+?):)
+        ([^/]+/.*?)
+        (?:\.git)?
+        \Z
+      }x
+
+      UPSTREAM_BRANCH_REGEX = %r{\A[^/]+/([^/]+)\Z}
+
+      CLEAN_TREE_MESSAGE_REGEX = /^nothing to commit, working tree clean$/
+
+      def initialize(location: nil)
+        @location = location
+      end
+
+      ##########################################################################
+      # BRANCH/TREE APIS
+      ##########################################################################
+
+      # Return the commit shas between HEAD and `limit`, excluding the already applied commits
+      # (which start with `-`)
+      #
+      def cherry(limit)
+        raw_commits = execute_command("git #{gitdir_option} cherry #{limit.shellescape}")
+
+        raw_commits.split("\n").grep(/^\+/).map { |line| line[3..-1] }
+      end
+
+      def current_branch
+        branch = execute_command("git #{gitdir_option} rev-parse --abbrev-ref HEAD")
+
+        raise "Couldn't find current branch" if branch == 'HEAD'
+
+        branch
+      end
+
+      # Not to be confused with `upstream` repository!
+      #
+      # return: nil, if the upstream branch is not configured.
+      #
+      def upstream_branch
+        head_symbolic_ref = execute_command("git #{gitdir_option} symbolic-ref -q HEAD")
+
+        raw_upstream_branch = execute_command("git #{gitdir_option} for-each-ref --format='%(upstream:short)' #{head_symbolic_ref.shellescape}").strip
+
+        if raw_upstream_branch != ''
+          raw_upstream_branch[UPSTREAM_BRANCH_REGEX, 1] || raise("Unexpected upstream format: #{raw_upstream_branch}")
+        else
+          nil
+        end
+      end
+
+      def working_tree_clean?
+        git_message = execute_command("git #{gitdir_option} status")
+
+        !!(git_message =~ CLEAN_TREE_MESSAGE_REGEX)
+      end
+
+      ##########################################################################
+      # COMMIT/OBJECT APIS
+      ##########################################################################
+
+      # Show the description ("<subject>\n\n<body>") for the given git object.
+      #
+      def show_description(object)
+        execute_command("git #{gitdir_option} show --quiet --format='%s\n\n%b' #{object.shellescape}")
+      end
+
+      ##########################################################################
+      # REPOSITORY/REMOTE APIS
+      ##########################################################################
+
+      # Example: `donaldduck/geet`
+      #
+      def path(upstream: false)
+        remote_name = upstream ? UPSTREAM_NAME : ORIGIN_NAME
+
+        remote(remote_name)[REMOTE_ORIGIN_REGEX, 3]
+      end
+
+      def provider_domain
+        # We assume that it's not possible to have origin and upstream on different providers.
+        #
+        remote_url = remote(ORIGIN_NAME)
+
+        domain = remote_url[REMOTE_ORIGIN_REGEX, 1] || remote_url[REMOTE_ORIGIN_REGEX, 2]
+
+        raise "Can't identify domain in the provider domain string: #{domain}" if domain !~ /(.*)\.\w+/
+
+        domain
+      end
+
+      # Returns the URL of the remote with the given name.
+      # Sanity checks are performed.
+      #
+      # The result is in the format `git@github.com:donaldduck/geet.git`
+      #
+      def remote(name)
+        remote_url = execute_command("git #{gitdir_option} ls-remote --get-url #{name}")
+
+        if remote_url == name
+          raise "Remote #{name.inspect} not found!"
+        elsif remote_url !~ REMOTE_ORIGIN_REGEX
+          raise "Unexpected remote reference format: #{remote_url.inspect}"
+        end
+
+        remote_url
+      end
+
+      # Doesn't sanity check for the remote url format; this action is for querying
+      # purposes, any any action that needs to work with the remote, uses #remote.
+      #
+      def remote_defined?(name)
+        remote_url = execute_command("git #{gitdir_option} ls-remote --get-url #{name}")
+
+        # If the remote is not define, `git ls-remote` will return the passed value.
+        remote_url != name
+      end
+
+      ##########################################################################
+      # OPERATION APIS
+      ##########################################################################
+
+      # upstream_branch: create an upstream branch.
+      #
+      def push(upstream_branch: nil)
+        upstream_branch_option = "-u origin #{upstream_branch.shellescape}" if upstream_branch
+
+        execute_command("git #{gitdir_option} push #{upstream_branch_option}")
+      end
+
+      ##########################################################################
+      # INTERNAL HELPERS
+      ##########################################################################
+
+      private
+
+      def gitdir_option
+        "--git-dir #{@location.shellescape}/.git" if @location
+      end
+    end
+  end
+end

data/lib/geet/utils/manual_list_selection.rb

@@ -5,41 +5,59 @@ require 'temp-fork-tp-filter'
 module Geet
   module Utils
     class ManualListSelection
-      PAGER_SIZE = 16
+      NO_SELECTION_KEY = '(none)'
 
-      PROMPT_METHODS = {
-        single: :select,
-        multiple: :multi_select,
-      }
+      PAGER_SIZE = 16
 
-      # selection_type: :single or :multiple
+      # entry_type:      description of the entries type.
+      # entries:         array of objects; if they're not strings, must also pass :instance_method.
+      #                  this value must not be empty.
+      # selection_type:  :single or :multiple
+      # instance_method: required when non-string objects are passed as entries; its invocation on
+      #                  each object must return a string, which is used as key.
+      #
+      # returns: the selected entry or array of entries. for single selection, if no entries are
+      #          chosen, nil is returned.
+      #
       def select(entry_type, entries, selection_type, instance_method: nil)
-        raise "No #{entry_type} provided!" if entries.empty?
+        check_entries(entries)
 
-        prompt_method = find_prompt_method(selection_type)
-        prompt_title = "Please select the #{entry_type}(s):"
+        entries = create_entries_map(entries, instance_method)
+
+        result = show_prompt(entry_type, selection_type, entries)
+
+        result
+      end
+
+      private
 
-        if instance_method
-          entries = entries.each_with_object({}) do |entry, current_map|
-            current_map[entry.send(instance_method)] = entry
-          end
+      def check_entries(entries)
+        raise "No #{entry_type} provided!" if entries.empty?
+      end
+
+      def create_entries_map(entries, instance_method)
+        entries.each_with_object({}) do |entry, current_map|
+          key = instance_method ? entry.send(instance_method) : entry
+          current_map[key] = entry
         end
+      end
 
-        selected_entries = TTY::Prompt.new.send(prompt_method, prompt_title, entries, filter: true, per_page: PAGER_SIZE)
+      def show_prompt(entry_type, selection_type, entries)
+        prompt_title = "Please select the #{entry_type}(s):"
 
-        if selected_entries.is_a?(Array)
-          raise "No #{entry_type} selected!" if selected_entries.empty?
+        case selection_type
+        when :single
+          entries = add_no_selection_entry(entries)
+          TTY::Prompt.new.select(prompt_title, entries, filter: true, per_page: PAGER_SIZE)
+        when :multiple
+          TTY::Prompt.new.multi_select(prompt_title, entries, filter: true, per_page: PAGER_SIZE)
         else
-          raise "No #{entry_type} selected!" if selected_entries.nil?
+          raise "Unexpected selection type: #{selection_type.inspect}"
         end
-
-        selected_entries
       end
 
-      private
-
-      def find_prompt_method(selection_type)
-        PROMPT_METHODS[selection_type] || raise("Unrecognized selection_type: #{selection_type}")
+      def add_no_selection_entry(entries)
+        {NO_SELECTION_KEY => nil}.merge(entries)
       end
     end
   end

data/lib/geet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geet
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

data/spec/integration/create_gist_spec.rb

@@ -7,7 +7,6 @@ require_relative '../../lib/geet/git/repository'
 require_relative '../../lib/geet/services/create_gist'
 
 describe Geet::Services::CreateGist do
-  let(:repository) { Geet::Git::Repository.new }
   let(:tempfile) { Tempfile.open('geet_gist') { |file| file << 'testcontent' } }
 
   it 'should create a public gist' do
@@ -20,8 +19,7 @@ describe Geet::Services::CreateGist do
 
     VCR.use_cassette('create_gist_public') do
       described_class.new.execute(
-        repository, tempfile.path,
-        description: 'testdescription', publik: true, no_browse: true, output: actual_output
+        tempfile.path, description: 'testdescription', publik: true, no_browse: true, output: actual_output
       )
     end
 
@@ -38,8 +36,7 @@ describe Geet::Services::CreateGist do
 
     VCR.use_cassette('create_gist_private') do
       described_class.new.execute(
-        repository, tempfile.path,
-        description: 'testdescription', no_browse: true, output: actual_output
+        tempfile.path, description: 'testdescription', no_browse: true, output: actual_output
       )
     end
 

data/spec/integration/create_issue_spec.rb

@@ -6,12 +6,13 @@ require_relative '../../lib/geet/git/repository'
 require_relative '../../lib/geet/services/create_issue'
 
 describe Geet::Services::CreateIssue do
-  let(:repository) { Geet::Git::Repository.new }
-  let(:upstream_repository) { Geet::Git::Repository.new(upstream: true) }
+  let(:git_client) { Geet::Utils::GitClient.new }
+  let(:repository) { Geet::Git::Repository.new(git_client: git_client) }
+  let(:upstream_repository) { Geet::Git::Repository.new(upstream: true, git_client: git_client) }
 
   context 'with labels, assignees and milestones' do
     it 'should create an issue' do
-      allow(repository).to receive(:remote).with('origin').and_return('git@github.com:donaldduck/testrepo')
+      allow(git_client).to receive(:remote).with('origin').and_return('git@github.com:donaldduck/testrepo')
 
       expected_output = <<~STR
         Finding labels...
@@ -27,8 +28,8 @@ describe Geet::Services::CreateIssue do
       actual_output = StringIO.new
 
       actual_created_issue = VCR.use_cassette('create_issue') do
-        described_class.new.execute(
-          repository, 'Title', 'Description',
+        described_class.new(repository).execute(
+          'Title', 'Description',
           label_patterns: 'bug,invalid', milestone_pattern: '0.0.1', assignee_patterns: 'nald-ts,nald-fr',
           no_open_issue: true, output: actual_output
         )
@@ -43,13 +44,12 @@ describe Geet::Services::CreateIssue do
   end
 
   it 'should create an upstream issue' do
-    allow(upstream_repository).to receive(:current_branch).and_return('mybranch')
-    allow(upstream_repository).to receive(:remote).with('origin').and_return('git@github.com:donaldduck/testrepo')
-    allow(upstream_repository).to receive(:remote).with('upstream').and_return('git@github.com:donald-fr/testrepo_u')
+    allow(git_client).to receive(:current_branch).and_return('mybranch')
+    allow(git_client).to receive(:remote).with('origin').and_return('git@github.com:donaldduck/testrepo')
+    allow(git_client).to receive(:remote).with('upstream').and_return('git@github.com:donald-fr/testrepo_u')
 
     expected_output = <<~STR
       Creating the issue...
-      Assigning authenticated user...
       Issue address: https://github.com/donald-fr/testrepo_u/issues/7
     STR
 
@@ -57,7 +57,7 @@ describe Geet::Services::CreateIssue do
 
     actual_created_issue = VCR.use_cassette('create_issue_upstream') do
       create_options = { no_open_issue: true, output: actual_output }
-      described_class.new.execute(upstream_repository, 'Title', 'Description', create_options)
+      described_class.new(upstream_repository).execute('Title', 'Description', create_options)
     end
 
     expect(actual_output.string).to eql(expected_output)