modulesync 1.2.0 → 2.1.0

data/lib/modulesync/pr/gitlab.rb

@@ -15,25 +15,39 @@ module ModuleSync
 
       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
 
-        head = "#{namespace}:#{options[:branch]}"
         merge_requests = @api.merge_requests(repo_path,
                                              :state => 'opened',
                                              :source_branch => head,
-                                             :target_branch => 'master')
-        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 => 'master',
-                                         :labels => mr_labels)
-          $stdout.puts "Submitted MR '#{options[:pr_title]}' to #{repo_path} - merges #{options[:branch]} into master"
-          return if mr_labels.empty?
-          $stdout.puts "Attached the following labels to MR #{mr.iid}: #{mr_labels.join(', ')}"
-        else
+                                             :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 #{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

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,158 @@
+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
+        repo.checkout('origin/master')
+        puts "Creating new branch #{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'
+        puts "Cloning 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

data/lib/modulesync/source_code.rb

@@ -0,0 +1,57 @@
+require 'modulesync'
+require 'modulesync/repository'
+require 'modulesync/util'
+
+module ModuleSync
+  # Provide methods to retrieve source code attributes
+  class SourceCode
+    attr_reader :given_name
+    attr_reader :options
+
+    def initialize(given_name, options)
+      @options = Util.symbolize_keys(options || {})
+
+      @given_name = given_name
+
+      return unless given_name.include?('/')
+
+      @repository_name = given_name.split('/').last
+      @repository_namespace = given_name.split('/')[0...-1].join('/')
+    end
+
+    def repository
+      @repository ||= Repository.new directory: working_directory, remote: repository_remote
+    end
+
+    def repository_name
+      @repository_name ||= given_name
+    end
+
+    def repository_namespace
+      @repository_namespace ||= @options[:namespace] || ModuleSync.options[:namespace]
+    end
+
+    def repository_path
+      @repository_path ||= "#{repository_namespace}/#{repository_name}"
+    end
+
+    def repository_remote
+      @repository_remote ||= @options[:remote] || _repository_remote
+    end
+
+    def working_directory
+      @working_directory ||= File.join(ModuleSync.options[:project_root], repository_path)
+    end
+
+    def path(*parts)
+      File.join(working_directory, *parts)
+    end
+
+    private
+
+    def _repository_remote
+      git_base = ModuleSync.options[:git_base]
+      git_base.start_with?('file://') ? "#{git_base}#{repository_path}" : "#{git_base}#{repository_path}.git"
+    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

data/modulesync.gemspec

@@ -3,14 +3,14 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name                  = 'modulesync'
-  spec.version               = '1.2.0'
+  spec.version               = '2.1.0'
   spec.authors               = ['Vox Pupuli']
   spec.email                 = ['voxpupuli@groups.io']
   spec.summary               = 'Puppet Module Synchronizer'
   spec.description           = 'Utility to synchronize common files across puppet modules in Github.'
   spec.homepage              = 'http://github.com/voxpupuli/modulesync'
   spec.license               = 'Apache-2.0'
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.required_ruby_version = '>= 2.5.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -23,9 +23,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop', '~> 0.50.0'
 
-  spec.add_runtime_dependency 'git', '~>1.3'
+  spec.add_runtime_dependency 'git', '~>1.7'
   spec.add_runtime_dependency 'gitlab', '~>4.0'
   spec.add_runtime_dependency 'octokit', '~>4.0'
-  spec.add_runtime_dependency 'puppet-blacksmith', '~>3.0'
+  spec.add_runtime_dependency 'puppet-blacksmith', '>= 3.0', '< 7'
   spec.add_runtime_dependency 'thor'
 end

data/spec/helpers/faker.rb

@@ -0,0 +1,14 @@
+module ModuleSync
+  # Faker is a top-level module to keep global faker config
+  module Faker
+    def self.working_directory=(path)
+      @working_directory = path
+    end
+
+    def self.working_directory
+      raise 'Working directory must be set' if @working_directory.nil?
+      FileUtils.mkdir_p @working_directory
+      @working_directory
+    end
+  end
+end

data/spec/helpers/faker/puppet_module_remote_repo.rb

@@ -0,0 +1,146 @@
+require 'open3'
+
+require_relative '../faker'
+
+module ModuleSync
+  # Fake a remote git repository that holds a puppet module
+  #
+  # This module allows to fake a remote repositiory using:
+  #  - a bare repo
+  #  - a temporary cloned repo to operate on the remote before exposing to modulesync
+  #
+  # Note: This module needs to have working_directory sets before using it
+  module Faker
+    class PuppetModuleRemoteRepo
+      class CommandExecutionError < StandardError; end
+
+      attr_reader :name, :namespace
+
+      def initialize(name, namespace)
+        @name = name
+        @namespace = namespace
+      end
+
+      def populate
+        FileUtils.chdir(Faker.working_directory) do
+          run %W[git init --bare #{bare_repo_dir}]
+          run %W[git clone #{bare_repo_dir} #{tmp_repo_dir}]
+
+          module_short_name = name.split('-').last
+
+          FileUtils.chdir(tmp_repo_dir) do
+            metadata = {
+              name: "modulesync-#{module_short_name}",
+              version: '0.4.2',
+              author: 'ModuleSync team',
+            }
+
+            File.write 'metadata.json', metadata.to_json
+            run %w[git add metadata.json]
+            run %w[git commit --message] << 'Initial commit'
+            run %w[git push]
+          end
+        end
+      end
+
+      def read_only=(value)
+        mode = value ? '0444' : '0644'
+        FileUtils.chdir(bare_repo_dir) do
+          run %W[git config core.sharedRepository #{mode}]
+        end
+      end
+
+      def default_branch
+        FileUtils.chdir(bare_repo_dir) do
+          stdout = run %w[git symbolic-ref --short HEAD]
+          return stdout.chomp
+        end
+      end
+
+      def default_branch=(value)
+        FileUtils.chdir(bare_repo_dir) do
+          run %W[git branch -M #{default_branch} #{value}]
+          run %W[git symbolic-ref HEAD refs/heads/#{value}]
+        end
+      end
+
+      def read_file(filename, branch = nil)
+        branch ||= default_branch
+        FileUtils.chdir(bare_repo_dir) do
+          return run %W[git show #{branch}:#{filename}]
+        rescue CommandExecutionError
+          return nil
+        end
+      end
+
+      def add_file(filename, content, branch = nil)
+        branch ||= default_branch
+        FileUtils.chdir(tmp_repo_dir) do
+          run %W[git checkout #{branch}]
+          File.write filename, content
+          run %W[git add #{filename}]
+          run %w[git commit --message] << "Add file: '#{filename}'"
+          run %w[git push]
+        end
+      end
+
+      def commit_count_between(commit1, commit2)
+        FileUtils.chdir(bare_repo_dir) do
+          stdout = run %W[git rev-list --count #{commit1}..#{commit2}]
+          return Integer(stdout)
+        end
+      end
+
+      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]
+          return Integer(stdout)
+        end
+      end
+
+      def tags
+        FileUtils.chdir(bare_repo_dir) do
+          return run %w{git tag --list}
+        end
+      end
+
+      def remote_url
+        "file://#{bare_repo_dir}"
+      end
+
+      def self.git_base
+        "file://#{Faker.working_directory}/bare/"
+      end
+
+      private
+
+      def tmp_repo_dir
+        File.join Faker.working_directory, 'tmp', namespace, name
+      end
+
+      def bare_repo_dir
+        File.join Faker.working_directory, 'bare', namespace, "#{name}.git"
+      end
+
+      GIT_ENV = {
+        'GIT_AUTHOR_NAME' => 'Faker',
+        'GIT_AUTHOR_EMAIL' => 'faker@example.com',
+        'GIT_COMMITTER_NAME' => 'Faker',
+        'GIT_COMMITTER_EMAIL' => 'faker@example.com',
+      }.freeze
+
+      def run(command)
+        stdout, stderr, status = Open3.capture3(GIT_ENV, *command)
+        return stdout if status.success?
+
+        warn "Command '#{command}' failed: #{status}"
+        warn '  STDOUT:'
+        warn stdout
+        warn '  STDERR:'
+        warn stderr
+        raise CommandExecutionError, "Command '#{command}' failed: #{status}"
+      end
+    end
+  end
+end