berkshelf 2.0.18 → 3.0.0.beta1

data/generator_files/Berksfile.erb

@@ -1,5 +1,6 @@
-site :opscode
+source "http://api.berkshelf.com"
 <% if options[:chef_minitest] -%>
+
 group :integration do
   cookbook 'minitest-handler'
 end

data/generator_files/Vagrantfile.erb

@@ -62,6 +62,9 @@ Vagrant.configure("2") do |config|
   # View the documentation for the provider you're using for more
   # information on available options.
 
+  config.ssh.max_tries = 40
+  config.ssh.timeout   = 120
+
   # The path to the Berksfile to use with Vagrant Berkshelf
   # config.berkshelf.berksfile_path = "./Berksfile"
 

data/generator_files/default_test.rb.erb

@@ -2,7 +2,7 @@ require File.expand_path('../support/helpers', __FILE__)
 
 describe '<%= cookbook_name %>::default' do
 
-  include Helpers::<%= cookbook_name.capitalize.sub('-','_') %>
+  include Helpers::<%= cookbook_name.capitalize.gsub('-','_') %>
 
   # Example spec tests can be found at http://git.io/Fahwsw
   it 'runs no tests by default' do

data/generator_files/helpers.rb.erb

@@ -1,5 +1,5 @@
 module Helpers
-  module <%= cookbook_name.capitalize.sub('-','_') %>
+  module <%= cookbook_name.capitalize.gsub('-','_') %>
     include MiniTest::Chef::Assertions
     include MiniTest::Chef::Context
     include MiniTest::Chef::Resources

data/lib/berkshelf.rb

@@ -1,6 +1,6 @@
-require 'active_support/core_ext'
+require 'buff/extensions'
 require 'archive/tar/minitar'
-require 'chozo/core_ext'
+require 'celluloid'
 require 'digest/md5'
 require 'forwardable'
 require 'hashie'
@@ -12,24 +12,24 @@ require 'thor'
 require 'tmpdir'
 require 'uri'
 require 'zlib'
-require 'rbzip2'
+
+JSON.create_id = nil
 
 require_relative 'berkshelf/core_ext'
-require_relative 'berkshelf/errors'
-require_relative 'berkshelf/mixin'
 require_relative 'berkshelf/thor_ext'
 
-JSON.create_id = nil
-
 module Berkshelf
+  require_relative 'berkshelf/errors'
+  require_relative 'berkshelf/mixin'
+
   DEFAULT_FILENAME = 'Berksfile'.freeze
 
   class << self
     include Berkshelf::Mixin::Logging
 
+    attr_writer :berkshelf_path
     attr_accessor :ui
     attr_accessor :logger
-    attr_writer :cookbook_store
 
     # @return [Pathname]
     def root
@@ -50,21 +50,42 @@ module Berkshelf
     #
     # @return [String]
     def berkshelf_path
-      ENV['BERKSHELF_PATH'] || File.expand_path('~/.berkshelf')
+      @berkshelf_path || ENV['BERKSHELF_PATH'] || File.expand_path('~/.berkshelf')
+    end
+
+    # The Berkshelf configuration.
+    #
+    # @return [Berkshelf::Config]
+    def config
+      Berkshelf::Config.instance
+    end
+
+    # @param [Berkshelf::Config]
+    def config=(config)
+      Berkshelf::Config.set_config(config)
     end
 
     # The Chef configuration file.
     #
     # @return [Berkshelf::Chef::Config]
     def chef_config
-      @chef_config ||= Berkshelf::Chef::Config.load
+      Berkshelf::Chef::Config.instance
     end
 
-    # Set the Chef configuration file.
-    #
-    # @param [Berkshelf::Chef::Config] new_config
-    #   the new configuration file to use
-    attr_writer :chef_config
+    # @param [Berkshelf::Chef::Config]
+    def chef_config=(config)
+      Berkshelf::Chef::Config.set_config(config)
+    end
+
+    # Initialize the filepath for the Berkshelf path..
+    def initialize_filesystem
+      FileUtils.mkdir_p(berkshelf_path, mode: 0755)
+
+      unless File.writable?(berkshelf_path)
+        raise InsufficientPrivledges, "You do not have permission to write to '#{berkshelf_path}'!" +
+          " Please either chown the directory or use a different filepath."
+      end
+    end
 
     # @return [String]
     def tmp_dir
@@ -80,13 +101,9 @@ module Berkshelf
       Dir.mktmpdir(nil, tmp_dir)
     end
 
-    def cookbooks_dir
-      File.join(berkshelf_path, 'cookbooks')
-    end
-
     # @return [Berkshelf::CookbookStore]
     def cookbook_store
-      @cookbook_store ||= CookbookStore.new(cookbooks_dir)
+      CookbookStore.instance
     end
 
     # Get the appropriate Formatter object based on the formatter
@@ -122,6 +139,7 @@ module Berkshelf
   end
 end
 
+require_relative 'berkshelf/api_client'
 require_relative 'berkshelf/base_generator'
 require_relative 'berkshelf/berksfile'
 require_relative 'berkshelf/cached_cookbook'
@@ -129,21 +147,22 @@ require_relative 'berkshelf/chef'
 require_relative 'berkshelf/cli'
 require_relative 'berkshelf/community_rest'
 require_relative 'berkshelf/cookbook_generator'
-require_relative 'berkshelf/cookbook_source'
 require_relative 'berkshelf/cookbook_store'
 require_relative 'berkshelf/config'
+require_relative 'berkshelf/dependency'
 require_relative 'berkshelf/downloader'
 require_relative 'berkshelf/formatters'
 require_relative 'berkshelf/git'
 require_relative 'berkshelf/init_generator'
+require_relative 'berkshelf/installer'
 require_relative 'berkshelf/location'
 require_relative 'berkshelf/lockfile'
 require_relative 'berkshelf/logger'
 require_relative 'berkshelf/resolver'
-require_relative 'berkshelf/test' if ENV['RUBY_ENV'] == 'test'
+require_relative 'berkshelf/source'
+require_relative 'berkshelf/source_uri'
 require_relative 'berkshelf/ui'
 require_relative 'berkshelf/version'
 
-Ridley.logger = Berkshelf.logger = Logger.new(STDOUT)
+Ridley.logger = Celluloid.logger = Berkshelf.logger = Logger.new(STDOUT)
 Berkshelf.logger.level = Logger::WARN
-Celluloid.logger.level = Logger::FATAL if defined?(Celluloid)

data/lib/berkshelf/api_client.rb

@@ -0,0 +1,67 @@
+require 'addressable/uri'
+
+module Berkshelf
+  # Used to communicate with a remotely hosted [Berkshelf API Server](https://github.com/riotgames/berkshelf-api).
+  #
+  # @example
+  #   client = Berkshelf::APIClient.new("http://api.berkshelf.com")
+  #   client.universe #=> [...]
+  class APIClient < Faraday::Connection
+    require_relative 'api_client/remote_cookbook'
+
+    # @return [Addressable::URI]
+    attr_reader :url
+
+    # @return [Integer]
+    #   how many retries to attempt on HTTP requests
+    attr_reader :retries
+
+    # @return [Float]
+    #   time to wait between retries
+    attr_reader :retry_interval
+
+    # @param [String, Addressable::URI] url
+    #
+    # @option options [Integer] :retries
+    #   how many retries to perform before giving up
+    # @option options [Float] :retry_interval
+    #   how long to wait (in seconds) between each retry
+    def initialize(url, options = {})
+      options         = options.reverse_merge(retries: 5, retry_interval: 0.5)
+      @url            = Addressable::URI.parse(url)
+      @retries        = options[:retries]
+      @retry_interval = options[:retry_interval]
+
+      builder = Faraday::Builder.new do |b|
+        b.response :parse_json
+        b.response :gzip
+        b.request :retry,
+          max: self.retries,
+          interval: self.retry_interval,
+          exceptions: [ Faraday::Error::TimeoutError ]
+
+        b.adapter :net_http
+      end
+
+      super(self.url, builder: builder)
+    end
+
+    # Retrieves the entire universe of known cookbooks from the API source
+    #
+    # @return [Array<APIClient::RemoteCookbook>]
+    def universe
+      response = get("universe")
+
+      case response.status
+      when 200
+        [].tap do |cookbooks|
+          response.body.each do |name, versions|
+            versions.each { |version, attributes| cookbooks << RemoteCookbook.new(name, version, attributes) }
+          end
+        end
+      else
+        raise RuntimeError, "bad response #{response.inspect}"
+      end
+    end
+  end
+end

data/lib/berkshelf/api_client/remote_cookbook.rb

@@ -0,0 +1,42 @@
+module Berkshelf
+  class APIClient
+    # A representation of cookbook metadata indexed by a Berkshelf API Server. Returned
+    # by sending messages to a {Berkshelf::APIClient} and used to download cookbooks
+    # indexed by the Berkshelf API Server.
+    class RemoteCookbook
+      # @return [String]
+      attr_reader :name
+      # @return [String]
+      attr_reader :version
+
+      # @param [String] name
+      # @param [String] version
+      # @param [Hash] attributes
+      def initialize(name, version, attributes = {})
+        @name       = name
+        @version    = version
+        @attributes = attributes
+      end
+
+      # @return [Hash]
+      def dependencies
+        @attributes[:dependencies]
+      end
+
+      # @return [Hash]
+      def platforms
+        @attributes[:platforms]
+      end
+
+      # @return [Symbol]
+      def location_type
+        @attributes[:location_type].to_sym
+      end
+
+      # @return [String]
+      def location_path
+        @attributes[:location_path]
+      end
+    end
+  end
+end

data/lib/berkshelf/berksfile.rb

@@ -1,71 +1,38 @@
 module Berkshelf
   class Berksfile
     class << self
+      # The sources to use if no sources are explicitly provided
+      #
+      # @return [Array<Berkshelf::Source>]
+      def default_sources
+        @default_sources ||= [ Source.new(DEFAULT_API_URL) ]
+      end
+
       # @param [#to_s] file
       #   a path on disk to a Berksfile to instantiate from
       #
       # @return [Berksfile]
       def from_file(file)
-        raise BerksfileNotFound.new(file) unless File.exist?(file)
-
-        begin
-          new(file).dsl_eval_file(file)
-        rescue => ex
-          raise BerksfileReadError.new(ex)
-        end
-      end
-
-      # Copy all cached_cookbooks to the given directory. Each cookbook will be contained in
-      # a directory named after the name of the cookbook.
-      #
-      # @param [Array<CachedCookbook>] cookbooks
-      #   an array of CachedCookbooks to be copied to a vendor directory
-      # @param [String] path
-      #   filepath to vendor cookbooks to
-      #
-      # @return [String]
-      #   expanded filepath to the vendor directory
-      def vendor(cookbooks, path)
-        chefignore = nil
-        path       = File.expand_path(path)
-        scratch    = Berkshelf.mktmpdir
-
-        FileUtils.mkdir_p(path)
-
-        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)
-
-          # Dir.glob does not support backslash as a File separator
-          src = cb.path.to_s.gsub('\\', '/')
-          files = Dir.glob(File.join(src, '*'))
-
-          # Filter out files using chefignore
-          files = chefignore.remove_ignores_from(files) if chefignore
-
-          FileUtils.cp_r(files, dest)
-        end
-
-        FileUtils.remove_dir(path, force: true)
-        FileUtils.mv(scratch, path)
-
-        path
+        new(file).dsl_eval_file(file)
+      rescue Errno::ENOENT => ex
+        raise BerksfileNotFound, "No Berksfile or Berksfile.lock found at: #{file}"
+      rescue => ex
+        raise BerksfileReadError.new(ex)
       end
     end
 
+    DEFAULT_API_URL = "http://api.berkshelf.com".freeze
+
     include Berkshelf::Mixin::Logging
     include Berkshelf::Mixin::DSLEval
     extend Forwardable
 
+    expose_method :source
+    expose_method :site     # @todo remove in Berkshelf 4.0
+    expose_method :chef_api # @todo remove in Berkshelf 4.0
     expose_method :metadata
-    expose_method :group
-    expose_method :site
-    expose_method :chef_api
     expose_method :cookbook
+    expose_method :group
 
     @@active_group = nil
 
@@ -73,90 +40,53 @@ module Berkshelf
     #   The path on disk to the file representing this instance of Berksfile
     attr_reader :filepath
 
-    # @return [Berkshelf::Downloader]
-    attr_reader :downloader
-
     # @return [Array<Berkshelf::CachedCookbook>]
     attr_reader :cached_cookbooks
 
-    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)
+      @dependencies     = Hash.new
       @cached_cookbooks = nil
+      @sources          = Array.new
     end
 
     # Add a cookbook dependency to the Berksfile to be retrieved and have it's dependencies recursively retrieved
     # and resolved.
     #
-    # @example a cookbook source that will be retrieved from one of the default locations
+    # @example a cookbook dependency that will be retrieved from one of the default locations
     #   cookbook 'artifact'
     #
-    # @example a cookbook source that will be retrieved from a path on disk
+    # @example a cookbook dependency that will be retrieved from a path on disk
     #   cookbook 'artifact', path: '/Users/reset/code/artifact'
     #
-    # @example a cookbook source that will be retrieved from a remote community site
-    #   cookbook 'artifact', site: 'http://cookbooks.opscode.com/api/v1/cookbooks'
-    #
-    # @example a cookbook source that will be retrieved from the latest API of the Opscode Community Site
-    #   cookbook 'artifact', site: :opscode
-    #
-    # @example a cookbook source that will be retrieved from a Git server
+    # @example a cookbook dependency that will be retrieved from a Git server
     #   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'
-    #
-    # @example a cookbook source that will be retrieved from a Chef API using your Berkshelf config
-    #   cookbook 'artifact', chef_api: :config
-    #
     # @overload cookbook(name, version_constraint, options = {})
     #   @param [#to_s] name
     #   @param [#to_s] version_constraint
-    #   @param [Hash] options
     #
     #   @option options [Symbol, Array] :group
     #     the group or groups that the cookbook belongs to
-    #   @option options [String, Symbol] :chef_api
-    #     a URL to a Chef API. Alternatively the symbol :config can be provided
-    #     which will instantiate this location with the values found in your
-    #     Berkshelf configuration.
-    #   @option options [String] :site
-    #     a URL pointing to a community API endpoint
     #   @option options [String] :path
     #     a filepath to the cookbook on your local disk
     #   @option options [String] :git
     #     the Git URL to clone
     #
-    #   @see ChefAPILocation
-    #   @see SiteLocation
     #   @see PathLocation
     #   @see GitLocation
     # @overload cookbook(name, options = {})
     #   @param [#to_s] name
-    #   @param [Hash] options
     #
     #   @option options [Symbol, Array] :group
     #     the group or groups that the cookbook belongs to
-    #   @option options [String, Symbol] :chef_api
-    #     a URL to a Chef API. Alternatively the symbol :config can be provided
-    #     which will instantiate this location with the values found in your
-    #     Berkshelf configuration.
-    #   @option options [String] :site
-    #     a URL pointing to a community API endpoint
     #   @option options [String] :path
     #     a filepath to the cookbook on your local disk
     #   @option options [String] :git
     #     the Git URL to clone
     #
-    #   @see ChefAPILocation
-    #   @see SiteLocation
     #   @see PathLocation
     #   @see GitLocation
     def cookbook(*args)
@@ -170,7 +100,7 @@ module Berkshelf
         options[:group] += @@active_group
       end
 
-      add_source(name, constraint, options)
+      add_dependency(name, constraint, options)
     end
 
     def group(*args)
@@ -179,8 +109,8 @@ module Berkshelf
       @@active_group = nil
     end
 
-    # Use a Cookbook metadata file to determine additional cookbook sources to retrieve. All
-    # sources found in the metadata will use the default locations set in the Berksfile (if any are set)
+    # Use a Cookbook metadata file to determine additional cookbook dependencies to retrieve. All
+    # dependencies found in the metadata will use the default locations set in the Berksfile (if any are set)
     # or the default locations defined by Berkshelf.
     #
     # @param [Hash] options
@@ -195,68 +125,85 @@ module Berkshelf
 
       name = metadata.name.presence || File.basename(File.expand_path(path))
 
-      add_source(name, nil, { path: path, metadata: true })
+      add_dependency(name, nil, path: path, metadata: true)
     end
 
-    # Add a 'Site' default location which will be used to resolve cookbook sources that do not
-    # contain an explicit location.
-    #
-    # @note
-    #   specifying the symbol :opscode as the value of the site default location is an alias for the
-    #   latest API of the Opscode Community Site.
+    # Add a Berkshelf API source to use when building the index of known cookbooks. The indexes will be
+    # searched in the order they are added. If a cookbook is found in the first source then a cookbook
+    # in a second source would not be used.
     #
     # @example
-    #   site :opscode
-    #   site "http://cookbooks.opscode.com/api/v1/cookbooks"
+    #   source "http://api.berkshelf.com"
+    #   source "http://berks-api.riotgames.com"
     #
-    # @param [String, Symbol] value
+    # @param [String] api_url
+    #   url for the api to add
     #
-    # @return [Hash]
-    def site(value)
-      add_location(:site, value)
+    # @raise [Berkshelf::InvalidSourceURI]
+    #
+    # @return [Array<SourceURI>]
+    def source(api_url)
+      new_source = Source.new(api_url)
+      @sources.push(new_source) unless @sources.include?(new_source)
     end
 
-    # Add a 'Chef API' default location which will be used to resolve cookbook sources that do not
-    # contain an explicit location.
-    #
-    # @note
-    #   specifying the symbol :config as the value of the chef_api default location will attempt to use the
-    #   contents of your Berkshelf configuration to find the Chef API to interact with.
-    #
-    # @example using the symbol :config to add a Chef API default location
-    #   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'
-    #
-    # @param [String, Symbol] value
-    # @param [Hash] options
+    # @return [Array<SourceURI>]
+    def sources
+      @sources.empty? ? self.class.default_sources : @sources
+    end
+
+    # @todo remove in Berkshelf 4.0
+    #
+    # @raise [Berkshelf::DeprecatedError]
+    def site(*args)
+      if args.first == :opscode
+        Berkshelf.formatter.deprecation "Your Berksfile contains a site location pointing to the Opscode Community " +
+          "Site (site :opscode). Site locations have been replaced by the source location. Change this to: " +
+          "'source \"http://api.berkshelf.com\" to remove this warning. For more information visit " +
+          "https://github.com/RiotGames/berkshelf/wiki/deprecated-locations"
+        source(DEFAULT_API_URL)
+        return
+      end
+
+      raise Berkshelf::DeprecatedError.new "Your Berksfile contains a site location. Site locations have been " +
+        " replaced by the source location. Please remove your site location and try again. For more information " +
+        " visit https://github.com/RiotGames/berkshelf/wiki/deprecated-locations"
+    end
+
+    # @todo remove in Berkshelf 4.0
     #
-    # @return [Hash]
-    def chef_api(value, options = {})
-      add_location(:chef_api, value, options)
+    # @raise [Berkshelf::DeprecatedError]
+    def chef_api(*args)
+      raise Berkshelf::DeprecatedError.new "Your Berksfile contains a chef_api location. Chef API locations have " +
+        " been replaced by the source location. Please remove your site location and try again. For more " +
+        " information visit https://github.com/RiotGames/berkshelf/wiki/deprecated-locations"
     end
 
-    # Add a source of the given name and constraint to the array of sources.
+    # Add a dependency of the given name and constraint to the array of dependencies.
     #
     # @param [String] name
-    #   the name of the source to add
+    #   the name of the dependency to add
     # @param [String, Solve::Constraint] constraint
-    #   the constraint to lock the source to
-    # @param [Hash] options
+    #   the constraint to lock the dependency to
+    #
+    # @option options [Symbol, Array] :group
+    #   the group or groups that the cookbook belongs to
+    # @option options [String] :path
+    #   a filepath to the cookbook on your local disk
+    # @option options [String] :git
+    #   the Git URL to clone
     #
-    # @raise [DuplicateSourceDefined] if a source is added whose name conflicts
-    #   with a source who has already been added.
+    # @raise [DuplicateDependencyDefined] if a dependency is added whose name conflicts
+    #   with a dependency who has already been added.
     #
-    # @return [Array<Berkshelf::CookbookSource]
-    def add_source(name, constraint = nil, options = {})
-      if has_source?(name)
-        # Only raise an exception if the source is a true duplicate
+    # @return [Array<Berkshelf::Dependency]
+    def add_dependency(name, constraint = nil, options = {})
+      if has_dependency?(name)
+        # Only raise an exception if the dependency 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."
+        if !(@dependencies[name].groups & groups).empty?
+          raise DuplicateDependencyDefined,
+            "Berksfile contains multiple entries named '#{name}'. Use only one, or put them in different groups."
         end
       end
 
@@ -266,47 +213,36 @@ module Berkshelf
 
       options[:constraint] = constraint
 
-      @sources[name] = CookbookSource.new(self, name, options)
+      @dependencies[name] = Berkshelf::Dependency.new(self, name, options)
     end
 
-    # @param [#to_s] source
-    #   the source to remove
+    # @param [#to_s] dependency
+    #   the dependency to remove
     #
-    # @return [Berkshelf::CookbookSource]
-    def remove_source(source)
-      @sources.delete(source.to_s)
+    # @return [Berkshelf::Dependency]
+    def remove_dependency(dependency)
+      @dependencies.delete(dependency.to_s)
     end
 
-    # @param [#to_s] source
-    #   the source to check presence of
+    # @param [#to_s] dependency
+    #   the dependency to check presence of
     #
     # @return [Boolean]
-    def has_source?(source)
-      @sources.has_key?(source.to_s)
+    def has_dependency?(dependency)
+      @dependencies.has_key?(dependency.to_s)
     end
 
-    # The list of cookbook sources specified in this Berksfile
-    #
-    # @param [Array] sources
-    #   the list of sources to filter
-    #
     # @option options [Symbol, Array] :except
-    #   group(s) to exclude to exclude from the returned Array of sources
+    #   Group(s) to exclude which will cause any dependencies 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(s) to include which will cause any dependencies 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
-    #
-    # @raise [Berkshelf::ArgumentError]
-    #   if a value for both :except and :only is provided
+    #   Names of the cookbooks to retrieve dependencies for
     #
-    # @return [Array<Berkshelf::CookbookSource>]
-    #   the list of cookbook sources that match the given options
-    def sources(options = {})
-      l_sources = @sources.values
-
+    # @return [Array<Berkshelf::Dependency>]
+    def dependencies(options = {})
       cookbooks = Array(options[:cookbooks])
       except    = Array(options[:except]).collect(&:to_sym)
       only      = Array(options[:only]).collect(&:to_sym)
@@ -318,65 +254,65 @@ module Berkshelf
         if !except.empty? && !only.empty?
           Berkshelf.ui.warn 'Cookbooks were specified, ignoring :except and :only'
         end
-        l_sources.select { |source| cookbooks.include?(source.name) }
+        @dependencies.values.select { |dependency| cookbooks.include?(dependency.name) }
       when !except.empty?
-        l_sources.select { |source| (except & source.groups).empty? }
+        @dependencies.values.select { |dependency| (except & dependency.groups).empty? }
       when !only.empty?
-        l_sources.select { |source| !(only & source.groups).empty? }
+        @dependencies.values.select { |dependency| !(only & dependency.groups).empty? }
       else
-        l_sources
+        @dependencies.values
       end
     end
 
-    # Find a source defined in this berksfile by name.
+    # Find a dependency defined in this berksfile by name.
     #
     # @param [String] name
-    #   the name of the cookbook source to search for
-    # @return [Berkshelf::CookbookSource, nil]
-    #   the cookbook source, or nil if one does not exist
+    #   the name of the cookbook dependency to search for
+    # @return [Berkshelf::Dependency, nil]
+    #   the cookbook dependency, or nil if one does not exist
     def find(name)
-      @sources[name]
+      @dependencies[name]
     end
 
     # @return [Hash]
-    #   a hash containing group names as keys and an array of CookbookSources
+    #   a hash containing group names as keys and an array of Berkshelf::Dependencies
     #   that are a member of that group as values
     #
     #   Example:
     #     {
     #       nautilus: [
-    #         #<Berkshelf::CookbookSource: nginx (~> 1.0.0)>,
-    #         #<Berkshelf::CookbookSource: mysql (~> 1.2.4)>
+    #         #<Berkshelf::Dependency: nginx (~> 1.0.0)>,
+    #         #<Berkshelf::Dependency: mysql (~> 1.2.4)>
     #       ],
     #       skarner: [
-    #         #<Berkshelf::CookbookSource: nginx (~> 1.0.0)>
+    #         #<Berkshelf::Dependency: nginx (~> 1.0.0)>
     #       ]
     #     }
     def groups
       {}.tap do |groups|
-        sources.each do |source|
-          source.groups.each do |group|
+        dependencies.each do |dependency|
+          dependency.groups.each do |group|
             groups[group] ||= []
-            groups[group] << source
+            groups[group] << dependency
           end
         end
       end
     end
 
     # @param [String] name
-    #   name of the source to return
+    #   name of the dependency to return
     #
-    # @return [Berkshelf::CookbookSource]
+    # @return [Berkshelf::Dependency]
     def [](name)
-      @sources[name]
+      @dependencies[name]
     end
-    alias_method :get_source, :[]
+    alias_method :get_dependency, :[]
 
-    # Install the sources listed in the Berksfile, respecting the locked
+    # Install the dependencies listed in the Berksfile, respecting the locked
     # versions in the Berksfile.lock.
     #
     # 1. Check that a lockfile exists. If a lockfile does not exist, all
-    #    sources are considered to be "unlocked". If a lockfile is specified, a
+    #    dependencies are considered to be "unlocked". If a lockfile is specified, a
     #    definition is created via the following algorithm:
     #
     #    - For each source, see if there exists a locked version that still
@@ -390,98 +326,67 @@ module Berkshelf
     #    - Remove any locked sources that no longer exist in the Berksfile
     #      (i.e. a cookbook source was removed from the Berksfile).
     #
-    # 2. Resolve the collection of locked and unlocked sources.
+    # 2. Resolve the collection of locked and unlocked dependencies.
     #
     # 3. Write out a new lockfile.
     #
     # @option options [Symbol, Array] :except
-    #   Group(s) to exclude which will cause any sources marked as a member of the
+    #   Group(s) to exclude which will cause any dependencies 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(s) to include which will cause any dependencies marked as a member of the
     #   group to be installed and all others to be ignored
-    # @option options [String] :path
-    #   a path to "vendor" the cached_cookbooks resolved by the resolver. Vendoring
-    #   is a technique for packaging all cookbooks resolved by a Berksfile.
-    # @option options [Boolean] :update_lockfile (true)
-    #   a boolean method indicating whether we should update the lockfile
+    # @option cookbooks [String, Array] :cookbooks
+    #   Names of the cookbooks to retrieve dependencies for
     #
-    # @raise [Berkshelf::OutdatedCookbookSource]
+    # @raise [Berkshelf::OutdatedDependency]
     #   if the lockfile constraints do not satisfy the Berskfile constraints
-    # @raise [Berkshelf::ArgumentError]
-    #   if there are missing or conflicting options
     #
     # @return [Array<Berkshelf::CachedCookbook>]
     def install(options = {})
-      local_sources = apply_lockfile(sources(options))
-
-      resolver          = resolve(local_sources)
-      @cached_cookbooks = resolver[:solution]
-      local_sources     = resolver[:sources]
-
-      verify_licenses!
-
-      self.class.vendor(@cached_cookbooks, options[:path]) if options[:path]
-
-      lockfile.update(local_sources) unless options[:update_lockfile] == false
-
-      self.cached_cookbooks
+      Installer.new(self).run(options)
     end
 
     # @option options [Symbol, Array] :except
-    #   Group(s) to exclude which will cause any sources marked as a member of the
+    #   Group(s) to exclude which will cause any dependencies 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(s) to include which will cause any dependencies 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
+    #   Names of the cookbooks to retrieve dependencies for
     def update(options = {})
       validate_cookbook_names!(options)
 
       # Unlock any/all specified cookbooks
-      sources(options).each { |source| lockfile.unlock(source) }
+      dependencies(options).each { |dependency| lockfile.unlock(dependency) }
 
       # NOTE: We intentionally do NOT pass options to the installer
       self.install
     end
 
-    # Get a list of all the cookbooks which have newer versions found on the community
-    # site versus what your current constraints allow
+    # List of all the cookbooks which have a newer version found at a source that satisfies
+    # the constraints of your dependencies
     #
     # @option options [Symbol, Array] :except
-    #   Group(s) to exclude which will cause any sources marked as a member of the
+    #   Group(s) to exclude which will cause any dependencies 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(s) to include which will cause any dependencies 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
+    #   Whitelist of cookbooks to to check for updated versions for
     #
     # @return [Hash]
     #   a hash of cached cookbooks and their latest version. An empty hash is returned
-    #   if there are no newer cookbooks for any of your sources
+    #   if there are no newer cookbooks for any of your dependencies
     #
     # @example
-    #   berksfile.outdated => {
+    #   berksfile.outdated #=> {
     #     #<CachedCookbook name="artifact"> => "0.11.2"
     #   }
     def outdated(options = {})
-      outdated = Hash.new
-
-      sources(options).each do |cookbook|
-        location = cookbook.location || Location.init(cookbook.name, cookbook.version_constraint, site: :opscode)
-
-        if location.is_a?(SiteLocation)
-          latest_version = location.latest_version
-
-          unless cookbook.version_constraint.satisfies?(latest_version)
-            outdated[cookbook] = latest_version
-          end
-        end
-      end
-
-      outdated
+      raise RuntimeError, "not yet implemented"
     end
 
     # Upload the cookbooks installed by this Berksfile
@@ -492,66 +397,40 @@ module Berkshelf
     # @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(s) to exclude which will cause any dependencies 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(s) to include which will cause any dependencies 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
+    #   Names of the cookbooks to retrieve dependencies for
     # @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.
     # @option options [String] :server_url
     #   An overriding Chef Server to upload the cookbooks to
-    # @option options [String] :client_name
-    #   An overriding client name to use for connecting to the chef server
-    # @option options [String] :client_key
-    #   An overriding client key to use for connecting to the chef server
     #
-    # @raise [UploadFailure]
+    # @raise [Berkshelf::UploadFailure]
     #   if you are uploading cookbooks with an invalid or not-specified client key
+    # @raise [Berkshelf::DependencyNotFound]
+    #   if one of the given cookbooks is not a dependency defined in the Berksfile
     # @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 = {})
-      options = options.reverse_merge(force: false, freeze: true, skip_dependencies: false, halt_on_frozen: false, update_lockfile: false, validate: true)
+      options = options.reverse_merge(force: false, freeze: true, halt_on_frozen: false, cookbooks: [])
 
-      cached_cookbooks = install(options)
-      upload_opts      = options.slice(:force, :freeze, :validate)
-      conn             = ridley_connection(options)
-
-      cached_cookbooks.each do |cookbook|
-        Berkshelf.formatter.upload(cookbook.cookbook_name, cookbook.version, conn.server_url)
-        validate_files!(cookbook)
-
-        begin
-          conn.cookbook.upload(cookbook.path, upload_opts.merge(name: cookbook.cookbook_name))
-        rescue Ridley::Errors::FrozenCookbook => ex
-          if options[:halt_on_frozen]
-            raise Berkshelf::FrozenCookbook, ex
-          end
+      options[:cookbooks].each do |cookbook|
+        unless dependency = find(cookbook)
+          raise DependencyNotFound, "Failed to upload cookbook '#{cookbook}'. Not defined in Berksfile."
         end
       end
 
-      if options[:skip_dependencies]
-        missing_cookbooks = options.fetch(:cookbooks, nil) - cached_cookbooks.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"
-          msg << " `--skip-dependencies` option"
-          raise ExplicitCookbookNotFound.new(msg)
-        end
-      end
-    rescue Ridley::Errors::RidleyError => ex
-      log_exception(ex)
-      raise ChefConnectionError, ex # todo implement
-    ensure
-      conn.terminate if conn && conn.alive?
+      cached_cookbooks = install(options)
+      cached_cookbooks = filter_to_upload(cached_cookbooks, options[:cookbooks]) if options[:cookbooks]
+      do_upload(cached_cookbooks, options)
     end
 
     # Resolve this Berksfile and apply the locks found in the generated Berksfile.lock to the
@@ -562,38 +441,24 @@ module Berkshelf
     # @option options [Hash] :ssl_verify (true)
     #   Disable/Enable SSL verification during uploads
     #
-    # @raise [EnvironmentNotFound] if the target environment was not found
-    # @raise [ChefConnectionError] if you are locking cookbooks with an invalid or not-specified client configuration
-    # @raise [EnvironmentFileNotFound] if you are uploading environment from local file
+    # @raise [EnvironmentNotFound]
+    #   if the target environment was not found
+    # @raise [ChefConnectionError]
+    #   if you are locking cookbooks with an invalid or not-specified client configuration
     def apply(environment_name, options = {})
-      conn        = ridley_connection(options)
-
-      if options[:from_file]
-        environment_path = options[:from_file]
-        begin
-          environment = conn.environment.from_file(environment_path)
-        rescue # Ridley::Errors::RidleyError => ex
-          raise EnvironmentFileNotFound, "Local environment file #{environment_path} not found."
+      ridley_connection(options) do |conn|
+        unless environment = conn.environment.find(environment_name)
+          raise EnvironmentNotFound.new(environment_name)
         end
-      else
-        environment = conn.environment.find(environment_name)
-      end
 
-      if environment
         install
 
         environment.cookbook_versions = {}.tap do |cookbook_versions|
-          lockfile.sources.each { |source| cookbook_versions[source.name] = "= #{source.locked_version.to_s}" }
+          lockfile.dependencies.each { |dependency| cookbook_versions[dependency.name] = dependency.locked_version }
         end
 
         environment.save
-      else
-        raise EnvironmentNotFound.new(environment_name)
       end
-    rescue Ridley::Errors::RidleyError => ex
-      raise ChefConnectionError, ex
-    ensure
-      conn.terminate if conn && conn.alive?
     end
 
     # Package the given cookbook for distribution outside of berkshelf. If the
@@ -607,8 +472,6 @@ module Berkshelf
     #
     # @option options [String] :output
     #   the path to output the tarball
-    # @option options [Boolean] :skip_dependencies
-    #   package cookbook dependencies as well
     # @option options [Boolean] :ignore_chefignore
     #   do not apply the chefignore file to the packed cookbooks
     #
@@ -616,29 +479,25 @@ module Berkshelf
     #   the path to the package
     def package(name = nil, options = {})
       tar_name = "#{name || 'package'}.tar.gz"
-      output = File.expand_path(File.join(options[:output], tar_name))
+      output   = File.expand_path(File.join(options[:output], tar_name))
 
-      unless name.nil?
-        source = self.find(name)
-        raise CookbookNotFound, "Cookbook '#{name}' is not in your Berksfile" unless source
+      cached_cookbooks = unless name.nil?
+        unless dependency = find(name)
+          raise CookbookNotFound, "Cookbook '#{name}' is not in your Berksfile"
+        end
 
-        package = Berkshelf.ui.mute {
-          self.resolve(source, options)[:solution]
-        }
+        options[:cookbooks] = name
+        Berkshelf.ui.mute { install(options) }
       else
-        package = Berkshelf.ui.mute {
-          self.resolve(sources, options)[:solution]
-        }
+        Berkshelf.ui.mute { install(options) }
       end
 
-      package.each do |cookbook|
-        validate_files!(cookbook)
-      end
+      cached_cookbooks.each { |cookbook| validate_files!(cookbook) }
 
       Dir.mktmpdir do |tmp|
-        package.each do |cached_cookbook|
-          path = cached_cookbook.path.to_s
-          destination = File.join(tmp, cached_cookbook.cookbook_name)
+        cached_cookbooks.each do |cookbook|
+          path        = cookbook.path.to_s
+          destination = File.join(tmp, cookbook.cookbook_name)
 
           FileUtils.cp_r(path, destination)
 
@@ -663,25 +522,6 @@ module Berkshelf
       output
     end
 
-    # Finds a solution for the Berksfile and returns an array of CachedCookbooks.
-    #
-    # @param [Array<Berkshelf::CookbookSource>] sources
-    #   Array of cookbook sources to resolve
-    #
-    # @option options [Boolean] :skip_dependencies
-    #   Skip resolving of dependencies
-    #
-    # @return [Array<Berkshelf::CachedCookbooks>]
-    def resolve(sources = [], options = {})
-      resolver = Resolver.new(
-        self,
-        sources: sources,
-        skip_dependencies: options[:skip_dependencies]
-      )
-
-      { solution: resolver.resolve, sources: resolver.sources }
-    end
-
     # Get the lockfile corresponding to this Berksfile. This is necessary because
     # the user can specify a different path to the Berksfile. So assuming the lockfile
     # is named "Berksfile.lock" is a poor assumption.
@@ -695,12 +535,55 @@ module Berkshelf
 
     private
 
-      def ridley_connection(options = {})
+      def do_upload(cookbooks, options = {})
+        upload_opts = options.slice(:force, :freeze)
+
+        ridley_connection(options) do |conn|
+          cookbooks.each do |cookbook|
+            Berkshelf.formatter.upload(cookbook.cookbook_name, cookbook.version, conn.server_url)
+            validate_files!(cookbook)
+
+            begin
+              conn.cookbook.upload(cookbook.path, upload_opts.merge(name: cookbook.cookbook_name))
+            rescue Ridley::Errors::FrozenCookbook => ex
+              if options[:halt_on_frozen]
+                raise Berkshelf::FrozenCookbook, ex
+              end
+            end
+          end
+        end
+      end
+
+      # Filter the cookbooks to upload based on a set of given names. The dependencies of a cookbook
+      # will always be included in the filtered results even if the dependency's name is not
+      # explicitly provided.
+      #
+      # @param [Array<Berkshelf::CachedCookbooks>] cookbooks
+      #   set of cookbooks to filter
+      # @param [Array<String>] names
+      #   names of cookbooks to include in the filtered results
+      #
+      # @return [Array<Berkshelf::CachedCookbooks]
+      def filter_to_upload(cookbooks, names)
+        unless names.empty?
+          explicit = cookbooks.select { |cookbook| names.include?(cookbook.cookbook_name) }
+          explicit.each do |cookbook|
+            cookbook.dependencies.each do |name, version|
+              explicit += cookbooks.select { |cookbook| cookbook.cookbook_name == name }
+            end
+          end
+          cookbooks = explicit.uniq
+        end
+        cookbooks
+      end
+
+      # @raise [Berkshelf::ChefConnectionError]
+      def ridley_connection(options = {}, &block)
         ridley_options               = options.slice(:ssl)
-        ridley_options[:server_url]  = options[:server_url] || Berkshelf::Config.instance.chef.chef_server_url
-        ridley_options[:client_name] = options[:client_name] || Berkshelf::Config.instance.chef.node_name
-        ridley_options[:client_key]  = options[:client_key] || Berkshelf::Config.instance.chef.client_key
-        ridley_options[:ssl]         = { verify: (options[:ssl_verify] || Berkshelf::Config.instance.ssl.verify) }
+        ridley_options[:server_url]  = options[:server_url] || Berkshelf.config.chef.chef_server_url
+        ridley_options[:client_name] = Berkshelf.config.chef.node_name
+        ridley_options[:client_key]  = Berkshelf.config.chef.client_key
+        ridley_options[:ssl]         = { verify: (options[:ssl_verify] || Berkshelf.config.ssl.verify) }
 
         unless ridley_options[:server_url].present?
           raise ChefConnectionError, 'Missing required attribute in your Berkshelf configuration: chef.server_url'
@@ -714,12 +597,10 @@ module Berkshelf
           raise ChefConnectionError, 'Missing required attribute in your Berkshelf configuration: chef.client_key'
         end
 
-        Ridley.new(ridley_options)
-      end
-
-      def descendant_directory?(candidate, parent)
-        hack = FileUtils::Entry_.new('/tmp')
-        hack.send(:descendant_diretory?, candidate, parent)
+        Ridley.open(ridley_options, &block)
+      rescue Ridley::Errors::RidleyError => ex
+        log_exception(ex)
+        raise ChefConnectionError, ex # todo implement
       end
 
       # Determine if any cookbooks were specified that aren't in our shelf.
@@ -730,52 +611,12 @@ module Berkshelf
       # @raise [Berkshelf::CookbookNotFound]
       #   if a cookbook name is given that does not exist
       def validate_cookbook_names!(options = {})
-        missing = (Array(options[:cookbooks]) - sources.map(&:name))
+        missing = (Array(options[:cookbooks]) - dependencies.map(&:name))
         unless missing.empty?
           raise Berkshelf::CookbookNotFound,
-            "Could not find cookbooks #{missing.collect{ |c| "'#{c}'" }.join(', ')} " +
-            "in any of the sources. #{missing.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
-        end
-      end
-
-      # The list of sources "locked" by the lockfile.
-      #
-      # @return [Array<Berkshelf::CookbookSource>]
-      #   the list of sources in this lockfile
-      def locked_sources
-        lockfile.sources
-      end
-
-      # Merge the locked sources against the given sources.
-      #
-      # For each the given sources, check if there's a locked version that
-      # still satisfies the version constraint. If it does, "lock" that source
-      # because we should just use the locked version.
-      #
-      # If a locked source exists, but doesn't satisfy the constraint, raise a
-      # {Berkshelf::OutdatedCookbookSource} and tell the user to run update.
-      def apply_lockfile(sources = [])
-        sources.collect do |source|
-          source_from_lockfile(source) || source
-        end
-      end
-
-      def source_from_lockfile(source)
-        locked_source = lockfile.find(source)
-
-        return nil unless locked_source
-
-        # If there's a locked_version, make sure it's still satisfied
-        # by the constraint
-        if locked_source.locked_version
-          unless source.version_constraint.satisfies?(locked_source.locked_version)
-            raise Berkshelf::OutdatedCookbookSource.new(locked_source, source)
-          end
+            "Could not find cookbook(s) #{missing.collect{ |c| "'#{c}'" }.join(', ')} " +
+            "in any of the configured dependencies. #{missing.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
         end
-
-        # Update to the new constraint (it might have changed, but still be satisfied)
-        locked_source.version_constraint = source.version_constraint
-        locked_source
       end
 
       # Validate that the given cookbook does not have "bad" files. Currently
@@ -793,34 +634,5 @@ module Berkshelf
 
         raise Berkshelf::InvalidCookbookFiles.new(cookbook, files) unless files.empty?
       end
-
-      # Verify that the licenses of all the cached cookbooks fall in the realm of
-      # allowed licenses from the Berkshelf Config.
-      #
-      # @raise [Berkshelf::LicenseNotAllowed]
-      #   if the license is not permitted and `raise_license_exception` is true
-      def verify_licenses!
-        licenses = Array(Berkshelf::Config.instance.allowed_licenses)
-        return if licenses.empty?
-
-        sources.each do |source|
-          next if source.location.is_a?(Berkshelf::PathLocation)
-          cached = source.cached_cookbook
-
-          begin
-            unless licenses.include?(cached.metadata.license)
-              raise Berkshelf::LicenseNotAllowed.new(cached)
-            end
-          rescue Berkshelf::LicenseNotAllowed => e
-            if Berkshelf::Config.instance.raise_license_exception
-              FileUtils.rm_rf(cached.path)
-              raise
-            end
-
-            Berkshelf.ui.warn(e.to_s)
-          end
-        end
-      end
-
   end
 end