berkshelf 0.6.0.beta4 → 1.0.0.rc1

data/lib/berkshelf/config.rb

@@ -1,31 +1,46 @@
+require 'chozo/config'
+
 module Berkshelf
   # @author Justin Campbell <justin@justincampbell.me>
-  class Config < Hashie::Mash
-    DEFAULT_PATH = "~/.berkshelf/config.json"
-
-    include ActiveModel::Validations
-    validates_with ConfigValidator
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Config < Chozo::Config::JSON
+    FILENAME = "config.json".freeze
 
     class << self
-      # @return [String, nil]
-      #   the contents of the file
-      def file
-        File.read path if File.exists? path
+      attr_writer :path
+
+      # @return [String]
+      def path
+        File.join(Berkshelf.berkshelf_path, FILENAME)
       end
 
-      # @param [#to_s] json
-      #
-      # @return [Config]
-      def from_json(json)
-        hash = JSON.parse(json).to_hash
+      # @return [String]
+      def chef_config_path
+        @chef_config_path ||= File.expand_path(ENV["BERKSHELF_CHEF_CONFIG"] || "~/.chef/knife.rb")
+      end
 
-        new.tap do |config|
-          hash.each do |key, value|
-            config[key] = value
-          end
+      # @param [String] value
+      def chef_config_path=(value)
+        @chef_config = nil
+        @chef_config_path = value
+      end
+
+      # @return [Chef::Config]
+      def chef_config
+        @chef_config ||= begin
+          Chef::Config.from_file(File.expand_path(chef_config_path))
+          Chef::Config
+        rescue
+          Chef::Config
         end
       end
 
+      # @return [String, nil]
+      #   the contents of the file
+      def file
+        File.read(path) if File.exists?(path)
+      end
+
       # @return [Config]
       def instance
         @instance ||= if file
@@ -34,18 +49,52 @@ module Berkshelf
           new
         end
       end
-
-      # @return [String]
-      def path
-        File.expand_path DEFAULT_PATH
-      end
     end
 
-    # @param [String, Symbol] key
-    #
-    # @return [Config, Object]
-    def [](key)
-      super or self.class.new
+    # @param [String] path
+    # @param [Hash] options
+    #   @see {Chozo::Config::JSON}
+    def initialize(path = self.class.path, options = {})
+      super(path, options)
     end
+
+    attribute 'chef.chef_server_url',
+      type: String,
+      default: chef_config[:chef_server_url]
+    attribute 'chef.validation_client_name',
+      type: String,
+      default: chef_config[:validation_client_name]
+    attribute 'chef.validation_key_path',
+      type: String,
+      default: chef_config[:validation_key]
+    attribute 'chef.client_key',
+      type: String,
+      default: chef_config[:client_key]
+    attribute 'chef.node_name',
+      type: String,
+      default: chef_config[:node_name]
+    attribute 'vagrant.vm.box',
+      type: String,
+      default: 'Berkshelf-CentOS-6.3-x86_64-minimal',
+      required: true
+    attribute 'vagrant.vm.box_url',
+      type: String,
+      default: 'https://dl.dropbox.com/u/31081437/Berkshelf-CentOS-6.3-x86_64-minimal.box',
+      required: true
+    attribute 'vagrant.vm.forward_port',
+      type: Hash,
+      default: Hash.new
+    attribute 'vagrant.vm.network.bridged',
+      type: Boolean,
+      default: true
+    attribute 'vagrant.vm.network.hostonly',
+      type: String,
+      default: '33.33.33.10'
+    attribute 'vagrant.vm.provision',
+      type: String,
+      default: 'chef_solo'
+    attribute 'ssl.verify',
+      type: Boolean,
+      default: true
   end
 end

data/lib/berkshelf/errors.rb

@@ -41,7 +41,7 @@ module Berkshelf
   class NoSolution < BerkshelfError; status_code(106); end
   class CookbookSyntaxError < BerkshelfError; status_code(107); end
   class UploadFailure < BerkshelfError; status_code(108); end
-  class KnifeConfigNotFound < BerkshelfError; status_code(109); end
+  class BerksConfigNotFound < BerkshelfError; status_code(109); end
 
   class InvalidGitURI < BerkshelfError
     status_code(110)
@@ -91,7 +91,7 @@ module Berkshelf
     def to_s
       strings = ["Invalid configuration:"]
 
-      @errors.messages.each do |key, errors|
+      @errors.each do |key, errors|
         errors.each do |error|
           strings << "  #{key} #{error}"
         end
@@ -100,4 +100,7 @@ module Berkshelf
       strings.join "\n"
     end
   end
+
+  class ConfigExists < BerkshelfError; status_code(116); end
+  class ConfigurationError < BerkshelfError; status_code(117); end
 end

data/lib/berkshelf/locations/chef_api_location.rb

@@ -86,9 +86,9 @@ module Berkshelf
     # @param [Hash] options
     #
     # @option options [String, Symbol] :chef_api
-    #   a URL to a Chef API. Alternatively the symbol :knife can be provided
+    #   a URL to a Chef API. Alternatively the symbol :config can be provided
     #   which will instantiate this location with the values found in your
-    #   knife configuration.
+    #   Berkshelf configuration.
     # @option options [String] :node_name
     #   the name of the client to use to communicate with the Chef API.
     #   Default: Chef::Config[:node_name]
@@ -100,17 +100,22 @@ module Berkshelf
       @version_constraint = version_constraint
       @downloaded_status  = false
 
+      if options[:chef_api] == :knife
+        Berkshelf.formatter.deprecation "specifying 'chef_api :knife' is deprecated. Please use 'chef_api :config'."
+        options[:chef_api] = :config
+      end
+
       validate_options!(options)
 
-      if options[:chef_api] == :knife
-        begin
-          Berkshelf.load_config
-        rescue KnifeConfigNotFound => e
-          raise KnifeConfigNotFound, "A Knife config is required when ':knife' is given for the value of a 'chef_api' location. #{e}"
+      if options[:chef_api] == :config
+        unless Berkshelf::Config.instance.chef.node_name.present? &&
+          Berkshelf::Config.instance.chef.client_key.present? &&
+          Berkshelf::Config.instance.chef.chef_server_url.present?
+          raise ConfigurationError, "A Berkshelf configuration is required with a 'chef.client_key', 'chef.chef_server_Url', and 'chef.node_name' setting to install or upload cookbooks using 'chef_api :config'."
         end
-        @node_name  = Chef::Config[:node_name]
-        @client_key = Chef::Config[:client_key]
-        @uri        = Chef::Config[:chef_server_url]
+        @node_name  = Berkshelf::Config.instance.chef.node_name
+        @client_key = Berkshelf::Config.instance.chef.client_key
+        @uri        = Berkshelf::Config.instance.chef.chef_server_url
       else
         @node_name  = options[:node_name]
         @client_key = options[:client_key]
@@ -250,7 +255,7 @@ module Berkshelf
       # @raise [InvalidChefAPILocation] if any of the options are missing or their values do not
       #   pass validation
       def validate_options!(options)
-        if options[:chef_api] == :knife
+        if options[:chef_api] == :config
           return true
         end
 

data/lib/berkshelf/vagrant/action/install.rb

@@ -4,17 +4,13 @@ module Berkshelf
       # @author Jamie Winsor <jamie@vialstudios.com>
       # @author Andrew Garson <andrew.garson@gmail.com>
       class Install
-        attr_reader :config
         attr_reader :shelf
         attr_reader :berksfile
 
         def initialize(app, env)
-          @app                  = app
-          @shelf                = Berkshelf::Vagrant.shelf_for(env)
-          @config               = env[:vm].config.berkshelf
-          Berkshelf.config_path = @config.config_path
-          Berkshelf.load_config
-          @berksfile            = Berksfile.from_file(@config.berksfile_path)
+          @app       = app
+          @shelf     = Berkshelf::Vagrant.shelf_for(env)
+          @berksfile = Berksfile.from_file(env[:vm].config.berkshelf.berksfile_path)
         end
 
         def call(env)
@@ -32,7 +28,7 @@ module Berkshelf
             Berkshelf.formatter.msg "installing cookbooks..."
             opts = {
               path: self.shelf
-            }.merge(self.config.to_hash).symbolize_keys!
+            }.merge(env[:vm].config.berkshelf.to_hash).symbolize_keys!
             berksfile.install(opts)
           end
 

data/lib/berkshelf/vagrant/action/upload.rb

@@ -4,16 +4,10 @@ module Berkshelf
       # @author Jamie Winsor <jamie@vialstudios.com>
       class Upload
         attr_reader :berksfile
-        attr_reader :node_name
-        attr_reader :client_key
-        attr_reader :ssl_verify
 
         def initialize(app, env)
-          @app = app
-          @node_name  = env[:vm].config.berkshelf.node_name
-          @client_key = env[:vm].config.berkshelf.client_key
-          @ssl_verify = env[:vm].config.berkshelf.ssl_verify
-          @berksfile  = Berksfile.from_file(env[:vm].config.berkshelf.berksfile_path)
+          @app       = app
+          @berksfile = Berksfile.from_file(env[:vm].config.berkshelf.berksfile_path)
         end
 
         def call(env)
@@ -31,10 +25,10 @@ module Berkshelf
               Berkshelf.formatter.msg "uploading cookbooks to '#{provisioner.config.chef_server_url}'"
               berksfile.upload(
                 server_url: provisioner.config.chef_server_url,
-                client_name: self.node_name,
-                client_key: self.client_key,
+                client_name: Berkshelf::Config.instance.chef.node_name,
+                client_key: Berkshelf::Config.instance.chef.client_key,
                 ssl: {
-                  verify: self.ssl_verify
+                  verify: Berkshelf::Config.instance.ssl.verify
                 }
               )
             end

data/lib/berkshelf/vagrant/config.rb

@@ -3,24 +3,10 @@ module Berkshelf
     # @author Jamie Winsor <jamie@vialstudios.com>
     # @author Andrew Garson <andrew.garson@gmail.com>
     class Config < ::Vagrant::Config::Base
-      # @return [String]
-      #   path to a knife configuration file
-      attr_reader :config_path
-
       # @return [String]
       #   path to the Berksfile to use with Vagrant
       attr_reader :berksfile_path
 
-      # @return [String]
-      #   A path to a client key on disk to use with the Chef Client provisioner to
-      #   upload cookbooks installed by Berkshelf.
-      attr_reader :client_key
-
-      # @return [String]
-      #   A client name (node_name) to use with the Chef Client provisioner to upload
-      #   cookbooks installed by Berkshelf.
-      attr_accessor :node_name
-
       # @return [Array<Symbol>]
       #   only cookbooks in these groups will be installed and copied to
       #   Vagrant's shelf
@@ -30,16 +16,11 @@ module Berkshelf
       #   cookbooks in all other groups except for these will be installed
       #   and copied to Vagrant's shelf
       attr_accessor :except
-      attr_accessor :ssl_verify
 
       def initialize
         @berksfile_path = File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME)
-        @config_path    = Berkshelf::DEFAULT_CONFIG
-        @node_name      = nil
-        @client_key     = nil
         @except         = Array.new
         @only           = Array.new
-        @ssl_verify     = true
       end
 
       # @param [String] value
@@ -47,11 +28,6 @@ module Berkshelf
         @berksfile_path = File.expand_path(value)
       end
 
-      # @param [String] value
-      def config_path=(value)
-        @config_path = File.expand_path(value)
-      end
-
       # @param [String] value
       def client_key=(value)
         @client_key = File.expand_path(value)
@@ -63,12 +39,12 @@ module Berkshelf
         end
 
         if Berkshelf::Vagrant.chef_client?(env.config.global)
-          if node_name.nil?
-            errors.add("A value for berkshelf.node_name is required when using the chef_client provisioner.")
+          if Berkshelf::Config.instance.chef.node_name.nil?
+            errors.add("A configuration must be set for chef.node_name when using the chef_client provisioner. Run 'berks configure' or edit your configuration.")
           end
 
-          if client_key.nil?
-            errors.add("A value for berkshelf.client_key is required when using the chef_client provisioner.")
+          if Berkshelf::Config.instance.chef.client_key.nil?
+            errors.add("A configuration must be set for chef.client_key when using the chef_client provisioner. Run 'berks configure' or edit your configuration.")
           end
         end
       end

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "0.6.0.beta4"
+  VERSION = "1.0.0.rc1"
 end

data/spec/unit/berkshelf/config_spec.rb

@@ -1,91 +1,51 @@
 require 'spec_helper'
 
 describe Berkshelf::Config do
-  subject { config }
-
-  let(:config) { klass.new }
   let(:klass) { described_class }
 
-  it { should be_valid }
-
-  its(:present?) { should be_false }
-
-  it "set and gets hash keys" do
-    config[:a] = 1
-    config[:a].should == 1
-  end
+  describe "ClassMethods" do
+    subject { klass }
 
-  it "does not raise an error for nested hash keys that have not been set" do
-    config[:d][:e]
-  end
+    describe "::file" do
+      subject { klass.file }
 
-  it "has indifferent access" do
-    config[:a] = 1
-    config['b'] = 2
+      context "when the file does not exist" do
+        before :each do
+          File.stub exists?: false
+        end
 
-    config['a'].should == 1
-    config[:b].should == 2
-  end
-
-  describe ".file" do
-    subject { klass.file }
-
-    context "when the file does not exist" do
-      before :each do
-        File.stub exists?: false
+        it { should be_nil }
       end
-
-      it { should be_nil }
     end
-  end
-
-  describe ".from_json" do
-    subject(:config) { klass.from_json json }
 
-    let(:json) {
-      <<-JSON
-        {
-          "a": 1,
-          "b": {
-            "c": 2
-          }
-        }
-      JSON
-    }
+    describe "::instance" do
+      subject { klass.instance }
 
-    it "has data" do
-      config[:a].should == 1
+      it { should be_a klass }
     end
 
-    it "has nested data" do
-      config[:b][:c].should == 2
-    end
-
-    it "does not raise an error for nested hash keys that have not been set" do
-      config[:d][:e]
-    end
+    describe "::path" do
+      subject { klass.path }
 
-    it "has indifferent access" do
-      config['a'].should == 1
-      config[:a].should == 1
-    end
+      it { should be_a String }
 
-    context "with an invalid configuration" do
-      let(:json) { '{ "wat": 1 }' }
+      it "points to a location within ENV['BERKSHELF_PATH']" do
+        ENV.stub(:[]).with('BERKSHELF_PATH').and_return('/tmp')
 
-      it { should_not be_valid }
+        subject.should eql("/tmp/config.json")
+      end
     end
-  end
 
-  describe ".instance" do
-    subject { klass.instance }
-
-    it { should be_a klass }
-  end
+    describe "::chef_config" do
+      it "returns the Chef::Config" do
+        subject.chef_config.should eql(Chef::Config)
+      end
+    end
 
-  describe ".path" do
-    subject { klass.path }
+    describe "::chef_config_path" do
+      subject { klass.chef_config_path }
 
-    it { should be_a String }
+      it { should be_a String }  
+    end
   end
 end