r10k 0.0.1rc1

data/bin/r10k

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'r10k/cli'
+
+R10K::CLI.command.run(ARGV)

data/lib/r10k.rb

@@ -0,0 +1,6 @@
+module R10K; end
+
+require 'r10k/root'
+require 'r10k/synchro/git'
+require 'r10k/librarian'
+require 'r10k/version'

data/lib/r10k/cli.rb

@@ -0,0 +1,33 @@
+require 'r10k'
+require 'cri'
+
+module R10K::CLI
+  def self.command
+    @cmd ||= Cri::Command.define do
+      name    'r10k'
+      usage   'r10k <subcommand> [options]'
+      summary 'Killer robot powered Puppet environment deployment'
+      description <<-EOD
+        r10k is a suite of commands to help deploy and manage puppet code for
+        complex environments.
+      EOD
+
+      flag :h, :help,  'show help for this command' do |value, cmd|
+        puts cmd.help
+        exit 0
+      end
+
+      required :c, :config, 'Specify a configuration file' do |value, cmd|
+        R10K::Deployment.instance.configfile = value
+      end
+
+      run do |opts, args, cmd|
+        puts cmd.help
+        exit 0
+      end
+    end
+  end
+end
+
+require 'r10k/cli/environment'
+require 'r10k/cli/module'

data/lib/r10k/cli/environment.rb

@@ -0,0 +1,26 @@
+require 'r10k/cli'
+require 'cri'
+
+module R10K::CLI
+  module Environment
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name  'environment'
+        usage 'environment <subcommand>'
+        summary 'Operate on a specific environment'
+
+        required :e, :environment, 'Specify a particular environment'
+
+        run do |opts, args, cmd|
+          puts cmd.help
+          exit 0
+        end
+      end
+    end
+  end
+  self.command.add_command(Environment.command)
+end
+
+require 'r10k/cli/environment/list'
+require 'r10k/cli/environment/deploy'
+require 'r10k/cli/environment/cache'

data/lib/r10k/cli/environment/cache.rb

@@ -0,0 +1,23 @@
+require 'r10k/cli/environment'
+require 'r10k/synchro/git'
+require 'cri'
+
+module R10K::CLI::Environment
+  module Cache
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name  'cache'
+        usage 'cache'
+        summary 'Update cache for all sources'
+
+        run do |opts, args, cmd|
+          R10K::Deployment.instance[:sources].each_pair do |name, source|
+            synchro = R10K::Synchro::Git.new(source)
+            synchro.cache
+          end
+        end
+      end
+    end
+  end
+  self.command.add_command(Cache.command)
+end

data/lib/r10k/cli/environment/deploy.rb

@@ -0,0 +1,46 @@
+require 'r10k/cli/environment'
+require 'r10k/deployment'
+require 'cri'
+
+require 'fileutils'
+
+module R10K::CLI::Environment
+  module Deploy
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name  'deploy'
+        usage 'deploy'
+        summary 'Deploy an environment'
+
+        flag :r, :recurse, 'Recursively update submodules'
+
+        required :u, :update, "Enable or disable cache updating"
+
+        run do |opts, args, cmd|
+          deployment = R10K::Deployment.instance
+          env_list   = deployment.environments
+
+          update_cache = (defined? opts[:update]) ? (opts[:update] == 'true') : false
+
+          if opts[:environment]
+            environments = env_list.select {|env| env.name == opts[:environment]}
+          else
+            environments = env_list
+          end
+
+          environments.each do |env|
+            FileUtils.mkdir_p env.full_path
+            env.sync! :update_cache => update_cache
+
+            if opts[:recurse]
+              env.modules.each do |mod|
+                mod.sync! :update_cache => update_cache
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  self.command.add_command(Deploy.command)
+end

data/lib/r10k/cli/environment/list.rb

@@ -0,0 +1,27 @@
+require 'r10k/cli/environment'
+require 'r10k/deployment'
+require 'cri'
+
+module R10K::CLI::Environment
+  module List
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name  'list'
+        usage 'list'
+        summary 'List all available environments'
+
+        run do |opts, args, cmd|
+          deployment = R10K::Deployment.instance
+          output = deployment.environments.inject('') do |str, root|
+            str << "  - "
+            str << "#{root.name}: #{root.full_path}"
+            str << "\n"
+          end
+
+          puts output
+        end
+      end
+    end
+  end
+  self.command.add_command(List.command)
+end

data/lib/r10k/cli/module.rb

@@ -0,0 +1,25 @@
+require 'r10k/cli'
+require 'cri'
+
+module R10K::CLI
+  module Module
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name  'module'
+        usage 'module <subcommand>'
+        summary 'Operate on a specific puppet module'
+
+        required :e, :environment, 'Specify a particular environment'
+
+        run do |opts, args, cmd|
+          puts cmd.help
+          exit 0
+        end
+      end
+    end
+  end
+  self.command.add_command(Module.command)
+end
+
+require 'r10k/cli/module/deploy'
+require 'r10k/cli/module/list'

data/lib/r10k/cli/module/deploy.rb

@@ -0,0 +1,55 @@
+require 'r10k/cli/module'
+require 'r10k/deployment'
+require 'cri'
+
+require 'fileutils'
+
+module R10K::CLI::Module
+  module Deploy
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name  'deploy'
+        usage 'deploy <module name>'
+        summary 'Deploy a module'
+
+        required :u, :update, "Enable or disable cache updating"
+
+        run do |opts, args, cmd|
+
+          unless (module_name = args[0])
+            puts cmd.help
+            exit 1
+          end
+
+          deployment = R10K::Deployment.instance
+          env_list   = deployment.environments
+
+          update_cache = (defined? opts[:update]) ? (opts[:update] == 'true') : false
+
+          if opts[:environment]
+            environments = env_list.select {|env| env.name == opts[:environment]}
+          else
+            environments = env_list
+          end
+
+          environments.each do |env|
+            FileUtils.mkdir_p env.full_path
+            env.sync! :update_cache => update_cache
+
+            mods = env.modules.select { |mod| mod.name == module_name }
+
+            if mods.empty?
+              puts "No modules with name #{module_name} matched in environments #{env.map(&:name).inspect}".red
+              exit 1
+            end
+
+            mods.each do |mod|
+              mod.sync! :update_cache => update_cache
+            end
+          end
+        end
+      end
+    end
+  end
+  self.command.add_command(Deploy.command)
+end

data/lib/r10k/cli/module/list.rb

@@ -0,0 +1,45 @@
+require 'r10k/cli/module'
+require 'r10k/deployment'
+require 'cri'
+
+module R10K::CLI::Module
+  module List
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name  'list'
+        usage 'list'
+        summary 'List modules that are instantiated in environments'
+
+        run do |opts, args, cmd|
+          deployment = R10K::Deployment.instance
+          env_list   = deployment.environments
+
+          update_cache = (defined? opts[:update]) ? (opts[:update] == 'true') : false
+
+          if opts[:environment]
+            environments = env_list.select {|env| env.name == opts[:environment]}
+          else
+            environments = env_list
+          end
+
+          printree = {}
+
+          environments.each do |env|
+            module_names = env.modules.map(&:name)
+
+            printree[env.name] = module_names
+          end
+
+          printree.each_pair do |env_name, mod_list|
+            puts "  - #{env_name}"
+            mod_list.each do |mod|
+              puts "      #{mod}"
+            end
+          end
+        end
+      end
+    end
+  end
+  self.command.add_command(List.command)
+end
+

data/lib/r10k/deployment.rb

@@ -0,0 +1,60 @@
+require 'r10k'
+require 'r10k/synchro/git'
+require 'r10k/environment_collection'
+require 'yaml'
+
+class R10K::Deployment
+  # Model a full installation of module directories and modules.
+
+  def self.instance
+    @myself ||= self.new
+  end
+
+  def initialize
+    @configfile   = File.join(Dir.getwd, "config.yaml")
+    @update_cache = true
+  end
+
+  attr_accessor :configfile
+
+  # Load up all module roots
+  #
+  # @return [Array<R10K::Root>]
+  def environments
+    collection = R10K::EnvironmentCollection.new(config)
+    collection.to_a
+  end
+
+  # Serve up the loaded config if it's already been loaded, otherwise try to
+  # load a config in the current wd.
+  def config
+    load_config unless @config
+    @config
+  end
+
+  # @return [Object] A top level key from the config hash
+  def setting(key)
+    self.config[key]
+  end
+  alias_method :[], :setting
+
+  private
+
+  # Load and store a config file, and set relevant options
+  #
+  # @param [String] configfile The path to the YAML config file
+  def load_config
+    File.open(@configfile) { |fh| @config = YAML.load(fh.read) }
+    apply_config_settings
+    @config
+  rescue => e
+    raise "Couldn't load #{configfile}: #{e}"
+  end
+
+  # Apply config settings to the relevant classes after a config has been loaded.
+  def apply_config_settings
+    if @config[:cachedir]
+      R10K::Synchro::Git.cache_root = @config[:cachedir]
+    end
+  end
+end

data/lib/r10k/environment_collection.rb

@@ -0,0 +1,53 @@
+require 'r10k'
+
+class R10K::EnvironmentCollection
+
+  attr_reader :update_cache
+
+  def initialize(config, options = {:update_cache => true})
+    @config       = config
+    @environments = []
+
+    @update_cache = options.delete(:update_cache)
+
+    load_all
+  end
+
+  # List subdirectories that aren't associated with an env
+  #
+  # If a branch associated with an environment is deleted then the associated
+  # branch ceases to be tracked. This method will scan a directory for
+  # subdirectories and return any subdirectories that don't have an active
+  # branch associated.
+  #
+  # @param [String] basedir The directory to scan
+  #
+  # @return [Array<String>] A list of filenames
+  def untracked_environments(basedir)
+    raise NotImplementedError
+  end
+
+  # @return [Array<R10K::Root>]
+  def to_a
+    @environments
+  end
+
+  private
+
+  def load_all
+    @config[:sources].each_pair do |repo_name, repo_config|
+      synchro = R10K::Synchro::Git.new(repo_config['remote'])
+      synchro.cache if @update_cache
+
+      if repo_config['ref']
+        @environments << R10K::Root.new(repo_config)
+      else
+        synchro.branches.each do |branch|
+          @environments << R10K::Root.new(repo_config.merge({'ref' => branch}))
+        end
+      end
+    end
+
+    @environments
+  end
+end

data/lib/r10k/librarian.rb

@@ -0,0 +1,31 @@
+require 'r10k'
+require 'r10k/module'
+
+class R10K::Librarian
+
+  attr_reader :forge
+
+  def initialize(puppetfile)
+    @puppetfile = puppetfile
+    @modules    = []
+    @forge      = 'forge.puppetlabs.com'
+  end
+
+  def load
+    dsl = R10K::Librarian::DSL.new(self)
+    dsl.instance_eval(File.read(@puppetfile), @puppetfile)
+
+    @modules
+  end
+
+  # This method only exists because people tried being excessively clever.
+  def set_forge(forge)
+    @forge = forge
+  end
+
+  def add_module(name, args)
+    @modules << [name, args]
+  end
+end
+
+require 'r10k/librarian/dsl'

data/lib/r10k/librarian/dsl.rb

@@ -0,0 +1,20 @@
+require 'r10k/librarian'
+
+class R10K::Librarian::DSL
+
+  def initialize(librarian)
+    @librarian = librarian
+  end
+
+  def mod(name, args = [])
+    @librarian.add_module(name, args)
+  end
+
+  def forge(location)
+    @librarian.set_forge(location)
+  end
+
+  def method_missing(method, *args)
+    raise NoMethodError, "unrecognized declaration '#{method}'"
+  end
+end

data/lib/r10k/module.rb

@@ -0,0 +1,45 @@
+require 'r10k'
+
+class R10K::Module
+
+  # Register an inheriting  class for later generation
+  def self.inherited(klass)
+    @klasses ||= []
+    @klasses << klass
+  end
+
+  # Look up the implementing class and instantiate an object
+  #
+  # This method takes the arguments for normal object generation and checks all
+  # inheriting classes to see if they implement the behavior needed to create
+  # the requested object. It selects the first class that can implement an object
+  # with `name, args`, and generates an object of that class.
+  #
+  # @param [String] name The unique name of the module
+  # @param [String] path The root path to install the module in
+  # @param [Object] args An arbitary value or set of values that specifies the implementation
+  #
+  # @return [Object < R10K::Module] A member of the implementing subclass
+  def self.new(name, path, args)
+    if implementation = @klasses.find { |klass| klass.implements(name, args) }
+      obj = implementation.send(:allocate)
+      obj.send(:initialize, name, path, args)
+      obj
+    else
+      raise "Module #{name} with args #{args.inspect} doesn't have an implementation. (Are you using the right arguments?)"
+    end
+  end
+
+  attr_accessor :name, :path
+
+  def initialize(name, path, args)
+    @name, @path, @args = name, path, args
+  end
+
+  def full_path
+    File.join(@path, @name)
+  end
+end
+
+require 'r10k/module/git'
+require 'r10k/module/forge'

data/lib/r10k/module/forge.rb

@@ -0,0 +1,19 @@
+require 'r10k'
+require 'r10k/module'
+
+class R10K::Module::Forge < R10K::Module
+
+  def self.implements(name, args)
+    args.is_a? String and args.match /\d+\.\d+\.\d+/
+  end
+
+  def initialize(name, path, args)
+    super
+
+    @version = @args
+  end
+
+  def sync!(options = {})
+    puts "#{self.class.name}#sync! is not implemented. Doing nothing."
+  end
+end

data/lib/r10k/module/git.rb

@@ -0,0 +1,24 @@
+require 'r10k'
+require 'r10k/module'
+require 'r10k/synchro/git'
+
+class R10K::Module::Git < R10K::Module
+
+  def self.implements(name, args)
+    args.is_a? Hash and args.has_key?(:git)
+  rescue
+    false
+  end
+
+  def initialize(name, path, args)
+    super
+
+    @remote = @args[:git]
+    @ref    = (@args[:ref] || 'master')
+  end
+
+  def sync!(options = {})
+    synchro = R10K::Synchro::Git.new(@remote)
+    synchro.sync(full_path, @ref, options)
+  end
+end

data/lib/r10k/root.rb

@@ -0,0 +1,95 @@
+require 'r10k'
+require 'r10k/module'
+require 'r10k/synchro/git'
+
+class R10K::Root
+
+  # @!attribute [r] name
+  #   The directory name of this root
+  attr_reader :name
+
+  # @!attribute [r] basedir
+  #   The basedir to clone the root into
+  attr_reader :basedir
+
+  # @!attribute [r] remote
+  #   The location of the remote git repository
+  attr_reader :remote
+
+  # @!attribute [r] ref
+  #   The git ref to instantiate into the basedir
+  attr_reader :ref
+
+  def initialize(hash)
+    parse_initialize_hash(hash)
+  end
+
+  def sync!(options = {})
+    synchro = R10K::Synchro::Git.new(@remote)
+    recursive_needed = !(synchro.cloned?(full_path))
+    synchro.sync(full_path, @ref, options)
+
+    sync_modules!(options) if recursive_needed
+  end
+
+  def sync_modules!(options = {})
+    modules.each do |mod|
+      mod.sync!(options)
+    end
+  end
+
+  def modules
+    librarian = R10K::Librarian.new("#{full_path}/Puppetfile")
+
+    module_data = librarian.load
+
+    @modules = module_data.map do |mod|
+      name = mod[0]
+      args = mod[1]
+      R10K::Module.new(name, "#{full_path}/modules", args)
+    end
+  rescue Errno::ENOENT
+    puts "#{self}: #{full_path} does not exist, cannot enumerate modules."
+    []
+  end
+
+  def full_path
+    @full_path ||= File.expand_path(File.join @basedir, @name)
+  end
+
+  private
+
+  def parse_initialize_hash(hash)
+    if hash['name']
+      @name = hash.delete('name')
+    elsif hash['ref']
+      @name = hash['ref']
+    else
+      raise "Unable to resolve directory name from options #{hash.inspect}"
+    end
+
+    # XXX This could be metaprogrammed, but it seems like the road to madness.
+
+    if hash['basedir']
+      @basedir = hash.delete('basedir')
+    else
+      raise "'basedir' is a required value for #{self.class}.new"
+    end
+
+    if hash['remote']
+      @remote = hash.delete('remote')
+    else
+      raise "'remote' is a required value for #{self.class}.new"
+    end
+
+    if hash['ref']
+      @ref = hash.delete('ref')
+    else
+      raise "'ref' is a required value for #{self.class}.new"
+    end
+
+    unless hash.empty?
+      raise "#{self.class}.new only expects keys ['name', 'basedir', 'remote', 'ref'], got #{hash.keys.inspect}"
+    end
+  end
+end

data/lib/r10k/synchro/git.rb

@@ -0,0 +1,186 @@
+require 'r10k'
+require 'shellter'
+require 'fileutils'
+
+module R10K::Synchro; end
+
+class R10K::Synchro::Git
+  # Define a thingy that can synchronize git repositories.
+  #
+  # This class is built to be a general purpose mechanism for syncing and
+  # caching git repositories.
+  #
+  # Class instances are memoized based on the git remote path. This way if a
+  # single git repository is instantiated multiple times, the object cache
+  # will only be updated once.
+
+  class << self
+    attr_accessor :cache_root
+
+    # @return [Hash<R10K::Synchro::Git>] A hash of memoized class instances
+    def synchros
+      @synchros ||= {}
+    end
+
+    # Memoize class instances and return existing instances.
+    #
+    # This allows objects to mark themselves as cached to prevent unnecessary
+    # cache refreshes.
+    #
+    # @param [String] remote A git remote URL
+    # @return [R10K::Synchro::Git]
+    def new(remote)
+      unless synchros[remote]
+        obj = self.allocate
+        obj.send(:initialize, remote)
+        synchros[remote] = obj
+      end
+      synchros[remote]
+    end
+  end
+
+  attr_reader :remote
+
+  # Instantiates a new git synchro and optionally prepares for caching
+  #
+  # @param [String] remote A git remote URL
+  def initialize(remote)
+    @remote = remote
+
+    if self.class.cache_root
+      @cache_path = File.join(self.class.cache_root, @remote.gsub(/[^@\w-]/, '-'))
+    end
+  end
+
+  # Synchronize the local git repository.
+  #
+  # @param [String] path The destination path for the files
+  # @param [String] ref The git ref to instantiate at the destination path
+  def sync(path, ref, options = {:update_cache => true})
+    path = File.expand_path(path)
+    cache if options[:update_cache]
+
+    if self.cloned?(path)
+      fetch(path)
+    else
+      clone(path)
+    end
+    reset(path, ref)
+  end
+
+  # @return [TrueClass] if the git repository is cached
+  def has_cache?
+    @cache_path and File.directory? @cache_path
+  end
+
+  # Determine if repo has been cloned into a specific dir
+  #
+  # @param [String] dirname The directory to check
+  #
+  # @return [true, false] If the repo has already been cloned
+  def cloned?(directory)
+    File.directory?(File.join(directory, '.git'))
+  end
+
+  # Update the git object cache repository if it hasn't been done
+  #
+  # @return [true, nil] If the cache was actually updated
+  def cache
+    unless @cached
+      cache!
+      @cached = true
+    end
+  end
+
+  # Force a cache refresh
+  def cache!
+    if has_cache?
+      git "--git-dir #{@cache_path} fetch --prune"
+    else
+      FileUtils.mkdir_p File.dirname(File.join(@cache_path))
+      git "clone --mirror #{@remote} #{@cache_path}"
+    end
+  end
+
+  # Retrieve a list of cached branches for the git repo associated with this
+  # object.
+  #
+  # @return [Array<String>] A list of all cached remote branches
+  def branches
+    cache
+    output = git "--git-dir #{@cache_path} branch"
+    output.split("\n").map { |str| str[2..-1] }
+  end
+
+  private
+
+  # Perform a non-bare clone of a git repository.
+  #
+  # If a cachedir is available and the repo is already cached, it will be
+  # used as an object reference to speed up the clone.
+  #
+  # @param [String] path The directory to create the repo working directory
+  def clone(path)
+    if has_cache?
+      git "clone --reference #{@cache_path} #{@remote} #{path}"
+    else
+      FileUtils.mkdir_p path unless File.directory? path
+      git "clone #{@remote} #{path}"
+    end
+  end
+
+  def fetch(path)
+    if has_cache?
+      git "fetch --prune #{@cache_path}", path
+    else
+      git "fetch --prune", path
+    end
+  end
+
+  # Reset a git repo with a working directory to a specific ref
+  #
+  # @param [String] path The path to the working directory of the git repo
+  # @param [String] ref The git reference to reset to.
+  def reset(path, ref)
+
+    # Helloooo, hackery. Try to parse the ref as a commit object. If that fails
+    # this probably means that the ref is a remote branch. For the sake of
+    # brevity this code blindly makes that assumption on the failure of 
+    # `git rev-parse`.
+    begin
+      commit = git "--git-dir #{@cache_path} rev-parse #{ref}^{commit}"
+    rescue RuntimeError => e
+      commit = "origin/#{ref}"
+    end
+
+    git "reset --hard #{commit}", path
+  end
+
+  # Wrap git commands
+  #
+  # @param [String] command_line_args The arguments for the git prompt
+  # @param [String] git_dir An optional git working directory
+  #
+  # @return [String] The git command output
+  def git(command_line_args, git_dir = nil)
+    args = []
+
+    if git_dir
+      args << "--work-tree" << git_dir
+      args << "--git-dir"   << "#{git_dir}/.git"
+    end
+
+    args << command_line_args.split(/\s+/)
+
+    result = Shellter.run!('git', args.join(' '))
+    puts "Execute: #{result.last_command}".green
+
+    stderr = result.stderr.read
+    stdout = result.stdout.read
+
+    puts stdout.blue unless stdout.empty?
+    puts stderr.red  unless stderr.empty?
+
+    stdout
+  end
+end

data/lib/r10k/util/interp.rb

@@ -0,0 +1,25 @@
+
+module R10K; end
+module R10K::Util; end
+
+module R10K::Util::Interp
+
+  # Interpolate a string with a given scope
+  #
+  # @param [String] string
+  # @param [Hash]   scope
+  #
+  # @return [String]
+  def interpolate_string(string, scope)
+
+    interp = string.clone
+
+    while (matchdata = interp.match /%\{.+?\}/)
+      var_name = matchdata[1].intern
+      var_data = scope[var_name]
+      interp.gsub!(/%\{#{var_name}\}/, var_data)
+    end
+
+    interp
+  end
+end

data/lib/r10k/version.rb

@@ -0,0 +1,3 @@
+module R10K
+  VERSION = '0.0.1rc1'
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: r10k
+version: !ruby/object:Gem::Version
+  version: 0.0.1rc1
+  prerelease: 5
+platform: ruby
+authors:
+- adrien@somethingsinistral.net
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: shellter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+- !ruby/object:Gem::Dependency
+  name: popen4
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+description: ! "    R10K is an implementation of the Dynamic Puppet environments based
+  on git repositories\n    as described in http://puppetlabs.com/blog/git-workflow-and-puppet-environments/.
+  It\n    aggressively caches and tries to minimize network activity to ensure that
+  interactive\n    deployment is as fast as possible.\n"
+email: 
+executables:
+- r10k
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/r10k
+- lib/r10k/cli/environment/cache.rb
+- lib/r10k/cli/environment/deploy.rb
+- lib/r10k/cli/environment/list.rb
+- lib/r10k/cli/environment.rb
+- lib/r10k/cli/module/deploy.rb
+- lib/r10k/cli/module/list.rb
+- lib/r10k/cli/module.rb
+- lib/r10k/cli.rb
+- lib/r10k/deployment.rb
+- lib/r10k/environment_collection.rb
+- lib/r10k/librarian/dsl.rb
+- lib/r10k/librarian.rb
+- lib/r10k/module/forge.rb
+- lib/r10k/module/git.rb
+- lib/r10k/module.rb
+- lib/r10k/root.rb
+- lib/r10k/synchro/git.rb
+- lib/r10k/util/interp.rb
+- lib/r10k/version.rb
+- lib/r10k.rb
+homepage: http://github.com/adrienthebo/r10k
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Dynamic Puppet environments with Git
+test_files: []