berkshelf 3.0.0.beta1 → 3.0.0.beta2

data/lib/berkshelf/installer.rb

@@ -90,21 +90,21 @@ module Berkshelf
     private
 
       def dependency_from_lockfile(dependency)
-        locked_dependency = lockfile.find(dependency)
+        locked = lockfile.find(dependency)
 
-        return nil unless locked_dependency
+        return nil unless locked
 
         # If there's a locked_version, make sure it's still satisfied
         # by the constraint
-        if locked_dependency.locked_version
-          unless dependency.version_constraint.satisfies?(locked_dependency.locked_version)
-            raise Berkshelf::OutdatedDependency.new(locked_dependency, dependency)
+        if locked.locked_version
+          unless dependency.version_constraint.satisfies?(locked.locked_version)
+            raise Berkshelf::OutdatedDependency.new(locked, dependency)
           end
         end
 
-        # Update to the new constraint (it might have changed, but still be satisfied)
-        locked_dependency.version_constraint = dependency.version_constraint
-        locked_dependency
+        # Update to the constraint to be a hard one
+        locked.version_constraint = Solve::Constraint.new(locked.locked_version.to_s)
+        locked
       end
 
       # Merge the locked dependencies against the given dependencies.

data/lib/berkshelf/location.rb

@@ -12,6 +12,9 @@ module Berkshelf
       #   Location.init('nginx', '>= 0.0.0', git: 'git://github.com/RiotGames/artifact-cookbook.git') =>
       #     instantiates a GitLocation
       #
+      #   Location.init('nginx', '>= 0.0.0', hg: 'http://hghub.com/RiotGames/') =>
+      #     instantiates a MercurialLocation
+      #
       #   Location.init('nginx', '>= 0.0.0', path: '/Users/reset/code/nginx-cookbook') =>
       #     instantiates a PathLocation
       #
@@ -126,6 +129,20 @@ module Berkshelf
         JSON.pretty_generate(to_hash, options)
       end
     end
+
+    class ScmLocation < Location::Base
+      class << self
+        # Create a temporary directory for the cloned repository within Berkshelf's
+        # temporary directory
+        #
+        # @return [String]
+        #   the path to the created temporary directory
+        def tmpdir
+          @tmpdir ||= Berkshelf.mktmpdir
+        end
+      end
+    end
+
   end
 end
 

data/lib/berkshelf/locations/git_location.rb

@@ -1,15 +1,5 @@
 module Berkshelf
-  class GitLocation < Location::Base
-    class << self
-      # Create a temporary directory for the cloned repository within Berkshelf's
-      # temporary directory
-      #
-      # @return [String]
-      #   the path to the created temporary directory
-      def tmpdir
-        @tmpdir ||= Berkshelf.mktmpdir
-      end
-    end
+  class GitLocation < Location::ScmLocation
 
     set_location_key :git
     set_valid_options :ref, :branch, :tag, :rel
@@ -22,7 +12,7 @@ module Berkshelf
 
     alias_method :tag, :branch
 
-    # @param [Solve::Constraint] version_constraint
+    # @param [Dependency] dependency
     # @param [Hash] options
     #
     # @option options [String] :git
@@ -37,10 +27,10 @@ module Berkshelf
     #   the path within the repository to find the cookbook
     def initialize(dependency, options = {})
       super
-      @uri                = options[:git]
-      @branch             = options[:branch] || options[:tag] || 'master'
-      @ref                = options[:ref]
-      @rel                = options[:rel]
+      @uri    = options[:git]
+      @branch = options[:branch] || options[:tag] || 'master'
+      @ref    = options[:ref]
+      @rel    = options[:rel]
 
       Git.validate_uri!(@uri)
     end
@@ -68,7 +58,7 @@ module Berkshelf
         raise CookbookNotFound, msg
       end
 
-      cb_path = File.join(destination, "#{dependency.name}-#{ref}")
+      cb_path = revision_path(destination)
       FileUtils.rm_rf(cb_path)
       FileUtils.mv(tmp_path, cb_path)
 

data/lib/berkshelf/locations/mercurial_location.rb

@@ -0,0 +1,112 @@
+module Berkshelf
+  class MercurialLocation < Location::ScmLocation
+
+    set_location_key :hg
+    set_valid_options :rev, :branch, :tag, :rel
+
+    attr_accessor :uri
+    attr_accessor :rel
+    attr_accessor :rev
+    attr_reader :options
+
+    alias_method :tag, :rev
+    alias_method :branch, :rev
+
+    # @param [Dependency] dependency
+    # @param [Hash] options
+    #
+    # @option options [String] :hg
+    #   the URL to clone
+    # @option options [String] :rev
+    #   the revision to checkout
+    # @option options [String] :branch
+    #   same as rev
+    # @option options [String] :tag
+    #   same as rev
+    # @option options [String] :rel
+    #   the path within the repository to find the cookbook
+    def initialize(dependency, options = {})
+      super
+      @uri = options[:hg]
+      @rev = options[:rev] || options[:branch] || options[:tag] || 'default'
+      @rel = options[:rel]
+
+      Mercurial.validate_uri!(@uri)
+    end
+
+    # @return [Berkshelf::CachedCookbook]
+    def do_download
+      destination = Berkshelf::CookbookStore.instance.storage_path
+
+      if cached?(destination)
+        @rev ||= Berkshelf::Mercurial.rev_parse(revision_path(destination))
+        return local_revision(destination)
+      end
+
+      Berkshelf::Mercurial.checkout(clone, rev || branch || tag) if rev || branch || tag
+      @rev = Berkshelf::Mercurial.rev_parse(clone)
+
+      tmp_path = rel ? File.join(clone, rel) : clone
+      unless File.chef_cookbook?(tmp_path)
+        msg = "Cookbook '#{dependency.name}' not found at hg: #{uri}"
+        msg << " with rev '#{rev}'" if rev
+        msg << " at path '#{rel}'" if rel
+        raise CookbookNotFound, msg
+      end
+
+      cb_path = revision_path(destination)
+      FileUtils.rm_rf(cb_path)
+      FileUtils.mv(tmp_path, cb_path)
+
+      cached = CachedCookbook.from_store_path(cb_path)
+      validate_cached(cached)
+
+      cached
+    end
+
+    def to_hash
+      super.tap do |h|
+        h[:value]  = self.uri
+        h[:branch] = self.branch if branch
+      end
+    end
+
+    def to_s
+      s = "#{self.class.location_key}: '#{uri}'"
+      s << " at rev: '#{rev}'" if rev
+      s
+    end
+
+    private
+
+      def hg
+        @hg ||= Berkshelf::Mercurial.new(uri)
+      end
+
+      def clone
+        tmp_clone = File.join(self.class.tmpdir, uri.gsub(/[\/:]/,'-'))
+        FileUtils.mkdir_p(File.join(File.split(tmp_clone).shift))
+        unless File.exists?(tmp_clone)
+          Berkshelf::Mercurial.clone(uri, tmp_clone)
+        end
+
+        tmp_clone
+      end
+
+      def cached?(destination)
+        revision_path(destination) && File.exists?(revision_path(destination))
+      end
+
+      def local_revision(destination)
+        path = revision_path(destination)
+        cached = Berkshelf::CachedCookbook.from_store_path(path)
+        validate_cached(cached)
+        return cached
+      end
+
+      def revision_path(destination)
+        return unless rev
+        File.join(destination, "#{dependency.name}-#{rev}")
+      end
+  end
+end

data/lib/berkshelf/lockfile.rb

@@ -47,7 +47,7 @@ module Berkshelf
       end
     end
 
-    # The list of sources constrained in this lockfile.
+    # The list of dependencies constrained in this lockfile.
     #
     # @return [Array<Berkshelf::Dependency>]
     #   the list of dependencies in this lockfile

data/lib/berkshelf/mercurial.rb

@@ -0,0 +1,146 @@
+require 'uri'
+require 'buff/shell_out'
+
+module Berkshelf
+  class Mercurial
+    HG_REGEXP = URI.regexp(%w(http https file ssh))
+
+    HAS_QUOTE_RE = %r{\"}.freeze
+    HAS_SPACE_RE = %r{\s}.freeze
+
+    class << self
+      include Buff::ShellOut
+
+      # @overload hg(commands)
+      #   Shellout to the Mercurial executable on your system with the given commands.
+      #
+      #   @param [Array<String>]
+      #
+      #   @return [String]
+      #     the output of the execution of the Mercurial command
+      def hg(*command)
+        command.unshift(hg_cmd)
+        command_str = command.map { |p| quote_cmd_arg(p) }.join(' ')
+        response    = shell_out(command_str)
+
+        unless response.success?
+          raise MercurialError.new(response.stderr.strip)
+        end
+
+        response.stdout.strip
+      end
+
+      # Clone a remote Mercurial repository to disk
+      #
+      # @param [String] uri
+      #   a Mercurial 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)
+        hg('clone', uri, destination.to_s)
+        destination
+      end
+
+      # Checkout the given revision in the given repository
+      #
+      # @param [String] repo_path
+      #   path to a mercurial repo on disk
+      # @param [String] rev
+      #   revision to checkout
+      def checkout(repo_path, rev)
+        Dir.chdir repo_path do
+          hg('update','--clean', '--rev', rev)
+        end
+      end
+
+      # @param [String] repo_path
+      def rev_parse(repo_path)
+        Dir.chdir repo_path do
+          hg('id', '-i')
+        end
+      end
+
+      # Return an absolute path to the Mercurial executable on your system
+      #
+      # @return [String]
+      #   absolute path to mercurial executable
+      #
+      # @raise [MercurialNotFound] if executable is not found in system path
+      def find_hg
+        hg_path = nil
+        ENV['PATH'].split(::File::PATH_SEPARATOR).each do |path|
+          hg_path = detect_hg_path(path)
+          break if hg_path
+        end
+
+        unless hg_path
+          raise MercurialNotFound
+        end
+
+        return hg_path
+      end
+
+      # Determines if the given URI is a valid mercurial URI. A valid mercurial URI is a string
+      # containing the location of a mercurial repository by either the HTTP protocol,
+      # HTTPS protocol, or SSH protocol.
+      #
+      # @example Valid HTTP protocol URI
+      #   'http://hghub.com/project'
+      # @example Valid HTTPS URI
+      #   'https://hghub.com/project'
+      # @example Valid SSH protocol URI
+      #   'ssh://user@hghub.com:22/path/to/repo'
+      #
+      # @param [String] uri
+      #
+      # @return [Boolean]
+      def validate_uri(uri)
+        unless uri.is_a?(String)
+          return false
+        end
+
+        unless uri.slice(HG_REGEXP).nil?
+          return true
+        end
+
+        false
+      end
+
+      # @raise [InvalidMercurialURI] if the given object is not a String containing a valid Mercurial URI
+      #
+      # @see validate_uri
+      def validate_uri!(uri)
+        unless validate_uri(uri)
+          raise InvalidHgURI.new(uri)
+        end
+
+        true
+      end
+
+      private
+
+        def hg_cmd
+          @hg_cmd ||= find_hg
+        end
+
+        def quote_cmd_arg(arg)
+          return arg if HAS_QUOTE_RE.match(arg)
+          return arg unless HAS_SPACE_RE.match(arg)
+          "\"#{arg}\""
+        end
+
+        def detect_hg_path(base_dir)
+          %w(hg hg.exe hg.cmd).each do |hg_cmd|
+            potential_path = File.join(base_dir, hg_cmd)
+            if File.executable?(potential_path)
+              return potential_path
+            end
+          end
+          nil
+        end
+      end
+  end
+end

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "3.0.0.beta1"
+  VERSION = "3.0.0.beta2"
 end

data/spec/config/knife.rb

@@ -1,11 +1,9 @@
-current_dir = File.expand_path(File.dirname(__FILE__))
-
 log_level                :info
 log_location             STDOUT
 node_name                "berkshelf"
-client_key               "#{current_dir}/berkshelf.pem"
+client_key               File.expand_path("spec/config/berkshelf.pem")
 validation_client_name   "validator"
-validation_key           "#{current_dir}/validator.pem"
+validation_key           File.expand_path("spec/config/validator.pem")
 chef_server_url          "http://localhost:26310"
 cache_type               'BasicFile'
 cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )

data/spec/fixtures/lockfiles/default.lock

@@ -1,5 +1,4 @@
 {
-  "sha":"6b76225554cc1f7c0aea0f8b3f10c6743aeba67e",
   "dependencies":{
     "build-essential":{
       "locked_version":"1.1.2"

data/spec/support/chef_api.rb

@@ -8,9 +8,16 @@ module Berkshelf
         ridley.cookbook.all
       end
 
-      def upload_cookbook(path)
+      def upload_cookbook(path, options = {})
         cached = CachedCookbook.from_store_path(path)
-        ridley.cookbook.upload(cached.path, name: cached.cookbook_name)
+
+        options = {
+          force: false,
+          freeze: false,
+          name: cached.cookbook_name,
+        }.merge(options)
+
+        ridley.cookbook.upload(cached.path, options)
       end
 
       # Remove the version of the given cookbook from the Chef Server defined

data/spec/support/mercurial.rb

@@ -0,0 +1,122 @@
+module Berkshelf
+  module RSpec
+    module Mercurial
+      require 'buff/shell_out'
+      include Buff::ShellOut
+
+      require_relative 'path_helpers'
+      include Berkshelf::RSpec::PathHelpers
+
+      def mercurial_origin_for(repo, options = {})
+        "file://localhost#{generate_fake_mercurial_remote(repo, options)}"
+      end
+
+      def generate_fake_mercurial_remote(uri, options = {})
+        repo_path = remotes.join(uri)
+
+        FileUtils.mkdir repo_path
+
+        Dir.chdir(repo_path) do
+          ENV['HGUSER'] = 'test_user'
+          shell_out "hg init"
+          shell_out "echo '# a change!' >> content_file"
+          if options[:is_cookbook]
+            shell_out "echo '#cookbook' >> metadata.rb"
+          end
+          shell_out "hg add ."
+          shell_out "hg commit -m 'A commit.'"
+          options[:tags].each do |tag|
+            shell_out "echo '#{tag}' > content_file"
+            shell_out "hg commit -m '#{tag} content'"
+            shell_out "hg tag '#{tag}'"
+          end if options.has_key? :tags
+          options[:branches].each do |branch|
+            shell_out "hg branch #{branch}"
+            shell_out "echo '#{branch}' > content_file"
+            shell_out "hg commit -m '#{branch} content'"
+            shell_out "hg up default"
+          end if options.has_key? :branches
+        end
+        repo_path.to_path
+      end
+
+      # Calculate the id for the given mercurial rev.
+      #
+      # @param [#to_s] repo
+      #   the repository to show the rev for
+      # @param [#to_s] rev
+      #   the revision to identify
+      #
+      # @return [String]
+      def id_for_rev(repo, rev)
+        Dir.chdir remote_path(repo) do
+          shell_out("hg id -r '#{rev}'").stdout.split(' ').first.strip
+        end
+      end
+
+      # The clone path the given repo.
+      #
+      # @param [#to_s] repo
+      #   the name of the local repo
+      #
+      # @return [Pathname]
+      #   the path to the clone
+      def clone_path(repo)
+        clones.join(repo.to_s)
+      end
+
+      # The clone path the remote repo.
+      #
+      # @param [#to_s] repo
+      #   the name of the remote repo
+      #
+      # @return [Pathname]
+      #   the path to the clone
+      def remote_path(repo)
+        remotes.join(repo.to_s)
+      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
+
+      # 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)
+
+        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