modulesync 1.0.0 → 2.0.1

data/Rakefile

@@ -19,3 +19,28 @@ Cucumber::Rake::Task.new do |t|
 end
 
 task :test => %i[clean spec cucumber rubocop]
+task :default => %i[test]
+
+begin
+  require 'github_changelog_generator/task'
+  GitHubChangelogGenerator::RakeTask.new :changelog do |config|
+    config.header = "# Changelog\n\nAll notable changes to this project will be documented in this file."
+    config.exclude_labels = %w[duplicate question invalid wontfix wont-fix modulesync skip-changelog]
+    config.user = 'voxpupuli'
+    config.project = 'modulesync'
+    config.future_release = Gem::Specification.load("#{config.project}.gemspec").version
+  end
+
+  # Workaround for https://github.com/github-changelog-generator/github-changelog-generator/issues/715
+  require 'rbconfig'
+  if RbConfig::CONFIG['host_os'] =~ /linux/
+    task :changelog do
+      puts 'Fixing line endings...'
+      changelog_file = File.join(__dir__, 'CHANGELOG.md')
+      changelog_txt = File.read(changelog_file)
+      new_contents = changelog_txt.gsub(/\r\n/, "\n")
+      File.open(changelog_file, 'w') { |file| file.puts new_contents }
+    end
+  end
+rescue LoadError
+end

data/features/update.feature

@@ -905,6 +905,28 @@ Feature: update
     Then the output should not contain "error"
     Then the output should not contain "rejected"
 
+  Scenario: Creating a GitHub PR with an update
+    Given a mocked git configuration
+    And a remote module repository
+    And a directory named "moduleroot"
+    And I set the environment variables to:
+      | variable     | value  |
+      | GITHUB_TOKEN | foobar |
+    When I run `msync update --noop --branch managed_update --pr`
+    Then the output should contain "Would submit PR "
+    And the exit status should be 0
+
+  Scenario: Creating a GitLab MR with an update
+    Given a mocked git configuration
+    And a remote module repository
+    And a directory named "moduleroot"
+    And I set the environment variables to:
+      | variable     | value  |
+      | GITLAB_TOKEN | foobar |
+    When I run `msync update --noop --branch managed_update --pr`
+    Then the output should contain "Would submit MR "
+    And the exit status should be 0
+
   Scenario: Repository with a default branch other than master
     Given a mocked git configuration
     And a remote module repository with "develop" as the default branch
@@ -922,3 +944,36 @@ Feature: update
     When I run `msync update -m "Update Gemfile"`
     Then the exit status should be 0
     Then the output should contain "Using repository's default branch: develop"
+
+  Scenario: Adding a new file from a template using meta data
+    And a file named "config_defaults.yml" with:
+      """
+      ---
+      """
+    Given a file named "managed_modules.yml" with:
+      """
+      ---
+        - puppet-test
+      """
+    And a file named "modulesync.yml" with:
+      """
+      ---
+        namespace: maestrodev
+        git_base: https://github.com/
+      """
+    And a directory named "moduleroot"
+    And a file named "moduleroot/test.erb" with:
+      """
+      module: <%= @metadata[:module_name] %>
+      target: <%= @metadata[:target_file] %>
+      workdir: <%= @metadata[:workdir] %>
+      """
+    When I run `msync update --noop`
+    Then the exit status should be 0
+    Given I run `cat modules/maestrodev/puppet-test/test`
+    Then the output should contain:
+      """
+      module: puppet-test
+      target: modules/maestrodev/puppet-test/test
+      workdir: modules/maestrodev/puppet-test
+      """

data/lib/modulesync.rb

@@ -1,5 +1,4 @@
 require 'fileutils'
-require 'octokit'
 require 'pathname'
 require 'modulesync/cli'
 require 'modulesync/constants'
@@ -10,13 +9,7 @@ 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
+module ModuleSync # rubocop:disable Metrics/ModuleLength
   include Constants
 
   def self.config_defaults
@@ -32,8 +25,8 @@ module ModuleSync
     File.join(config_path, MODULE_FILES_DIR, file)
   end
 
-  def self.module_file(project_root, namespace, puppet_module, file)
-    File.join(project_root, namespace, puppet_module, file)
+  def self.module_file(project_root, namespace, puppet_module, *parts)
+    File.join(project_root, namespace, puppet_module, *parts)
   end
 
   # List all template files.
@@ -46,7 +39,7 @@ module ModuleSync
           .collect { |p| p.chomp('.erb') }
           .to_a
     else
-      puts "#{local_template_dir} does not exist." \
+      $stdout.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
@@ -60,7 +53,7 @@ module ModuleSync
   def self.managed_modules(config_file, filter, negative_filter)
     managed_modules = Util.parse_config(config_file)
     if managed_modules.empty?
-      puts "No modules found in #{config_file}." \
+      $stdout.puts "No modules found in #{config_file}." \
         ' Check that you specified the right :configs directory and :managed_modules_conf file.'
       exit
     end
@@ -89,28 +82,34 @@ module ModuleSync
     namespace = settings.additional_settings[:namespace]
     module_name = settings.additional_settings[:puppet_module]
     configs = settings.build_file_configs(filename)
+    target_file = module_file(options[:project_root], namespace, module_name, filename)
     if configs['delete']
-      Renderer.remove(module_file(options[:project_root], namespace, module_name, filename))
+      Renderer.remove(target_file)
     else
       templatename = local_file(options[:configs], filename)
       begin
         erb = Renderer.build(templatename)
-        template = Renderer.render(erb, configs)
-        Renderer.sync(template, module_file(options[:project_root], namespace, module_name, filename))
+        # Meta data passed to the template as @metadata[:name]
+        metadata = {
+          :module_name => module_name,
+          :workdir     => module_file(options[:project_root], namespace, module_name),
+          :target_file => target_file,
+        }
+        template = Renderer.render(erb, configs, metadata)
+        Renderer.sync(template, target_file)
       rescue # rubocop:disable Lint/RescueWithoutErrorClass
-        STDERR.puts "Error while rendering #{filename}"
+        $stderr.puts "Error while rendering #{filename}"
         raise
       end
     end
   end
 
   def self.manage_module(puppet_module, module_files, module_options, defaults, options)
-    if options[:pr] && !GITHUB_TOKEN
-      STDERR.puts 'Environment variable GITHUB_TOKEN must be set to use --pr!'
-      raise unless options[:skip_broken]
+    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, options[:namespace])
+    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 || {})
@@ -125,7 +124,7 @@ module ModuleSync
                             :git_base => options[:git_base],
                             :namespace => namespace)
     settings.unmanaged_files(module_files).each do |filename|
-      puts "Not managing #{filename} in #{module_name}"
+      $stdout.puts "Not managing #{filename} in #{module_name}"
     end
 
     files_to_manage = settings.managed_files(module_files)
@@ -133,40 +132,39 @@ module ModuleSync
 
     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]
-
-      # We only do GitHub PR work if the GITHUB_TOKEN variable is set in the environment.
-      repo_path = File.join(namespace, module_name)
-      puts "Submitting PR '#{options[:pr_title]}' on GitHub to #{repo_path} - merges #{options[:branch]} into master"
-      github = Octokit::Client.new(:access_token => GITHUB_TOKEN)
-      pr = github.create_pull_request(repo_path, 'master', options[:branch], options[:pr_title], options[:message])
-      puts "PR created at #{pr['html_url']}"
-
-      # 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])
-
-      # 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.
-      unless pr_labels.empty?
-        puts "Attaching the following labels to PR #{pr['number']}: #{pr_labels.join(', ')}"
-        github.add_labels_to_an_issue(repo_path, pr['number'], pr_labels)
-      end
+      pushed && options[:pr] && pr(module_options).manage(namespace, module_name, options)
     end
   end
 
+  def self.config_path(file, options)
+    return file if Pathname.new(file).absolute?
+    File.join(options[:configs], file)
+  end
+
+  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
 
-    local_template_dir = File.join(options[:configs], MODULE_FILES_DIR)
+      @pr = create_pr_manager if options[:pr]
+    end
+
+    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])
 
@@ -174,14 +172,51 @@ module ModuleSync
     # 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}"
+        $stderr.puts "Error while updating #{puppet_module}"
         raise unless options[:skip_broken]
         errors = true
-        puts "Skipping #{puppet_module} as update process failed"
+        $stdout.puts "Skipping #{puppet_module} as update process failed"
       end
     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

@@ -67,6 +67,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,14 +92,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,
-             :desc => 'Labels to add to the GitHub PR',
+             :type => :array,
+             :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/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