modulesync 1.1.0 → 2.0.2

data/features/update/bad_context.feature

@@ -0,0 +1,26 @@
+Feature: Run `msync update` without a good context
+
+  Scenario: Run `msync update` without any module
+    Given a directory named "moduleroot"
+    When I run `msync update --message "In a bad context"`
+    Then the exit status should be 1
+    And the stderr should contain:
+      """
+      No modules found
+      """
+
+  Scenario: Run `msync update` without the "moduleroot" directory
+    Given a basic setup with a puppet module "puppet-test" from "fakenamespace"
+    When I run `msync update --message "In a bad context"`
+    Then the exit status should be 1
+    And the stderr should contain "moduleroot"
+
+  Scenario: Run `msync update` without commit message
+    Given a basic setup with a puppet module "puppet-test" from "fakenamespace"
+    And a directory named "moduleroot"
+    When I run `msync update`
+    Then the exit status should be 1
+    And the stderr should contain:
+      """
+      No value provided for required option "--message"
+      """

data/lib/modulesync.rb

@@ -1,5 +1,4 @@
 require 'fileutils'
-require 'octokit'
 require 'pathname'
 require 'modulesync/cli'
 require 'modulesync/constants'
@@ -10,12 +9,6 @@ require 'modulesync/settings'
 require 'modulesync/util'
 require 'monkey_patches'
 
-GITHUB_TOKEN = ENV.fetch('GITHUB_TOKEN', '')
-
-Octokit.configure do |c|
-  c.api_endpoint = ENV.fetch('GITHUB_BASE_URL', 'https://api.github.com')
-end
-
 module ModuleSync # rubocop:disable Metrics/ModuleLength
   include Constants
 
@@ -46,10 +39,10 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
           .collect { |p| p.chomp('.erb') }
           .to_a
     else
-      $stdout.puts "#{local_template_dir} does not exist." \
+      $stderr.puts "#{local_template_dir} does not exist." \
         ' Check that you are working in your module configs directory or' \
         ' that you have passed in the correct directory with -c.'
-      exit
+      exit 1
     end
   end
 
@@ -60,9 +53,9 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
   def self.managed_modules(config_file, filter, negative_filter)
     managed_modules = Util.parse_config(config_file)
     if managed_modules.empty?
-      $stdout.puts "No modules found in #{config_file}." \
+      $stderr.puts "No modules found in #{config_file}." \
         ' Check that you specified the right :configs directory and :managed_modules_conf file.'
-      exit
+      exit 1
     end
     managed_modules.select! { |m| m =~ Regexp.new(filter) } unless filter.nil?
     managed_modules.reject! { |m| m =~ Regexp.new(negative_filter) } unless negative_filter.nil?
@@ -112,7 +105,11 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
   end
 
   def self.manage_module(puppet_module, module_files, module_options, defaults, options)
-    namespace, module_name = module_name(puppet_module, options[:namespace])
+    default_namespace = options[:namespace]
+    if module_options.is_a?(Hash) && module_options.key?(:namespace)
+      default_namespace = module_options[:namespace]
+    end
+    namespace, module_name = module_name(puppet_module, default_namespace)
     git_repo = File.join(namespace, module_name)
     unless options[:offline]
       Git.pull(options[:git_base], git_repo, options[:branch], options[:project_root], module_options || {})
@@ -135,55 +132,39 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
 
     if options[:noop]
       Git.update_noop(git_repo, options)
+      options[:pr] && pr(module_options).manage(namespace, module_name, options)
     elsif !options[:offline]
-      # Git.update() returns a boolean: true if files were pushed, false if not.
       pushed = Git.update(git_repo, files_to_manage, options)
-      return nil unless pushed && options[:pr]
-
-      manage_pr(namespace, module_name, options)
+      pushed && options[:pr] && pr(module_options).manage(namespace, module_name, options)
     end
   end
 
-  def self.manage_pr(namespace, module_name, options)
-    if options[:pr] && GITHUB_TOKEN.empty?
-      $stderr.puts 'Environment variable GITHUB_TOKEN must be set to use --pr!'
-      raise unless options[:skip_broken]
-    end
-
-    # We only do GitHub PR work if the GITHUB_TOKEN variable is set in the environment.
-    repo_path = File.join(namespace, module_name)
-    github = Octokit::Client.new(:access_token => GITHUB_TOKEN)
-
-    # Skip creating the PR if it exists already.
-    head = "#{namespace}:#{options[:branch]}"
-    pull_requests = github.pull_requests(repo_path, :state => 'open', :base => 'master', :head => head)
-    if pull_requests.empty?
-      pr = github.create_pull_request(repo_path, 'master', options[:branch], options[:pr_title], options[:message])
-      $stdout.puts "Submitted PR '#{options[:pr_title]}' to #{repo_path} - merges #{options[:branch]} into master"
-    else
-      $stdout.puts "Skipped! #{pull_requests.length} PRs found for branch #{options[:branch]}"
-    end
-
-    # PR labels can either be a list in the YAML file or they can pass in a comma
-    # separated list via the command line argument.
-    pr_labels = Util.parse_list(options[:pr_labels])
+  def self.config_path(file, options)
+    return file if Pathname.new(file).absolute?
+    File.join(options[:configs], file)
+  end
 
-    # 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(', ')}"
-    github.add_labels_to_an_issue(repo_path, pr['number'], pr_labels)
+  def config_path(file, options)
+    self.class.config_path(file, options)
   end
 
   def self.update(options)
     options = config_defaults.merge(options)
-    defaults = Util.parse_config(File.join(options[:configs], CONF_FILE))
+    defaults = Util.parse_config(config_path(CONF_FILE, options))
+    if options[:pr]
+      unless options[:branch]
+        $stderr.puts 'A branch must be specified with --branch to use --pr!'
+        raise
+      end
+
+      @pr = create_pr_manager if options[:pr]
+    end
 
-    local_template_dir = File.join(options[:configs], MODULE_FILES_DIR)
+    local_template_dir = config_path(MODULE_FILES_DIR, options)
     local_files = find_template_files(local_template_dir)
     module_files = relative_names(local_files, local_template_dir)
 
-    managed_modules = self.managed_modules(File.join(options[:configs], options[:managed_modules_conf]),
+    managed_modules = self.managed_modules(config_path(options[:managed_modules_conf], options),
                                            options[:filter],
                                            options[:negative_filter])
 
@@ -191,7 +172,8 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     # managed_modules is either an array or a hash
     managed_modules.each do |puppet_module, module_options|
       begin
-        manage_module(puppet_module, module_files, module_options, defaults, options)
+        mod_options = module_options.nil? ? nil : Util.symbolize_keys(module_options)
+        manage_module(puppet_module, module_files, mod_options, defaults, options)
       rescue # rubocop:disable Lint/RescueWithoutErrorClass
         $stderr.puts "Error while updating #{puppet_module}"
         raise unless options[:skip_broken]
@@ -201,4 +183,40 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     end
     exit 1 if errors && options[:fail_on_warnings]
   end
+
+  def self.pr(module_options)
+    module_options ||= {}
+    github_conf = module_options[:github]
+    gitlab_conf = module_options[:gitlab]
+
+    if !github_conf.nil?
+      base_url = github_conf[:base_url] || ENV.fetch('GITHUB_BASE_URL', 'https://api.github.com')
+      require 'modulesync/pr/github'
+      ModuleSync::PR::GitHub.new(github_conf[:token], base_url)
+    elsif !gitlab_conf.nil?
+      base_url = gitlab_conf[:base_url] || ENV.fetch('GITLAB_BASE_URL', 'https://gitlab.com/api/v4')
+      require 'modulesync/pr/gitlab'
+      ModuleSync::PR::GitLab.new(gitlab_conf[:token], base_url)
+    elsif @pr.nil?
+      $stderr.puts 'No GitHub or GitLab token specified for --pr!'
+      raise
+    else
+      @pr
+    end
+  end
+
+  def self.create_pr_manager
+    github_token = ENV.fetch('GITHUB_TOKEN', '')
+    gitlab_token = ENV.fetch('GITLAB_TOKEN', '')
+
+    if !github_token.empty?
+      require 'modulesync/pr/github'
+      ModuleSync::PR::GitHub.new(github_token, ENV.fetch('GITHUB_BASE_URL', 'https://api.github.com'))
+    elsif !gitlab_token.empty?
+      require 'modulesync/pr/gitlab'
+      ModuleSync::PR::GitLab.new(gitlab_token, ENV.fetch('GITLAB_BASE_URL', 'https://gitlab.com/api/v4'))
+    else
+      warn '--pr specified without environment variables GITHUB_TOKEN or GITLAB_TOKEN'
+    end
+  end
 end

data/lib/modulesync/cli.rb

@@ -1,10 +1,12 @@
 require 'thor'
+
 require 'modulesync'
+require 'modulesync/cli/thor'
 require 'modulesync/constants'
 require 'modulesync/util'
 
 module ModuleSync
-  class CLI
+  module CLI
     def self.defaults
       @defaults ||= Util.symbolize_keys(Util.parse_config(Constants::MODULESYNC_CONF_FILE))
     end
@@ -36,15 +38,14 @@ module ModuleSync
     class Base < Thor
       class_option :project_root,
                    :aliases => '-c',
-                   :desc => 'Path used by git to clone modules into. Defaults to "modules"',
+                   :desc => 'Path used by git to clone modules into.',
                    :default => CLI.defaults[:project_root] || 'modules'
       class_option :git_base,
                    :desc => 'Specify the base part of a git URL to pull from',
                    :default => CLI.defaults[:git_base] || 'git@github.com:'
       class_option :namespace,
                    :aliases => '-n',
-                   :desc => 'Remote github namespace (user or organization) to clone from and push to.' \
-                              ' Defaults to puppetlabs',
+                   :desc => 'Remote github namespace (user or organization) to clone from and push to.',
                    :default => CLI.defaults[:namespace] || 'puppetlabs'
       class_option :filter,
                    :aliases => '-f',
@@ -67,6 +68,8 @@ module ModuleSync
              :aliases => '-c',
              :desc => 'The local directory or remote repository to define the list of managed modules,' \
                         ' the file templates, and the default values for template variables.'
+      option :managed_modules_conf,
+             :desc => 'The file name to define the list of managed modules'
       option :remote_branch,
              :aliases => '-r',
              :desc => 'Remote branch name to push the changes to. Defaults to the branch name.',
@@ -90,15 +93,18 @@ module ModuleSync
              :default => false
       option :pr,
              :type => :boolean,
-             :desc => 'Submit GitHub PR',
+             :desc => 'Submit pull/merge request',
              :default => false
       option :pr_title,
-             :desc => 'Title of GitHub PR',
+             :desc => 'Title of pull/merge request',
              :default => CLI.defaults[:pr_title] || 'Update to module template files'
       option :pr_labels,
              :type => :array,
-             :desc => 'Labels to add to the GitHub PR',
+             :desc => 'Labels to add to the pull/merge request',
              :default => CLI.defaults[:pr_labels] || []
+      option :pr_target_branch,
+             :desc => 'Target branch for the pull/merge request',
+             :default => CLI.defaults[:pr_target_branch] || 'master'
       option :offline,
              :type => :boolean,
              :desc => 'Do not run any Git commands. Allows the user to manage Git outside of ModuleSync.',

data/lib/modulesync/cli/thor.rb

@@ -0,0 +1,24 @@
+require 'thor'
+require 'modulesync/cli'
+
+module ModuleSync
+  module CLI
+    # Workaround some, still unfixed, Thor behaviors
+    #
+    # This class extends ::Thor class to
+    # - exit with status code sets to `1` on Thor failure (e.g. missing required option)
+    # - exit with status code sets to `1` when user calls `msync` (or a subcommand) without required arguments
+    class Thor < ::Thor
+      desc '_invalid_command_call', 'Invalid command', hide: true
+      def _invalid_command_call
+        self.class.new.help
+        exit 1
+      end
+      default_task :_invalid_command_call
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/modulesync/git.rb

@@ -150,7 +150,7 @@ module ModuleSync
           tag(repo, new, options[:tag_pattern]) if options[:tag]
         end
       rescue ::Git::GitExecuteError => git_error
-        if git_error.message =~ /working (directory|tree) clean/
+        if git_error.message.match?(/working (directory|tree) clean/)
           puts "There were no files to update in #{name}. Not committing."
           return false
         else

data/lib/modulesync/pr/github.rb

@@ -0,0 +1,57 @@
+require 'octokit'
+require 'modulesync/util'
+
+module ModuleSync
+  module PR
+    # GitHub creates and manages pull requests on github.com or GitHub
+    # Enterprise installations.
+    class GitHub
+      def initialize(token, endpoint)
+        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'
+
+        if options[:noop]
+          $stdout.puts \
+            "Using no-op. Would submit PR '#{options[:pr_title]}' to #{repo_path} " \
+            "- merges #{branch} into #{target_branch}"
+          return
+        end
+
+        pull_requests = @api.pull_requests(repo_path,
+                                           :state => 'open',
+                                           :base => target_branch,
+                                           :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}"
+          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])
+        $stdout.puts \
+          "Submitted PR '#{options[:pr_title]}' to #{repo_path} " \
+          "- merges #{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)
+      end
+    end
+  end
+end

data/lib/modulesync/pr/gitlab.rb

@@ -0,0 +1,54 @@
+require 'gitlab'
+require 'modulesync/util'
+
+module ModuleSync
+  module PR
+    # GitLab creates and manages merge requests on gitlab.com or private GitLab
+    # installations.
+    class GitLab
+      def initialize(token, endpoint)
+        @api = Gitlab::Client.new(
+          :endpoint => endpoint,
+          :private_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'
+
+        if options[:noop]
+          $stdout.puts \
+            "Using no-op. Would submit MR '#{options[:pr_title]}' to #{repo_path} " \
+            "- merges #{branch} into #{target_branch}"
+          return
+        end
+
+        merge_requests = @api.merge_requests(repo_path,
+                                             :state => 'opened',
+                                             :source_branch => head,
+                                             :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 #{branch}"
+          return
+        end
+
+        mr_labels = ModuleSync::Util.parse_list(options[:pr_labels])
+        mr = @api.create_merge_request(repo_path,
+                                       options[:pr_title],
+                                       :source_branch => branch,
+                                       :target_branch => target_branch,
+                                       :labels => mr_labels)
+        $stdout.puts \
+          "Submitted MR '#{options[:pr_title]}' to #{repo_path} " \
+          "- merges #{branch} into #{target_branch}"
+
+        return if mr_labels.empty?
+        $stdout.puts "Attached the following labels to MR #{mr.iid}: #{mr_labels.join(', ')}"
+      end
+    end
+  end
+end

data/lib/modulesync/util.rb

@@ -3,7 +3,10 @@ require 'yaml'
 module ModuleSync
   module Util
     def self.symbolize_keys(hash)
-      hash.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo }
+      hash.inject({}) do |memo, (k, v)|
+        memo[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
+        memo
+      end
     end
 
     def self.parse_config(config_file)

data/lib/monkey_patches.rb

@@ -1,55 +1,16 @@
 module Git
-  class Diff
-    # Monkey patch process_full_diff until https://github.com/schacon/ruby-git/issues/326 is resolved
-    def process_full_diff
-      defaults = {
-        :mode => '',
-        :src => '',
-        :dst => '',
-        :type => 'modified'
-      }
-      final = {}
-      current_file = nil
-      full_diff_utf8_encoded = @full_diff.encode("UTF-8", "binary", {
-    :invalid => :replace,
-    :undef => :replace
-  })
-      full_diff_utf8_encoded.split("\n").each do |line|
-        if m = /^diff --git a\/(.*?) b\/(.*?)/.match(line)
-          current_file = m[1]
-          final[current_file] = defaults.merge({:patch => line, :path => current_file})
-        elsif !current_file.nil?
-          if m = /^index (.......)\.\.(.......)( ......)*/.match(line)
-            final[current_file][:src] = m[1]
-            final[current_file][:dst] = m[2]
-            final[current_file][:mode] = m[3].strip if m[3]
-          end
-          if m = /^([[:alpha:]]*?) file mode (......)/.match(line)
-            final[current_file][:type] = m[1]
-            final[current_file][:mode] = m[2]
-          end
-          if m = /^Binary files /.match(line)
-            final[current_file][:binary] = true
-          end
-          final[current_file][:patch] << "\n" + line
-        end
-      end
-      final.map { |e| [e[0], DiffFile.new(@base, e[1])] }
+  module LibMonkeyPatch
+    # Monkey patch set_custom_git_env_variables due to our ::Git::GitExecuteError handling.
+    #
+    # We rescue on the GitExecuteError and proceed differently based on the output of git.
+    # This way makes code language-dependent, so here we ensure that Git gem throw git commands with the "C" language
+    def set_custom_git_env_variables
+      super
+      ENV['LANG'] = 'C.UTF-8'
     end
   end
 
   class Lib
-    # Monkey patch ls_files until https://github.com/ruby-git/ruby-git/pull/320 is resolved
-    def ls_files(location=nil)
-      location ||= '.'
-      hsh = {}
-      command_lines('ls-files', ['--stage', location]).each do |line|
-        (info, file) = line.split("\t")
-        (mode, sha, stage) = info.split
-        file = eval(file) if file =~ /^\".*\"$/ # This takes care of quoted strings returned from git
-        hsh[file] = {:path => file, :mode_index => mode, :sha_index => sha, :stage => stage}
-      end
-      hsh
-    end
+    prepend LibMonkeyPatch
   end
 end