modulesync 2.0.1 → 2.2.0

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,50 +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)
-      options[:pr] && pr(module_options).manage(namespace, module_name, 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
 
@@ -148,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!'
@@ -164,28 +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
-        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}"
+        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)
-    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/puppet_module.rb

@@ -0,0 +1,37 @@
+require 'puppet_blacksmith'
+
+require 'modulesync/source_code'
+
+module ModuleSync
+  # Provide methods to manipulate puppet module code
+  class PuppetModule < SourceCode
+    def update_changelog(version, message)
+      changelog = path('CHANGELOG.md')
+      if File.exist?(changelog)
+        puts "Updating #{changelog} for version #{version}"
+        changes = File.readlines(changelog)
+        File.open(changelog, 'w') do |f|
+          date = Time.now.strftime('%Y-%m-%d')
+          f.puts "## #{date} - Release #{version}\n\n"
+          f.puts "#{message}\n\n"
+          # Add old lines again
+          f.puts changes
+        end
+        repository.git.add('CHANGELOG.md')
+      else
+        puts 'No CHANGELOG.md file found, not updating.'
+      end
+    end
+
+    def bump(message, changelog = false)
+      m = Blacksmith::Modulefile.new path('metadata.json')
+      new = m.bump!
+      puts "Bumped to version #{new}"
+      repository.git.add('metadata.json')
+      update_changelog(new, message) if changelog
+      repository.git.commit("Release version #{new}")
+      repository.git.push
+      new
+    end
+  end
+end

data/lib/modulesync/repository.rb

@@ -0,0 +1,162 @@
+require 'git'
+
+module ModuleSync
+  # Wrapper for Git in ModuleSync context
+  class Repository
+    def initialize(directory:, remote:)
+      @directory = directory
+      @remote = remote
+    end
+
+    def git
+      @git ||= Git.open @directory
+    end
+
+    # This is an alias to minimize code alteration
+    def repo
+      git
+    end
+
+    def remote_branch_exists?(branch)
+      repo.branches.remote.collect(&:name).include?(branch)
+    end
+
+    def local_branch_exists?(branch)
+      repo.branches.local.collect(&:name).include?(branch)
+    end
+
+    def remote_branch_differ?(local_branch, remote_branch)
+      !remote_branch_exists?(remote_branch) ||
+        repo.diff("#{local_branch}..origin/#{remote_branch}").any?
+    end
+
+    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)
+      unless branch
+        branch = default_branch
+        puts "Using repository's default branch: #{branch}"
+      end
+      return if repo.current_branch == branch
+
+      if local_branch_exists?(branch)
+        puts "Switching to branch #{branch}"
+        repo.checkout(branch)
+      elsif remote_branch_exists?(branch)
+        puts "Creating local branch #{branch} from origin/#{branch}"
+        repo.checkout("origin/#{branch}")
+        repo.branch(branch).checkout
+      else
+        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 from '#{@remote}'"
+        @git = Git.clone(@remote, @directory)
+        switch_branch(branch)
+      # Repo already cloned, check out master and override local changes
+      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
+      end
+    end
+
+    def tag(version, tag_pattern)
+      tag = tag_pattern % version
+      puts "Tagging with #{tag}"
+      repo.add_tag(tag)
+      repo.push('origin', tag)
+    end
+
+    def checkout_branch(branch)
+      selected_branch = branch || repo.current_branch || 'master'
+      repo.branch(selected_branch).checkout
+      selected_branch
+    end
+
+    # Git add/rm, git commit, git push
+    def submit_changes(files, options)
+      message = options[:message]
+      branch = checkout_branch(options[:branch])
+      files.each do |file|
+        if repo.status.deleted.include?(file)
+          repo.remove(file)
+        elsif File.exist?("#{@directory}/#{file}")
+          repo.add(file)
+        end
+      end
+      begin
+        opts_commit = {}
+        opts_push = {}
+        opts_commit = { :amend => true } if options[:amend]
+        opts_push = { :force => true } if options[:force]
+        if options[:pre_commit_script]
+          script = "#{File.dirname(File.dirname(__FILE__))}/../contrib/#{options[:pre_commit_script]}"
+          `#{script} #{@directory}`
+        end
+        repo.commit(message, opts_commit)
+        if options[:remote_branch]
+          if remote_branch_differ?(branch, options[:remote_branch])
+            repo.push('origin', "#{branch}:#{options[:remote_branch]}", opts_push)
+          end
+        else
+          repo.push('origin', branch, opts_push)
+        end
+      rescue Git::GitExecuteError => e
+        raise unless e.message.match?(/working (directory|tree) clean/)
+
+        puts "There were no changes in '#{@directory}'. Not committing."
+        return false
+      end
+
+      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"
+      ignored = File.exist?(ignore_path) ? File.read(ignore_path).split : []
+      repo.status.untracked.keep_if { |f, _| ignored.none? { |i| File.fnmatch(i, f) } }
+    end
+
+    def show_changes(options)
+      checkout_branch(options[:branch])
+
+      puts 'Files changed:'
+      repo.diff('HEAD', '--').each do |diff|
+        puts diff.patch
+      end
+
+      puts 'Files added:'
+      untracked_unignored_files.each_key do |file|
+        puts file
+      end
+
+      puts "\n\n"
+      puts '--------------------------------'
+    end
+  end
+end