librarian-puppet-simple.haf 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rspec
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1 @@
+Apache License 2.0

data/README.md

@@ -0,0 +1,73 @@
+# librarian-puppet-simple
+
+This project was created out of my frustration with dependency management in librarian-puppet, some people need external dependencies, I just need to be able to pin revisions for a collection of modules, and I found the dependency managment features of librarian-puppet too heavy for my simple use case.
+
+This project just has fewer commands, but they should be compatible with the original librarian-puppet:
+
+### Clean
+Remove the directory where the modules will be installed. At the moment the supported options are:
+* `--verbose` display progress messages
+* `--path` override the default `./modules` where modules will be installed
+
+```
+  librarian-puppet clean [--verbose] [--path]
+```
+
+### Install
+Iterates through your Puppetfile and installs git sources. At the moment the supported options are:
+* `--verbose` display progress messages
+* `--clean` remove the directory before installing modules
+* `--path` override the default `./modules` where modules will be installed
+* `--puppetfile` override the default `./Puppetfile` used to find the modules
+
+```
+  librarian-puppet install [--verbose] [--clean] [--path] [--puppetfile]
+```
+
+### Update
+Iterates through your Puppetfile and updates git sources. If a SHA-1 hash is specified in the `:ref`, the module will not be updated.
+
+Supported options are:<br/>
+<li>`--verbose` display progress messages</li>
+<li>`--path` override the default `./modules` where modules will be installed</li>
+<li> `--puppetfile` override the default `./Puppetfile` used to find the modules</li>
+
+```
+  librarian-puppet update [--verbose] [--path] [--puppetfile]
+```
+
+## Puppetfile
+The processed Puppetfile may contain two different types of modules, `git` and `tarball`. The `git` option accepts an optional `ref` parameter.
+
+The module names can be namespaced, but the created directory will only contain the last part of the name. For example, a module named `puppetlabs/ntp` will generate a directory `ntp`, and so will a module simply named `ntp`.
+
+Here's an example of a valid Puppetfile showcasing all valid options:
+
+```
+mod "puppetlabs/ntp",
+    :git => "git://github.com/puppetlabs/puppetlabs-ntp.git",
+    :ref => "99bae40f225db0dd052efbf1d4078a21f0333331"
+
+mod "apache",
+    :tarball => "https://forge.puppetlabs.com/puppetlabs/apache/0.6.0.tar.gz"
+
+#Deploy mysql module into modules/databases/mysql with the :subdir param
+mod "mysql",
+    :git => "gitolite@myserver.com:mysql.git",
+    :subdir => "databases"
+```
+## Setting up for development and running the specs
+Just clone the repo and run the following commands:
+```
+bundle exec install --path=vendor
+bundle exec rspec
+```
+
+Beware that the functional tests will download files from GitHub and PuppetForge and will break if either is unavailable.
+
+## License
+
+See [LICENSE](/LICENSE)
+
+## Credits
+The untar and ungzip methods came from https://gist.github.com/sinisterchipmunk/1335041

data/bin/librarian-puppet

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'thor'
+lib = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib) unless $:.include?(lib)
+require 'librarian/puppet/simple/cli'
+
+Librarian::Puppet::Simple::CLI.bin!

data/lib/librarian/puppet/simple/cli.rb

@@ -0,0 +1,281 @@
+require 'librarian/puppet/simple/installer'
+require 'librarian/puppet/simple/iterator'
+require 'fileutils'
+
+module Librarian
+  module Puppet
+    module Simple
+      class CLI < Thor
+
+        include Librarian::Puppet::Simple::Util
+        include Librarian::Puppet::Simple::Installer
+        include Librarian::Puppet::Simple::Iterator
+
+        class_option :verbose, :type => :boolean,
+                     :desc => 'verbose output for executed commands'
+
+        class_option :path, :type => :string,
+                     :desc => "overrides target directory, default is ./modules"
+        class_option :puppetfile, :type => :string,
+                     :desc => "overrides used Puppetfile",
+                     :default => './Puppetfile'
+
+
+        def self.bin!
+          start
+        end
+
+        desc 'install', 'installs all git sources from your Puppetfile'
+        method_option :clean, :type => :boolean, :desc => "calls clean before executing install"
+        def install
+          @verbose = options[:verbose]
+          clean if options[:clean]
+          @custom_module_path = options[:path]
+          # evaluate the file to populate @modules
+          eval(File.read(File.expand_path(options[:puppetfile])))
+          install!
+        end
+
+        desc 'update', 'updates all git sources from your Puppetfile'
+        method_option :update, :type => :boolean, :desc => "Updates git sources"
+        def update
+          @verbose = options[:verbose]
+          @custom_module_path = options[:path]
+          eval(File.read(File.expand_path(options[:puppetfile])))
+          each_module_of_type(:git) do |repo|
+            Dir.chdir(File.join(module_path, repo[:name])) do
+              # if no ref is given, assume master
+              if repo[:ref] == nil
+                checkout_ref  = 'origin/master'
+                remote_branch = 'master'
+              else
+                checkout_ref  = repo[:ref]
+                remote_branch = repo[:ref].gsub(/^origin\//, '')
+              end
+              print_verbose "\n\n#{repo[:name]} -- git fetch origin && git checkout #{checkout_ref}"
+              git_pull_cmd = system_cmd("git fetch origin && git checkout #{checkout_ref}")
+            end
+          end
+        end
+
+        desc 'clean', 'clean modules directory'
+        def clean
+          target_directory = options[:path] || File.expand_path("./modules")
+          puts "Target Directory: #{target_directory}" if options[:verbose]
+          FileUtils.rm_rf target_directory
+        end
+
+        desc 'git_status', 'determine the current status of checked out git repos'
+        def git_status
+          @custom_module_path = options[:path]
+          # populate @modules
+          eval(File.read(File.expand_path(options[:puppetfile])))
+          each_module_of_type(:git) do |repo|
+            Dir.chdir(File.join(module_path, repo[:name])) do
+              status = system_cmd('git status')
+              if status.include?('nothing to commit (working directory clean)')
+                puts "Module #{repo[:name]} has not changed" if options[:verbose]
+              else
+                puts "Uncommitted changes for: #{repo[:name]}"
+                puts "  #{status.join("\n  ")}"
+              end
+            end
+          end
+        end
+
+        desc 'dev_setup', 'adds development r/w remotes to each repo (assumes remote has the same name as current repo)'
+        def dev_setup(remote_name)
+          @custom_module_path = options[:path]
+          # populate @modules
+          eval(File.read(File.expand_path(options[:puppetfile])))
+          each_module_of_type(:git) do |repo|
+            Dir.chdir(File.join((options[:path] || 'modules'), repo[:name])) do
+              print_verbose "Adding development remote for git repo #{repo[:name]}"
+              remotes = system_cmd('git remote')
+              if remotes.include?(remote_name)
+                puts "Did not have to add remote #{remote_name} to #{repo[:name]}"
+              elsif ! remotes.include?('origin')
+                raise(TestException, "Repo #{repo[:name]} has no remote called origin, failing")
+              else
+                remote_url = system_cmd('git remote show origin').detect {|x| x =~ /\s+Push\s+URL: / }
+                if remote_url =~ /(git|https?):\/\/(.+)\/(.+)?\/(.+)/
+                  url = "git@#{$2}:#{remote_name}/#{$4}"
+                  puts "Adding remote #{remote_name} as #{url}"
+                  system_cmd("git remote add #{remote_name} #{url}")
+                elsif remote_url =~ /^git@/
+                  puts "Origin is already a read/write remote, skipping b/c this is unexpected"
+                else
+                  puts "remote_url #{remote_url} did not have the expected format. weird..."
+                end
+              end
+            end
+          end
+        end
+
+        #
+        # I am not sure if anyone besides me (Dan Bode) should use this command.
+        # It is specifically for the use case where you are managing downstream versions
+        # of Puppet modules, where you want to track the relationship between your downstream
+        # forks and upstream.
+        # It required a specially formatted Puppetfile that expects an environment variable called
+        # repo_to_use that accepts the values 'upstream' and 'downstream'. It should use that environment
+        # variable to be able to generate either the upstream or downstream set of repos.
+        #
+        # Given those requirements, it can be used to compare the revision history differences betwee
+        # those commits.
+        #
+        desc 'compare_repos', 'compares the specified upstream and downstream repos'
+        method_option :output_file, :type => :string,
+          :desc => "Name of Puppetfile to save the results as"
+        method_option :ignore_merges, :type => :boolean,
+          :desc => 'Indicates that merge commits should be ignored'
+        method_option :show_diffs, :type => :boolean,
+          :desc => 'Show code differences of divergent commits (add -u)'
+        # I was really just using this for testing
+        # not sure if end users need it
+        method_option :existing_tmp_dir, :type => :string,
+          :desc => 'Uses an existing directory. Assumes the downstream repos have already been populated.'
+        method_option :upstream_only, :type => :boolean,
+          :desc => 'Only show commits that are only in the upstream'
+        method_option :downstream_only, :type => :boolean,
+          :desc => 'Only show commits that are only in downstream'
+        method_option :oneline, :type => :boolean,
+          :desc => 'Condense log output to one line'
+
+
+        def compare_repos
+
+          repo_hash = {}
+          @verbose            = options[:verbose]
+          abort('path not supported by compare_repos command') if options[:path]
+          if options[:downstream_only] and options[:upstream_only]
+            abort('Cannot specify both downstream_only and upstream_only')
+          end
+
+          # create path where code will be stored
+          if options[:existing_tmp_dir]
+            path = options[:existing_tmp_dir]
+          else
+            path = File.join('.tmp', Time.now.strftime("%Y_%m_%d_%H_%S"))
+          end
+
+          FileUtils.mkdir_p(path)
+          @custom_module_path = path
+
+          # install the downstream modules in our tmp directory and build out a hash
+          downstream = build_puppetfile_hash('downstream', !options[:existing_tmp_dir])
+          # just build a hash of the downstream modules
+          upstream   = build_puppetfile_hash('upstream', false)
+
+          unless ( (downstream.keys - upstream.keys) == [] and
+                   (upstream.keys - downstream.keys)
+                 )
+            abort('Your Puppetfile did not produce the same upstream and downstream repos, this is not yet supported')
+          else
+
+            upstream.each do |us_name, us_repo|
+              # compare to see if the source of revisions are the same
+              ds_repo = downstream[us_name]
+              if ds_repo[:git] == us_repo[:git] and ds_repo[:ref] == us_repo[:ref]
+                print_verbose("\nSources of #{us_name} are the same, nothing to compare.")
+              else
+                Dir.chdir(File.join(path, us_name)) do
+                  if us_repo[:git] =~ /(git|https?):\/\/(.+)\/(.+)?\/(.+)/
+                    remote_name = $3
+                    remotes = system_cmd('git remote')
+                    if remotes.include?(remote_name)
+                      puts "Did not have to add remote #{remote_name} to #{us_repo[:name]}, it was already there"
+                    else
+                      puts "Adding remote #{remote_name} #{us_repo[:git]}"
+                      system_cmd("git remote add #{remote_name} #{us_repo[:git]}")
+                    end
+                    system_cmd("git fetch #{remote_name}")
+                    if us_repo[:ref] =~ /^origin\/(\S+)$/
+                      compare_ref = "#{remote_name}/#{$1}"
+                    else
+                      compare_ref = "#{remote_name}/#{us_repo[:ref]}"
+                    end
+
+                    # set up parameters for git log call
+                    ignore_merges = options[:ignore_merges] ? '--no-merges' : ''
+                    show_diffs    = options[:show_diffs]    ? '-u' : ''
+                    oneline       = options[:oneline]       ? '--oneline' : ''
+                    # show the results, this assumes that HEAD is up-to-date (which it should be)
+
+                    if options[:downstream_only] and options[:upstream_only]
+                      abort('Cannot specify both downstream_only and upstream_only')
+                    end
+                    puts "########## Results for #{us_name} ##########"
+                    unless options[:upstream_only]
+                      puts "  ######## Commits only in downstream ########"
+                      results = system_cmd("git log --left-only HEAD...#{compare_ref} #{ignore_merges} #{show_diffs} #{oneline}", true)
+                      puts "  ######## End Downstream results ########"
+                    end
+                    unless options[:downstream_only]
+                      puts "  ######## Commits only in upstream ########"
+                      results = system_cmd("git log --right-only HEAD...#{compare_ref} #{ignore_merges} #{show_diffs} #{oneline}", true)
+                      puts "  ######## End upstream ########"
+                    end
+                    puts "########## End of Results for #{us_name} ##########"
+                  else
+                    abort("Unrecognizable upstream url #{us_repo[:git]}")
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        desc 'generate_puppetfile', 'generates a static version of the Puppetfile'
+        method_option :out_file,
+          :desc => 'output file where static puppetfile should be written to'
+        def generate_puppetfile
+          eval(File.read(File.expand_path(options[:puppetfile])))
+          if options[:out_file]
+            File.open(options[:out_file], 'w') do |fh|
+              print_puppet_file(fh)
+            end
+          else
+            print_puppet_file(STDOUT)
+          end
+        end
+
+        private
+
+          def print_puppet_file(stream)
+            each_module do |repo|
+              repo.delete(:name)
+              out_str = repo.delete(:full_name)
+              repo.each do |k,v|
+                out_str << ", :#{k} => #{v}"
+              end
+              stream.puts(out_str)
+            end
+          end
+
+          # builds out a certain type of repo
+          def build_puppetfile_hash(name, perform_installation=false)
+            repo_hash = {}
+            # set environment variable to determine what version of modules to install
+            # this assumes that the environment variable repos_to_use has been coded in
+            # your Puppetfile to allow installation of different versions of modules
+            ENV['repos_to_use'] = name
+            # parse Puppetfile and install modules in our tmp directory.
+            eval(File.read(File.expand_path(options[:puppetfile])))
+            # install modules if desired
+            install! if perform_installation
+
+            # iterate through all git modules
+            each_module_of_type(:git) do |git_repo|
+              abort("Module git_repo[:name] was defined multiple times in same Puppetfile") if repo_hash[git_repo[:name]]
+              repo_hash[git_repo[:name]] = git_repo
+            end
+            # clear out the modules once finished
+            clear_modules
+            repo_hash
+          end
+
+      end
+    end
+  end
+end

data/lib/librarian/puppet/simple/installer.rb

@@ -0,0 +1,116 @@
+require 'fileutils'
+require 'rubygems/package'
+require 'zlib'
+require 'open-uri'
+require 'librarian/puppet/simple/util'
+require 'librarian/puppet/simple/iterator'
+
+# This is an extremely simple file that can consume
+# a Puppet file with git references
+#
+# It does absolutely no dependency resolution by design.
+#
+module Librarian
+  module Puppet
+    module Simple
+      module Installer
+
+        include Librarian::Puppet::Simple::Util
+        include Librarian::Puppet::Simple::Iterator
+
+        # installs modules using the each_module method from our
+        # iterator mixin
+        def install!
+          each_module do |repo|
+            print_verbose "\n##### processing module #{repo[:name]}..."
+            module_path = module_path()
+            if repo[:subdir] 
+              module_path = File.join(module_path, repo[:subdir])
+              FileUtils.mkdir_p(module_path) unless File.exists?(module_path)
+            end
+            module_dir = File.join(module_path, repo[:name])
+
+            unless File.exists?(module_dir)
+              case
+              when repo[:git]
+                install_git module_path, repo[:name], repo[:git], repo[:ref]
+              when repo[:tarball]
+                install_tarball module_path, repo[:name], repo[:tarball]
+              else
+                abort('only the :git and :tarball provider are currently supported')
+              end
+            else
+              print_verbose "\nModule #{repo[:name]} already installed in #{module_path}"
+            end
+          end
+        end
+
+        private
+
+        # installs sources that are git repos
+        def install_git(module_path, module_name, repo, ref = nil)
+          module_dir = File.join(module_path, module_name)
+
+          Dir.chdir(module_path) do
+            print_verbose "cloning #{repo}"
+            system_cmd("git clone #{repo} #{module_name}")
+            Dir.chdir(module_dir) do
+              system_cmd('git branch -r')
+              system_cmd("git checkout #{ref}") if ref
+            end
+          end
+        end
+
+        def install_tarball(module_path, module_name, remote_tarball)
+          Dir.mktmpdir do |tmp|
+            temp_file = File.join(tmp,"downloaded_module.tar.gz")
+            File.open(temp_file, "w+b") do |saved_file|
+              print_verbose "Downloading #{remote_tarball}..."
+              open(remote_tarball, 'rb') do |read_file|
+                saved_file.write(read_file.read)
+              end
+              saved_file.rewind
+
+              target_directory = File.join(module_path, module_name)
+              print_verbose "Extracting #{remote_tarball} to #{target_directory}..."
+              unzipped_target = ungzip(saved_file)
+              tarfile_full_name = untar(unzipped_target, module_path)
+              FileUtils.mv File.join(module_path, tarfile_full_name), target_directory
+            end
+          end
+        end
+
+        # un-gzips the given IO, returning the
+        # decompressed version as a StringIO
+        def ungzip(tarfile)
+          z = Zlib::GzipReader.new(tarfile)
+          unzipped = StringIO.new(z.read)
+          z.close
+          unzipped
+        end
+
+        # untars the given IO into the specified
+        # directory
+        def untar(io, destination)
+          tarfile_full_name = nil
+          Gem::Package::TarReader.new io do |tar|
+            tar.each do |tarfile|
+              tarfile_full_name ||= tarfile.full_name
+              destination_file = File.join destination, tarfile.full_name
+              if tarfile.directory?
+                FileUtils.mkdir_p destination_file
+              else
+                destination_directory = File.dirname(destination_file)
+                FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+                File.open destination_file, "wb" do |f|
+                  f.write tarfile.read
+                end
+              end
+            end
+          end
+          tarfile_full_name
+        end
+      end
+    end
+  end
+end

data/lib/librarian/puppet/simple/iterator.rb

@@ -0,0 +1,56 @@
+require 'librarian/puppet/simple/util'
+
+module Librarian
+  module Puppet
+    module Simple
+      module Iterator
+
+        # evaluate a module and add it our @modules instance variable
+        def mod(name, options = {})
+          @modules ||= {}
+          full_name   = name
+          module_name = name.split('/', 2).last
+
+          case
+          when options[:git]
+            @modules[:git] ||= []
+            @modules[:git].push(options.merge(:name => module_name, :full_name => full_name))
+          when options[:tarball]
+            @modules[:tarball] ||= []
+            @modules[:tarball].push(options.merge(:name => module_name, :full_name => full_name))
+          else
+            @modules[:forge] ||= []
+            @modules[:forge].push(options.merge(:name => module_name, :full_name => full_name))
+            #abort('only the :git and :tarball providers are currently supported')
+          end
+        end
+
+        def modules
+          @modules
+        end
+
+        def clear_modules
+          @modules = nil
+        end
+
+        # iterate through all modules
+        def each_module(&block)
+          (@modules || {}).each do |type, repos|
+            (repos || []).each do |repo|
+              yield repo
+            end
+          end
+        end
+
+        # loop over each module of a certain type
+        def each_module_of_type(type, &block)
+          abort("undefined type #{type}") unless [:git, :tarball].include?(type)
+          ((@modules || {})[type] || []).each do |repo|
+            yield repo
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/puppet/simple/util.rb

@@ -0,0 +1,51 @@
+#
+# this module contains all of the base helper methods
+# used by the other actions
+#
+module Librarian
+  module Puppet
+    module Simple
+      module Util
+
+        def forge(repo)
+          # this does nothing atm
+        end
+        # figure out what directory we are working out og
+        def base_dir
+          @base_dir ||= Dir.pwd
+        end
+
+        # figure out what the modulepath is
+        def module_path(dir=base_dir)
+          unless @module_path
+            if @custom_module_path
+              @module_path = File.expand_path @custom_module_path
+            else
+              @module_path = File.join(dir, 'modules')
+            end
+            Dir.mkdir(@module_path) unless File.exists?(@module_path)
+          end
+          @module_path
+        end
+
+        # run a command on the system
+        def system_cmd (cmd, print_output=false)
+          print_verbose "Running cmd: #{cmd}"
+          output = `#{cmd}`.split("\n")
+          if print_output
+            puts output
+          else
+            print_verbose output
+          end
+          raise(StandardError, "Cmd #{cmd} failed") unless $?.success?
+          output
+        end
+
+        def print_verbose(text)
+          puts text if @verbose
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/puppet/simple/version.rb

@@ -0,0 +1,7 @@
+module Librarian
+  module Puppet
+    module Simple
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/librarian/puppet/simple.rb

@@ -0,0 +1,9 @@
+require "librarian/puppet/simple/version"
+
+module Librarian
+  module Puppet
+    module Simple
+      # Your code goes here...
+    end
+  end
+end

data/librarian-puppet-simple.haf.gemspec

@@ -0,0 +1,25 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'librarian/puppet/simple/version'
+
+Gem::Specification.new do |s|
+  s.name = 'librarian-puppet-simple.haf'
+  s.version = Librarian::Puppet::Simple::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = %w|'Dan Bode', 'haf'|
+  s.email = ['bodepd@gmail.com']
+  s.homepage = 'https://github.com/haf/librarian-puppet-simple'
+  s.summary = 'Bundler for your Puppet modules. A fork until a new version is released by Dan.'
+  s.description = 'Simplify deployment of your Puppet infrastructure by
+  automatically pulling in modules from the forge and git repositories with
+  a single command.'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency "thor", "~> 0.15"
+
+  s.add_development_dependency "rspec", "~> 2.13"
+end

data/spec/fixtures/Puppetfile

@@ -0,0 +1,18 @@
+mod 'puppetlabs/ntp',
+    :git => 'git://github.com/puppetlabs/puppetlabs-ntp.git',
+    :ref => '99bae40f225db0dd052efbf1d4078a21f0333331'
+
+mod 'apache',
+    :tarball => 'https://forge.puppetlabs.com/puppetlabs/apache/0.6.0.tar.gz'
+
+mod 'ghoneycutt/testlps',
+  :git => 'git://github.com/ghoneycutt/testlps.git'
+
+mod 'ghoneycutt/dnsclient',
+  :git => 'git://github.com/ghoneycutt/puppet-module-dnsclient.git',
+  :ref => 'v3.0.4'
+
+mod 'haf/empty-repository',
+  :git => 'git://github.com/haf/empty-repository.git',
+  :subdir => 'subdir-A'
+

data/spec/functional/clean_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'tmpdir'
+
+describe "Functional - Clean" do
+  it "displays install help message" do
+    output, status = execute_captured("bin/librarian-puppet help clean")
+    output.should_not include("ERROR")
+    output.should_not include("Could not find command")
+    status.should == 0
+  end
+
+  describe "when running 'librarian-puppet clean'" do
+    temp_directory = nil
+
+    before :each do
+      temp_directory = Dir.mktmpdir
+      Dir.entries(temp_directory).should =~ ['.', '..']
+      FileUtils.touch File.join(temp_directory, 'trashfile')
+      Dir.entries(temp_directory).should =~ ['.', '..', 'trashfile']
+    end
+
+    after :each do
+      FileUtils.rm_rf temp_directory if File.exist?(temp_directory)
+    end
+
+    it "with --path it cleans the directory" do
+      output, status = execute_captured("bin/librarian-puppet clean --path=#{temp_directory}")
+
+      status.should == 0
+      # Using File.exist? to be compatible with Ruby 1.8.7
+      File.exist?(temp_directory).should be_false
+    end
+
+    it "with --verbose it shows progress messages" do
+      output, status = execute_captured("bin/librarian-puppet clean --verbose --path=#{temp_directory}")
+
+      status.should == 0
+      output.should include("Target Directory: #{temp_directory}")
+    end
+  end
+end

data/spec/functional/install_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+require 'tmpdir'
+
+describe "Functional - Install" do
+  before :all do
+    warning_message = "ATTENTION: these tests download information from github.com and forge.puppetlabs.com"
+    puts '*' * warning_message.length
+    puts warning_message
+    puts '*' * warning_message.length
+  end
+
+  it "displays install help message" do
+    output, status = execute_captured("bin/librarian-puppet help install")
+    output.should_not include("ERROR")
+    output.should_not include("Could not find command")
+    status.should == 0
+  end
+
+  describe "when running 'librarian-puppet install'" do
+    temp_directory = nil
+
+    before :each do
+      temp_directory = Dir.mktmpdir
+      Dir.entries(temp_directory).should =~ ['.', '..']
+      FileUtils.touch File.join(temp_directory, 'trashfile')
+      Dir.entries(temp_directory).should =~ ['.', '..', 'trashfile']
+    end
+
+    after :each do
+      FileUtils.rm_rf temp_directory
+    end
+
+    it "install the modules in a temp directory" do
+      output, status = execute_captured("bin/librarian-puppet install --path=#{temp_directory} --puppetfile=spec/fixtures/Puppetfile")
+
+      status.should == 0
+      Dir.entries(temp_directory).should =~ %w|. .. apache ntp trashfile dnsclient testlps subdir-A|
+    end
+
+    it "with --clean it cleans the directory before installing the modules in a temp directory" do
+      output, status = execute_captured("bin/librarian-puppet install --clean --path=#{temp_directory} --puppetfile=spec/fixtures/Puppetfile")
+
+      status.should == 0
+      Dir.entries(temp_directory).should =~ %w|. .. apache ntp dnsclient testlps subdir-A|
+    end
+
+    it "with --verbose it outputs progress messages" do
+      output, status = execute_captured("bin/librarian-puppet install --verbose --path=#{temp_directory} --puppetfile=spec/fixtures/Puppetfile")
+
+      status.should == 0
+      output.should include('##### processing module apache')
+    end
+
+    describe 'when modules are already installed' do
+      temp_directory = nil
+
+      before :each do
+        temp_directory = Dir.mktmpdir
+        Dir.entries(temp_directory).should =~ ['.', '..']
+        FileUtils.touch File.join(temp_directory, 'apache')
+        Dir.entries(temp_directory).should =~ ['.', '..', 'apache']
+      end
+
+      it 'without clean it should only install ntp' do
+        output, status = execute_captured("bin/librarian-puppet install --verbose --path=#{temp_directory} --puppetfile=spec/fixtures/Puppetfile")
+        status.should == 0
+        output.should include('Module apache already installed')
+        Dir.entries(temp_directory).should =~ %w|. .. apache ntp dnsclient testlps subdir-A|
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'open3'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  def execute_captured(command)
+    stdin, stdout, stderr = Open3.popen3(command)
+    condensed = stdout.readlines.join + stderr.readlines.join
+    [condensed, $?.exitstatus]
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: librarian-puppet-simple.haf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- ! '''Dan'
+- Bode',
+- ! '''haf'''
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+description: ! "Simplify deployment of your Puppet infrastructure by\n  automatically
+  pulling in modules from the forge and git repositories with\n  a single command."
+email:
+- bodepd@gmail.com
+executables:
+- librarian-puppet
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- bin/librarian-puppet
+- lib/librarian/puppet/simple.rb
+- lib/librarian/puppet/simple/cli.rb
+- lib/librarian/puppet/simple/installer.rb
+- lib/librarian/puppet/simple/iterator.rb
+- lib/librarian/puppet/simple/util.rb
+- lib/librarian/puppet/simple/version.rb
+- librarian-puppet-simple.haf.gemspec
+- spec/fixtures/Puppetfile
+- spec/functional/clean_spec.rb
+- spec/functional/install_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/haf/librarian-puppet-simple
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Bundler for your Puppet modules. A fork until a new version is released by
+  Dan.
+test_files:
+- spec/fixtures/Puppetfile
+- spec/functional/clean_spec.rb
+- spec/functional/install_spec.rb
+- spec/spec_helper.rb