berkshelf 2.0.18 → 3.0.0.beta1

data/lib/berkshelf/config.rb

@@ -1,36 +1,32 @@
-require 'chozo/config'
+require 'buff/config/json'
 
 module Berkshelf
-  class Config < Chozo::Config::JSON
-    LOCATIONS = [
-      File.join('.', '.berkshelf', 'config.json').freeze,
-      File.join('.',  'berkshelf', 'config.json').freeze,
-      File.join('.',  'berkshelf-config.json').freeze,
-      File.join('.',  'config.json').freeze
-    ].freeze
-
+  class Config < Buff::Config::JSON
     class << self
       # @return [String]
-      def default_location
+      def store_location
         File.join(Berkshelf.berkshelf_path, 'config.json')
       end
 
+      # @return [String]
+      def local_location
+        ENV['BERKSHELF_CONFIG'] || File.join('.', '.berkshelf', 'config.json')
+      end
+
       # @return [String]
       def path
-        @path ||= begin
-          location = LOCATIONS.find do |file|
-            path = File.expand_path(file)
-            File.exists?(path)
-          end
+        path = File.exists?(local_location) ? local_location : store_location
+        File.expand_path(path)
+      end
 
-          File.expand_path(location || default_location)
-        end
+      # @param [Berkshelf::Config] config
+      def set_config(config)
+        @instance = config
       end
 
       # @param [String] new_path
       def set_path(new_path)
         @instance = nil
-        @path     = File.expand_path(new_path)
       end
 
       # @return [String, nil]
@@ -62,35 +58,35 @@ module Berkshelf
 
     # @param [String] path
     # @param [Hash] options
-    #   @see {Chozo::Config::JSON}
+    #   @see {Buff::Config::JSON}
     def initialize(path = self.class.path, options = {})
       super(path, options)
     end
 
     attribute 'chef.chef_server_url',
       type: String,
-      default: Berkshelf.chef_config[:chef_server_url]
+      default: Berkshelf.chef_config.chef_server_url
     attribute 'chef.validation_client_name',
       type: String,
-      default: Berkshelf.chef_config[:validation_client_name]
+      default: Berkshelf.chef_config.validation_client_name
     attribute 'chef.validation_key_path',
       type: String,
-      default: Berkshelf.chef_config[:validation_key]
+      default: Berkshelf.chef_config.validation_key
     attribute 'chef.client_key',
       type: String,
-      default: Berkshelf.chef_config[:client_key]
+      default: Berkshelf.chef_config.client_key
     attribute 'chef.node_name',
       type: String,
-      default: Berkshelf.chef_config[:node_name]
+      default: Berkshelf.chef_config.node_name
     attribute 'cookbook.copyright',
       type: String,
-      default: Berkshelf.chef_config[:cookbook_copyright]
+      default: Berkshelf.chef_config.cookbook_copyright
     attribute 'cookbook.email',
       type: String,
-      default: Berkshelf.chef_config[:cookbook_email]
+      default: Berkshelf.chef_config.cookbook_email
     attribute 'cookbook.license',
       type: String,
-      default: Berkshelf.chef_config[:cookbook_license]
+      default: Berkshelf.chef_config.cookbook_license
     attribute 'allowed_licenses',
       type: Array,
       default: Array.new

data/lib/berkshelf/cookbook_generator.rb

@@ -45,21 +45,20 @@ module Berkshelf
 
     class_option :license,
       type: :string,
-      default: Berkshelf::Config.instance.cookbook.license
+      default: Berkshelf.config.cookbook.license
 
     class_option :maintainer,
       type: :string,
-      default: Berkshelf::Config.instance.cookbook.copyright
+      default: Berkshelf.config.cookbook.copyright
 
     class_option :maintainer_email,
       type: :string,
-      default: Berkshelf::Config.instance.cookbook.email
+      default: Berkshelf.config.cookbook.email
 
     def generate
       empty_directory target.join('files/default')
       empty_directory target.join('templates/default')
       empty_directory target.join('attributes')
-      empty_directory target.join('definitions')
       empty_directory target.join('libraries')
       empty_directory target.join('providers')
       empty_directory target.join('recipes')

data/lib/berkshelf/cookbook_store.rb

@@ -2,6 +2,35 @@ require 'fileutils'
 
 module Berkshelf
   class CookbookStore
+    class << self
+      # The default path to the cookbook store relative to the Berkshelf path.
+      #
+      # @return [String]
+      def default_path
+        File.join(Berkshelf.berkshelf_path, 'cookbooks')
+      end
+
+      # @return [Berkshelf::CookbookStore]
+      def instance
+        @instance ||= new(default_path)
+      end
+
+      # Import a cookbook found on the local filesystem into the current instance of
+      # the cookbook store.
+      #
+      # @param [String] name
+      #   name of the cookbook
+      # @param [String] version
+      #   verison of the cookbook
+      # @param [String] path
+      #   location on disk of the cookbook
+      #
+      # @return [Berkshelf::CachedCookbook]
+      def import(name, version, path)
+        instance.import(name, version, path)
+      end
+    end
+
     # @return [String]
     #   filepath to where cookbooks are stored
     attr_reader :storage_path
@@ -17,6 +46,30 @@ module Berkshelf
       initialize_filesystem
     end
 
+    # Destroy the contents of the initialized storage path.
+    def clean!
+      FileUtils.rm_rf(Dir.glob(File.join(storage_path, '*')))
+    end
+
+    # Import a cookbook found on the local filesystem into this instance of the cookbook store.
+    #
+    # @param [String] name
+    #   name of the cookbook
+    # @param [String] version
+    #   verison of the cookbook
+    # @param [String] path
+    #   location on disk of the cookbook
+    #
+    # @return [Berkshelf::CachedCookbook]
+    def import(name, version, path)
+      destination = cookbook_path(name, version)
+      FileUtils.mv(path, destination)
+      cookbook(name, version)
+    rescue => ex
+      FileUtils.rm_f(destination)
+      raise
+    end
+
     # Returns an instance of CachedCookbook representing the
     # Cookbook of your given name and version.
     #
@@ -41,15 +94,20 @@ module Berkshelf
     #
     # @return [Array<Berkshelf::CachedCookbook>]
     def cookbooks(filter = nil)
-      cookbooks = storage_path.children.collect do |path|
-        CachedCookbook.from_store_path(path)
-      end.compact
+      cookbooks = []
 
-      return cookbooks unless filter
+      storage_path.each_child.map do |path|
+        Celluloid::Future.new do
+          cached_cookbook = CachedCookbook.from_store_path(path)
 
-      cookbooks.select do |cookbook|
-        cookbook.cookbook_name == filter
-      end
+          next unless cached_cookbook
+          next if filter && cached_cookbook.cookbook_name != filter
+
+          cookbooks << cached_cookbook
+        end
+      end.each(&:value)
+
+      cookbooks
     end
 
     # Returns an expanded path to the location on disk where the Cookbook
@@ -63,6 +121,15 @@ module Berkshelf
       storage_path.join("#{name}-#{version}")
     end
 
+    def initialize_filesystem
+      FileUtils.mkdir_p(storage_path, mode: 0755)
+
+      unless File.writable?(storage_path)
+        raise InsufficientPrivledges, "You do not have permission to write to '#{storage_path}'!" +
+          " Please either chown the directory or use a different Cookbook Store."
+      end
+    end
+
     # Return a CachedCookbook matching the best solution for the given name and
     # constraint. Nil is returned if no matching CachedCookbook is found.
     #
@@ -80,15 +147,5 @@ module Berkshelf
     rescue Solve::Errors::NoSolutionError
       nil
     end
-
-    private
-
-      def initialize_filesystem
-        FileUtils.mkdir_p(storage_path, mode: 0755)
-
-        unless File.writable?(storage_path)
-          raise InsufficientPrivledges, "You do not have permission to write to '#{storage_path}'! Please either chown the directory or use a different Cookbook Store."
-        end
-      end
   end
 end

data/lib/berkshelf/core_ext/file.rb

@@ -1,13 +1,13 @@
 class File
   class << self
-    # Returns true or false if the given path contains a Chef Cookbook
+    # Returns true or false if the given path is a Chef Cookbook
     #
     # @param [#to_s] path
     #   path of directory to reflect on
     #
     # @return [Boolean]
     def cookbook?(path)
-      File.exists?(File.join(path, "metadata.json")) || File.exists?(File.join(path, "metadata.rb"))
+      File.exists?(File.join(path, 'metadata.rb'))
     end
     alias_method :chef_cookbook?, :cookbook?
   end

data/lib/berkshelf/core_ext/pathname.rb

@@ -1,18 +1,20 @@
 class Pathname
-  # Returns true or false if the path contains a "metadata.json" or a "metadata.rb" file.
+  # Returns true or false if the path of the instantiated
+  # Pathname or a parent directory contains a Tryhard Pack
+  # data directory.
   #
   # @return [Boolean]
   def cookbook?
-    join("metadata.json").exist? || join("metadata.rb").exist?
+    self.join('metadata.rb').exist?
   end
   alias_method :chef_cookbook?, :cookbook?
 
-  # Ascend the directory structure from the given path to find  the root of a
-  # Cookbook. If no Cookbook is found, nil is returned.
+  # Ascend the directory structure from the given path to find a
+  # the root of a Chef Cookbook. If no Cookbook is found, nil is returned
   #
   # @return [Pathname, nil]
   def cookbook_root
-    ascend do |potential_root|
+    self.ascend do |potential_root|
       if potential_root.cookbook?
         return potential_root
       end

data/lib/berkshelf/{cookbook_source.rb → dependency.rb}

@@ -1,5 +1,5 @@
 module Berkshelf
-  class CookbookSource
+  class Dependency
     class << self
       @@valid_options = [:constraint, :locations, :group, :locked_version]
       @@location_keys = Hash.new
@@ -13,7 +13,7 @@ module Berkshelf
 
       # Returns an array of the registered source location keys. Every source
       # location is identified by a key (symbol) to differentiate which class
-      # to instantiate for the location of a CookbookSource at initialization.
+      # to instantiate for the location of a Dependency at initialization.
       #
       # @return [Array<Symbol>]
       def location_keys
@@ -31,7 +31,7 @@ module Berkshelf
         @@valid_options
       end
 
-      # Register a location key with the CookbookSource class
+      # Register a location key with the Dependency class
       # @see #location_keys
       #
       # @param [Symbol] location
@@ -53,19 +53,20 @@ module Berkshelf
 
         unless invalid_options.empty?
           invalid_options.collect! { |opt| "'#{opt}'" }
-          raise InternalError, "Invalid options for Cookbook Source: #{invalid_options.join(', ')}."
+          raise InternalError, "Invalid options for dependency: #{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!"
+        if (options.keys & location_keys.keys).size > 1
+          invalid = (options.keys & location_keys.keys).map { |opt| "'#{opt}'" }
+          raise InternalError, "Cannot specify #{invalid.join(' and ')} for a dependency!"
         end
 
         true
       end
     end
 
-    DEFAULT_CONSTRAINT = '>= 0.0.0'
+    DEFAULT_CONSTRAINT = '>= 0.0.0'.freeze
+    SCM_LOCATIONS      = [ :git, :github ].freeze
 
     # @return [Berkshelf::Berksfile]
     attr_reader :berksfile
@@ -81,16 +82,14 @@ module Berkshelf
     attr_accessor :cached_cookbook
 
     # @param [Berkshelf::Berksfile] berksfile
-    #   the berksfile this source belongs to
+    #   the berksfile this dependency belongs to
     # @param [String] name
-    #   the name of source
+    #   the name of dependency
     #
     # @option options [String, Solve::Constraint] :constraint
-    #   version constraint to resolve for this source
+    #   version constraint for this dependency
     # @option options [String] :git
     #   the Git URL to clone
-    # @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] :metadata
@@ -105,17 +104,15 @@ module Berkshelf
     #   same as tag
     # @option options [String] :locked_version
     def initialize(berksfile, name, options = {})
-      @options = options
-
       self.class.validate_options(options)
 
+      @options            = options
       @berksfile          = berksfile
       @name               = name
+      @location           = Location.init(self, options)
       @locked_version     = Solve::Version.new(options[:locked_version]) if options[:locked_version]
       @version_constraint = Solve::Constraint.new(options[:constraint] || DEFAULT_CONSTRAINT)
 
-      @cached_cookbook, @location = cached_and_location(options)
-
       add_group(options[:group]) if options[:group]
       add_group(:default) if groups.empty?
     end
@@ -129,22 +126,29 @@ module Berkshelf
       end
     end
 
-    # Determine the CachedCookbook and Location information from the given options.
-    #
-    # @return [Array<CachedCookbook, Location>]
-    def cached_and_location(options = {})
-      from_path(options) || from_default(options)
+    # @return [Berkshelf::CachedCookbook]
+    def cached_cookbook
+      @cached_cookbook ||= if location
+        location.download
+      else
+        Berkshelf::CookbookStore.instance.satisfy(name, version_constraint)
+      end
+    end
+
+    # @return [Berkshelf::CachedCookbook]
+    def download
+      @cached_cookbook = location.download
     end
 
-    # Returns true if the cookbook source has already been downloaded. A cookbook
-    # source is downloaded when a cached cookbook is present.
+    # Returns true if the dependency has already been downloaded. A dependency is downloaded when a
+    # cached cookbook is present.
     #
     # @return [Boolean]
     def downloaded?
-      !self.cached_cookbook.nil?
+      !cached_cookbook.nil?
     end
 
-    # Returns true if this CookbookSource has the given group.
+    # Returns true if this dependency has the given group.
     #
     # @return [Boolean]
     def has_group?(group)
@@ -160,10 +164,10 @@ module Berkshelf
     # @return [Solve::Version, nil]
     #   the locked version of this cookbook
     def locked_version
-      @locked_version ||= cached_cookbook.try(:version)
+      @locked_version ||= cached_cookbook ? cached_cookbook.version : nil
     end
 
-    # The location for this CookbookSource, such as a remote Chef Server, the
+    # The location for this dependency, such as a remote Chef Server, the
     # community API, :git, or a :path location. By default, this will be the
     # community API.
     #
@@ -172,21 +176,30 @@ module Berkshelf
       @location
     end
 
-    # The list of groups this CookbookSource belongs to.
+    # The list of groups this dependency belongs to.
     #
     # @return [Array<Symbol>]
     def groups
       @groups ||= []
     end
 
+    # @return [Boolean]
+    def scm_location?
+      if location.nil?
+        return false
+      end
+
+      SCM_LOCATIONS.include?(location.class.location_key)
+    end
+
     def to_s
-      "#<Berkshelf::CookbookSource: #{name} (#{version_constraint})>"
+      "#{name} (#{version_constraint})"
     end
 
     def inspect
-      '#<Berkshelf::CookbookSource: ' << [
+      '#<Berkshelf::Dependency: ' << [
         "#{name} (#{version_constraint})",
-        "locked_version: #{locked_version ? locked_version.to_s : 'nil'}",
+        "locked_version: #{locked_version.inspect}",
         "groups: #{groups}",
         "location: #{location || 'default'}>"
       ].join(', ')
@@ -198,8 +211,8 @@ module Berkshelf
           h[:locked_version] = locked_version.to_s
         end
 
-        if location.kind_of?(SiteLocation)
-          h[:site] = location.api_uri if location.api_uri != CommunityREST::V1_API
+        unless version_constraint.to_s == DEFAULT_CONSTRAINT
+          h[:constraint] = version_constraint.to_s
         end
 
         if location.kind_of?(PathLocation)
@@ -217,38 +230,5 @@ module Berkshelf
     def to_json(options = {})
       JSON.pretty_generate(to_hash, options)
     end
-
-    private
-      # 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.
-      #
-      # @raise [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, options)
-
-        [ location.cookbook, location ]
-      rescue IOError => ex
-        raise Berkshelf::CookbookNotFound, ex
-      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
   end
 end