berkshelf 1.3.1 → 1.4.0.rc1

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 1.3.1
+- Support for Vagrant 1.1.x
+- Move Berkshelf Vagrant plugin into it's [own repository](https://github.com/RiotGames/berkshelf-vagrant)
+- Added -d flag to output debug information in berks command
+- Various bug fixes in uploading cookbooks
+
 # 1.2.0
 - Remove Vagrant as a gem dependency
 - Remove Chef as a gem dependency

data/berkshelf.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'mixlib-shellout', '~> 1.1'
   s.add_dependency 'mixlib-config', '~> 1.1'
   s.add_dependency 'faraday', '>= 0.8.5'
-  s.add_dependency 'ridley', '>= 0.8.6'
+  s.add_dependency 'ridley', '~> 0.9.0'
   s.add_dependency 'chozo', '>= 0.6.1'
   s.add_dependency 'hashie', '>= 2.0.2'
   s.add_dependency 'minitar'

data/lib/berkshelf.rb

@@ -1,14 +1,5 @@
 require 'multi_json'
-
-# Fix for Facter < 1.7.0 changing LANG to C
-# https://github.com/puppetlabs/facter/commit/f77584f4
-begin
-  old_lang = ENV['LANG']
-  require 'ridley'
-ensure
-  ENV['LANG'] = old_lang
-end
-
+require 'ridley'
 require 'chozo/core_ext'
 require 'active_support/core_ext'
 require 'archive/tar/minitar'
@@ -46,6 +37,7 @@ module Berkshelf
   autoload :Git, 'berkshelf/git'
   autoload :InitGenerator, 'berkshelf/init_generator'
   autoload :Lockfile, 'berkshelf/lockfile'
+  autoload :Logger, 'berkshelf/logger'
   autoload :Mixin, 'berkshelf/mixin'
   autoload :Resolver, 'berkshelf/resolver'
   autoload :UI, 'berkshelf/ui'
@@ -53,8 +45,9 @@ module Berkshelf
   require 'berkshelf/location'
 
   class << self
-    attr_accessor :ui
+    include Berkshelf::Mixin::Logging
 
+    attr_accessor :ui
     attr_writer :cookbook_store
 
     # @return [Pathname]
@@ -79,7 +72,7 @@ module Berkshelf
     end
 
     # @return [Logger]
-    def log
+    def logger
       Celluloid.logger
     end
 

data/lib/berkshelf/berksfile.rb

@@ -2,6 +2,7 @@ module Berkshelf
   # @author Jamie Winsor <reset@riotgames.com>
   class Berksfile
     extend Forwardable
+    include Berkshelf::Mixin::Logging
 
     class << self
       # @param [String] file
@@ -27,16 +28,16 @@ module Berkshelf
       # @return [String]
       #   expanded filepath to the vendor directory
       def vendor(cookbooks, path)
-        chefignore_file = [
-          File.join(Dir.pwd, Berkshelf::Chef::Cookbook::Chefignore::FILENAME),
-          File.join(Dir.pwd, 'cookbooks', Berkshelf::Chef::Cookbook::Chefignore::FILENAME)
-        ].find { |f| File.exists?(f) }
-
-        chefignore = chefignore_file && Berkshelf::Chef::Cookbook::Chefignore.new(chefignore_file)
+        chefignore = nil
         path       = File.expand_path(path)
+        scratch    = Berkshelf.mktmpdir
+
         FileUtils.mkdir_p(path)
 
-        scratch = Berkshelf.mktmpdir
+        unless (ignore_file = Berkshelf::Chef::Cookbook::Chefignore.find_relative_to(Dir.pwd)).nil?
+          chefignore = Berkshelf::Chef::Cookbook::Chefignore.new(ignore_file)
+        end
+
         cookbooks.each do |cb|
           dest = File.join(scratch, cb.cookbook_name, "/")
           FileUtils.mkdir_p(dest)
@@ -73,10 +74,12 @@ module Berkshelf
     def_delegator :downloader, :add_location
     def_delegator :downloader, :locations
 
+    # @param [String] path
+    #   path on disk to the file containing the contents of this Berksfile
     def initialize(path)
-      @filepath = path
-      @sources = Hash.new
-      @downloader = Downloader.new(Berkshelf.cookbook_store)
+      @filepath         = path
+      @sources          = Hash.new
+      @downloader       = Downloader.new(Berkshelf.cookbook_store)
       @cached_cookbooks = nil
     end
 
@@ -99,7 +102,8 @@ module Berkshelf
     #   cookbook 'artifact', git: 'git://github.com/RiotGames/artifact-cookbook.git'
     #
     # @example a cookbook source that will be retrieved from a Chef API (Chef Server)
-    #   cookbook 'artifact', chef_api: 'https://api.opscode.com/organizations/vialstudios', node_name: 'reset', client_key: '/Users/reset/.chef/knife.rb'
+    #   cookbook 'artifact', chef_api: 'https://api.opscode.com/organizations/vialstudios',
+    #     node_name: 'reset', client_key: '/Users/reset/.chef/knife.rb'
     #
     # @example a cookbook source that will be retrieved from a Chef API using your Berkshelf config
     #   cookbook 'artifact', chef_api: :config
@@ -225,7 +229,8 @@ module Berkshelf
     #   chef_api :config
     #
     # @example using a URL, node_name, and client_key to add a Chef API default location
-    #   chef_api "https://api.opscode.com/organizations/vialstudios", node_name: "reset", client_key: "/Users/reset/.chef/knife.rb"
+    #   chef_api "https://api.opscode.com/organizations/vialstudios", node_name: "reset",
+    #     client_key: "/Users/reset/.chef/knife.rb"
     #
     # @param [String, Symbol] value
     # @param [Hash] options
@@ -252,7 +257,8 @@ module Berkshelf
         # Only raise an exception if the source is a true duplicate
         groups = (options[:group].nil? || options[:group].empty?) ? [:default] : options[:group]
         if !(@sources[name].groups & groups).empty?
-          raise DuplicateSourceDefined, "Berksfile contains multiple sources named '#{name}'. Use only one, or put them in different groups."
+          raise DuplicateSourceDefined,
+            "Berksfile contains multiple sources named '#{name}'. Use only one, or put them in different groups."
         end
       end
 
@@ -393,7 +399,9 @@ module Berkshelf
       missing_cookbooks = (options[:cookbooks] - cookbooks.map(&:cookbook_name))
 
       unless missing_cookbooks.empty?
-        raise Berkshelf::CookbookNotFound, "Could not find cookbooks #{missing_cookbooks.collect{|cookbook| "'#{cookbook}'"}.join(', ')} in any of the sources. #{missing_cookbooks.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
+        msg = "Could not find cookbooks #{missing_cookbooks.collect{|cookbook| "'#{cookbook}'"}.join(', ')}"
+        msg << " in any of the sources. #{missing_cookbooks.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
+        raise Berkshelf::CookbookNotFound, msg
       end
 
       update_lockfile(sources)
@@ -443,64 +451,86 @@ module Berkshelf
       outdated
     end
 
-    # @option options [String] :server_url
-    #   URL to the Chef API
-    # @option options [String] :client_name
-    #   name of the client used to authenticate with the Chef API
-    # @option options [String] :client_key
-    #   filepath to the client's private key used to authenticate with
-    #   the Chef API
-    # @option options [String] :organization
-    #   the Organization to connect to. This is only used if you are connecting to
-    #   private Chef or hosted Chef
-    # @option options [Boolean] :force Upload the Cookbook even if the version
-    #   already exists and is frozen on the target Chef Server
-    # @option options [Boolean] :freeze Freeze the uploaded Cookbook on the Chef
-    #   Server so that it cannot be overwritten
+    # @option options [Boolean] :force (false)
+    #   Upload the Cookbook even if the version already exists and is frozen on the
+    #   target Chef Server
+    # @option options [Boolean] :freeze (true)
+    #   Freeze the uploaded Cookbook on the Chef Server so that it cannot be overwritten
     # @option options [Symbol, Array] :except
     #   Group(s) to exclude which will cause any sources marked as a member of the
     #   group to not be installed
     # @option options [Symbol, Array] :only
     #   Group(s) to include which will cause any sources marked as a member of the
     #   group to be installed and all others to be ignored
-    # @option cookbooks [String, Array] :cookbooks
+    # @option options [String, Array] :cookbooks
     #   Names of the cookbooks to retrieve sources for
-    # @option options [Hash] :params
-    #   URI query unencoded key/value pairs
-    # @option options [Hash] :headers
-    #   unencoded HTTP header key/value pairs
-    # @option options [Hash] :request
-    #   request options
-    # @option options [Hash] :ssl
-    #   SSL options
-    # @option options [URI, String, Hash] :proxy
-    #   URI, String, or Hash of HTTP proxy options
+    # @option options [Hash] :ssl_verify (true)
+    #   Disable/Enable SSL verification during uploads
+    # @option options [Boolean] :skip_dependencies (false)
+    #   Skip uploading dependent cookbook(s).
+    # @option options [Boolean] :halt_on_frozen (false)
+    #   Raise a FrozenCookbook error if one of the cookbooks being uploaded is already located
+    #   on the remote Chef Server and frozen.
     #
     # @raise [UploadFailure] if you are uploading cookbooks with an invalid or not-specified client key
+    # @raise [Berkshelf::FrozenCookbook]
+    #   if an attempt to upload a cookbook which has been frozen on the target server is made
+    #   and the :halt_on_frozen option was true
     def upload(options = {})
-      conn     = Ridley.new(options)
-      solution = resolve(options)
+      options = options.reverse_merge(
+        force: false,
+        freeze: true,
+        ssl_verify: Berkshelf::Config.instance.ssl.verify,
+        skip_dependencies: false,
+        halt_on_frozen: false
+      )
+
+      ridley_options               = options.slice(:ssl)
+      ridley_options[:server_url]  = Berkshelf::Config.instance.chef.chef_server_url
+      ridley_options[:client_name] = Berkshelf::Config.instance.chef.node_name
+      ridley_options[:client_key]  = Berkshelf::Config.instance.chef.client_key
+      ridley_options[:ssl]         = { verify: options[:ssl_verify] }
+
+      unless ridley_options[:server_url].present?
+        raise UploadFailure, "Missing required attribute in your Berkshelf configuration: chef.server_url"
+      end
+
+      unless ridley_options[:client_name].present?
+        raise UploadFailure, "Missing required attribute in your Berkshelf configuration: chef.node_name"
+      end
+
+      unless ridley_options[:client_key].present?
+        raise UploadFailure, "Missing required attribute in your Berkshelf configuration: chef.client_key"
+      end
+
+      conn        = Ridley.new(ridley_options)
+      solution    = resolve(options)
+      upload_opts = options.slice(:force, :freeze)
 
       solution.each do |cb|
-        upload_opts = options.dup
-        upload_opts[:name] = cb.cookbook_name
+        Berkshelf.formatter.upload(cb.cookbook_name, cb.version, conn.server_url)
 
-        Berkshelf.formatter.upload cb.cookbook_name, cb.version, upload_opts[:server_url]
-        conn.cookbook.upload(cb.path, upload_opts)
+        begin
+          conn.cookbook.upload(cb.path, upload_opts.merge(name: cb.cookbook_name))
+        rescue Ridley::Errors::FrozenCookbook => ex
+          if options[:halt_on_frozen]
+            raise Berkshelf::FrozenCookbook, ex
+          end
+        end
       end
 
       if options[:skip_dependencies]
         missing_cookbooks = options.fetch(:cookbooks, nil) - solution.map(&:cookbook_name)
         unless missing_cookbooks.empty?
           msg = "Unable to upload cookbooks: #{missing_cookbooks.sort.join(', ')}\n"
-          msg << "Specified cookbooks must be defined within the Berkshelf file when using the `--skip-dependencies` option"
+          msg << "Specified cookbooks must be defined within the Berkshelf file when using the"
+          msg << " `--skip-dependencies` option"
           raise ExplicitCookbookNotFound.new(msg)
         end
       end
-    rescue Ridley::Errors::ClientKeyFileNotFound => e
-      msg = "Could not upload cookbooks: Missing Chef client key: '#{Berkshelf::Config.instance.chef.client_key}'."
-      msg << " Generate or update your Berkshelf configuration that contains a valid path to a Chef client key."
-      raise UploadFailure, msg
+    rescue Ridley::Errors::RidleyError => ex
+      log_exception(ex)
+      raise UploadFailure, ex
     ensure
       conn.terminate if conn && conn.alive?
     end
@@ -515,32 +545,14 @@ module Berkshelf
     #   group to be installed and all others to be ignored
     # @option cookbooks [String, Array] :cookbooks
     #   Names of the cookbooks to retrieve sources for
+    # @option options [Boolean] :skip_dependencies
+    #   Skip resolving of dependencies
     #
     # @return [Array<Berkshelf::CachedCookbooks]
     def resolve(options = {})
       resolver(options).resolve
     end
 
-    # Builds a Resolver instance
-    #
-    # @option options [Symbol, Array] :except
-    #   Group(s) to exclude which will cause any sources marked as a member of the
-    #   group to not be installed
-    # @option options [Symbol, Array] :only
-    #   Group(s) to include which will cause any sources marked as a member of the
-    #   group to be installed and all others to be ignored
-    # @option cookbooks [String, Array] :cookbooks
-    #   Names of the cookbooks to retrieve sources for
-    #
-    # @return <Berkshelf::Resolver>
-    def resolver(options={})
-      Resolver.new(
-        self.downloader,
-        sources: sources(options),
-        skip_dependencies: options[:skip_dependencies]
-      )
-    end
-
     # Reload this instance of Berksfile with the given content. The content
     # is a string that may contain terms from the included DSL.
     #
@@ -569,6 +581,28 @@ module Berkshelf
         File.exist?(Berkshelf::Lockfile::DEFAULT_FILENAME)
       end
 
+      # Builds a Resolver instance
+      #
+      # @option options [Symbol, Array] :except
+      #   Group(s) to exclude which will cause any sources marked as a member of the
+      #   group to not be installed
+      # @option options [Symbol, Array] :only
+      #   Group(s) to include which will cause any sources marked as a member of the
+      #   group to be installed and all others to be ignored
+      # @option options [String, Array] :cookbooks
+      #   Names of the cookbooks to retrieve sources for
+      # @option options [Boolean] :skip_dependencies
+      #   Skip resolving of dependencies
+      #
+      # @return <Berkshelf::Resolver>
+      def resolver(options = {})
+        Resolver.new(
+          self.downloader,
+          sources: sources(options),
+          skip_dependencies: options[:skip_dependencies]
+        )
+      end
+
       def write_lockfile(sources)
         Berkshelf::Lockfile.new(sources).write
       end

data/lib/berkshelf/cached_cookbook.rb

@@ -13,7 +13,7 @@ module Berkshelf
         cached_name = File.basename(path.to_s).slice(DIRNAME_REGEXP, 1)
         return nil if cached_name.nil?
 
-        from_path(path, name: cached_name)      
+        from_path(path, name: cached_name)
       end
     end
 

data/lib/berkshelf/chef/cookbook/chefignore.rb

@@ -15,6 +15,21 @@ module Berkshelf::Chef::Cookbook
   # See the License for the specific language governing permissions and
   # limitations under the License.
   class Chefignore
+    class << self
+      # Traverse a path in relative context to find a Chefignore file
+      #
+      # @param [String] path
+      #   path to traverse
+      #
+      # @return [String, nil]
+      def find_relative_to(path)
+        [
+          File.join(path, Berkshelf::Chef::Cookbook::Chefignore::FILENAME),
+          File.join(path, 'cookbooks', Berkshelf::Chef::Cookbook::Chefignore::FILENAME)
+        ].find { |f| File.exists?(f) }
+      end
+    end
+
     FILENAME                = "chefignore".freeze
     COMMENTS_AND_WHITESPACE = /^\s*(?:#.*)?$/
 

data/lib/berkshelf/cli.rb

@@ -31,7 +31,7 @@ module Berkshelf
       end
 
       if @options[:debug]
-        Berkshelf.log.level = ::Logger::DEBUG
+        Berkshelf.logger.level = ::Logger::DEBUG
       end
 
       if @options[:quiet]
@@ -199,53 +199,39 @@ module Berkshelf
       type: :array,
       desc: "Only cookbooks that are in these groups.",
       aliases: "-o"
-    method_option :freeze,
+    method_option :no_freeze,
       type: :boolean,
       default: false,
-      desc: "Freeze the uploaded cookbooks so that they cannot be overwritten"
-    option :force,
+      desc: "Do not freeze uploaded cookbook(s)."
+    method_option :force,
       type: :boolean,
       default: false,
-      desc: "Upload cookbook(s) even if a frozen one exists on the target Chef Server"
-    option :ssl_verify,
+      desc: "Upload all cookbook(s) even if a frozen one exists on the Chef Server."
+    method_option :ssl_verify,
       type: :boolean,
       default: nil,
-      desc: "Disable/Enable SSL verification when uploading cookbooks"
-    option :skip_syntax_check,
+      desc: "Disable/Enable SSL verification when uploading cookbooks."
+    method_option :skip_syntax_check,
       type: :boolean,
       default: false,
-      desc: "Skip Ruby syntax check when uploading cookbooks",
+      desc: "Skip Ruby syntax check when uploading cookbooks.",
       aliases: "-s"
-    option :skip_dependencies,
+    method_option :skip_dependencies,
+      type: :boolean,
+      desc: "Skip uploading dependent cookbook(s).",
+      default: false,
+      aliases: "-D"
+    method_option :halt_on_frozen,
       type: :boolean,
-      desc: 'Do not upload dependencies',
       default: false,
-      aliases: '-D'
+      desc: "Halt uploading and exit if the Chef Server has a frozen version of the cookbook(s)."
     desc "upload [COOKBOOKS]", "Upload cookbook(s) specified by a Berksfile to the configured Chef Server."
     def upload(*cookbook_names)
       berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
 
-      unless Berkshelf::Config.instance.chef.chef_server_url.present?
-        msg = "Could not upload cookbooks: Missing Chef server_url."
-        msg << " Generate or update your Berkshelf configuration that contains a valid Chef Server URL."
-        raise UploadFailure, msg
-      end
-
-      unless Berkshelf::Config.instance.chef.node_name.present?
-        msg = "Could not upload cookbooks: Missing Chef node_name."
-        msg << " Generate or update your Berkshelf configuration that contains a valid Chef node_name."
-        raise UploadFailure, msg
-      end
-
-      upload_options = {
-        server_url: Berkshelf::Config.instance.chef.chef_server_url,
-        client_name: Berkshelf::Config.instance.chef.node_name,
-        client_key: Berkshelf::Config.instance.chef.client_key,
-        ssl: {
-          verify: (options[:ssl_verify].nil? ? Berkshelf::Config.instance.ssl.verify : options[:ssl_verify])
-        },
-        cookbooks: cookbook_names
-      }.merge(options).symbolize_keys
+      upload_options             = Hash[options.except(:no_freeze, :berksfile)].symbolize_keys
+      upload_options[:cookbooks] = cookbook_names
+      upload_options[:freeze]    = false if options[:no_freeze]
 
       berksfile.upload(upload_options)
     end

data/lib/berkshelf/cookbook_source.rb

@@ -57,6 +57,11 @@ module Berkshelf
           raise InternalError, "Invalid options for Cookbook Source: #{invalid_options.join(', ')}."
         end
 
+        if (options.keys & [:site, :path, :git]).size > 1
+          invalid = (options.keys & [:site, :path, :git]).map { |opt| "'#{opt}" }
+          raise InternalError, "Cannot specify #{invalid.to_sentence} for a Cookbook Source!"
+        end
+
         true
       end
     end
@@ -64,13 +69,10 @@ module Berkshelf
     extend Forwardable
 
     attr_reader :name
+    attr_reader :options
     attr_reader :version_constraint
-    attr_reader :groups
-    attr_reader :location
     attr_accessor :cached_cookbook
 
-    def_delegator :cached_cookbook, :version, :locked_version
-
     #  @param [String] name
     #  @param [Hash] options
     #
@@ -92,52 +94,70 @@ module Berkshelf
     #    same as tag
     #  @option options [String] :locked_version
     def initialize(name, options = {})
-      @name = name
-      @version_constraint = Solve::Constraint.new(options[:constraint] || ">= 0.0.0")
-      @groups = []
-      @cached_cookbook = nil
-      @location = nil
-
       self.class.validate_options(options)
 
-      unless (options.keys & self.class.location_keys.keys).empty?
-        @location = Location.init(name, version_constraint, options)
-      end
-
-      if @location.is_a?(PathLocation)
-        begin
-          @cached_cookbook = CachedCookbook.from_path(location.path)
-        rescue IOError
-          raise Berkshelf::CookbookNotFound
-        end
-      end
-
+      @name = name
       @locked_version = Solve::Version.new(options[:locked_version]) if options[:locked_version]
+      @version_constraint = Solve::Constraint.new(options[:locked_version] || options[:constraint] || ">= 0.0.0")
+
+      @cached_cookbook, @location = cached_and_location(options)
 
       add_group(options[:group]) if options[:group]
       add_group(:default) if groups.empty?
     end
 
-    def add_group(*groups)
-      groups = groups.first if groups.first.is_a?(Array)
-      groups.each do |group|
+    def add_group(*local_groups)
+      local_groups = local_groups.first if local_groups.first.is_a?(Array)
+
+      local_groups.each do |group|
         group = group.to_sym
-        @groups << group unless @groups.include?(group)
+        groups << group unless groups.include?(group)
       end
     end
 
     # Returns true if the cookbook source has already been downloaded. A cookbook
-    # source is downloaded when a cached cookbooked is present.
+    # source is downloaded when a cached cookbook is present.
     #
     # @return [Boolean]
     def downloaded?
       !self.cached_cookbook.nil?
     end
 
+    # Returns true if this CookbookSource has the given group.
+    #
+    # @return [Boolean]
     def has_group?(group)
       groups.include?(group.to_sym)
     end
 
+    # Get the locked version of this cookbook. First check the instance variable
+    # and then resort to the cached_cookbook for the version.
+    #
+    # This was formerly a delegator, but it would fail if the `@cached_cookbook`
+    # was nil or undefined.
+    #
+    # @return [Solve::Version, nil]
+    #   the locked version of this cookbook
+    def locked_version
+      @locked_version ||= cached_cookbook.try(:version)
+    end
+
+    # The location for this CookbookSource, such as a remote Chef Server, the
+    # community API, :git, or a :path location. By default, this will be the
+    # community API.
+    #
+    # @return [Berkshelf::Location]
+    def location
+      @location
+    end
+
+    # The list of groups this CookbookSource belongs to.
+    #
+    # @return [Array<Symbol>]
+    def groups
+      @groups ||= []
+    end
+
     def to_s
       msg = "#{self.name} (#{self.version_constraint}) groups: #{self.groups}"
       msg << " location: #{self.location}" if self.location
@@ -155,5 +175,69 @@ module Berkshelf
     def to_json
       MultiJson.dump(self.to_hash, pretty: true)
     end
+
+    private
+
+      # Determine the CachedCookbook and Location information from the given options.
+      #
+      # @return [Array<CachedCookbook, Location>]
+      def cached_and_location(options = {})
+        from_path(options) || from_cache(options) || from_default(options)
+      end
+
+      # Attempt to load a CachedCookbook from a local file system path (if the :path
+      # option was given). If one is found, the location and cached_cookbook is
+      # updated. Otherwise, this method will raise a CookbookNotFound exception.
+      #
+      # @raises [Berkshelf::CookbookNotFound]
+      #   if no CachedCookbook exists at the given path
+      #
+      # @return [Berkshelf::CachedCookbook]
+      def from_path(options = {})
+        return nil unless options[:path]
+
+        location = PathLocation.new(name, version_constraint, path: options[:path])
+        cached = CachedCookbook.from_path(location.path)
+
+        [cached, location]
+      rescue IOError
+        raise Berkshelf::CookbookNotFound
+      end
+
+      # Attempt to load a CachedCookbook from the local CookbookStore. This will save
+      # the need to make an http request to download a cookbook we already have cached
+      # locally.
+      #
+      # @return [Berkshelf::CachedCookbook, nil]
+      def from_cache(options = {})
+        path = File.join(Berkshelf.cookbooks_dir, filename(options))
+        return nil unless File.exists?(path)
+
+        location = PathLocation.new(name, version_constraint, path: path)
+        cached = CachedCookbook.from_path(path, name: name)
+
+        [cached, location]
+      end
+
+      # Use the default location, and a nil CachedCookbook. If there is no location
+      # specified,
+      #
+      # @return [Array<nil, Location>]
+      def from_default(options = {})
+        if (options.keys & self.class.location_keys.keys).empty?
+          location = nil
+        else
+          location = Location.init(name, version_constraint, options)
+        end
+
+        [nil, location]
+      end
+
+      # The hypothetical location of this CachedCookbook, if it were to exist.
+      #
+      # @return [String]
+      def filename(options = {})
+        "#{name}-#{options[:locked_version]}"
+      end
   end
 end