berkshelf 0.3.3 → 0.3.7

data/lib/berkshelf/cookbook_source/git_location.rb

@@ -7,12 +7,24 @@ module Berkshelf
       attr_accessor :uri
       attr_accessor :branch
 
-      def initialize(name, options)
+      alias_method :ref, :branch
+      alias_method :tag, :branch
+
+      # @param [#to_s] name
+      # @param [DepSelector::VersionConstraint] version_constraint
+      # @param [Hash] options
+      def initialize(name, version_constraint, options)
         @name = name
+        @version_constraint = version_constraint
         @uri = options[:git]
         @branch = options[:branch] || options[:ref] || options[:tag]
+
+        Git.validate_uri!(@uri)
       end
 
+      # @param [#to_s] destination
+      #
+      # @return [Berkshelf::CachedCookbook]
       def download(destination)
         tmp_clone = Dir.mktmpdir
         ::Berkshelf::Git.clone(uri, tmp_clone)
@@ -27,20 +39,19 @@ module Berkshelf
           raise CookbookNotFound, msg
         end
 
-        cb_path = File.join(destination, "#{self.name}-#{self.branch}")
-
-        FileUtils.mv(tmp_clone, cb_path, :force => true)
+        cb_path = File.join(destination, "#{self.name}-#{Git.rev_parse(tmp_clone)}")
+        FileUtils.mv(tmp_clone, cb_path, force: true)
+                
+        cached = CachedCookbook.from_store_path(cb_path)
+        validate_cached(cached)
 
-        cb_path
-      rescue Berkshelf::GitError
-        msg = "Cookbook '#{name}' not found at git: #{uri}" 
-        msg << " with branch '#{branch}'" if branch
-        raise CookbookNotFound, msg
+        set_downloaded_status(true)
+        cached
       end
 
       def to_s
         s = "git: '#{uri}'"
-        s << " with branch '#{branch}'" if branch
+        s << " with branch: '#{branch}'" if branch
         s
       end
 

data/lib/berkshelf/cookbook_source/location.rb

@@ -0,0 +1,50 @@
+module Berkshelf
+  class CookbookSource
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    module Location
+      attr_reader :name
+      attr_reader :version_constraint
+
+      # @param [#to_s] name
+      def initialize(name, version_constraint)
+        @name = name
+        @version_constraint = version_constraint
+        @downloaded_status = false
+      end
+
+      # @param [#to_s] destination
+      #
+      # @return [Berkshelf::CachedCookbook]
+      def download(destination)
+        raise NotImplementedError, "Function must be implemented on includer"
+      end
+
+      # @return [Boolean]
+      def downloaded?
+        @downloaded_status
+      end
+
+      # Ensures that the given CachedCookbook satisfies the constraint
+      #
+      # @param [CachedCookbook] cached_cookbook
+      #
+      # @raise [ConstraintNotSatisfied] if the CachedCookbook does not satisfy the version constraint of
+      #   this instance of Location.
+      #
+      # @return [Boolean]
+      def validate_cached(cached_cookbook)
+        unless version_constraint.include?(cached_cookbook.version)
+          raise ConstraintNotSatisfied, "A cookbook satisfying '#{name}' (#{version_constraint}) not found at #{self}"
+        end
+
+        true
+      end
+
+      private
+
+        def set_downloaded_status(state)
+          @downloaded_status = state
+        end
+    end
+  end
+end

data/lib/berkshelf/cookbook_source/path_location.rb

@@ -6,17 +6,25 @@ module Berkshelf
 
       attr_accessor :path
 
-      def initialize(name, options = {})
+      # @param [#to_s] name
+      # @param [DepSelector::VersionConstraint] version_constraint
+      # @param [Hash] options
+      def initialize(name, version_constraint, options = {})
         @name = name
+        @version_constraint = version_constraint
         @path = File.expand_path(options[:path])
+        set_downloaded_status(true)
       end
 
+      # @param [#to_s] destination
+      #
+      # @return [Berkshelf::CachedCookbook]
       def download(destination)
-        unless File.chef_cookbook?(path)
-          raise CookbookNotFound, "Cookbook '#{name}' not found at path: '#{path}'"
-        end
+        cached = CachedCookbook.from_path(path)
+        validate_cached(cached)
 
-        path
+        set_downloaded_status(true)
+        cached
       end
 
       def to_s

data/lib/berkshelf/cookbook_source/site_location.rb

@@ -53,14 +53,20 @@ module Berkshelf
         end
       end
 
-      def initialize(name, options = {})
+      # @param [#to_s] name
+      # @param [DepSelector::VersionConstraint] version_constraint
+      # @param [Hash] options
+      def initialize(name, version_constraint, options = {})
         options[:site] ||= OPSCODE_COMMUNITY_API
 
         @name = name
-        @version_constraint = options[:version_constraint]
+        @version_constraint = version_constraint
         @api_uri = options[:site]
       end
 
+      # @param [#to_s] destination
+      #
+      # @return [Berkshelf::CachedCookbook]
       def download(destination)
         version, uri = target_version
         remote_file = rest.get_rest(uri)['file']
@@ -70,9 +76,13 @@ module Berkshelf
         cb_path = File.join(destination, "#{name}-#{version}")
 
         self.class.unpack(downloaded_tf.path, dir)
-        FileUtils.mv(File.join(dir, name), cb_path, :force => true)
+        FileUtils.mv(File.join(dir, name), cb_path, force: true)
 
-        cb_path
+        cached = CachedCookbook.from_store_path(cb_path)
+        validate_cached(cached)
+        
+        set_downloaded_status(true)
+        cached
       end
 
       # @return [Array]

data/lib/berkshelf/cookbook_store.rb

@@ -3,6 +3,9 @@ require 'fileutils'
 module Berkshelf
   # @author Jamie Winsor <jamie@vialstudios.com>
   class CookbookStore
+    include DepSelector
+    include DepSelector::Exceptions
+
     attr_reader :storage_path
 
     # Create a new instance of CookbookStore with the given
@@ -24,24 +27,29 @@ module Berkshelf
     # @param [String] version
     #   version of the Cookbook you want to retrieve
     #
-    # @return [Berkshelf::CachedCookbook]
+    # @return [Berkshelf::CachedCookbook, nil]
     def cookbook(name, version)
-      return nil unless downloaded?(name, version)
-
       path = cookbook_path(name, version)
-      CachedCookbook.from_path(path)
+      return nil unless path.cookbook?
+
+      CachedCookbook.from_store_path(path)
     end
 
-    # Returns an array of all of the Cookbooks that have been cached
-    # to the storage_path of this instance of CookbookStore.
+    # Returns an array of the Cookbooks that have been cached to the
+    # storage_path of this instance of CookbookStore. Passing the filter
+    # option will return only the CachedCookbooks whose name match the
+    # filter.
     #
     # @return [Array<Berkshelf::CachedCookbook>]
-    def cookbooks
+    def cookbooks(filter = nil)
       [].tap do |cookbooks|
         storage_path.each_child do |p|
-          cached_cookbook = CachedCookbook.from_path(p)
+          cached_cookbook = CachedCookbook.from_store_path(p)
           
-          cookbooks << cached_cookbook if cached_cookbook
+          next unless cached_cookbook
+          next if filter && cached_cookbook.cookbook_name != filter
+
+          cookbooks << cached_cookbook
         end
       end
     end
@@ -57,15 +65,25 @@ module Berkshelf
       storage_path.join("#{name}-#{version}")
     end
 
-    # Returns true if the Cookbook of the given name and verion is downloaded
-    # to this instance of CookbookStore.
+    # Return a CachedCookbook matching the best solution for the given name and
+    # constraint. Nil is returned if no matching CachedCookbook is found.
     #
-    # @param [String] name
-    # @param [String] version
+    # @param [#to_s] name
+    # @param [DepSelector::VersionConstraint] constraint
     #
-    # @return [Boolean]
-    def downloaded?(name, version)
-      cookbook_path(name, version).cookbook?
+    # @return [Berkshelf::CachedCookbook, nil]
+    def satisfy(name, constraint)
+      graph                = DependencyGraph.new
+      selector             = Selector.new(graph)
+      package              = graph.package(name)
+      solution_constraints = [ SolutionConstraint.new(graph.package(name), constraint) ]
+
+      cookbooks(name).each { |cookbook| package.add_version(Version.new(cookbook.version)) }
+      name, version = quietly { selector.find_solution(solution_constraints).first }
+      
+      cookbook(name, version)
+    rescue InvalidSolutionConstraints, NoSolutionExists
+      nil
     end
 
     private

data/lib/berkshelf/core_ext/string.rb

@@ -0,0 +1,12 @@
+class String
+  # Separates the string on the given separator and prepends the given
+  # value to each and returns a new string from the result.
+  #
+  # @param [String] separator
+  # @param [String] value
+  #
+  # @return [String]
+  def prepend_each(separator, value)
+    lines(separator).collect { |x| value + x }.join
+  end
+end

data/lib/berkshelf/downloader.rb

@@ -79,10 +79,6 @@ module Berkshelf
       result
     end
 
-    def downloaded?(source)
-      source.downloaded? || cookbook_store.downloaded?(source.name, source.local_version)
-    end
-
     private
 
       def validate_source(source)

data/lib/berkshelf/errors.rb

@@ -1,21 +1,61 @@
 module Berkshelf
   class BerkshelfError < StandardError
     class << self
+      # @param [Integer] code
       def status_code(code)
         define_method(:status_code) { code }
         define_singleton_method(:status_code) { code }
       end
     end
+
+    alias_method :message, :to_s
   end
 
   class BerksfileNotFound < BerkshelfError; status_code(100); end
   class NoVersionForConstraints < BerkshelfError; status_code(101); end
   class DownloadFailure < BerkshelfError; status_code(102); end
   class CookbookNotFound < BerkshelfError; status_code(103); end
-  class GitError < BerkshelfError; status_code(104); end
+  class GitError < BerkshelfError
+    status_code(104)
+    attr_reader :stderr
+
+    def initialize(stderr)
+      @stderr = stderr
+    end
+
+    def to_s
+      out = "An error occured during Git execution:\n"
+      out << stderr.prepend_each("\n", "\t")
+    end
+  end
+
   class DuplicateSourceDefined < BerkshelfError; status_code(105); end
   class NoSolution < BerkshelfError; status_code(106); end
   class CookbookSyntaxError < BerkshelfError; status_code(107); end
   class UploadFailure < BerkshelfError; status_code(108); end
   class KnifeConfigNotFound < BerkshelfError; status_code(109); end
+
+  class InvalidGitURI < BerkshelfError
+    status_code(110)
+    attr_reader :uri
+
+    # @param [String] uri
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def to_s
+      "'#{uri}' is not a valid Git URI."
+    end
+  end
+
+  class GitNotFound < BerkshelfError
+    status_code(110)
+
+    def to_s
+      "Could not find a Git executable in your path. Please add it and try again."
+    end
+  end
+
+  class ConstraintNotSatisfied < BerkshelfError; status_code(111); end
 end

data/lib/berkshelf/git.rb

@@ -1,39 +1,71 @@
+require 'uri'
+require 'mixlib/shellout'
+
 module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
   class Git
+    GIT_REGEXP = URI.regexp(%w{ https git })
+    SSH_REGEXP = /(.+)@(.+):(.+)\/(.+)\.git/
+
     class << self
+      # @overload git(commands)
+      #   Shellout to the Git executable on your system with the given commands.
+      #
+      #   @param [Array<String>]
+      #
+      #   @return [String]
+      #     the output of the execution of the Git command
       def git(*command)
-        out = quietly {
-          %x{ #{git_cmd} #{command.join(' ')} }
-        }
-        error_check
+        cmd = Mixlib::ShellOut.new(git_cmd, *command)
+        cmd.run_command
+
+        unless cmd.exitstatus == 0
+          raise GitError.new(cmd.stderr)
+        end
         
-        out.chomp
+        cmd.stdout.chomp
       end
 
+      # Clone a remote Git repository to disk
+      #
+      # @param [String] uri
+      #   a Git URI to clone
+      # @param [#to_s] destination
+      #   a local path on disk to clone to
+      #
+      # @return [String]
+      #   the destination the URI was cloned to
       def clone(uri, destination = Dir.mktmpdir)
         git("clone", uri, destination.to_s)
 
-        error_check
-
         destination
       end
 
+      # Checkout the given reference in the given repository
+      #
+      # @param [String] repo_path
+      #   path to a Git repo on disk
+      # @param [String] ref
+      #   reference to checkout
       def checkout(repo_path, ref)
         Dir.chdir repo_path do
           git("checkout", "-q", ref)
         end
       end
 
+      # @param [Strin] repo_path
       def rev_parse(repo_path)
         Dir.chdir repo_path do
           git("rev-parse", "HEAD")
         end
       end
 
+      # Return an absolute path to the Git executable on your system
       #
-      # This is to defeat aliases/shell functions called 'git' and a number of
-      # other problems.
+      # @return [String]
+      #   absolute path to git executable
       #
+      # @raise [GitNotFound] if executable is not found in system path
       def find_git
         git_path = nil
         ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
@@ -50,21 +82,58 @@ module Berkshelf
         end
 
         unless git_path
-          raise "Could not find git. Please ensure it is in your path."
+          raise GitNotFound
         end
 
         return git_path
       end
 
+      # Determines if the given URI is a valid Git URI. A valid Git URI is a string
+      # containing the location of a Git repository by either the Git protocol,
+      # SSH protocol, or HTTPS protocol.
+      #
+      # @example Valid Git protocol URI
+      #   "git://github.com/reset/thor-foodcritic.git"
+      # @example Valid HTTPS URI
+      #   "https://github.com/reset/solve.git"
+      # @example Valid SSH protocol URI
+      #   "git@github.com:reset/solve.git"
+      # 
+      # @param [String] uri
+      #
+      # @return [Boolean]
+      def validate_uri(uri)
+        unless uri.is_a?(String)
+          return false
+        end
+
+        unless uri.slice(SSH_REGEXP).nil?
+          return true
+        end
+
+        unless uri.slice(GIT_REGEXP).nil?
+          return true
+        end
+
+        false
+      end
+
+      # @raise [InvalidGitURI] if the given object is not a String containing a valid Git URI
+      #
+      # @see validate_uri
+      def validate_uri!(uri)
+        unless validate_uri(uri)
+          raise InvalidGitURI.new(uri)
+        end
+
+        true
+      end
+
       private
 
         def git_cmd
           @git_cmd ||= find_git
         end
-
-        def error_check
-          raise Berkshelf::GitError, "Did not succeed executing git; check the output above." unless $?.success?
-        end
     end
   end
 end