modulesync 1.3.0 → 2.1.1

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/features/update/bump_version.feature

@@ -0,0 +1,87 @@
+Feature: Bump a new version after an update
+  Scenario: Bump the module version, update changelog and tag it after an update that produces changes
+    Given a basic setup with a puppet module "puppet-test" from "fakenamespace"
+    And the puppet module "puppet-test" from "fakenamespace" has a file named "CHANGELOG.md" with:
+      """
+      ## 1965-04-14 - Release 0.4.2
+      """
+    And a file named "config_defaults.yml" with:
+      """
+      ---
+      new-file:
+        content: aruba
+      """
+    And a directory named "moduleroot"
+    And a file named "moduleroot/new-file.erb" with:
+      """
+      <%= @configs['content'] %>
+      """
+    When I run `msync update --message "Add new-file" --bump --changelog --tag`
+    Then the exit status should be 0
+    And the file named "modules/fakenamespace/puppet-test/new-file" should contain "aruba"
+    And the stdout should contain:
+      """
+      Bumped to version 0.4.3
+      """
+    And the stdout should contain:
+      """
+      Tagging with 0.4.3
+      """
+    And the file named "modules/fakenamespace/puppet-test/CHANGELOG.md" should contain "0.4.3"
+    And the puppet module "puppet-test" from "fakenamespace" should have 2 commits made by "Aruba"
+    And the puppet module "puppet-test" from "fakenamespace" should have a tag named "0.4.3"
+
+  Scenario: Bump the module version after an update that produces changes
+    Given a basic setup with a puppet module "puppet-test" from "fakenamespace"
+    And a file named "config_defaults.yml" with:
+      """
+      ---
+      new-file:
+        content: aruba
+      """
+    And a directory named "moduleroot"
+    And a file named "moduleroot/new-file.erb" with:
+      """
+      <%= @configs['content'] %>
+      """
+    When I run `msync update --message "Add new-file" --bump`
+    Then the exit status should be 0
+    And the file named "modules/fakenamespace/puppet-test/new-file" should contain "aruba"
+    And the stdout should contain:
+      """
+      Bumped to version 0.4.3
+      """
+    And the puppet module "puppet-test" from "fakenamespace" should have 2 commits made by "Aruba"
+    And the puppet module "puppet-test" from "fakenamespace" should not have a tag named "0.4.3"
+
+  Scenario: Bump the module version with changelog update when no CHANGELOG.md is available
+    Given a basic setup with a puppet module "puppet-test" from "fakenamespace"
+    And a file named "config_defaults.yml" with:
+      """
+      ---
+      new-file:
+        content: aruba
+      """
+    And a directory named "moduleroot"
+    And a file named "moduleroot/new-file.erb" with:
+      """
+      <%= @configs['content'] %>
+      """
+    When I run `msync update --message "Add new-file" --bump --changelog`
+    Then the exit status should be 0
+    And the file named "modules/fakenamespace/puppet-test/new-file" should contain "aruba"
+    And the stdout should contain:
+      """
+      Bumped to version 0.4.3
+      No CHANGELOG.md file found, not updating.
+      """
+    And the file named "modules/fakenamespace/puppet-test/CHANGELOG.md" should not exist
+    And the puppet module "puppet-test" from "fakenamespace" should have 2 commits made by "Aruba"
+
+  Scenario: Dont bump the module version after an update that produces no changes
+    Given a basic setup with a puppet module "puppet-test" from "fakenamespace"
+    And a directory named "moduleroot"
+    When I run `msync update --message "Add new-file" --bump --tag`
+    Then the exit status should be 0
+    And the puppet module "puppet-test" from "fakenamespace" should have no commits made by "Aruba"
+    And the puppet module "puppet-test" from "fakenamespace" should not have a tag named "0.4.3"

data/lib/modulesync.rb

@@ -1,15 +1,19 @@
 require 'fileutils'
 require 'pathname'
+
 require 'modulesync/cli'
 require 'modulesync/constants'
-require 'modulesync/git'
 require 'modulesync/hook'
+require 'modulesync/puppet_module'
 require 'modulesync/renderer'
 require 'modulesync/settings'
 require 'modulesync/util'
+
 require 'monkey_patches'
 
 module ModuleSync # rubocop:disable Metrics/ModuleLength
+  class Error < StandardError; end
+
   include Constants
 
   def self.config_defaults
@@ -21,12 +25,12 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     }
   end
 
-  def self.local_file(config_path, file)
-    File.join(config_path, MODULE_FILES_DIR, file)
+  def self.options
+    @options
   end
 
-  def self.module_file(project_root, namespace, puppet_module, *parts)
-    File.join(project_root, namespace, puppet_module, *parts)
+  def self.local_file(config_path, file)
+    File.join(config_path, MODULE_FILES_DIR, file)
   end
 
   # List all template files.
@@ -39,10 +43,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
 
@@ -50,21 +54,20 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     file_list.map { |file| file.sub(/#{path}/, '') }
   end
 
-  def self.managed_modules(config_file, filter, negative_filter)
+  def self.managed_modules
+    config_file = config_path(options[:managed_modules_conf], options)
+    filter = options[:filter]
+    negative_filter = options[: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?
-    managed_modules
-  end
-
-  def self.module_name(module_name, default_namespace)
-    return [default_namespace, module_name] unless module_name.include?('/')
-    ns, mod = module_name.split('/')
+    managed_modules.map { |given_name, options| PuppetModule.new(given_name, options) }
   end
 
   def self.hook(options)
@@ -78,11 +81,11 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     end
   end
 
-  def self.manage_file(filename, settings, options)
+  def self.manage_file(puppet_module, filename, settings, options)
     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)
+    target_file = puppet_module.path(filename)
     if configs['delete']
       Renderer.remove(target_file)
     else
@@ -92,49 +95,52 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
         # Meta data passed to the template as @metadata[:name]
         metadata = {
           :module_name => module_name,
-          :workdir     => module_file(options[:project_root], namespace, module_name),
+          :workdir     => puppet_module.working_directory,
           :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}"
+      rescue StandardError => e
+        $stderr.puts "#{puppet_module.given_name}: Error while rendering file: '#{filename}'"
         raise
       end
     end
   end
 
-  def self.manage_module(puppet_module, module_files, module_options, defaults, options)
-    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 || {})
-    end
+  def self.manage_module(puppet_module, module_files, defaults)
+    puts "Syncing '#{puppet_module.given_name}'"
+    puppet_module.repository.prepare_workspace(options[:branch]) unless options[:offline]
 
-    module_configs = Util.parse_config(module_file(options[:project_root], namespace, module_name, MODULE_CONF_FILE))
+    module_configs = Util.parse_config puppet_module.path(MODULE_CONF_FILE)
     settings = Settings.new(defaults[GLOBAL_DEFAULTS_KEY] || {},
                             defaults,
                             module_configs[GLOBAL_DEFAULTS_KEY] || {},
                             module_configs,
-                            :puppet_module => module_name,
+                            :puppet_module => puppet_module.repository_name,
                             :git_base => options[:git_base],
-                            :namespace => namespace)
+                            :namespace => puppet_module.repository_namespace)
+
     settings.unmanaged_files(module_files).each do |filename|
-      $stdout.puts "Not managing #{filename} in #{module_name}"
+      $stdout.puts "Not managing '#{filename}' in '#{puppet_module.given_name}'"
     end
 
     files_to_manage = settings.managed_files(module_files)
-    files_to_manage.each { |filename| manage_file(filename, settings, options) }
+    files_to_manage.each { |filename| manage_file(puppet_module, filename, settings, options) }
 
     if options[:noop]
-      Git.update_noop(git_repo, options)
+      puts "Using no-op. Files in '#{puppet_module.given_name}' may be changed but will not be committed."
+      puppet_module.repository.show_changes(options)
+      options[:pr] && \
+        pr(puppet_module).manage(puppet_module.repository_namespace, puppet_module.repository_name, options)
     elsif !options[:offline]
-      pushed = Git.update(git_repo, files_to_manage, options)
-      pushed && options[:pr] && pr(module_options).manage(namespace, module_name, options)
+      pushed = puppet_module.repository.submit_changes(files_to_manage, options)
+      # Only bump/tag if pushing didn't fail (i.e. there were changes)
+      if pushed && options[:bump]
+        new = puppet_module.bump(options[:message], options[:changelog])
+        puppet_module.repository.tag(new, options[:tag_pattern]) if options[:tag]
+      end
+      pushed && options[:pr] && \
+        pr(puppet_module).manage(puppet_module.repository_namespace, puppet_module.repository_name, options)
     end
   end
 
@@ -147,9 +153,10 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     self.class.config_path(file, options)
   end
 
-  def self.update(options)
-    options = config_defaults.merge(options)
+  def self.update(cli_options)
+    @options = config_defaults.merge(cli_options)
     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!'
@@ -163,26 +170,28 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     local_files = find_template_files(local_template_dir)
     module_files = relative_names(local_files, local_template_dir)
 
-    managed_modules = self.managed_modules(config_path(options[:managed_modules_conf], options),
-                                           options[:filter],
-                                           options[:negative_filter])
-
     errors = false
     # managed_modules is either an array or a hash
-    managed_modules.each do |puppet_module, module_options|
+    managed_modules.each do |puppet_module|
       begin
-        manage_module(puppet_module, module_files, module_options, defaults, options)
-      rescue # rubocop:disable Lint/RescueWithoutErrorClass
-        $stderr.puts "Error while updating #{puppet_module}"
+        manage_module(puppet_module, module_files, defaults)
+      rescue ModuleSync::Error, Git::GitExecuteError => e
+        message = e.message || "Error during '#{options[:command]}'"
+        $stderr.puts "#{puppet_module.given_name}: #{message}"
+        exit 1 unless options[:skip_broken]
+        errors = true
+        $stdout.puts "Skipping '#{puppet_module.given_name}' as update process failed"
+      rescue StandardError => e
         raise unless options[:skip_broken]
         errors = true
-        $stdout.puts "Skipping #{puppet_module} as update process failed"
+        $stdout.puts "Skipping '#{puppet_module.given_name}' as update process failed"
       end
     end
     exit 1 if errors && options[:fail_on_warnings]
   end
 
-  def self.pr(module_options)
+  def self.pr(puppet_module)
+    module_options = puppet_module.options
     github_conf = module_options[:github]
     gitlab_conf = module_options[:gitlab]
 

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',

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/pr/github.rb

@@ -15,26 +15,36 @@ module ModuleSync
 
       def manage(namespace, module_name, options)
         repo_path = File.join(namespace, module_name)
-        head = "#{namespace}:#{options[:branch]}"
+        branch = options[:remote_branch] || options[:branch]
+        head = "#{namespace}:#{branch}"
         target_branch = options[:pr_target_branch] || 'master'
 
-        pull_requests = @api.pull_requests(repo_path, :state => 'open', :base => target_branch, :head => head)
-        if pull_requests.empty?
-          pr = @api.create_pull_request(repo_path,
-                                        target_branch,
-                                        options[:branch],
-                                        options[:pr_title],
-                                        options[:message])
+        if options[:noop]
           $stdout.puts \
-            "Submitted PR '#{options[:pr_title]}' to #{repo_path} - merges #{options[:branch]} into #{target_branch}"
-        else
+            "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 #{options[:branch]}"
+          $stdout.puts "Skipped! #{pull_requests.length} PRs found for branch #{branch}"
+          return
         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 = 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.

data/lib/modulesync/pr/gitlab.rb

@@ -15,27 +15,39 @@ module ModuleSync
 
       def manage(namespace, module_name, options)
         repo_path = File.join(namespace, module_name)
-
-        head = "#{namespace}:#{options[:branch]}"
+        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)
-        if merge_requests.empty?
-          mr_labels = ModuleSync::Util.parse_list(options[:pr_labels])
-          mr = @api.create_merge_request(repo_path, options[:pr_title],
-                                         :source_branch => options[:branch],
-                                         :target_branch => target_branch,
-                                         :labels => mr_labels)
-          $stdout.puts \
-            "Submitted MR '#{options[:pr_title]}' to #{repo_path} - merges #{options[:branch]} into #{target_branch}"
-          return if mr_labels.empty?
-          $stdout.puts "Attached the following labels to MR #{mr.iid}: #{mr_labels.join(', ')}"
-        else
+        unless merge_requests.empty?
           # Skip creating the MR if it exists already.
-          $stdout.puts "Skipped! #{merge_requests.length} MRs found for branch #{options[:branch]}"
+          $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