modulesync 2.1.0 → 2.3.0

data/lib/modulesync/git_service/base.rb

@@ -0,0 +1,63 @@
+module ModuleSync
+  module GitService
+    # Generic class for git services
+    class Base
+      def open_pull_request(repo_path:, namespace:, title:, message:, source_branch:, target_branch:, labels:, noop:) # rubocop:disable Metrics/ParameterLists
+        unless source_branch != target_branch
+          raise ModuleSync::Error,
+                "Unable to open a pull request with the same source and target branch: '#{source_branch}'"
+        end
+
+        _open_pull_request(
+          repo_path: repo_path,
+          namespace: namespace,
+          title: title,
+          message: message,
+          source_branch: source_branch,
+          target_branch: target_branch,
+          labels: labels,
+          noop: noop,
+        )
+      end
+
+      # This method attempts to guess the git service endpoint based on remote
+      def self.guess_endpoint_from(remote:)
+        hostname = extract_hostname(remote)
+        return nil if hostname.nil?
+
+        "https://#{hostname}"
+      end
+
+      # This method extracts hostname from URL like:
+      #
+      # - ssh://[user@]host.xz[:port]/path/to/repo.git/
+      # - git://host.xz[:port]/path/to/repo.git/
+      # - [user@]host.xz:path/to/repo.git/
+      # - http[s]://host.xz[:port]/path/to/repo.git/
+      # - ftp[s]://host.xz[:port]/path/to/repo.git/
+      #
+      # Returns nil if
+      # - /path/to/repo.git/
+      # - file:///path/to/repo.git/
+      # - any invalid URL
+      def self.extract_hostname(url)
+        return nil if url.start_with?('/') || url.start_with?('file://') # local path (e.g. file:///path/to/repo)
+
+        unless url.start_with?(%r{[a-z]+://}) # SSH notation does not contain protocol (e.g. user@server:path/to/repo/)
+          pattern = /^(?<user>.*@)?(?<hostname>[\w|.]*):(?<repo>.*)$/ # SSH path (e.g. user@server:repo)
+          return url.match(pattern)[:hostname] if url.match?(pattern)
+        end
+
+        URI.parse(url).host
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      protected
+
+      def _open_pull_request(repo_path:, namespace:, title:, message:, source_branch:, target_branch:, labels:, noop:) # rubocop:disable Metrics/ParameterLists
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/modulesync/git_service/factory.rb

@@ -0,0 +1,28 @@
+module ModuleSync
+  module GitService
+    # Git service's factory
+    module Factory
+      def self.instantiate(type:, endpoint:, token:)
+        raise MissingCredentialsError, <<~MESSAGE if token.nil?
+          A token is required to use services from #{type}:
+            Please set environment variable: "#{type.upcase}_TOKEN" or set the token entry in module options.
+        MESSAGE
+
+        klass(type: type).new token, endpoint
+      end
+
+      def self.klass(type:)
+        case type
+        when :github
+          require 'modulesync/git_service/github'
+          ModuleSync::GitService::GitHub
+        when :gitlab
+          require 'modulesync/git_service/gitlab'
+          ModuleSync::GitService::GitLab
+        else
+          raise NotImplementedError, "Unknown git service: '#{type}'"
+        end
+      end
+    end
+  end
+end

data/lib/modulesync/{pr → git_service}/github.rb

@@ -1,28 +1,30 @@
+require 'modulesync/git_service'
+require 'modulesync/git_service/base'
 require 'octokit'
-require 'modulesync/util'
 
 module ModuleSync
-  module PR
+  module GitService
     # GitHub creates and manages pull requests on github.com or GitHub
     # Enterprise installations.
-    class GitHub
+    class GitHub < Base
       def initialize(token, endpoint)
+        super()
+
         Octokit.configure do |c|
           c.api_endpoint = endpoint
         end
         @api = Octokit::Client.new(:access_token => token)
       end
 
-      def manage(namespace, module_name, options)
-        repo_path = File.join(namespace, module_name)
-        branch = options[:remote_branch] || options[:branch]
-        head = "#{namespace}:#{branch}"
-        target_branch = options[:pr_target_branch] || 'master'
+      private
+
+      def _open_pull_request(repo_path:, namespace:, title:, message:, source_branch:, target_branch:, labels:, noop:) # rubocop:disable Metrics/ParameterLists
+        head = "#{namespace}:#{source_branch}"
 
-        if options[:noop]
+        if noop
           $stdout.puts \
-            "Using no-op. Would submit PR '#{options[:pr_title]}' to #{repo_path} " \
-            "- merges #{branch} into #{target_branch}"
+            "Using no-op. Would submit PR '#{title}' to '#{repo_path}' " \
+            "- merges '#{source_branch}' into '#{target_branch}'"
           return
         end
 
@@ -32,25 +34,25 @@ module ModuleSync
                                            :head => head)
         unless pull_requests.empty?
           # Skip creating the PR if it exists already.
-          $stdout.puts "Skipped! #{pull_requests.length} PRs found for branch #{branch}"
+          $stdout.puts "Skipped! #{pull_requests.length} PRs found for branch '#{source_branch}'"
           return
         end
 
-        pr_labels = ModuleSync::Util.parse_list(options[:pr_labels])
         pr = @api.create_pull_request(repo_path,
                                       target_branch,
-                                      branch,
-                                      options[:pr_title],
-                                      options[:message])
+                                      source_branch,
+                                      title,
+                                      message)
         $stdout.puts \
-          "Submitted PR '#{options[:pr_title]}' to #{repo_path} " \
-          "- merges #{branch} into #{target_branch}"
+          "Submitted PR '#{title}' to '#{repo_path}' " \
+          "- merges #{source_branch} into #{target_branch}"
 
         # We only assign labels to the PR if we've discovered a list > 1. The labels MUST
         # already exist. We DO NOT create missing labels.
-        return if pr_labels.empty?
-        $stdout.puts "Attaching the following labels to PR #{pr['number']}: #{pr_labels.join(', ')}"
-        @api.add_labels_to_an_issue(repo_path, pr['number'], pr_labels)
+        return if labels.empty?
+
+        $stdout.puts "Attaching the following labels to PR #{pr['number']}: #{labels.join(', ')}"
+        @api.add_labels_to_an_issue(repo_path, pr['number'], labels)
       end
     end
   end

data/lib/modulesync/git_service/gitlab.rb

@@ -0,0 +1,62 @@
+require 'gitlab'
+require 'modulesync/git_service'
+require 'modulesync/git_service/base'
+
+module ModuleSync
+  module GitService
+    # GitLab creates and manages merge requests on gitlab.com or private GitLab
+    # installations.
+    class GitLab < Base
+      def initialize(token, endpoint)
+        super()
+
+        @api = Gitlab::Client.new(
+          :endpoint => endpoint,
+          :private_token => token,
+        )
+      end
+
+      def self.guess_endpoint_from(remote:)
+        endpoint = super
+        return nil if endpoint.nil?
+
+        endpoint += '/api/v4'
+        endpoint
+      end
+
+      private
+
+      def _open_pull_request(repo_path:, namespace:, title:, message:, source_branch:, target_branch:, labels:, noop:) # rubocop:disable Metrics/ParameterLists, Lint/UnusedMethodArgument
+        if noop
+          $stdout.puts \
+            "Using no-op. Would submit MR '#{title}' to '#{repo_path}' " \
+            "- merges #{source_branch} into #{target_branch}"
+          return
+        end
+
+        merge_requests = @api.merge_requests(repo_path,
+                                             :state => 'opened',
+                                             :source_branch => source_branch,
+                                             :target_branch => target_branch)
+        unless merge_requests.empty?
+          # Skip creating the MR if it exists already.
+          $stdout.puts "Skipped! #{merge_requests.length} MRs found for branch '#{source_branch}'"
+          return
+        end
+
+        mr = @api.create_merge_request(repo_path,
+                                       title,
+                                       :source_branch => source_branch,
+                                       :target_branch => target_branch,
+                                       :labels => labels)
+        $stdout.puts \
+          "Submitted MR '#{title}' to '#{repo_path}' " \
+          "- merges '#{source_branch}' into '#{target_branch}'"
+
+        return if labels.empty?
+
+        $stdout.puts "Attached the following labels to MR #{mr.iid}: #{labels.join(', ')}"
+      end
+    end
+  end
+end

data/lib/modulesync/git_service.rb

@@ -0,0 +1,96 @@
+module ModuleSync
+  class Error < StandardError; end
+
+  # Namespace for Git service classes (ie. GitHub, GitLab)
+  module GitService
+    class MissingCredentialsError < Error; end
+
+    class UnguessableTypeError < Error; end
+
+    def self.configuration_for(sourcecode:)
+      type = type_for(sourcecode: sourcecode)
+
+      {
+        type: type,
+        endpoint: endpoint_for(sourcecode: sourcecode, type: type),
+        token: token_for(sourcecode: sourcecode, type: type),
+      }
+    end
+
+    # This method attempts to guess git service's type (ie. gitlab or github)
+    # It process in this order
+    #   1. use module specific configuration entry (ie. a specific entry named `gitlab` or `github`)
+    #   2. guess using remote url (ie. looking for `github` or `gitlab` string)
+    #   3. use environment variables (ie. check if GITHUB_TOKEN or GITLAB_TOKEN is set)
+    #   4. fail
+    def self.type_for(sourcecode:)
+      return :github unless sourcecode.options[:github].nil?
+      return :gitlab unless sourcecode.options[:gitlab].nil?
+      return :github if sourcecode.repository_remote.include? 'github'
+      return :gitlab if sourcecode.repository_remote.include? 'gitlab'
+
+      if ENV['GITLAB_TOKEN'].nil? && ENV['GITHUB_TOKEN'].nil?
+        raise UnguessableTypeError, <<~MESSAGE
+          Unable to guess Git service type without GITLAB_TOKEN or GITHUB_TOKEN sets.
+        MESSAGE
+      end
+
+      unless ENV['GITLAB_TOKEN'].nil? || ENV['GITHUB_TOKEN'].nil?
+        raise UnguessableTypeError, <<~MESSAGE
+          Unable to guess Git service type with both GITLAB_TOKEN and GITHUB_TOKEN sets.
+
+          Please set the wanted one in configuration (ie. add `gitlab:` or `github:` key)
+        MESSAGE
+      end
+
+      return :github unless ENV['GITHUB_TOKEN'].nil?
+      return :gitlab unless ENV['GITLAB_TOKEN'].nil?
+
+      raise NotImplementedError
+    end
+
+    # This method attempts to find git service's endpoint based on sourcecode and type
+    # It process in this order
+    #   1. use module specific configuration (ie. `base_url`)
+    #   2. use environment variable dependending on type (e.g. GITLAB_BASE_URL)
+    #   3. guess using the git remote url
+    #   4. fail
+    def self.endpoint_for(sourcecode:, type:)
+      endpoint = sourcecode.options.dig(type, :base_url)
+
+      endpoint ||= case type
+                   when :github
+                     ENV['GITHUB_BASE_URL']
+                   when :gitlab
+                     ENV['GITLAB_BASE_URL']
+                   end
+
+      endpoint ||= GitService::Factory.klass(type: type).guess_endpoint_from(remote: sourcecode.repository_remote)
+
+      raise NotImplementedError, <<~MESSAGE if endpoint.nil?
+        Unable to guess endpoint for remote: '#{sourcecode.repository_remote}'
+        Please provide `base_url` option in configuration file
+      MESSAGE
+
+      endpoint
+    end
+
+    # This method attempts to find the token associated to provided sourcecode and type
+    # It process in this order:
+    #   1. use module specific configuration (ie. `token`)
+    #   2. use environment variable depending on type (e.g. GITLAB_TOKEN)
+    #   3. fail
+    def self.token_for(sourcecode:, type:)
+      token = sourcecode.options.dig(type, :token)
+
+      token ||= case type
+                when :github
+                  ENV['GITHUB_TOKEN']
+                when :gitlab
+                  ENV['GITLAB_TOKEN']
+                end
+
+      token
+    end
+  end
+end

data/lib/modulesync/hook.rb

@@ -6,20 +6,20 @@ module ModuleSync
 
     def initialize(hook_file, options = [])
       @hook_file = hook_file
-      @namespace = options['namespace']
-      @branch = options['branch']
-      @args = options['hook_args']
+      @namespace = options[:namespace]
+      @branch = options[:branch]
+      @args = options[:hook_args]
     end
 
     def content(arguments)
-      <<-CONTENT
-#!/usr/bin/env bash
+      <<~CONTENT
+        #!/usr/bin/env bash
 
-current_branch=\`git symbolic-ref HEAD | sed -e 's,.*/\(.*\),\1,'\`
-git_dir=\`git rev-parse --show-toplevel\`
-message=\`git log -1 --format=%B\`
-msync -m "\$message" #{arguments}
-CONTENT
+        current_branch=\`git symbolic-ref HEAD | sed -e 's,.*/\(.*\),\1,'\`
+        git_dir=\`git rev-parse --show-toplevel\`
+        message=\`git log -1 --format=%B\`
+        msync -m "\$message" #{arguments}
+      CONTENT
     end
 
     def activate
@@ -28,9 +28,7 @@ CONTENT
       hook_args << "-b #{branch}" if branch
       hook_args << args if args
 
-      File.open(hook_file, 'w') do |file|
-        file.write(content(hook_args.join(' ')))
-      end
+      File.write(hook_file, content(hook_args.join(' ')))
     end
 
     def deactivate

data/lib/modulesync/renderer.rb

@@ -12,7 +12,7 @@ module ModuleSync
 
     def self.build(target_name)
       template_file = if !File.exist?("#{target_name}.erb") && File.exist?(target_name)
-                        STDERR.puts "Warning: using '#{target_name}' as template without '.erb' suffix"
+                        $stderr.puts "Warning: using '#{target_name}' as template without '.erb' suffix"
                         target_name
                       else
                         "#{target_name}.erb"
@@ -32,11 +32,8 @@ module ModuleSync
     end
 
     def self.sync(template, target_name)
-      path = target_name.rpartition('/').first
-      FileUtils.mkdir_p(path) unless path.empty?
-      File.open(target_name, 'w') do |file|
-        file.write(template)
-      end
+      FileUtils.mkdir_p(File.dirname(target_name))
+      File.write(target_name, template)
     end
   end
 end

data/lib/modulesync/repository.rb

@@ -33,10 +33,11 @@ module ModuleSync
     def default_branch
       symbolic_ref = repo.branches.find { |b| b.full =~ %r{remotes/origin/HEAD} }
       return unless symbolic_ref
+
       %r{remotes/origin/HEAD\s+->\s+origin/(?<branch>.+?)$}.match(symbolic_ref.full)[:branch]
     end
 
-    def switch_branch(branch)
+    def switch(branch:)
       unless branch
         branch = default_branch
         puts "Using repository's default branch: #{branch}"
@@ -51,30 +52,61 @@ module ModuleSync
         repo.checkout("origin/#{branch}")
         repo.branch(branch).checkout
       else
-        repo.checkout('origin/master')
-        puts "Creating new branch #{branch}"
+        base_branch = default_branch
+        unless base_branch
+          puts "Couldn't detect default branch. Falling back to assuming 'master'"
+          base_branch = 'master'
+        end
+        puts "Creating new branch #{branch} from #{base_branch}"
+        repo.checkout("origin/#{base_branch}")
         repo.branch(branch).checkout
       end
     end
 
-    def prepare_workspace(branch)
-      # Repo needs to be cloned in the cwd
-      if !Dir.exist?("#{@directory}/.git")
-        puts 'Cloning repository fresh'
-        puts "Cloning from '#{@remote}'"
-        @git = Git.clone(@remote, @directory)
-        switch_branch(branch)
-      # Repo already cloned, check out master and override local changes
+    def cloned?
+      Dir.exist? File.join(@directory, '.git')
+    end
+
+    def clone
+      puts "Cloning from '#{@remote}'"
+      @git = Git.clone(@remote, @directory)
+    end
+
+    def prepare_workspace(branch:, operate_offline:)
+      if cloned?
+        puts "Overriding any local changes to repository in '#{@directory}'"
+        git.fetch 'origin', prune: true unless operate_offline
+        git.reset_hard
+        switch(branch: branch)
+        git.pull('origin', branch) if !operate_offline && remote_branch_exists?(branch)
       else
-        # Some versions of git can't properly handle managing a repo from outside the repo directory
-        Dir.chdir(@directory) do
-          puts "Overriding any local changes to repository in '#{@directory}'"
-          @git = Git.open('.')
-          repo.fetch
-          repo.reset_hard
-          switch_branch(branch)
-          git.pull('origin', branch) if remote_branch_exists?(branch)
-        end
+        raise ModuleSync::Error, 'Unable to clone in offline mode.' if operate_offline
+
+        clone
+        switch(branch: branch)
+      end
+    end
+
+    def default_reset_branch(branch)
+      remote_branch_exists?(branch) ? branch : default_branch
+    end
+
+    def reset_workspace(branch:, operate_offline:, source_branch: nil)
+      raise if branch.nil?
+
+      if cloned?
+        source_branch ||= "origin/#{default_reset_branch branch}"
+        puts "Hard-resetting any local changes to repository in '#{@directory}' from branch '#{source_branch}'"
+        switch(branch: branch)
+        git.fetch 'origin', prune: true unless operate_offline
+
+        git.reset_hard source_branch
+        git.clean(d: true, force: true)
+      else
+        raise ModuleSync::Error, 'Unable to clone in offline mode.' if operate_offline
+
+        clone
+        switch(branch: branch)
       end
     end
 
@@ -98,7 +130,7 @@ module ModuleSync
       files.each do |file|
         if repo.status.deleted.include?(file)
           repo.remove(file)
-        elsif File.exist?("#{@directory}/#{file}")
+        elsif File.exist? File.join(@directory, file)
           repo.add(file)
         end
       end
@@ -115,9 +147,11 @@ module ModuleSync
         if options[:remote_branch]
           if remote_branch_differ?(branch, options[:remote_branch])
             repo.push('origin', "#{branch}:#{options[:remote_branch]}", opts_push)
+            puts "Changes have been pushed to: '#{branch}:#{options[:remote_branch]}'"
           end
         else
           repo.push('origin', branch, opts_push)
+          puts "Changes have been pushed to: '#{branch}'"
         end
       rescue Git::GitExecuteError => e
         raise unless e.message.match?(/working (directory|tree) clean/)
@@ -129,11 +163,21 @@ module ModuleSync
       true
     end
 
+    def push(branch:, remote_branch:, remote_name: 'origin')
+      raise ModuleSync::Error, 'Repository must be locally available before trying to push' unless cloned?
+
+      remote_url = git.remote(remote_name).url
+      remote_branch ||= branch
+      puts "Push branch '#{branch}' to '#{remote_url}' (#{remote_name}/#{remote_branch})"
+
+      git.push(remote_name, "#{branch}:#{remote_branch}", force: true)
+    end
+
     # Needed because of a bug in the git gem that lists ignored files as
     # untracked under some circumstances
     # https://github.com/schacon/ruby-git/issues/130
     def untracked_unignored_files
-      ignore_path = "#{@directory}/.gitignore"
+      ignore_path = File.join @directory, '.gitignore'
       ignored = File.exist?(ignore_path) ? File.read(ignore_path).split : []
       repo.status.untracked.keep_if { |f, _| ignored.none? { |i| File.fnmatch(i, f) } }
     end
@@ -141,18 +185,24 @@ module ModuleSync
     def show_changes(options)
       checkout_branch(options[:branch])
 
-      puts 'Files changed:'
+      $stdout.puts 'Files changed:'
       repo.diff('HEAD', '--').each do |diff|
-        puts diff.patch
+        $stdout.puts diff.patch
       end
 
-      puts 'Files added:'
+      $stdout.puts 'Files added:'
       untracked_unignored_files.each_key do |file|
-        puts file
+        $stdout.puts file
       end
 
-      puts "\n\n"
-      puts '--------------------------------'
+      $stdout.puts "\n\n"
+      $stdout.puts '--------------------------------'
+
+      git.diff('HEAD', '--').any? || untracked_unignored_files.any?
+    end
+
+    def puts(*args)
+      $stdout.puts(*args) if ModuleSync.options[:verbose]
     end
   end
 end

data/lib/modulesync/settings.rb

@@ -1,4 +1,3 @@
-
 module ModuleSync
   # Encapsulate a configs for a module, providing easy access to its parts
   # All configs MUST be keyed by the relative target filename

data/lib/modulesync/source_code.rb

@@ -1,12 +1,13 @@
 require 'modulesync'
+require 'modulesync/git_service'
+require 'modulesync/git_service/factory'
 require 'modulesync/repository'
 require 'modulesync/util'
 
 module ModuleSync
   # Provide methods to retrieve source code attributes
   class SourceCode
-    attr_reader :given_name
-    attr_reader :options
+    attr_reader :given_name, :options
 
     def initialize(given_name, options)
       @options = Util.symbolize_keys(options || {})
@@ -47,6 +48,31 @@ module ModuleSync
       File.join(working_directory, *parts)
     end
 
+    def git_service
+      return nil if git_service_configuration.nil?
+
+      @git_service ||= GitService::Factory.instantiate(**git_service_configuration)
+    end
+
+    def git_service_configuration
+      @git_service_configuration ||= GitService.configuration_for(sourcecode: self)
+    rescue GitService::UnguessableTypeError
+      nil
+    end
+
+    def open_pull_request
+      git_service.open_pull_request(
+        repo_path: repository_path,
+        namespace: repository_namespace,
+        title: ModuleSync.options[:pr_title],
+        message: ModuleSync.options[:message],
+        source_branch: ModuleSync.options[:remote_branch] || ModuleSync.options[:branch] || repository.default_branch,
+        target_branch: ModuleSync.options[:pr_target_branch] || repository.default_branch,
+        labels: ModuleSync::Util.parse_list(ModuleSync.options[:pr_labels]),
+        noop: ModuleSync.options[:noop],
+      )
+    end
+
     private
 
     def _repository_remote

data/lib/modulesync/util.rb

@@ -3,9 +3,8 @@ require 'yaml'
 module ModuleSync
   module Util
     def self.symbolize_keys(hash)
-      hash.inject({}) do |memo, (k, v)|
+      hash.each_with_object({}) do |(k, v), memo|
         memo[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
-        memo
       end
     end
 
@@ -19,9 +18,10 @@ module ModuleSync
     end
 
     def self.parse_list(option_value)
-      if option_value.is_a? String
+      case option_value
+      when String
         option_value.split(',')
-      elsif option_value.is_a? Array
+      when Array
         option_value
       else
         []