berkshelf 3.0.0.beta4 → 3.0.0.beta5

data/lib/berkshelf/locations/path_location.rb

@@ -49,6 +49,13 @@ module Berkshelf
       "./#{new_path}"
     end
 
+    # Valid if the path exists and is readable
+    #
+    # @return [Boolean]
+    def valid?
+      File.exist?(path) && File.readable?(path)
+    end
+
     def to_hash
       super.merge(value: self.path)
     end

data/lib/berkshelf/lockfile.rb

@@ -99,7 +99,9 @@ module Berkshelf
         options[:path] &&= File.expand_path(options[:path], File.dirname(filepath))
 
         begin
-          add(Berkshelf::Dependency.new(berksfile, name.to_s, options))
+          dependency = Berkshelf::Dependency.new(berksfile, name.to_s, options)
+          next if dependency.location && !dependency.location.valid?
+          add(dependency)
         rescue Berkshelf::CookbookNotFound
           # It's possible that a source is locked that contains a path location, and
           # that path location was renamed or no longer exists. When loading the
@@ -123,6 +125,7 @@ module Berkshelf
     #
     # @param [String, Berkshelf::Dependency] dependency
     #   the cookbook dependency/name to find
+    #
     # @return [Berkshelf::Dependency, nil]
     #   the cookbook dependency from this lockfile or nil if one was not found
     def find(dependency)
@@ -133,6 +136,7 @@ module Berkshelf
     #
     # @param [String, Berkshelf::Dependency] dependency
     #   the cookbook dependency/name to determine existence of
+    #
     # @return [Boolean]
     #   true if the dependency exists, false otherwise
     def has_dependency?(dependency)

data/lib/berkshelf/packager.rb

@@ -0,0 +1,73 @@
+require 'archive/tar/minitar'
+require 'zlib'
+
+module Berkshelf
+  # A class for archiving and compressing directory containing one or more cookbooks.
+  #
+  # Example:
+  #   Archiving a path containing the cookbooks:
+  #     * "/path/to/cookbooks/my_face"
+  #     * "/path/to/cookbooks/nginx"
+  #
+  #   irb> source   = "/path/to/cookbooks"
+  #   irb> packager = Berkshelf::Packager.new("some/path/cookbooks.tar.gz")
+  #   irb> packager.run(source) #=> "some/path/cookbooks.tar.gz"
+  class Packager
+    class << self
+      def validate_destination(path)
+        path = path.to_s
+      end
+    end
+
+    # @return [String]
+    attr_reader :out_file
+
+    # @param [#to_s] out_file
+    #   path to write the archive to
+    def initialize(out_file)
+      @out_file           = out_file.to_s
+      @out_dir, @filename = File.split(@out_file)
+    end
+
+    # Archive the contents of given path
+    #
+    # @param [#to_s] source
+    #   the filepath to archive the contents of
+    #
+    # @raise [PackageError]
+    #   if an error is encountered while writing the out_file
+    #
+    # @return [String]
+    #   path to the generated archive
+    def run(source)
+      Dir.chdir(source.to_s) do |dir|
+        tgz = Zlib::GzipWriter.new(File.open(out_file, "wb"))
+        Archive::Tar::Minitar.pack(".", tgz)
+      end
+
+      out_file
+    rescue SystemCallError => ex
+      raise PackageError, ex
+    end
+
+    # Validate that running the packager would be successful. Returns nil if would be
+    # successful and raises an error if would not.
+    #
+    # @raise [PackageError]
+    #   if running the packager would absolutely not result in a success
+    #
+    # @return [nil]
+    def validate!
+      raise PackageError, "Path is not a directory: #{out_dir}" unless File.directory?(out_dir)
+      raise PackageError, "Directory is not writable: #{out_dir}" unless File.writable?(out_dir)
+    end
+
+    private
+
+      # @return [String]
+      attr_reader :out_dir
+
+      # @return [String]
+      attr_reader :filename
+  end
+end

data/lib/berkshelf/resolver.rb

@@ -41,11 +41,13 @@ module Berkshelf
       demands.push(demand)
     end
 
-    def add_explicit_dependencies(dependency)
-      unless cookbook = dependency.cached_cookbook
-        return nil
-      end
-
+    # Add dependencies of a locally cached cookbook which will take precedence over anything
+    # found in the universe.
+    #
+    # @param [Berkshelf::CachedCookbook] cookbook
+    #
+    # @return [Hash]
+    def add_explicit_dependencies(cookbook)
       graph.populate_local(cookbook)
     end
 

data/lib/berkshelf/resolver/graph.rb

@@ -10,6 +10,11 @@ module Berkshelf
         end
       end
 
+      # Add dependencies of a locally cached cookbook to the graph
+      #
+      # @param [Berkshelf::CachedCookbook] cookbook
+      #
+      # @return [Hash]
       def populate_local(cookbook)
         name    = cookbook.cookbook_name
         version = cookbook.version
@@ -23,6 +28,8 @@ module Berkshelf
       # @param [Array<Berkshelf::Source>, Berkshelf::Source] sources
       def populate(sources)
         universe(sources).each do |cookbook|
+          next if has_artifact?(cookbook.name, cookbook.version)
+
           artifacts(cookbook.name, cookbook.version)
 
           cookbook.dependencies.each do |dependency, constraint|

data/lib/berkshelf/source.rb

@@ -1,3 +1,5 @@
+require 'berkshelf/api-client'
+
 module Berkshelf
   class Source
     include Comparable
@@ -9,11 +11,29 @@ module Berkshelf
     def initialize(uri)
       @uri        = SourceURI.parse(uri)
       @api_client = APIClient.new(uri)
+      @universe   = nil
+    end
+
+    # Forcefully obtain the universe from the API endpoint and assign it to {#universe}. This
+    # will reload the value of {#universe} even if it has been loaded before.
+    #
+    # @return [Array<APIClient::RemoteCookbook>]
+    def build_universe
+      @universe = api_client.universe
+    rescue => ex
+      @universe = Array.new
+      raise ex
     end
 
-    # @return [Hash]
+    # Return the universe from the API endpoint.
+    #
+    # This is lazily loaded so the universe will be retrieved from the API endpoint on the first
+    # call and cached for future calls. Send the {#build_universe} message if you want to reload
+    # the cached universe.
+    #
+    # @return [Array<APIClient::RemoteCookbook>]
     def universe
-      @universe ||= api_client.universe
+      @universe || build_universe
     end
 
     # @param [String] name

data/lib/berkshelf/ui.rb

@@ -38,8 +38,6 @@ module Berkshelf
     end
 
     def error(message, color = :red)
-      return if quiet?
-
       message = set_color(message, *color) if color
       super(message)
     end

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "3.0.0.beta4"
+  VERSION = "3.0.0.beta5"
 end

data/spec/support/git.rb

@@ -82,6 +82,7 @@ module Berkshelf
       end
 
       private
+
         # The path to store the local git clones.
         #
         # @return [Pathname]

data/spec/support/mercurial.rb

@@ -77,46 +77,47 @@ module Berkshelf
       end
 
       private
-      # The path to store the local git clones.
-      #
-      # @return [Pathname]
-      def clones
-        ensure_and_return(tmp_path.join('clones'))
-      end
 
-      # The path to store the git remotes.
-      #
-      # @return [Pathname]
-      def remotes
-        ensure_and_return(tmp_path.join('remotes'))
-      end
+        # The path to store the local git clones.
+        #
+        # @return [Pathname]
+        def clones
+          ensure_and_return(tmp_path.join('clones'))
+        end
 
-      # Generate a cookbook by the given name.
-      #
-      # @param [#to_s] name
-      #   the name of the cookbook to create
-      # @param [Hash] options
-      #   the list ooptions to pass to the generator
-      def generate_mercurial_cookbook(name, options = {})
-        options = {
-            skip_vagrant: true,
-            skip_test_kitchen: true,
-            force: true,
-        }.merge(options)
+        # The path to store the git remotes.
+        #
+        # @return [Pathname]
+        def remotes
+          ensure_and_return(tmp_path.join('remotes'))
+        end
 
-        Berkshelf::Cli.new.invoke(:cookbook, [name.to_s], options)
-      end
+        # Generate a cookbook by the given name.
+        #
+        # @param [#to_s] name
+        #   the name of the cookbook to create
+        # @param [Hash] options
+        #   the list ooptions to pass to the generator
+        def generate_mercurial_cookbook(name, options = {})
+          options = {
+              skip_vagrant: true,
+              skip_test_kitchen: true,
+              force: true,
+          }.merge(options)
 
-      # Make sure the given path exists and return the path
-      #
-      # @param [#to_s] path
-      #   the path to create and return
-      #
-      # @return [Pathname]
-      def ensure_and_return(path)
-        FileUtils.mkdir(path) unless File.exist?(path)
-        return Pathname.new(path).expand_path
-      end
+          Berkshelf::Cli.new.invoke(:cookbook, [name.to_s], options)
+        end
+
+        # Make sure the given path exists and return the path
+        #
+        # @param [#to_s] path
+        #   the path to create and return
+        #
+        # @return [Pathname]
+        def ensure_and_return(path)
+          FileUtils.mkdir(path) unless File.exist?(path)
+          return Pathname.new(path).expand_path
+        end
     end
   end
 end

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -313,7 +313,7 @@ describe Berkshelf::Berksfile do
     end
 
     context "when given the :git option" do
-      let(:options) { { git: "git@github.com:RiotGames/berkshelf.git" } }
+      let(:options) { { git: "git@github.com:berkshelf/berkshelf.git" } }
 
       it "has a GitLocation location" do
         expect(dependency.location).to be_a(Berkshelf::GitLocation)
@@ -321,7 +321,7 @@ describe Berkshelf::Berksfile do
     end
 
     context "when given the :github option" do
-      let(:options) { { github: "RiotGames/berkshelf" } }
+      let(:options) { { github: "berkshelf/berkshelf" } }
 
       it "has a GithubLocation location" do
         expect(dependency.location).to be_a(Berkshelf::GithubLocation)
@@ -512,38 +512,6 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#package' do
-    context 'when the dependency does not exist' do
-      it 'raises a CookbookNotFound exception' do
-        expect {
-          subject.package('non-existent', output: Dir.tmpdir)
-        }.to raise_error(Berkshelf::CookbookNotFound)
-      end
-    end
-
-    context 'when the dependency exists' do
-      let(:dependency) { double('dependency') }
-      let(:cached) { double('cached', path: '/foo/bar', cookbook_name: 'cookbook') }
-      let(:options) { { output: Dir.tmpdir } }
-
-      before do
-        FileUtils.stub(:cp_r)
-        FileUtils.stub(:mkdir_p)
-        subject.stub(:find).with('non-existent').and_return(dependency)
-        subject.stub(:install).with(options).and_return([ cached ])
-      end
-
-      it 'resolves the dependencies' do
-        subject.should_receive(:install).with(options)
-        subject.package('non-existent', options)
-      end
-
-      it 'returns the output path' do
-        expect(subject.package('non-existent', options)).to eq(File.join(Dir.tmpdir, 'non-existent.tar.gz'))
-      end
-    end
-  end
-
   describe "#remove_dependency" do
     let(:dependency) { "nginx" }
     before { subject.add_dependency(dependency) }

data/spec/unit/berkshelf/cli_spec.rb

@@ -4,12 +4,13 @@ describe Berkshelf::Cli do
   let(:subject) { described_class.new }
   let(:berksfile) { double('Berksfile') }
   let(:cookbooks) { ['mysql'] }
+
   describe '#upload' do
     it 'calls to upload with params if passed in cli' do
       Berkshelf::Berksfile.should_receive(:from_file).and_return(berksfile)
-      berksfile.should_receive(:upload).with(include(:skip_syntax_check => true, :freeze => false, :cookbooks => cookbooks))
+      berksfile.should_receive(:upload).with(include(skip_syntax_check: true, freeze: false, cookbooks: cookbooks))
       subject.options[:skip_syntax_check] = true
-      subject.options[:no_freeze] = true
+      subject.options[:no_freeze]         = true
       subject.upload('mysql')
     end
   end

data/spec/unit/berkshelf/config_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Berkshelf::Config do
-  describe '.file' do
+  describe '::file' do
     context 'when the file does not exist' do
       before { File.stub(:exists?).and_return(false) }
 
@@ -11,13 +11,13 @@ describe Berkshelf::Config do
     end
   end
 
-  describe '.instance' do
+  describe '::instance' do
     it 'should be a Berkshelf::Config' do
       expect(Berkshelf::Config.instance).to be_an_instance_of(Berkshelf::Config)
     end
   end
 
-  describe '.path' do
+  describe '::path' do
     it 'is a string' do
       expect(Berkshelf::Config.path).to be_a(String)
     end

data/spec/unit/berkshelf/core_ext/pathname_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Pathname do
+  describe "#cookbook?" do
+    let(:cookbook_path) { tmp_path }
+    let(:metadata_rb) { tmp_path.join("metadata.rb") }
+    let(:metadata_json) { tmp_path.join("metadata.json") }
+
+    subject { Pathname.new(cookbook_path) }
+
+    context "when the path contains a metadata.json file" do
+      before { FileUtils.touch(metadata_json) }
+      its(:cookbook?) { should be_true }
+    end
+
+    context "when the path contains a metadata.rb file" do
+      before { FileUtils.touch(metadata_rb) }
+      its(:cookbook?) { should be_true }
+    end
+
+    context "when the path does not contain a metadata.json or metadata.rb file" do
+      before { FileUtils.rm_f(metadata_rb) && FileUtils.rm_f(metadata_json) }
+      its(:cookbook?) { should be_false }
+    end
+  end
+
+  describe "#cookbook_root" do
+    let(:root_path) { fixtures_path.join("cookbooks", "example_cookbook") }
+    let(:cookbook_path) { root_path }
+    subject { Pathname.new(cookbook_path) }
+
+    context "when in the root of a cookbook" do
+      its(:cookbook_root) { should eql(root_path) }
+    end
+
+    context "when in the structure of a cookbook" do
+      let(:cookbook_path) { root_path.join("recipes") }
+      its(:cookbook_root) { should eql(root_path) }
+    end
+
+    context "when not within the structure of a cookbook" do
+      let(:cookbook_path) { "/" }
+      its(:cookbook_root) { should be_nil }
+    end
+  end
+end