modulesync 2.2.0 → 2.3.0

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}"
@@ -62,23 +63,50 @@ module ModuleSync
       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
+    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
 
@@ -102,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
@@ -119,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/)
@@ -133,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
@@ -145,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
         []

data/lib/modulesync.rb

@@ -1,3 +1,4 @@
+require 'English'
 require 'fileutils'
 require 'pathname'
 
@@ -18,10 +19,10 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
 
   def self.config_defaults
     {
-      :project_root         => 'modules/',
+      :project_root => 'modules/',
       :managed_modules_conf => 'managed_modules.yml',
-      :configs              => '.',
-      :tag_pattern          => '%s'
+      :configs => '.',
+      :tag_pattern => '%s',
     }
   end
 
@@ -44,8 +45,8 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
           .to_a
     else
       $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.'
+                   ' Check that you are working in your module configs directory or' \
+                   ' that you have passed in the correct directory with -c.'
       exit 1
     end
   end
@@ -62,7 +63,7 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     managed_modules = Util.parse_config(config_file)
     if managed_modules.empty?
       $stderr.puts "No modules found in #{config_file}." \
-        ' Check that you specified the right :configs directory and :managed_modules_conf file.'
+                   ' Check that you specified the right :configs directory and :managed_modules_conf file.'
       exit 1
     end
     managed_modules.select! { |m| m =~ Regexp.new(filter) } unless filter.nil?
@@ -82,7 +83,6 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
   end
 
   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 = puppet_module.path(filename)
@@ -95,12 +95,12 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
         # Meta data passed to the template as @metadata[:name]
         metadata = {
           :module_name => module_name,
-          :workdir     => puppet_module.working_directory,
+          :workdir => puppet_module.working_directory,
           :target_file => target_file,
         }
         template = Renderer.render(erb, configs, metadata)
         Renderer.sync(template, target_file)
-      rescue StandardError => e
+      rescue StandardError
         $stderr.puts "#{puppet_module.given_name}: Error while rendering file: '#{filename}'"
         raise
       end
@@ -109,7 +109,12 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
 
   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]
+    # NOTE: #prepare_workspace now supports to execute only offline operations
+    # but we totally skip the workspace preparation to keep the current behavior
+    unless options[:offline]
+      puppet_module.repository.prepare_workspace(branch: options[:branch],
+                                                 operate_offline: false)
+    end
 
     module_configs = Util.parse_config puppet_module.path(MODULE_CONF_FILE)
     settings = Settings.new(defaults[GLOBAL_DEFAULTS_KEY] || {},
@@ -129,9 +134,8 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
 
     if options[:noop]
       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)
+      changed = puppet_module.repository.show_changes(options)
+      changed && options[:pr] && puppet_module.open_pull_request
     elsif !options[:offline]
       pushed = puppet_module.repository.submit_changes(files_to_manage, options)
       # Only bump/tag if pushing didn't fail (i.e. there were changes)
@@ -139,13 +143,13 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
         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)
+      pushed && options[:pr] && puppet_module.open_pull_request
     end
   end
 
   def self.config_path(file, options)
     return file if Pathname.new(file).absolute?
+
     File.join(options[:configs], file)
   end
 
@@ -157,15 +161,6 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     @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!'
-        raise
-      end
-
-      @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)
@@ -173,56 +168,99 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     errors = false
     # managed_modules is either an array or a hash
     managed_modules.each do |puppet_module|
-      begin
-        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.given_name}' as update process failed"
-      end
+      manage_module(puppet_module, module_files, defaults)
+    rescue ModuleSync::Error, Git::GitExecuteError => e
+      message = e.message || 'Error during `update`'
+      $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
+      raise unless options[:skip_broken]
+
+      errors = true
+      $stdout.puts "Skipping '#{puppet_module.given_name}' as update process failed"
     end
     exit 1 if errors && options[:fail_on_warnings]
   end
 
-  def self.pr(puppet_module)
-    module_options = puppet_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
+  def self.clone(cli_options)
+    @options = config_defaults.merge(cli_options)
+
+    managed_modules.each do |puppet_module|
+      puppet_module.repository.clone unless puppet_module.repository.cloned?
     end
   end
 
-  def self.create_pr_manager
-    github_token = ENV.fetch('GITHUB_TOKEN', '')
-    gitlab_token = ENV.fetch('GITLAB_TOKEN', '')
+  def self.execute(cli_options)
+    @options = config_defaults.merge(cli_options)
 
-    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'
+    errors = {}
+    managed_modules.each do |puppet_module|
+      $stdout.puts "#{puppet_module.given_name}:"
+
+      puppet_module.repository.clone unless puppet_module.repository.cloned?
+      puppet_module.repository.switch branch: @options[:branch]
+
+      command_args = cli_options[:command_args]
+      local_script = File.expand_path command_args[0]
+      command_args[0] = local_script if File.exist?(local_script)
+
+      # Remove bundler-related env vars to allow the subprocess to run `bundle`
+      command_env = ENV.reject { |k, _v| k.match?(/(^BUNDLE|^SOURCE_DATE_EPOCH$|^GEM_|RUBY)/) }
+
+      result = system command_env, *command_args, unsetenv_others: true, chdir: puppet_module.working_directory
+      unless result
+        message = "Command execution failed ('#{@options[:command_args].join ' '}': #{$CHILD_STATUS})"
+        raise Thor::Error, message if @options[:fail_fast]
+
+        errors.merge!(
+          puppet_module.given_name => message,
+        )
+        $stderr.puts message
+      end
+
+      $stdout.puts ''
+    end
+
+    unless errors.empty?
+      raise Thor::Error, <<~MSG
+        Error(s) during `execute` command:
+        #{errors.map { |name, message| "  * #{name}: #{message}" }.join "\n"}
+      MSG
+    end
+
+    exit 1 unless errors.empty?
+  end
+
+  def self.reset(cli_options)
+    @options = config_defaults.merge(cli_options)
+    if @options[:branch].nil?
+      raise Thor::Error,
+            "Error: 'branch' option is missing, please set it in configuration or in command line."
+    end
+
+    managed_modules.each do |puppet_module|
+      puppet_module.repository.reset_workspace(
+        branch: @options[:branch],
+        source_branch: @options[:source_branch],
+        operate_offline: @options[:offline],
+      )
+    end
+  end
+
+  def self.push(cli_options)
+    @options = config_defaults.merge(cli_options)
+
+    if @options[:branch].nil?
+      raise Thor::Error,
+            "Error: 'branch' option is missing, please set it in configuration or in command line."
+    end
+
+    managed_modules.each do |puppet_module|
+      puppet_module.repository.push branch: @options[:branch], remote_branch: @options[:remote_branch]
+    rescue ModuleSync::Error => e
+      raise Thor::Error, "#{puppet_module.given_name}: #{e.message}"
     end
   end
 end

data/modulesync.gemspec

@@ -1,9 +1,9 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name                  = 'modulesync'
-  spec.version               = '2.2.0'
+  spec.version               = '2.3.0'
   spec.authors               = ['Vox Pupuli']
   spec.email                 = ['voxpupuli@groups.io']
   spec.summary               = 'Puppet Module Synchronizer'
@@ -19,10 +19,13 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'aruba', '>= 0.14', '< 2'
   spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'cucumber'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rubocop', '~> 0.50.0'
-  spec.add_development_dependency 'cucumber'
+  spec.add_development_dependency 'rubocop', '~> 1.2'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'simplecov'
 
   spec.add_runtime_dependency 'git', '~>1.7'
   spec.add_runtime_dependency 'gitlab', '~>4.0'

data/spec/helpers/faker/puppet_module_remote_repo.rb

@@ -77,6 +77,7 @@ module ModuleSync
         branch ||= default_branch
         FileUtils.chdir(tmp_repo_dir) do
           run %W[git checkout #{branch}]
+          run %w[git pull --force --prune]
           File.write filename, content
           run %W[git add #{filename}]
           run %w[git commit --message] << "Add file: '#{filename}'"
@@ -94,7 +95,7 @@ module ModuleSync
       def commit_count_by(author, commit = nil)
         FileUtils.chdir(bare_repo_dir) do
           commit ||= '--all'
-          stdout = run %W[git rev-list #{commit} --author #{author} --count]
+          stdout = run %W[git rev-list --author #{author} --count #{commit} --]
           return Integer(stdout)
         end
       end
@@ -105,6 +106,20 @@ module ModuleSync
         end
       end
 
+      def delete_branch(branch)
+        FileUtils.chdir(bare_repo_dir) do
+          run %W{git branch -D #{branch}}
+        end
+      end
+
+      def create_branch(branch, from = nil)
+        from ||= default_branch
+        FileUtils.chdir(tmp_repo_dir) do
+          run %W{git branch -c #{from} #{branch}}
+          run %W{git push --set-upstream origin #{branch}}
+        end
+      end
+
       def remote_url
         "file://#{bare_repo_dir}"
       end

data/spec/spec_helper.rb

@@ -1,25 +1,3 @@
-begin
-  require 'simplecov'
-  require 'simplecov-console'
-  require 'codecov'
-rescue LoadError
-else
-  SimpleCov.start do
-    track_files 'lib/**/*.rb'
-
-    add_filter '/spec'
-
-    enable_coverage :branch
-
-    # do not track vendored files
-    add_filter '/vendor'
-    add_filter '/.vendor'
-  end
-
-  SimpleCov.formatters = [
-    SimpleCov::Formatter::Console,
-    SimpleCov::Formatter::Codecov,
-  ]
-end
+require 'simplecov'
 
 require 'modulesync'

data/spec/unit/modulesync/git_service/factory_spec.rb

@@ -0,0 +1,16 @@
+require 'modulesync'
+require 'modulesync/git_service/factory'
+
+describe ModuleSync::GitService::Factory do
+  context 'when instantiate a GitHub service without credentials' do
+    it 'raises an error' do
+      expect { ModuleSync::GitService::Factory.instantiate(type: :github, endpoint: nil, token: nil) }.to raise_error(ModuleSync::GitService::MissingCredentialsError)
+    end
+  end
+
+  context 'when instantiate a GitLab service without credentials' do
+    it 'raises an error' do
+      expect { ModuleSync::GitService::Factory.instantiate(type: :gitlab, endpoint: nil, token: nil) }.to raise_error(ModuleSync::GitService::MissingCredentialsError)
+    end
+  end
+end