berks-monolith 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e00e4691862cc03e4cca97a0722ad297e535391
+  data.tar.gz: 4183cdf8be169fc1b52c22f83e9f0fb4c8d49115
+SHA512:
+  metadata.gz: caf6a7a55dd3b38d1e6fde05e7df7efddd6f6c8aa247af5b835aad685d455db71015cda82e1d2d9046cf84ae24d3b8340941be58973afff3a1f095dd9eb79496
+  data.tar.gz: 82ff7940b2e02d68125bc479c40a2c27f06af2d712bc00b4d367d6a49588e8f8be28da8d40e7eaca5b9429901785a067baeffe174535adc0af8d05cd6f968fce

data/.gitignore

@@ -0,0 +1,12 @@
+# Bundler stuff
+Gemfile.lock
+.bundle
+vendor/
+tmp
+*.gem
+
+
+# In case these are used for testing
+Berksfile
+Berksfile.lock
+cookbooks/

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.1.0"
+  - "2.1.1"
+sudo: false

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Mark Harrison
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+[![Stories in Ready](https://badge.waffle.io/mivok/berks-monolith.png?label=ready&title=Ready)](https://waffle.io/mivok/berks-monolith)
+[![Build Status](https://travis-ci.org/mivok/berks-monolith.svg?branch=master)](https://travis-ci.org/mivok/berks-monolith)
+
+# berks-monolith
+
+Berks-monolith is a companion command to berkshelf that takes all cookbooks
+mentioned in a Berksfile and places development friendly versions of them
+under a single directory. Usually, this means you will end up with git clones
+for all cookbooks with git repositories in the Berksfile, and static copies of
+cookbooks that don't have identifiable VCS repositories.
+
+## Use cases
+
+* You have a Berksfile with many git based sources, and want a quick way to
+  clone them all under a single directory.
+* You have a mostly monolithic repository, but make use of berkshelf to manage
+  dependencies and use external cookbook sources, and you'd like to have
+  everything in one place to be able to search.
+* You are transitioning between a monolithic repository workflow and a
+  independent software artefacts workflow, and have a mix of artefacts in a
+  Berksfile as well as cookbooks in a monolithic repository, and you want all
+  cookbooks in one place.
+
+## Why not just use X?
+
+The `berks vendor` command comes close to what monolith does, grabbing all
+cookbooks mentioned in a Berksfile and putting copies of them under a single
+directory. However, berks vendor is intended for production rather than
+development use, and explicitly strips any VCS directories, chef ignored
+files, and metadata.rb files.
+
+The `berks install` command collects all cookbooks into
+`~/.berkshelf/cookbooks`, but again VCS information is stripped out, and this
+contains all cookbooks, not just those associated with a specific Berksfile.
+
+## Usage
+
+### berks-monolith install
+
+Clones/copies all cookbooks mentioned in the berksfile. By default they go
+into the 'cookbooks' directory. You can specify an alternate path if you wish
+by specifying it on the command line: `berks-monolith install vendor`.
+
+Exactly what you get depends on what the source of the cookbook is in the
+berksfile:
+
+* Normal community cookbooks (e.g. if you just specify `cookbook 'foo'` with
+  no other options) are just copied in place from the berkshelf directory.
+* Git cookbooks will result in a clone of the repository pointing to the
+  original source repository.
+* Path cookbooks will be skipped completely. This means you don't have to
+  worry if you have existing local cookbooks in a monolithic repository in
+  your Berksfile. They won't be copied again.
+
+### berks-monolith update
+
+Updates the cloned copies of cookbooks if possible. In practice this means
+'run git pull' for all git clones.
+
+### berks-monolith clean
+
+Removes all cookbooks that were installed with `berks-monolith install`.
+Anything else in the cookbooks directory is left alone.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/test_*.rb"
+end

data/berks-monolith.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'monolith/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "berks-monolith"
+  spec.version       = Monolith::VERSION
+  spec.authors       = ["Mark Harrison"]
+  spec.email         = ["mark@mivok.net"]
+  spec.summary       = %q{Berkshelf monolithic repository tools}
+  spec.description   = %q{Tools for working with cookbooks as if they were inside a monolithic repository}
+  spec.homepage      = "http://github.com/mivok/berks-monolith"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.9.2'
+
+  spec.add_dependency 'berkshelf', '~> 3.0', '>= 3.0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'pry', '~> 0.10'
+end

data/bin/berks-monolith

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This is a horrible hack right now until I can work out how to load
+# extensions for additional commands into berks.
+$:.push File.expand_path('../../lib', __FILE__)
+require 'monolith'
+Monolith::Command.start

data/lib/monolith.rb

@@ -0,0 +1,12 @@
+require_relative 'monolith/commands'
+
+require_relative 'monolith/locations/git'
+require_relative 'monolith/locations/github'
+require_relative 'monolith/locations/path'
+require_relative 'monolith/locations/default'
+
+module Monolith
+  def self.formatter
+    @formatter ||= Monolith::Formatter.new
+  end
+end

data/lib/monolith/berksfile.rb

@@ -0,0 +1,69 @@
+require 'berkshelf'
+require 'fileutils'
+
+module Monolith
+  class Berksfile
+    attr_reader :berksfile
+
+    def initialize(options)
+      Berkshelf.ui.mute! if Monolith.formatter.quiet
+      begin
+        @berksfile = Berkshelf::Berksfile.from_options(options)
+      rescue Berkshelf::BerksfileNotFound => e
+        Monolith.formatter.error(e)
+        exit(e.status_code)
+      end
+    end
+
+    # Runs berks install. This is needed before we install cookbooks ourselves
+    # to make sure berkshelf has a local copy of them for us to clone from or
+    # copy. However, it's not needed for other commands, so it separated out
+    # here.
+    def install
+      @berksfile.install
+    end
+
+    # Retrieve all cookbooks listed in the berksfile.
+    #
+    # Can take a block to do something with each cookbook.
+    def cookbooks(path)
+      FileUtils.mkdir_p(path)
+      cached_cookbooks = @berksfile.cookbooks
+      if block_given?
+        cached_cookbooks.each do |cookbook|
+          destination = File.join(File.expand_path(path),
+                                  cookbook.cookbook_name)
+          dep = berksfile.get_dependency(cookbook.cookbook_name)
+          if dep
+            yield cookbook, dep, destination
+          end
+        end
+      end
+      cached_cookbooks
+    end
+
+    def monolith_action(action, cookbook, dep, destination)
+      obj = monolith_obj(cookbook, dep, destination)
+      if obj.nil?
+        Monolith.formatter.unsupported_location(cookbook, dep)
+      else
+        obj.send(action)
+      end
+    end
+
+    # Feteches the appropriate monolith location object for a given cookbook
+    # dependency. I.e. Monolith::FooLocation.
+    def monolith_obj(cookbook, dep, destination)
+      if dep.location.nil?
+        Monolith::DefaultLocation.new(cookbook, dep, destination)
+      else
+        klass = dep.location.class.name.split('::')[-1]
+        Monolith.formatter.debug("Location class for " \
+                                 "#{cookbook.cookbook_name} is #{klass}")
+        if Monolith.const_defined?(klass)
+          Monolith.const_get(klass).new(cookbook, dep, destination)
+        end
+      end
+    end
+  end
+end

data/lib/monolith/commands.rb

@@ -0,0 +1,71 @@
+require 'thor'
+require 'monolith/berksfile'
+require 'monolith/formatter'
+require 'monolith/gitexclude'
+
+module Monolith
+  class Command < Thor
+    namespace ''
+
+    class_option :quiet,
+      :type => :boolean,
+      :desc => "Don't print out any informational messages",
+      :aliases => '-q',
+      :default => false
+
+    class_option :debug,
+      :type => :boolean,
+      :desc => 'Print additional debug messages',
+      :aliases => '-d',
+      :default => false
+
+    class_option :berksfile,
+      :desc => 'Location of the Berksfile to use',
+      :aliases => '-b'
+
+    class_option :git_exclude,
+      :type => :boolean,
+      :desc => 'Add installed cookbooks to git exclude file',
+      :default => true
+
+    def initialize(*args)
+      super(*args)
+
+      Monolith.formatter.quiet = @options[:quiet]
+      Monolith.formatter.debug = @options[:debug]
+    end
+
+    desc 'install [PATH]', 'Clone all cookbooks into the cookbooks directory'
+    def install(path = File.join(Dir.pwd, "cookbooks"))
+      berksfile = Monolith::Berksfile.new(options.dup)
+      berksfile.install # We need to run berks install first
+      gitpath = File.expand_path('../.git', berksfile.berksfile.filepath)
+      gitexclude = GitExclude.new(gitpath, options)
+      berksfile.cookbooks(path) do |cookbook, dep, destination|
+        berksfile.monolith_action(:install, cookbook, dep, destination)
+        gitexclude.add(destination)
+      end
+      gitexclude.update
+    end
+
+    desc 'update [PATH]', 'Update all cloned cookbooks'
+    def update(path = File.join(Dir.pwd, "cookbooks"))
+      berksfile = Monolith::Berksfile.new(options.dup)
+      berksfile.cookbooks(path) do |cookbook, dep, destination|
+        berksfile.monolith_action(:update, cookbook, dep, destination)
+      end
+    end
+
+    desc 'clean [PATH]', 'Delete all cloned cookbooks'
+    def clean(path = File.join(Dir.pwd, "cookbooks"))
+      berksfile = Monolith::Berksfile.new(options.dup)
+      gitpath = File.expand_path('../.git', berksfile.berksfile.filepath)
+      gitexclude = GitExclude.new(gitpath, options)
+      berksfile.cookbooks(path) do |cookbook, dep, destination|
+        berksfile.monolith_action(:clean, cookbook, dep, destination)
+        gitexclude.remove(destination)
+      end
+      gitexclude.update
+    end
+  end
+end

data/lib/monolith/formatter.rb

@@ -0,0 +1,50 @@
+module Monolith
+  class Formatter
+    attr_accessor :quiet
+    attr_accessor :debug
+
+    def initialize
+      @quiet = false
+      @debug = false
+      @base_path = Pathname.new(Dir.pwd)
+    end
+
+    def install(cookbook, destination)
+      msg "Installing #{cookbook.cookbook_name} to #{rel_dir(destination)}"
+    end
+
+    def update(cookbook, destination)
+      msg "Updating #{cookbook.cookbook_name} at #{rel_dir(destination)}"
+    end
+
+    def clean(cookbook, destination)
+      msg "Removing #{cookbook.cookbook_name} from #{rel_dir(destination)}"
+    end
+
+    def skip(cookbook, reason)
+      msg "Skipping #{cookbook.cookbook_name} (#{reason})"
+    end
+
+    def unsupported_location(cookbook, dep)
+      loctype = dep.location.class.name.split('::')[-1]
+      msg "Unsupported location type #{loctype} for cookbook " \
+        "#{cookbook.cookbook_name}. Skipping."
+    end
+
+    def debug(msg)
+      puts "DEBUG: #{msg}" if @debug
+    end
+
+    def msg(msg)
+      puts msg unless @quiet
+    end
+
+    def error(msg)
+      STDERR.puts msg
+    end
+
+    def rel_dir(dir)
+      return Pathname.new(dir).relative_path_from(@base_path)
+    end
+  end
+end

data/lib/monolith/gitexclude.rb

@@ -0,0 +1,54 @@
+module Monolith
+  class GitExclude
+    def initialize(git_dir, options)
+      @lines_to_add = []
+      @lines_to_remove = []
+      @git_dir = Pathname.new(git_dir)
+      @filename = @git_dir.join('info', 'exclude')
+      @enabled = options[:git_exclude]
+    end
+
+    def relative_path(path)
+      Pathname.new(path).relative_path_from(@git_dir.parent).to_s
+    end
+
+    def add(line)
+      @lines_to_add << relative_path(line)
+    end
+
+    def remove(line)
+      @lines_to_remove << relative_path(line)
+    end
+
+    def update
+      return unless @enabled
+
+      # We don't want to do anything if we're not actually in a git repo
+      return unless File.directory?(@git_dir)
+
+      if File.exist?(@filename)
+        data = File.read(@filename).split("\n")
+      else
+        data = []
+      end
+      # Don't go creating a file if there's nothing to add and we're already
+      # empty
+      return if data.empty? and @lines_to_add.empty?
+
+      # Now add/remove lines - additions first
+      data.concat(@lines_to_add.reject { |l| data.include?(l) })
+      data.reject! { |l| @lines_to_remove.include?(l) }
+
+      # And write out the new file
+      File.open(@filename, "w") do |file|
+        data.each do |l|
+          file.puts(l)
+        end
+      end
+
+      # Reset the list of lines to add/remove
+      @lines_to_add = []
+      @lines_to_remove = []
+    end
+  end
+end

data/lib/monolith/locations/base.rb

@@ -0,0 +1,37 @@
+module Monolith
+  class BaseLocation
+    def initialize(cookbook, dep, destination)
+      @dep = dep
+      @location = dep.location
+      @cookbook = cookbook
+      @destination = destination
+    end
+
+    # Install the cookbook in the development environment. If possible, the
+    # installed cookbook should look exactly as it would when used for
+    # development (e.g. a git checkout with all git metadata, no compiled
+    # artefacts).
+    def install
+      nil
+    end
+
+    # Update the cookbook in the development environment to the latest
+    # version. E.g. if git is used, run git pull.
+    def update
+      nil
+    end
+
+    # Remove a previously installed cookbook. If a cookbook was never
+    # installed in the first place (either because install wasn't run, or
+    # because of the location type), then this should do nothing.
+    def clean
+      if File.exist?(@destination)
+        Monolith.formatter.clean(@cookbook, @destination)
+        FileUtils.rm_rf(@destination)
+      else
+        rel_dest = Monolith.formatter.rel_dir(@destination)
+        Monolith.formatter.skip(@cookbook, "#{rel_dest} doesn't exist")
+      end
+    end
+  end
+end

data/lib/monolith/locations/default.rb

@@ -0,0 +1,24 @@
+# Default location aka community/supermarket cookbook
+module Monolith
+  class DefaultLocation < BaseLocation
+    def install
+      # For now we just copy any community cookbooks. It would be nice to be
+      # able to grab them from the source URL, but that isn't readily
+      # accessible, and then you have to guess how to check it out.
+      if File.directory?(@destination)
+        rel_dest = Monolith.formatter.rel_dir(@destination)
+        Monolith.formatter.skip(@cookbook, "#{rel_dest} already exists")
+      else
+        Monolith.formatter.install(@cookbook, @destination)
+        FileUtils.cp_r(@cookbook.path, @destination)
+      end
+    end
+
+    def update
+      # There isn't anything to do for updating a community cookbook except
+      # blowing it away and recreating it. For the moment I'm opting not to do
+      # that (it may be able ot be an option later)
+      Monolith.formatter.skip(@cookbook, "Not updating community cookbook")
+    end
+  end
+end

data/lib/monolith/locations/git.rb

@@ -0,0 +1,60 @@
+require 'berkshelf/mixin/git'
+require_relative 'base'
+
+module Monolith
+  class GitLocation < BaseLocation
+    include Berkshelf::Mixin::Git
+
+    def install
+      unless File.directory?(@destination)
+        Monolith.formatter.install(@cookbook, @destination)
+        # Clone from the cache. We've already done an install by this point, so
+        # berkshelf already made sure the cache exists and is up to date.
+        git %|clone "#{cache_path}" "#{@destination}"|
+
+        # Make sure the origin is correct and doesn't point to the cached
+        # version.
+        cached_origin_url = origin_url(cache_path)
+        set_origin_url(@destination, cached_origin_url)
+
+        # Not sure if I want to do this - should probably be an option
+        #git %|reset --hard #{@revision}|
+      else
+        rel_dest = Monolith.formatter.rel_dir(@destination)
+        Monolith.formatter.skip(@cookbook, "#{rel_dest} already exists")
+      end
+    end
+
+    def update
+      if File.directory?(@destination)
+        Monolith.formatter.update(@cookbook, @destination)
+        Dir.chdir(@destination) do
+          git %|pull|
+        end
+      else
+        rel_dest = Monolith.formatter.rel_dir(@destination)
+        Monolith.formatter.skip(@cookbook, "#{rel_dest} doesn't exist")
+      end
+    end
+
+    private
+
+    # Taken from Berkshelf::GitLocation
+    def cache_path
+      Pathname.new(Berkshelf.berkshelf_path)
+        .join('.cache', 'git', Digest::SHA1.hexdigest(@location.uri))
+    end
+
+    def origin_url(repo_dir)
+      Dir.chdir(repo_dir) do
+        git %|config --local --get remote.origin.url|
+      end
+    end
+
+    def set_origin_url(repo_dir, url)
+      Dir.chdir(repo_dir) do
+        git %|remote set-url origin "#{url}"|
+      end
+    end
+  end
+end

data/lib/monolith/locations/github.rb

@@ -0,0 +1,6 @@
+require_relative 'git'
+
+module Monolith
+  class GithubLocation < GitLocation
+  end
+end

data/lib/monolith/locations/path.rb

@@ -0,0 +1,23 @@
+# If a Berksfile mentions a cookbook with a path location, then we can
+# assume it's already available locally in a form suitable for
+# development. An example of this is if you have a (mostly) monolithic
+# chef repository and want to refer to cookbooks in this repository in
+# your Berksfile.
+module Monolith
+  class PathLocation < BaseLocation
+    def install
+      Monolith.formatter.debug("Skipping cookbook #{@cookbook.cookbook_name}" \
+                               "with path location")
+    end
+
+    def update
+      Monolith.formatter.debug("Skipping cookbook #{@cookbook.cookbook_name}" \
+                               "with path location")
+    end
+
+    def clean
+      Monolith.formatter.debug("Skipping cookbook #{@cookbook.cookbook_name}" \
+                               "with path location")
+    end
+  end
+end

data/lib/monolith/version.rb

@@ -0,0 +1,3 @@
+module Monolith
+  VERSION = '0.1.0'
+end

data/test/.gitignore

@@ -0,0 +1 @@
+tmp

data/test/helpers.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+require 'pathname'
+
+module Monolith
+  module TestHelpers
+    def tmp_path
+      Pathname.new(File.expand_path("../tmp", __FILE__))
+    end
+
+    def clean_tmp_path
+      FileUtils.rm_rf(tmp_path)
+      FileUtils.mkdir_p(tmp_path)
+    end
+
+    def make_git_repo(name)
+      # Makes an example git repo with a single file in and one commit
+      repo_path = tmp_path.join("git", name)
+      FileUtils.mkdir_p(repo_path)
+      Dir.chdir(repo_path) do
+        %x|git init|
+        File.open('metadata.rb', 'w') do |f|
+          f.puts "name '#{name}'"
+        end
+        %x|git add metadata.rb|
+        %x|git config --local user.name Me|
+        %x|git config --local user.email me@example.com|
+        %x|git commit -m "Test commit"|
+        %x|git remote add origin "git@git.example.com:#{name}"|
+      end
+      repo_path
+    end
+
+    def make_change_git(name)
+      repo_path = tmp_path.join("git", name)
+      Dir.chdir(repo_path) do
+        File.open('test.txt', 'w') do |f|
+          f.puts 'Testing'
+        end
+        %x|git add test.txt|
+        %x|git commit --author "Me <me@example.com>" -m "Update"|
+      end
+    end
+
+    def make_berksfile(types)
+      File.open(tmp_path.join('Berksfile'), 'w') do |berksfile|
+        berksfile.puts "source 'https://supermarket.chef.io/'"
+        types.each do |type|
+          if type == :git
+            repo_path = make_git_repo('test_git')
+            berksfile.puts("cookbook 'test_git', :git => '#{repo_path}'")
+          end
+        end
+      end
+
+      if block_given?
+        Dir.chdir(tmp_path) do
+          yield
+        end
+      end
+    end
+  end
+end

data/test/test_command_clean.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require_relative 'helpers'
+
+# Fix 'Celluloid::Error Thread pool is not running' error.
+# See https://github.com/celluloid/celluloid/pull/162
+require 'celluloid/test'
+Celluloid.init
+
+require 'monolith'
+
+class TestCommandInstall < MiniTest::Test
+  include Monolith::TestHelpers
+
+  def setup
+    clean_tmp_path
+  end
+
+  def test_clean_command
+    make_berksfile([:git]) do
+      # We need to install it first
+      Monolith::Command.start(['install', '-q'])
+      make_change_git('test_git')
+      # Verify the 'before' state
+      assert File.exist?("cookbooks/test_git")
+      # Perform the clean
+      Monolith::Command.start(['clean', '-q'])
+      refute File.exist?("cookbooks/test_git")
+    end
+  end
+end

data/test/test_command_install.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+require_relative 'helpers'
+
+# Fix 'Celluloid::Error Thread pool is not running' error.
+# See https://github.com/celluloid/celluloid/pull/162
+require 'celluloid/test'
+Celluloid.init
+
+require 'monolith'
+
+class TestCommandInstall < MiniTest::Test
+  include Monolith::TestHelpers
+
+  def setup
+    clean_tmp_path
+  end
+
+  def test_install_command
+    make_berksfile([:git]) do
+      Monolith::Command.start(['install', '-q'])
+      assert File.exist?("cookbooks/test_git")
+      assert File.exist?("cookbooks/test_git/.git")
+    end
+  end
+end

data/test/test_command_update.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require_relative 'helpers'
+
+# Fix 'Celluloid::Error Thread pool is not running' error.
+# See https://github.com/celluloid/celluloid/pull/162
+require 'celluloid/test'
+Celluloid.init
+
+require 'monolith'
+
+class TestCommandInstall < MiniTest::Test
+  include Monolith::TestHelpers
+
+  def setup
+    clean_tmp_path
+  end
+
+  def test_update_command
+    make_berksfile([:git]) do
+      # We need to install it first
+      Monolith::Command.start(['install', '-q'])
+      make_change_git('test_git')
+      # Verify the 'before' state
+      refute File.exist?("cookbooks/test_git/test.txt")
+      # Perform the update
+      Monolith::Command.start(['update', '-q'])
+      assert File.exist?("cookbooks/test_git")
+      assert File.exist?("cookbooks/test_git/.git")
+      assert File.exist?("cookbooks/test_git/test.txt")
+    end
+  end
+end

data/test/test_gitlocation.rb

@@ -0,0 +1,48 @@
+require 'minitest/autorun'
+require 'fileutils'
+
+require 'berkshelf'
+require 'monolith/locations/git'
+
+class TestGitLocation < MiniTest::Test
+
+  def setup
+    # Path variables
+    @test_cookbook = "test_cookbook"
+    @test_base = File.expand_path('../tmp', __FILE__)
+    @mock_cache = File.join(@test_base, 'cache', @test_cookbook)
+    @mock_destination = File.join(@test_base, 'cloned', @test_cookbook)
+    @mock_origin = 'user@example.com:some/repo'
+    # Set up a repo to clone from rather than using the real berkshelf cache
+    # dir.
+    FileUtils.rm_rf(@test_base)
+    FileUtils.mkdir_p(@mock_cache)
+    Dir.chdir(@mock_cache) do
+      %x|git init|
+      %x|git remote add origin #{@mock_origin}|
+    end
+    # Don't print informational messages while testing
+    Monolith.formatter.quiet = true
+  end
+
+  def teardown
+    FileUtils.rm_rf(@test_base)
+  end
+
+  def test_install
+    # Actually do the install
+    @mock_cookbook = Minitest::Mock.new
+    @mock_cookbook.expect :cookbook_name, @test_cookbook
+    @mock_dep = Minitest::Mock.new
+    @mock_dep.expect :location, nil
+    location = Monolith::GitLocation.new(@mock_cookbook, @mock_dep,
+                                         @mock_destination)
+    location.stub(:cache_path, @mock_cache) do
+      location.install
+    end
+
+    assert File.directory?(@mock_destination)
+    assert File.directory?(File.join(@mock_destination, '.git'))
+    assert_equal @mock_origin, location.send(:origin_url, @mock_destination)
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: berks-monolith
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Harrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: berkshelf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Tools for working with cookbooks as if they were inside a monolithic
+  repository
+email:
+- mark@mivok.net
+executables:
+- berks-monolith
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- berks-monolith.gemspec
+- bin/berks-monolith
+- lib/monolith.rb
+- lib/monolith/berksfile.rb
+- lib/monolith/commands.rb
+- lib/monolith/formatter.rb
+- lib/monolith/gitexclude.rb
+- lib/monolith/locations/base.rb
+- lib/monolith/locations/default.rb
+- lib/monolith/locations/git.rb
+- lib/monolith/locations/github.rb
+- lib/monolith/locations/path.rb
+- lib/monolith/version.rb
+- test/.gitignore
+- test/helpers.rb
+- test/test_command_clean.rb
+- test/test_command_install.rb
+- test/test_command_update.rb
+- test/test_gitlocation.rb
+homepage: http://github.com/mivok/berks-monolith
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Berkshelf monolithic repository tools
+test_files:
+- test/.gitignore
+- test/helpers.rb
+- test/test_command_clean.rb
+- test/test_command_install.rb
+- test/test_command_update.rb
+- test/test_gitlocation.rb
+has_rdoc: