chef-config 12.4.3 → 12.5.0.alpha.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04318bb1957964ab7a38dc8ef6c700cff7594ddb
-  data.tar.gz: 7af1c612414e25cd40cd01e0b5ad77d4e764d731
+  metadata.gz: 2347fb5ae0e3e633f6147f5dc882b304e151aa95
+  data.tar.gz: 08d2e27cff0117c90f66d1480a9c25ecc36b5e34
 SHA512:
-  metadata.gz: b1702f92959f4031d59d5f7835025b27309dccf736752b751a9ef509a61116f86e4d3a46d5aebbcd1bd94aea008e810fa50a57a89d07af1892660468a00a658b
-  data.tar.gz: de1b0c12333199c52de7b306bc7d943dbd7341c6de5c5f55bdbdf4d1f926aebdbbac5f3dd2342a758bf2eaa9a011eb2ace9ec4c960540136661e5d4f3cb3d889
+  metadata.gz: 7a3346f2a58de6eb58d17d916b13e590ec863e42d7408de0968d7df5a83e3a3872a507b8387571ee9c8cd52caaa2eabc9b34261dfcc5be27b56a25acaa056646
+  data.tar.gz: ba017cd8a5a5ccb7b221f5d352c0b6926aa4a8e21ece21b9b1fa5d9efd595a6c28abf4783157b0e90accd9be0955533b711a98f8e162d669a734c7599a843f0c

data/lib/chef-config/config.rb

@@ -739,6 +739,3 @@ module ChefConfig
     end
   end
 end
-
-
-

data/lib/chef-config/exceptions.rb

@@ -20,7 +20,7 @@ require 'chef-config/logger'
 
 module ChefConfig
 
-  class InvalidPath < StandardError
-  end
+  class ConfigurationError < ArgumentError; end
+  class InvalidPath < StandardError; end
 
 end

data/lib/chef-config/version.rb

@@ -20,6 +20,6 @@
 #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 module ChefConfig
-  VERSION = '12.4.3'
+  VERSION = '12.5.0.alpha.0'
 end
 

data/lib/chef-config/workstation_config_loader.rb

@@ -0,0 +1,179 @@
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef-config/config'
+require 'chef-config/exceptions'
+require 'chef-config/logger'
+require 'chef-config/path_helper'
+require 'chef-config/windows'
+
+module ChefConfig
+  class WorkstationConfigLoader
+
+    # Path to a config file requested by user, (e.g., via command line option). Can be nil
+    attr_accessor :explicit_config_file
+
+    # TODO: initialize this with a logger for Chef and Knife
+    def initialize(explicit_config_file, logger=nil)
+      @explicit_config_file = explicit_config_file
+      @chef_config_dir = nil
+      @config_location = nil
+      @logger = logger || NullLogger.new
+    end
+
+    def no_config_found?
+      config_location.nil?
+    end
+
+    def config_location
+      @config_location ||= (explicit_config_file || locate_local_config)
+    end
+
+    def chef_config_dir
+      if @chef_config_dir.nil?
+        @chef_config_dir = false
+        full_path = working_directory.split(File::SEPARATOR)
+        (full_path.length - 1).downto(0) do |i|
+          candidate_directory = File.join(full_path[0..i] + [".chef"])
+          if File.exist?(candidate_directory) && File.directory?(candidate_directory)
+            @chef_config_dir = candidate_directory
+            break
+          end
+        end
+      end
+      @chef_config_dir
+    end
+
+    def load
+      # Ignore it if there's no explicit_config_file and can't find one at a
+      # default path.
+      return false if config_location.nil?
+
+      if explicit_config_file && !path_exists?(config_location)
+        raise ChefConfig::ConfigurationError, "Specified config file #{config_location} does not exist"
+      end
+
+      # Have to set Config.config_file b/c other config is derived from it.
+      Config.config_file = config_location
+      read_config(IO.read(config_location), config_location)
+    end
+
+    # (Private API, public for test purposes)
+    def env
+      ENV
+    end
+
+    # (Private API, public for test purposes)
+    def path_exists?(path)
+      Pathname.new(path).expand_path.exist?
+    end
+
+    private
+
+    def have_config?(path)
+      if path_exists?(path)
+        logger.info("Using config at #{path}")
+        true
+      else
+        logger.debug("Config not found at #{path}, trying next option")
+        false
+      end
+    end
+
+    def locate_local_config
+      candidate_configs = []
+
+      # Look for $KNIFE_HOME/knife.rb (allow multiple knives config on same machine)
+      if env['KNIFE_HOME']
+        candidate_configs << File.join(env['KNIFE_HOME'], 'config.rb')
+        candidate_configs << File.join(env['KNIFE_HOME'], 'knife.rb')
+      end
+      # Look for $PWD/knife.rb
+      if Dir.pwd
+        candidate_configs << File.join(Dir.pwd, 'config.rb')
+        candidate_configs << File.join(Dir.pwd, 'knife.rb')
+      end
+      # Look for $UPWARD/.chef/knife.rb
+      if chef_config_dir
+        candidate_configs << File.join(chef_config_dir, 'config.rb')
+        candidate_configs << File.join(chef_config_dir, 'knife.rb')
+      end
+      # Look for $HOME/.chef/knife.rb
+      PathHelper.home('.chef') do |dot_chef_dir|
+        candidate_configs << File.join(dot_chef_dir, 'config.rb')
+        candidate_configs << File.join(dot_chef_dir, 'knife.rb')
+      end
+
+      candidate_configs.find do | candidate_config |
+        have_config?(candidate_config)
+      end
+    end
+
+    def working_directory
+      a = if ChefConfig.windows?
+            env['CD']
+          else
+            env['PWD']
+          end || Dir.pwd
+
+      a
+    end
+
+    def read_config(config_content, config_file_path)
+      Config.from_string(config_content, config_file_path)
+    rescue SignalException
+      raise
+    rescue SyntaxError => e
+      message = ""
+      message << "You have invalid ruby syntax in your config file #{config_file_path}\n\n"
+      message << "#{e.class.name}: #{e.message}\n"
+      if file_line = e.message[/#{Regexp.escape(config_file_path)}:[\d]+/]
+        line = file_line[/:([\d]+)$/, 1].to_i
+        message << highlight_config_error(config_file_path, line)
+      end
+      raise ChefConfig::ConfigurationError, message
+    rescue Exception => e
+      message = "You have an error in your config file #{config_file_path}\n\n"
+      message << "#{e.class.name}: #{e.message}\n"
+      filtered_trace = e.backtrace.grep(/#{Regexp.escape(config_file_path)}/)
+      filtered_trace.each {|bt_line| message << "  " << bt_line << "\n" }
+      if !filtered_trace.empty?
+        line_nr = filtered_trace.first[/#{Regexp.escape(config_file_path)}:([\d]+)/, 1]
+        message << highlight_config_error(config_file_path, line_nr.to_i)
+      end
+      raise ChefConfig::ConfigurationError, message
+    end
+
+
+    def highlight_config_error(file, line)
+      config_file_lines = []
+      IO.readlines(file).each_with_index {|l, i| config_file_lines << "#{(i + 1).to_s.rjust(3)}: #{l.chomp}"}
+      if line == 1
+        lines = config_file_lines[0..3]
+      else
+        lines = config_file_lines[Range.new(line - 2, line)]
+      end
+      "Relevant file content:\n" + lines.join("\n") + "\n"
+    end
+
+    def logger
+      @logger
+    end
+
+  end
+end

data/spec/unit/workstation_config_loader_spec.rb

@@ -0,0 +1,291 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'tempfile'
+
+require 'chef-config/exceptions'
+require 'chef-config/windows'
+require 'chef-config/workstation_config_loader'
+
+RSpec.describe ChefConfig::WorkstationConfigLoader do
+
+  let(:explicit_config_location) { nil }
+
+  let(:env) { {} }
+
+  let(:config_loader) do
+    described_class.new(explicit_config_location).tap do |c|
+      allow(c).to receive(:env).and_return(env)
+    end
+  end
+
+  # Test methods that do I/O or reference external state which are stubbed out
+  # elsewhere.
+  describe "external dependencies" do
+    let(:config_loader) { described_class.new(nil) }
+
+    it "delegates to ENV for env" do
+      expect(config_loader.env).to equal(ENV)
+    end
+
+    it "tests a path's existence" do
+      expect(config_loader.path_exists?('/nope/nope/nope/nope/frab/jab/nab')).to be(false)
+      expect(config_loader.path_exists?(__FILE__)).to be(true)
+    end
+
+  end
+
+  describe "locating the config file" do
+    context "without an explicit config" do
+
+      before do
+        allow(config_loader).to receive(:path_exists?).with(an_instance_of(String)).and_return(false)
+      end
+
+      it "has no config if HOME is not set" do
+        expect(config_loader.config_location).to be(nil)
+        expect(config_loader.no_config_found?).to be(true)
+      end
+
+      context "when HOME is set and contains a knife.rb" do
+
+        let(:home) { "/Users/example.user" }
+
+        before do
+          allow(ChefConfig::PathHelper).to receive(:home).with('.chef').and_yield(File.join(home, '.chef'))
+          allow(config_loader).to receive(:path_exists?).with("#{home}/.chef/knife.rb").and_return(true)
+        end
+
+        it "uses the config in HOME/.chef/knife.rb" do
+          expect(config_loader.config_location).to eq("#{home}/.chef/knife.rb")
+        end
+
+        context "and has a config.rb" do
+
+          before do
+            allow(config_loader).to receive(:path_exists?).with("#{home}/.chef/config.rb").and_return(true)
+          end
+
+          it "uses the config in HOME/.chef/config.rb" do
+            expect(config_loader.config_location).to eq("#{home}/.chef/config.rb")
+          end
+
+          context "and/or a parent dir contains a .chef dir" do
+
+            let(:env_pwd) { "/path/to/cwd" }
+
+            before do
+              if ChefConfig.windows?
+                env["CD"] = env_pwd
+              else
+                env["PWD"] = env_pwd
+              end
+
+              allow(config_loader).to receive(:path_exists?).with("#{env_pwd}/.chef/knife.rb").and_return(true)
+              allow(File).to receive(:exist?).with("#{env_pwd}/.chef").and_return(true)
+              allow(File).to receive(:directory?).with("#{env_pwd}/.chef").and_return(true)
+            end
+
+            it "prefers the config from parent_dir/.chef" do
+              expect(config_loader.config_location).to eq("#{env_pwd}/.chef/knife.rb")
+            end
+
+            context "and the parent dir's .chef dir has a config.rb" do
+
+              before do
+                allow(config_loader).to receive(:path_exists?).with("#{env_pwd}/.chef/config.rb").and_return(true)
+              end
+
+              it "prefers the config from parent_dir/.chef" do
+                expect(config_loader.config_location).to eq("#{env_pwd}/.chef/config.rb")
+              end
+
+              context "and/or the current working directory contains a .chef dir" do
+
+                let(:cwd) { Dir.pwd }
+
+                before do
+                  allow(config_loader).to receive(:path_exists?).with("#{cwd}/knife.rb").and_return(true)
+                end
+
+                it "prefers a knife.rb located in the cwd" do
+                  expect(config_loader.config_location).to eq("#{cwd}/knife.rb")
+                end
+
+                context "and the CWD's .chef dir has a config.rb" do
+
+                  before do
+                    allow(config_loader).to receive(:path_exists?).with("#{cwd}/config.rb").and_return(true)
+                  end
+
+                  it "prefers a config located in the cwd" do
+                    expect(config_loader.config_location).to eq("#{cwd}/config.rb")
+                  end
+
+
+                  context "and/or KNIFE_HOME is set" do
+
+                    let(:knife_home) { "/path/to/knife/home" }
+
+                    before do
+                      env["KNIFE_HOME"] = knife_home
+                      allow(config_loader).to receive(:path_exists?).with("#{knife_home}/knife.rb").and_return(true)
+                    end
+
+                    it "prefers a knife located in KNIFE_HOME" do
+                      expect(config_loader.config_location).to eq("/path/to/knife/home/knife.rb")
+                    end
+
+                    context "and KNIFE_HOME contains a config.rb" do
+
+                      before do
+                        env["KNIFE_HOME"] = knife_home
+                        allow(config_loader).to receive(:path_exists?).with("#{knife_home}/config.rb").and_return(true)
+                      end
+
+                      it "prefers a config.rb located in KNIFE_HOME" do
+                        expect(config_loader.config_location).to eq("/path/to/knife/home/config.rb")
+                      end
+
+                    end
+
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context "when the current working dir is inside a symlinked directory" do
+        before do
+          # pwd according to your shell is /home/someuser/prod/chef-repo, but
+          # chef-repo is a symlink to /home/someuser/codes/chef-repo
+          env["CD"] = "/home/someuser/prod/chef-repo" # windows
+          env["PWD"] = "/home/someuser/prod/chef-repo" # unix
+
+          allow(Dir).to receive(:pwd).and_return("/home/someuser/codes/chef-repo")
+        end
+
+        it "loads the config from the non-dereferenced directory path" do
+          expect(File).to receive(:exist?).with("/home/someuser/prod/chef-repo/.chef").and_return(false)
+          expect(File).to receive(:exist?).with("/home/someuser/prod/.chef").and_return(true)
+          expect(File).to receive(:directory?).with("/home/someuser/prod/.chef").and_return(true)
+
+          expect(config_loader).to receive(:path_exists?).with("/home/someuser/prod/.chef/knife.rb").and_return(true)
+
+          expect(config_loader.config_location).to eq("/home/someuser/prod/.chef/knife.rb")
+        end
+      end
+    end
+
+    context "when given an explicit config to load" do
+
+      let(:explicit_config_location) { "/path/to/explicit/config.rb" }
+
+      it "prefers the explicit config" do
+        expect(config_loader.config_location).to eq(explicit_config_location)
+      end
+
+    end
+  end
+
+
+  describe "loading the config file" do
+
+    context "when no explicit config is specifed and no implicit config is found" do
+
+      before do
+        allow(config_loader).to receive(:path_exists?).with(an_instance_of(String)).and_return(false)
+      end
+
+      it "skips loading" do
+        expect(config_loader.config_location).to be(nil)
+        expect(config_loader.load).to be(false)
+      end
+
+    end
+
+    context "when an explicit config is given but it doesn't exist" do
+
+      let(:explicit_config_location) { "/nope/nope/nope/frab/jab/nab" }
+
+      it "raises a configuration error" do
+        expect { config_loader.load }.to raise_error(ChefConfig::ConfigurationError)
+      end
+
+    end
+
+    context "when the config file exists" do
+
+      let(:config_content) { "" }
+
+      # We need to keep a reference to the tempfile because while #close does
+      # not unlink the file, the object being GC'd will.
+      let(:tempfile) do
+        Tempfile.new("Chef-WorkstationConfigLoader-rspec-test").tap do |t|
+          t.print(config_content)
+          t.close
+        end
+      end
+
+      let(:explicit_config_location) do
+        tempfile.path
+      end
+
+      after { File.unlink(explicit_config_location) if File.exist?(explicit_config_location) }
+
+      context "and is valid" do
+
+        let(:config_content) { "config_file_evaluated(true)" }
+
+        it "loads the config" do
+          expect(config_loader.load).to be(true)
+          expect(ChefConfig::Config.config_file_evaluated).to be(true)
+        end
+
+        it "sets ChefConfig::Config.config_file" do
+          config_loader.load
+          expect(ChefConfig::Config.config_file).to eq(explicit_config_location)
+        end
+      end
+
+      context "and has a syntax error" do
+
+        let(:config_content) { "{{{{{:{{" }
+
+        it "raises a ConfigurationError" do
+          expect { config_loader.load }.to raise_error(ChefConfig::ConfigurationError)
+        end
+      end
+
+      context "and raises a ruby exception during evaluation" do
+
+        let(:config_content) { ":foo\n:bar\nraise 'oops'\n:baz\n" }
+
+        it "raises a ConfigurationError" do
+          expect { config_loader.load }.to raise_error(ChefConfig::ConfigurationError)
+        end
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-config
 version: !ruby/object:Gem::Version
-  version: 12.4.3
+  version: 12.5.0.alpha.0
 platform: ruby
 authors:
 - Adam Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-23 00:00:00.000000000 Z
+date: 2015-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
@@ -111,9 +111,11 @@ files:
 - lib/chef-config/path_helper.rb
 - lib/chef-config/version.rb
 - lib/chef-config/windows.rb
+- lib/chef-config/workstation_config_loader.rb
 - spec/spec_helper.rb
 - spec/unit/config_spec.rb
 - spec/unit/path_helper_spec.rb
+- spec/unit/workstation_config_loader_spec.rb
 homepage: https://github.com/chef/chef
 licenses:
 - Apache-2.0
@@ -129,12 +131,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: Chef's default configuration and config loading