r10k 2.3.1 → 2.4.0

data/lib/r10k/git/rugged/working_repository.rb

@@ -25,7 +25,7 @@ class R10K::Git::Rugged::WorkingRepository < R10K::Git::Rugged::BaseRepository
   #
   # @return [void]
   def clone(remote, opts = {})
-    logger.debug1 { "Cloning '#{remote}' into #{@path}" }
+    logger.debug1 { _("Cloning '%{remote}' into %{path}") % {remote: remote, path: @path } }
 
     # libgit2/rugged doesn't support cloning a repository and providing an
     # alternate object database, making the handling of :alternates a noop.
@@ -60,23 +60,26 @@ class R10K::Git::Rugged::WorkingRepository < R10K::Git::Rugged::BaseRepository
   #
   # @param ref [String] The git reference to check out
   # @return [void]
-  def checkout(ref)
+  def checkout(ref, opts = {})
     sha = resolve(ref)
 
     if sha
-      logger.debug2 { "Checking out ref '#{ref}' (resolved to SHA '#{sha}') in repository #{@path}" }
+      logger.debug2 { _("Checking out ref '%{ref}' (resolved to SHA '%{sha}') in repository %{path}") % {ref: ref, sha: sha, path: @path} }
     else
       raise R10K::Git::GitError.new("Unable to check out unresolvable ref '#{ref}'", git_dir: git_dir)
     end
 
+    # :force defaults to true
+    force = !opts.has_key?(:force) || opts[:force]
+
     with_repo do |repo|
       repo.checkout(sha)
-      repo.reset(sha, :hard)
+      repo.reset(sha, :hard) if force
     end
   end
 
   def fetch(remote_name = 'origin')
-    logger.debug1 { "Fetching remote '#{remote_name}' at #{@path}" }
+    logger.debug1 { _("Fetching remote '%{remote}' at %{path}") % {remote: remote_name, path: @path} }
     options = {:credentials => credentials}
     refspecs = ["+refs/heads/*:refs/remotes/#{remote_name}/*"]
 
@@ -109,6 +112,10 @@ class R10K::Git::Rugged::WorkingRepository < R10K::Git::Rugged::BaseRepository
     with_repo { |repo| repo.config['remote.origin.url'] }
   end
 
+  def dirty?
+    with_repo { |repo| repo.diff_workdir('HEAD').size > 0 }
+  end
+
   private
 
   def with_repo

data/lib/r10k/git/shellgit/thin_repository.rb

@@ -39,6 +39,10 @@ class R10K::Git::ShellGit::ThinRepository < R10K::Git::ShellGit::WorkingReposito
     git(['config', '--get', 'remote.cache.url'], :path => @path.to_s, :raise_on_fail => false).stdout
   end
 
+  def tracked_paths(ref="HEAD")
+    git(['ls-tree', '-t', '-r', '--name-only', ref], :path => @path.to_s).stdout.split("\n")
+  end
+
   private
 
   def setup_cache_remote
@@ -58,7 +62,7 @@ class R10K::Git::ShellGit::ThinRepository < R10K::Git::ShellGit::WorkingReposito
     if git_dir.exist?
       entry_added = alternates.add?(@cache_repo.objects_dir.to_s)
       if entry_added
-        logger.debug2 { "Updated repo #{@path} to include alternate object db path #{@cache_repo.objects_dir}" }
+        logger.debug2 { _("Updated repo %{path} to include alternate object db path %{objects_dir}") % {path: @path, objects_dir: @cache_repo.objects_dir} }
       end
     end
   end

data/lib/r10k/git/shellgit/working_repository.rb

@@ -47,8 +47,16 @@ class R10K::Git::ShellGit::WorkingRepository < R10K::Git::ShellGit::BaseReposito
   # Check out the given Git ref
   #
   # @param ref [String] The git reference to check out
-  def checkout(ref)
-    git ['checkout', ref], :path => @path.to_s
+  # @param opts [Hash] Optional hash of additional options.
+  def checkout(ref, opts = {})
+    # :force defaults to true
+    if !opts.has_key?(:force) || opts[:force]
+      force_opt = '--force'
+    else
+      force_opt = ''
+    end
+
+    git ['checkout', ref, force_opt], :path => @path.to_s
   end
 
   def fetch(remote_name='origin')
@@ -80,4 +88,10 @@ class R10K::Git::ShellGit::WorkingRepository < R10K::Git::ShellGit::BaseReposito
       result.stdout
     end
   end
+
+  # does the working tree have local modifications to tracked files?
+  def dirty?
+    result = git(['diff-index', '--quiet','HEAD', '--'], :path => @path.to_s, :raise_on_fail => false)
+    result.exit_code != 0
+  end
 end

data/lib/r10k/git/stateful_repository.rb

@@ -13,48 +13,56 @@ class R10K::Git::StatefulRepository
   attr_reader :repo
 
   extend Forwardable
-  def_delegators :@repo, :head
+  def_delegators :@repo, :head, :tracked_paths
 
   # Create a new shallow git working directory
   #
-  # @param ref     [String] The git ref to check out
   # @param remote  [String] The git remote to use for the repo
   # @param basedir [String] The path containing the Git repo
   # @param dirname [String] The directory name of the Git repo
-  def initialize(ref, remote, basedir, dirname)
-    @ref = ref
+  def initialize(remote, basedir, dirname)
     @remote = remote
-
-    @cache = R10K::Git.cache.generate(remote)
+    @cache = R10K::Git.cache.generate(@remote)
     @repo = R10K::Git.thin_repository.new(basedir, dirname, @cache)
   end
 
-  def sync
-    @cache.sync if sync_cache?
+  def resolve(ref)
+    @cache.sync if sync_cache?(ref)
+    @cache.resolve(ref)
+  end
+
+  def sync(ref)
+    @cache.sync if sync_cache?(ref)
 
-    sha = @cache.resolve(@ref)
+    sha = @cache.resolve(ref)
 
     if sha.nil?
-      raise R10K::Git::UnresolvableRefError.new("Unable to sync repo to unresolvable ref '#{@ref}'", :git_dir => @repo.git_dir)
+      raise R10K::Git::UnresolvableRefError.new(_("Unable to sync repo to unresolvable ref '%{ref}'") % {ref: ref}, :git_dir => @repo.git_dir)
     end
 
-    case status
+    workdir_status = status(ref)
+
+    case workdir_status
     when :absent
-      logger.debug { "Cloning #{@repo.path} and checking out #{@ref}" }
+      logger.debug { _("Cloning %{repo_path} and checking out %{ref}") % {repo_path: @repo.path, ref: ref } }
       @repo.clone(@remote, {:ref => sha})
     when :mismatched
-      logger.debug { "Replacing #{@repo.path} and checking out #{@ref}" }
+      logger.debug { _("Replacing %{repo_path} and checking out %{ref}") % {repo_path: @repo.path, ref: ref } }
       @repo.path.rmtree
       @repo.clone(@remote, {:ref => sha})
-    when :outdated
-      logger.debug { "Updating #{@repo.path} to #{@ref}" }
-      @repo.checkout(sha)
+    when :outdated, :dirty
+      if workdir_status == :dirty
+        logger.warn { _("%{repo_path} has local modifications which will be overwritten") % {repo_path: @repo.path} }
+      end
+
+      logger.debug { _("Updating %{repo_path} to %{ref}") % {repo_path: @repo.path, ref: ref } }
+      @repo.checkout(sha, {:force => true})
     else
-      logger.debug { "#{@repo.path} is already at Git ref #{@ref}" }
+      logger.debug { _("%{repo_path} is already at Git ref %{ref}") % {repo_path: @repo.path, ref: ref } }
     end
   end
 
-  def status
+  def status(ref)
     if !@repo.exist?
       :absent
     elsif !@repo.git_dir.exist?
@@ -63,20 +71,22 @@ class R10K::Git::StatefulRepository
       :mismatched
     elsif !(@repo.origin == @remote)
       :mismatched
-    elsif !(@repo.head == @cache.resolve(@ref))
+    elsif !(@repo.head == @cache.resolve(ref))
       :outdated
-    elsif @cache.ref_type(@ref) == :branch && !@cache.synced?
+    elsif @cache.ref_type(ref) == :branch && !@cache.synced?
       :outdated
+    elsif @repo.dirty?
+      :dirty
     else
       :insync
     end
   end
 
   # @api private
-  def sync_cache?
+  def sync_cache?(ref)
     return true if !@cache.exist?
-    return true if !@cache.resolve(@ref)
-    return true if !([:commit, :tag].include? @cache.ref_type(@ref))
+    return true if !@cache.resolve(ref)
+    return true if !([:commit, :tag].include? @cache.ref_type(ref))
     return false
   end
 end

data/lib/r10k/initializers.rb

@@ -27,7 +27,7 @@ module R10K
     class GlobalInitializer < BaseInitializer
       def call
         with_setting(:purgedirs) do |_|
-          logger.warn("the purgedirs key in r10k.yaml is deprecated. it is currently ignored.")
+          logger.warn(_("the purgedirs key in r10k.yaml is deprecated. it is currently ignored."))
         end
 
         with_setting(:cachedir) { |value| R10K::Git::Cache.settings[:cache_root] = value }

data/lib/r10k/keyed_factory.rb

@@ -15,7 +15,7 @@ module R10K
 
     def register(key, klass)
       if @implementations.has_key?(key)
-        raise DuplicateImplementationError, "Class already registered for #{key}"
+        raise DuplicateImplementationError, _("Class already registered for %{key}") % {key: key}
       else
         @implementations[key] = klass
       end
@@ -29,7 +29,7 @@ module R10K
       if (impl = @implementations[key])
         impl.new(*args)
       else
-        raise UnknownImplementationError, "No class registered for #{key}"
+        raise UnknownImplementationError, _("No class registered for %{key}") % {key: key}
       end
     end
 

data/lib/r10k/logging.rb

@@ -57,7 +57,7 @@ module R10K::Logging
     def level=(val)
       level = parse_level(val)
       if level.nil?
-        raise ArgumentError, "Invalid log level '#{val}'. Valid levels are #{LOG_LEVELS.map(&:downcase).inspect}"
+        raise ArgumentError, _("Invalid log level '%{val}'. Valid levels are %{log_levels}") % {val: val, log_levels: LOG_LEVELS.map(&:downcase).inspect}
       end
       outputter.level = level
       @level = level

data/lib/r10k/module.rb

@@ -18,14 +18,15 @@ module R10K::Module
   # @param [String] name The unique name of the module
   # @param [String] basedir The root to install the module in
   # @param [Object] args An arbitary value or set of values that specifies the implementation
+  # @param [R10K::Environment] environment Optional environment that this module is a part of
   #
   # @return [Object < R10K::Module] A member of the implementing subclass
-  def self.new(name, basedir, args)
+  def self.new(name, basedir, args, environment=nil)
     if implementation = @klasses.find { |klass| klass.implement?(name, args) }
-      obj = implementation.new(name, basedir, args)
+      obj = implementation.new(name, basedir, args, environment)
       obj
     else
-      raise "Module #{name} with args #{args.inspect} doesn't have an implementation. (Are you using the right arguments?)"
+      raise _("Module %{name} with args %{args} doesn't have an implementation. (Are you using the right arguments?)") % {name: name, args: args.inspect}
     end
   end
 

data/lib/r10k/module/base.rb

@@ -36,12 +36,13 @@ class R10K::Module::Base
   # @param title [String]
   # @param dirname [String]
   # @param args [Array]
-  def initialize(title, dirname, args)
+  def initialize(title, dirname, args, environment=nil)
     @title   = PuppetForge::V3.normalize_name(title)
     @dirname = dirname
     @args    = args
     @owner, @name = parse_title(@title)
     @path = Pathname.new(File.join(@dirname, @name))
+    @environment = environment
   end
 
   # @deprecated
@@ -97,7 +98,7 @@ class R10K::Module::Base
     elsif (match = title.match(/\A(\w+)[-\/](\w+)\Z/))
       [match[1], match[2]]
     else
-      raise ArgumentError, "Module name (#{title}) must match either 'modulename' or 'owner/modulename'"
+      raise ArgumentError, _("Module name (%{title}) must match either 'modulename' or 'owner/modulename'") % {title: title}
     end
   end
 end

data/lib/r10k/module/forge.rb

@@ -13,7 +13,11 @@ class R10K::Module::Forge < R10K::Module::Base
   R10K::Module.register(self)
 
   def self.implement?(name, args)
-    !!(name.match %r[\w+[/-]\w+])
+    !!(name.match %r[\w+[/-]\w+]) && valid_version?(args)
+  end
+
+  def self.valid_version?(expected_version)
+    expected_version == :latest || expected_version.nil? || SemanticPuppet::Version.valid?(expected_version)
   end
 
   # @!attribute [r] metadata
@@ -28,8 +32,9 @@ class R10K::Module::Forge < R10K::Module::Base
 
   include R10K::Logging
 
-  def initialize(title, dirname, expected_version)
+  def initialize(title, dirname, expected_version, environment=nil)
     super
+
     @metadata_file = R10K::Module::MetadataFile.new(path + 'metadata.json')
     @metadata = @metadata_file.read
 
@@ -62,7 +67,7 @@ class R10K::Module::Forge < R10K::Module::Base
       begin
         @expected_version = @v3_module.current_release.version
       rescue Faraday::ResourceNotFound => e
-        raise PuppetForge::ReleaseNotFound, "The module #{@title} does not exist on #{PuppetForge::V3::Release.conn.url_prefix}.", e.backtrace
+        raise PuppetForge::ReleaseNotFound, _("The module %{title} does not exist on %{url}.") % {title: @title, url: PuppetForge::V3::Release.conn.url_prefix}, e.backtrace
       end
     end
     @expected_version
@@ -150,7 +155,7 @@ class R10K::Module::Forge < R10K::Module::Base
     if (match = title.match(/\A(\w+)[-\/](\w+)\Z/))
       [match[1], match[2]]
     else
-      raise ArgumentError, "Forge module names must match 'owner/modulename'"
+      raise ArgumentError, _("Forge module names must match 'owner/modulename'")
     end
   end
 end

data/lib/r10k/module/git.rb

@@ -18,53 +18,70 @@ class R10K::Module::Git < R10K::Module::Base
   #   @return [R10K::Git::StatefulRepository]
   attr_reader :repo
 
-  def initialize(title, dirname, args)
+  def initialize(title, dirname, args, environment=nil)
     super
+
     parse_options(@args)
-    @repo = R10K::Git::StatefulRepository.new(@ref, @remote, @dirname, @name)
+
+    @repo = R10K::Git::StatefulRepository.new(@remote, @dirname, @name)
   end
 
   def version
-    @ref
+    validate_ref(@desired_ref, @default_ref)
   end
 
   def properties
     {
-      :expected => @ref,
+      :expected => version,
       :actual   => (@repo.head || "(unresolvable)"),
       :type     => :git,
     }
   end
 
-  extend Forwardable
+  def sync
+    @repo.sync(version)
+  end
 
-  def_delegators :@repo, :sync, :status
+  def status
+    @repo.status(version)
+  end
 
   private
 
-  def parse_options(options)
-    @remote = options.delete(:git)
-
-    if options[:branch]
-      @ref = options.delete(:branch)
+  def validate_ref(desired, default)
+    if desired && @repo.resolve(desired)
+      return desired
+    elsif default && @repo.resolve(default)
+      return default
+    else
+      if default
+        raise ArgumentError, _("Unable to manage Puppetfile content '%{name}': Could not resolve desired ref '%{desired}' or default ref '%{default}'") % {name: @name, desired: desired, default: default}
+      else
+        raise ArgumentError, _("Unable to manage Puppetfile content '%{name}': Could not resolve desired ref '%{desired}' and no default given") % {name: @name, desired: desired}
+      end
     end
+  end
 
-    if options[:tag]
-      @ref = options.delete(:tag)
-    end
+  def parse_options(options)
+    ref_opts = [:branch, :tag, :commit, :ref]
+    known_opts = [:git, :default_branch] + ref_opts
 
-    if options[:commit]
-      @ref = options.delete(:commit)
+    unhandled = options.keys - known_opts
+    unless unhandled.empty?
+      raise ArgumentError, _("Unhandled options %{unhandled} specified for %{class}") % {unhandled: unhandled, class: self.class}
     end
 
-    if options[:ref]
-      @ref = options.delete(:ref)
-    end
+    @remote = options[:git]
 
-    @ref ||= 'master'
+    @desired_ref = ref_opts.find { |key| break options[key] if options.has_key?(key) } || 'master'
+    @default_ref = options[:default_branch]
 
-    unless options.empty?
-      raise ArgumentError, "Unhandled options #{options.keys.inspect} specified for #{self.class}"
+    if @desired_ref == :control_branch
+      if @environment && @environment.respond_to?(:ref)
+        @desired_ref = @environment.ref
+      else
+        raise ArgumentError, _("Cannot track control repo branch from Puppetfile in this context: environment is nil or did not provide a valid ref")
+      end
     end
   end
 end

data/lib/r10k/module/local.rb

@@ -31,6 +31,6 @@ class R10K::Module::Local < R10K::Module::Base
   end
 
   def sync
-    logger.debug1 "Module #{title} is a local module, always indicating synced."
+    logger.debug1 _("Module %{title} is a local module, always indicating synced.") % {title: title}
   end
 end

data/lib/r10k/module/metadata_file.rb

@@ -22,7 +22,7 @@ class R10K::Module::MetadataFile
           metadata = PuppetForge::Metadata.new
           metadata.update(JSON.load(f), false)
         rescue JSON::ParserError => e
-          exception = R10K::Error.wrap(e, "Could not read metadata.json")
+          exception = R10K::Error.wrap(e, _("Could not read metadata.json"))
           raise exception
         end
       end

data/lib/r10k/module/svn.rb

@@ -44,9 +44,11 @@ class R10K::Module::SVN < R10K::Module::Base
     :password => :self
   }
 
-  def initialize(name, dirname, opts)
+  def initialize(name, dirname, opts, environment=nil)
     super
+
     setopts(opts, INITIALIZE_OPTS)
+
     @working_dir = R10K::SVN::WorkingDir.new(@path, :username => @username, :password => @password)
   end