chef-sugar 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66a357a489b8f06b63b80a4f27388f34dcfabfb8
-  data.tar.gz: a918f43f869416832f5df31c528d31199177cb24
+  metadata.gz: 93e0d5081147bfd7cd05eb8091c27da520a831e8
+  data.tar.gz: ae8139070b27cca2c83659be2d1bf23b14e31157
 SHA512:
-  metadata.gz: 632e3cf402e28a4e70daf2fa2cb1e1c9c55f5f5fae114c2cd4e3e436ee14f1ecaad627b0ec2c35caf316a89a46c2ce8ada33bc27709716db26c9ca4ff700d589
-  data.tar.gz: af93b654a34537965675d2e3ded37cdc4dc9339b69c259257f2aabecd878e58056ad5fbe9af6495b700183af4b7f5b0121e7c9564208ea0d13ed873e5dd31fd6
+  metadata.gz: 4c2b69db6e0c2ec129c90bb89ba67c48fb65b68cbb83da240ddb22b72d0285b0b019a35733f8f61cb7c32e42ff8f3444a665f259fa04479c088d27a307d40ea9
+  data.tar.gz: da5c22f889074fd2e7d8c3f46f9429ae95524c521bd50e31c9af446ea14a4471176968da07579d67c1d7c69df5cd415b9e7edbbfa0c71c36b38470d49e18def4

data/.hound.yml

@@ -0,0 +1,2 @@
+DotPosition:
+  EnforcedStyle: leading

data/CHANGELOG.md

@@ -2,8 +2,22 @@ Chef Sugar Changelog
 =========================
 This file is used to list changes made in each version of the chef-sugar cookbook and gem.
 
-vx.y.z (not yet released)
--------------------------
+v2.0.0 (2014-06-16)
+-------------------
+### Breaking
+- Remove `not_linux?` method
+- Remove `not_windows?` method
+
+### Improvements
+- Miscellaneous spelling fixes
+- Update a failing unit test for `installed?`
+- Add Mac OS X to the list of platforms (Yosemite)
+- Upgrade to RSpec 3
+- Fix `which` (and `installed?` and `installed_at_version?`) when given an absolute path
+- Fix `linux?` check to only return true on real linuxes
+
+v1.3.0 (2014-05-05)
+-------------------
 - Check both `$stdout` and `$stderr` in `version_for`
 - Add additional platform versions
 - Make `includes_recipe?` a top-level API (instead of just Node)

data/README.md

@@ -42,7 +42,7 @@ include_recipe 'chef-sugar::default'
 
 Alternatively you can put it in a base role or recipe and it will be included subsequently.
 
-Requiring the Chef Sugar Gem will automatically extend the Recipe DSL, `Chef::Resource`, and `Chef::Provider` with helpful convienence methods.
+Requiring the Chef Sugar Gem will automatically extend the Recipe DSL, `Chef::Resource`, and `Chef::Provider` with helpful convenience methods.
 
 ### Module Method
 If you are working outside of the Recipe DSL, you can use the module methods instead of the Recipe DSL. In general, the module methods have the same name as their Recipe-DSL counterparts, but require the node object as a parameter. For example:
@@ -181,7 +181,7 @@ end
 ```
 
 ### Constraints
-- `constaints` - create a new contraint (or requirement) that can be used to test version validations.
+- `constraints` - create a new constraint (or requirement) that can be used to test version validations.
 - `chef_version` - (DSL only) a wrapper for `version(Chef::VERSION)`
 - `version` - create a new version that can be used to test constraint validation.
 
@@ -210,7 +210,7 @@ end
 ```
 
 ### Kernel
-- `require_chef_gem` - "safely" require a gem. Loading a gem with Chef is sometimes difficult and confusing. The errors that Chef produces are also sometimes not very intuitive. In the event you require a gem to exist on the system, you can use `require_chef_gem`, which wil attempt to require the gem and then produce helpful output if the gem is not installed:
+- `require_chef_gem` - "safely" require a gem. Loading a gem with Chef is sometimes difficult and confusing. The errors that Chef produces are also sometimes not very intuitive. In the event you require a gem to exist on the system, you can use `require_chef_gem`, which will attempt to require the gem and then produce helpful output if the gem is not installed:
 
         Chef could not load the gem `#{name}'! You may need to install the gem
         manually with `gem install #{name}', or include a recipe before you can
@@ -320,7 +320,7 @@ node['attribute'] = if windows?
 ```
 
 ### Ruby
-**Note:** The applies to the the Ruby found at `node['languages']['ruby']`.
+**Note:** The applies to the Ruby found at `node['languages']['ruby']`.
 
 - `ruby_20?`
 - `ruby_19?`

data/chef-sugar.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
 
-  spec.add_development_dependency 'chefspec',        '~> 3.0'
+  spec.add_development_dependency 'chefspec',        '~> 4.0'
   spec.add_development_dependency 'test-kitchen',    '~> 1.1'
   spec.add_development_dependency 'kitchen-vagrant', '~> 0.14'
 end

data/lib/chef/sugar/platform.rb

@@ -36,6 +36,7 @@ class Chef
           'lion'          => '10.7',
           'mountain_lion' => '10.8',
           'mavericks'     => '10.9',
+          'yosemite'      => '10.10',
         },
         'ubuntu' => {
           'lucid'    => '10.04',

data/lib/chef/sugar/platform_family.rb

@@ -143,7 +143,6 @@ class Chef
       def windows?(node)
         node['platform_family'] == 'windows'
       end
-      alias_method :not_linux?, :windows?
 
       #
       # Determine if the current system is a linux derivative
@@ -153,9 +152,16 @@ class Chef
       # @return [Boolean]
       #
       def linux?(node)
-        !windows?(node)
+        %w(
+          arch
+          debian
+          fedora
+          gentoo
+          rhel
+          slackware
+          suse
+        ).include?(node['platform_family'])
       end
-      alias_method :not_windows?, :linux?
     end
 
     module DSL

data/lib/chef/sugar/shell.rb

@@ -15,6 +15,7 @@
 #
 
 require 'mixlib/shellout'
+require 'pathname'
 
 class Chef
   module Sugar
@@ -30,14 +31,18 @@ class Chef
       # @return [String, nil]
       #
       def which(cmd)
-        paths = ENV['PATH'].split(::File::PATH_SEPARATOR) + %w(/bin /usr/bin /sbin /usr/sbin)
+        if Pathname.new(cmd).absolute?
+          File.executable?(cmd) ? cmd : nil
+        else
+          paths = ENV['PATH'].split(::File::PATH_SEPARATOR) + %w(/bin /usr/bin /sbin /usr/sbin)
 
-        paths.each do |path|
-          possible = File.join(path, cmd)
-          return possible if File.executable?(possible)
-        end
+          paths.each do |path|
+            possible = File.join(path, cmd)
+            return possible if File.executable?(possible)
+          end
 
-        nil
+          nil
+        end
       end
 
       #

data/lib/chef/sugar/version.rb

@@ -16,6 +16,6 @@
 
 class Chef
   module Sugar
-    VERSION = '1.3.0'
+    VERSION = '2.0.0'
   end
 end

data/metadata.rb

@@ -14,4 +14,4 @@ For the most up-to-date information and documentation, please visit the [Chef
 Sugar project page on GitHub](https://github.com/sethvargo/chef-sugar).
 EOH
 
-version          '1.3.0'
+version          '2.0.0'

data/recipes/default.rb

@@ -18,7 +18,7 @@
 #
 
 chef_gem('chef-sugar') do
-  version '1.2.6'
+  version '2.0.0'
   action  :nothing
 end.run_action(:install)
 

data/spec/spec_helper.rb

@@ -11,7 +11,6 @@ RSpec.configure do |config|
   end
 
   # Focus groups
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run(focus: true)
   config.run_all_when_everything_filtered = true
 

data/spec/unit/chef/sugar/architecture_spec.rb

@@ -6,24 +6,24 @@ describe Chef::Sugar::Architecture do
   describe '#_64_bit?' do
     it 'returns true when the system is 64 bit' do
       node = { 'kernel' => { 'machine' => 'x86_64' } }
-      expect(described_class._64_bit?(node)).to be_true
+      expect(described_class._64_bit?(node)).to be_truthy
     end
 
     it 'returns false when the system is not 64 bit' do
       node = { 'kernel' => { 'machine' => 'i386' } }
-      expect(described_class._64_bit?(node)).to be_false
+      expect(described_class._64_bit?(node)).to be_falsey
     end
   end
 
   describe '#_32_bit?' do
     it 'returns true when the system is 32 bit' do
       node = { 'kernel' => { 'machine' => 'i386' } }
-      expect(described_class._32_bit?(node)).to be_true
+      expect(described_class._32_bit?(node)).to be_truthy
     end
 
     it 'returns false when the system is not 32 bit' do
       node = { 'kernel' => { 'machine' => 'x86_64' } }
-      expect(described_class._32_bit?(node)).to be_false
+      expect(described_class._32_bit?(node)).to be_falsey
     end
   end
 end

data/spec/unit/chef/sugar/cloud_spec.rb

@@ -6,120 +6,120 @@ describe Chef::Sugar::Cloud do
   describe '#cloud?' do
     it 'is true when the node is on cloud' do
       node = { 'cloud' => nil }
-      expect(described_class.cloud?(node)).to be_true
+      expect(described_class.cloud?(node)).to be_truthy
     end
 
     it 'is false when the node is not on cloud' do
       node = {}
-      expect(described_class.cloud?(node)).to be_false
+      expect(described_class.cloud?(node)).to be_falsey
     end
   end
 
   describe '#ec2?' do
     it 'is true when the node is on ec2' do
       node = { 'ec2' => nil }
-      expect(described_class.ec2?(node)).to be_true
+      expect(described_class.ec2?(node)).to be_truthy
     end
 
     it 'is false when the node is not on ec2' do
       node = {}
-      expect(described_class.ec2?(node)).to be_false
+      expect(described_class.ec2?(node)).to be_falsey
     end
   end
 
   describe '#gce?' do
     it 'is true when the node is on gce' do
       node = { 'gce' => nil }
-      expect(described_class.gce?(node)).to be_true
+      expect(described_class.gce?(node)).to be_truthy
     end
 
     it 'is false when the node is not on gce' do
       node = {}
-      expect(described_class.gce?(node)).to be_false
+      expect(described_class.gce?(node)).to be_falsey
     end
   end
 
   describe '#rackspace?' do
     it 'is true when the node is on rackspace' do
       node = { 'rackspace' => nil }
-      expect(described_class.rackspace?(node)).to be_true
+      expect(described_class.rackspace?(node)).to be_truthy
     end
 
     it 'is false when the node is not on rackspace' do
       node = {}
-      expect(described_class.rackspace?(node)).to be_false
+      expect(described_class.rackspace?(node)).to be_falsey
     end
   end
 
   describe '#eucalyptus?' do
     it 'is true when the node is on eucalyptus' do
       node = { 'eucalyptus' => nil }
-      expect(described_class.eucalyptus?(node)).to be_true
+      expect(described_class.eucalyptus?(node)).to be_truthy
     end
 
     it 'is false when the node is not on eucalyptus' do
       node = {}
-      expect(described_class.eucalyptus?(node)).to be_false
+      expect(described_class.eucalyptus?(node)).to be_falsey
     end
   end
 
   describe '#euca?' do
     it 'is true when the node is on eucalyptus' do
       node = { 'eucalyptus' => nil }
-      expect(described_class.euca?(node)).to be_true
+      expect(described_class.euca?(node)).to be_truthy
     end
 
     it 'is false when the node is not on eucalyptus' do
       node = {}
-      expect(described_class.euca?(node)).to be_false
+      expect(described_class.euca?(node)).to be_falsey
     end
   end
 
   describe '#linode?' do
     it 'is true when the node is on linode' do
       node = { 'linode' => nil }
-      expect(described_class.linode?(node)).to be_true
+      expect(described_class.linode?(node)).to be_truthy
     end
 
     it 'is false when the node is not on linode' do
       node = {}
-      expect(described_class.linode?(node)).to be_false
+      expect(described_class.linode?(node)).to be_falsey
     end
   end
 
   describe '#openstack?' do
     it 'is true when the node is on openstack' do
       node = { 'openstack' => nil }
-      expect(described_class.openstack?(node)).to be_true
+      expect(described_class.openstack?(node)).to be_truthy
     end
 
     it 'is false when the node is not on openstack' do
       node = {}
-      expect(described_class.openstack?(node)).to be_false
+      expect(described_class.openstack?(node)).to be_falsey
     end
   end
 
   describe '#cloudstack?' do
     it 'is true when the node is on cloudstack' do
       node = { 'cloudstack' => nil }
-      expect(described_class.cloudstack?(node)).to be_true
+      expect(described_class.cloudstack?(node)).to be_truthy
     end
 
     it 'is false when the node is not on cloudstack' do
       node = {}
-      expect(described_class.cloudstack?(node)).to be_false
+      expect(described_class.cloudstack?(node)).to be_falsey
     end
   end
 
   describe '#azure?' do
     it 'is true when the node is on azure' do
       node = { 'azure' => nil }
-      expect(described_class.azure?(node)).to be_true
+      expect(described_class.azure?(node)).to be_truthy
     end
 
     it 'is false when the node is not on azure' do
       node = {}
-      expect(described_class.azure?(node)).to be_false
+      expect(described_class.azure?(node)).to be_falsey
     end
   end
 end

data/spec/unit/chef/sugar/data_bag_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Chef::Sugar::DataBag do
   describe '#encrypted_data_bag_item' do
-    before { Chef::EncryptedDataBagItem.stub(:load) }
+    before { allow(Chef::EncryptedDataBagItem).to receive(:load) }
 
     it 'loads the encrypted data bag item' do
       expect(Chef::EncryptedDataBagItem).to receive(:load)
@@ -13,8 +13,8 @@ describe Chef::Sugar::DataBag do
 
     context 'when Chef::Config is set' do
       it 'loads the secret key from the Chef::Config' do
-        Chef::Config.stub(:[]).with(:encrypted_data_bag_secret).and_return('/data/path')
-        File.stub(:read).with('/data/path').and_return('B@c0n')
+        allow(Chef::Config).to receive(:[]).with(:encrypted_data_bag_secret).and_return('/data/path')
+        allow(File).to receive(:read).with('/data/path').and_return('B@c0n')
 
         expect(Chef::EncryptedDataBagItem).to receive(:load)
           .with('accounts', 'github', 'B@c0n')
@@ -37,7 +37,7 @@ describe Chef::Sugar::DataBag do
 
     context 'when the environment exists' do
       it 'loads the data from the environment' do
-        Chef::EncryptedDataBagItem.stub(:load).and_return(
+        allow(Chef::EncryptedDataBagItem).to receive(:load).and_return(
           'production' => {
             'username' => 'sethvargo',
             'password' => 'bacon',
@@ -53,7 +53,7 @@ describe Chef::Sugar::DataBag do
 
     context 'when the environment does not exist' do
       it 'loads the data from the default bucket' do
-        Chef::EncryptedDataBagItem.stub(:load).and_return(
+        allow(Chef::EncryptedDataBagItem).to receive(:load).and_return(
           'staging' => {
             'username' => 'sethvargo',
             'password' => 'bacon',

data/spec/unit/chef/sugar/kernel_spec.rb

@@ -9,8 +9,8 @@ describe Chef::Sugar::Kernel do
     end
 
     it 'loads the gem' do
-      Chef::Sugar::Kernel.stub(:require).and_return(true)
-      expect(described_class.require_chef_gem('bacon')).to be_true
+      allow(Chef::Sugar::Kernel).to receive(:require).and_return(true)
+      expect(described_class.require_chef_gem('bacon')).to be_truthy
     end
   end
 end

data/spec/unit/chef/sugar/node_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Chef::Node do
   describe '#in?' do
     it 'returns true when the node is in the environment' do
-      subject.stub(:chef_environment).and_return('production')
-      expect(subject.in?('production')).to be_true
-      expect(subject.in?(/production$/)).to be_true
+      allow(subject).to receive(:chef_environment).and_return('production')
+      expect(subject.in?('production')).to be_truthy
+      expect(subject.in?(/production$/)).to be_truthy
     end
 
     it 'returns false when the node is not in the environment' do
-      subject.stub(:chef_environment).and_return('staging')
-      expect(subject.in?('production')).to be_false
-      expect(subject.in?(/production$/)).to be_false
+      allow(subject).to receive(:chef_environment).and_return('staging')
+      expect(subject.in?('production')).to be_falsey
+      expect(subject.in?(/production$/)).to be_falsey
     end
   end
 

data/spec/unit/chef/sugar/platform_family_spec.rb

@@ -6,144 +6,159 @@ describe Chef::Sugar::PlatformFamily do
   describe '#arch_linux?' do
     it 'returns true when the platform_family is arch linux' do
       node = { 'platform_family' => 'arch' }
-      expect(described_class.arch_linux?(node)).to be_true
+      expect(described_class.arch_linux?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not arch linux' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.arch_linux?(node)).to be_false
+      expect(described_class.arch_linux?(node)).to be_falsey
     end
   end
 
   describe '#debian?' do
     it 'returns true when the platform_family is debian' do
       node = { 'platform_family' => 'debian' }
-      expect(described_class.debian?(node)).to be_true
+      expect(described_class.debian?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not debian' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.debian?(node)).to be_false
+      expect(described_class.debian?(node)).to be_falsey
     end
   end
 
   describe '#fedora?' do
     it 'returns true when the platform_family is fedora' do
       node = { 'platform_family' => 'fedora' }
-      expect(described_class.fedora?(node)).to be_true
+      expect(described_class.fedora?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not fedora' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.fedora?(node)).to be_false
+      expect(described_class.fedora?(node)).to be_falsey
     end
   end
 
   describe '#freebsd?' do
     it 'returns true when the platform_family is freebsd' do
       node = { 'platform_family' => 'freebsd' }
-      expect(described_class.freebsd?(node)).to be_true
+      expect(described_class.freebsd?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not freebsd' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.freebsd?(node)).to be_false
+      expect(described_class.freebsd?(node)).to be_falsey
     end
   end
 
   describe '#gentoo?' do
     it 'returns true when the platform_family is gentoo' do
       node = { 'platform_family' => 'gentoo' }
-      expect(described_class.gentoo?(node)).to be_true
+      expect(described_class.gentoo?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not gentoo' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.gentoo?(node)).to be_false
+      expect(described_class.gentoo?(node)).to be_falsey
     end
   end
 
   describe '#mac_os_x?' do
     it 'returns true when the platform_family is mac_os_x' do
       node = { 'platform_family' => 'mac_os_x' }
-      expect(described_class.mac_os_x?(node)).to be_true
+      expect(described_class.mac_os_x?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not mac_os_x' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.mac_os_x?(node)).to be_false
+      expect(described_class.mac_os_x?(node)).to be_falsey
     end
   end
 
   describe '#openbsd?' do
     it 'returns true when the platform_family is openbsd' do
       node = { 'platform_family' => 'openbsd' }
-      expect(described_class.openbsd?(node)).to be_true
+      expect(described_class.openbsd?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not openbsd' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.openbsd?(node)).to be_false
+      expect(described_class.openbsd?(node)).to be_falsey
     end
   end
 
   describe '#rhel?' do
     it 'returns true when the platform_family is rhel' do
       node = { 'platform_family' => 'rhel' }
-      expect(described_class.rhel?(node)).to be_true
+      expect(described_class.rhel?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not rhel' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.rhel?(node)).to be_false
+      expect(described_class.rhel?(node)).to be_falsey
     end
   end
 
   describe '#slackware?' do
     it 'returns true when the platform_family is slackware' do
       node = { 'platform_family' => 'slackware' }
-      expect(described_class.slackware?(node)).to be_true
+      expect(described_class.slackware?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not slackware' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.slackware?(node)).to be_false
+      expect(described_class.slackware?(node)).to be_falsey
     end
   end
 
   describe '#suse?' do
     it 'returns true when the platform_family is suse' do
       node = { 'platform_family' => 'suse' }
-      expect(described_class.suse?(node)).to be_true
+      expect(described_class.suse?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not suse' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.suse?(node)).to be_false
+      expect(described_class.suse?(node)).to be_falsey
     end
   end
 
   describe '#windows?' do
     it 'returns true when the platform_family is windows' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.windows?(node)).to be_true
+      expect(described_class.windows?(node)).to be_truthy
     end
 
     it 'returns false when the platform_family is not windows' do
       node = { 'platform_family' => 'debian' }
-      expect(described_class.windows?(node)).to be_false
+      expect(described_class.windows?(node)).to be_falsey
     end
   end
 
   describe '#linux?' do
-    it 'returns true when the platform_family is linux-based' do
+    it 'returns true when the platform_family is Debian' do
       node = { 'platform_family' => 'debian' }
-      expect(described_class.debian?(node)).to be_true
+      expect(described_class.linux?(node)).to be_truthy
     end
 
-    it 'returns false when the platform_family is not linux-based' do
+    it 'returns true when the platform_family is RedHat' do
+      node = { 'platform_family' => 'rhel' }
+      expect(described_class.linux?(node)).to be_truthy
+    end
+
+    it 'returns false when the platform_family is Windows' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.debian?(node)).to be_false
+      expect(described_class.linux?(node)).to be_falsey
+    end
+
+    it 'returns false when the platform_family is OSX' do
+      node = { 'platform_family' => 'mac_os_x' }
+      expect(described_class.linux?(node)).to be_falsey
+    end
+
+    it 'returns false when the platform_family is OpenBSD' do
+      node = { 'platform_family' => 'openbsd' }
+      expect(described_class.linux?(node)).to be_falsey
     end
   end
 end

data/spec/unit/chef/sugar/platform_spec.rb

@@ -6,84 +6,84 @@ describe Chef::Sugar::Platform do
   describe '#linux_mint?' do
     it 'returns true when the platform is linux mint' do
       node = { 'platform' => 'linuxmint' }
-      expect(described_class.linux_mint?(node)).to be_true
+      expect(described_class.linux_mint?(node)).to be_truthy
     end
 
     it 'returns false when the platform is not linux mint' do
       node = { 'platform' => 'windows' }
-      expect(described_class.linux_mint?(node)).to be_false
+      expect(described_class.linux_mint?(node)).to be_falsey
     end
   end
 
   describe '#ubuntu?' do
     it 'returns true when the platform is ubuntu' do
       node = { 'platform' => 'ubuntu' }
-      expect(described_class.ubuntu?(node)).to be_true
+      expect(described_class.ubuntu?(node)).to be_truthy
     end
 
     it 'returns false when the platform is not ubuntu' do
       node = { 'platform' => 'windows' }
-      expect(described_class.ubuntu?(node)).to be_false
+      expect(described_class.ubuntu?(node)).to be_falsey
     end
   end
 
   describe '#amazon_linux?' do
     it 'returns true when the platform is amazon linux' do
       node = { 'platform' => 'amazon' }
-      expect(described_class.amazon_linux?(node)).to be_true
+      expect(described_class.amazon_linux?(node)).to be_truthy
     end
 
     it 'returns false when the platform is not amazon linux' do
       node = { 'platform' => 'windows' }
-      expect(described_class.amazon_linux?(node)).to be_false
+      expect(described_class.amazon_linux?(node)).to be_falsey
     end
   end
 
   describe '#centos?' do
     it 'returns true when the platform is centos' do
       node = { 'platform' => 'centos' }
-      expect(described_class.centos?(node)).to be_true
+      expect(described_class.centos?(node)).to be_truthy
     end
 
     it 'returns false when the platform is not centos' do
       node = { 'platform' => 'windows' }
-      expect(described_class.centos?(node)).to be_false
+      expect(described_class.centos?(node)).to be_falsey
     end
   end
 
   describe '#oracle_linux?' do
     it 'returns true when the platform is oracle linux' do
       node = { 'platform' => 'oracle' }
-      expect(described_class.oracle_linux?(node)).to be_true
+      expect(described_class.oracle_linux?(node)).to be_truthy
     end
 
     it 'returns false when the platform is not oracle linux' do
       node = { 'platform' => 'windows' }
-      expect(described_class.oracle_linux?(node)).to be_false
+      expect(described_class.oracle_linux?(node)).to be_falsey
     end
   end
 
   describe '#scientific_linux?' do
     it 'returns true when the platform is scientific linux' do
       node = { 'platform' => 'scientific' }
-      expect(described_class.scientific_linux?(node)).to be_true
+      expect(described_class.scientific_linux?(node)).to be_truthy
     end
 
     it 'returns false when the platform is not scientific linux' do
       node = { 'platform' => 'windows' }
-      expect(described_class.scientific_linux?(node)).to be_false
+      expect(described_class.scientific_linux?(node)).to be_falsey
     end
   end
 
   describe '#redhat_enterprise_linux?' do
     it 'returns true when the platform is redhat enterprise linux' do
       node = { 'platform' => 'enterprise' }
-      expect(described_class.redhat_enterprise_linux?(node)).to be_true
+      expect(described_class.redhat_enterprise_linux?(node)).to be_truthy
     end
 
     it 'returns false when the platform is not redhat enterprise linux' do
       node = { 'platform' => 'windows' }
-      expect(described_class.redhat_enterprise_linux?(node)).to be_false
+      expect(described_class.redhat_enterprise_linux?(node)).to be_falsey
     end
   end
 
@@ -91,134 +91,134 @@ describe Chef::Sugar::Platform do
     describe '#ubuntu_after_lucid?' do
       it 'returns true when the version is later than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
-        expect(described_class.ubuntu_after_lucid?(node)).to be_true
+        expect(described_class.ubuntu_after_lucid?(node)).to be_truthy
       end
 
       it 'returns false when the version is 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
-        expect(described_class.ubuntu_after_lucid?(node)).to be_false
+        expect(described_class.ubuntu_after_lucid?(node)).to be_falsey
       end
 
       it 'returns false when the version is a patch release higher than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
-        expect(described_class.ubuntu_after_lucid?(node)).to be_false
+        expect(described_class.ubuntu_after_lucid?(node)).to be_falsey
       end
 
       it 'returns false when the version is less than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
-        expect(described_class.ubuntu_after_lucid?(node)).to be_false
+        expect(described_class.ubuntu_after_lucid?(node)).to be_falsey
       end
     end
 
     describe '#ubuntu_after_or_at_lucid?' do
       it 'returns true when the version is later than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
-        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_true
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_truthy
       end
 
       it 'returns true when the version is 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
-        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_true
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_truthy
       end
 
       it 'returns true when the version is a patch release higher than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
-        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_true
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_truthy
       end
 
       it 'returns false when the version is less than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
-        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_false
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be_falsey
       end
     end
 
     describe '#ubuntu_lucid?' do
       it 'returns false when the version is later than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
-        expect(described_class.ubuntu_lucid?(node)).to be_false
+        expect(described_class.ubuntu_lucid?(node)).to be_falsey
       end
 
       it 'returns true when the version is 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
-        expect(described_class.ubuntu_lucid?(node)).to be_true
+        expect(described_class.ubuntu_lucid?(node)).to be_truthy
       end
 
       it 'returns true when the version is a patch release higher than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
-        expect(described_class.ubuntu_lucid?(node)).to be_true
+        expect(described_class.ubuntu_lucid?(node)).to be_truthy
       end
 
       it 'returns false when the version is less than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
-        expect(described_class.ubuntu_lucid?(node)).to be_false
+        expect(described_class.ubuntu_lucid?(node)).to be_falsey
       end
     end
 
     describe '#ubuntu_before_lucid?' do
       it 'returns false when the version is later than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
-        expect(described_class.ubuntu_before_lucid?(node)).to be_false
+        expect(described_class.ubuntu_before_lucid?(node)).to be_falsey
       end
 
       it 'returns false when the version is 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
-        expect(described_class.ubuntu_before_lucid?(node)).to be_false
+        expect(described_class.ubuntu_before_lucid?(node)).to be_falsey
       end
 
       it 'returns false when the version is a patch release higher than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
-        expect(described_class.ubuntu_before_lucid?(node)).to be_false
+        expect(described_class.ubuntu_before_lucid?(node)).to be_falsey
       end
 
       it 'returns true when the version is less than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
-        expect(described_class.ubuntu_before_lucid?(node)).to be_true
+        expect(described_class.ubuntu_before_lucid?(node)).to be_truthy
       end
     end
 
     describe '#ubuntu_before_or_at_lucid?' do
       it 'returns false when the version is later than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
-        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_false
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_falsey
       end
 
       it 'returns true when the version is 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
-        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_true
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_truthy
       end
 
       it 'returns true when the version is a patch release higher than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
-        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_true
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_truthy
       end
 
       it 'returns true when the version is less than 10.04' do
         node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
-        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_true
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be_truthy
       end
     end
 
     describe '#debian_wheezy?' do
       it 'returns true when the version is a subset of the major' do
         node = { 'platform' => 'debian', 'platform_version' => '7.1' }
-        expect(described_class.debian_wheezy?(node)).to be_true
+        expect(described_class.debian_wheezy?(node)).to be_truthy
       end
 
       it 'returns false when the version is not the major' do
         node = { 'platform' => 'debian', 'platform_version' => '6.1' }
-        expect(described_class.debian_wheezy?(node)).to be_false
+        expect(described_class.debian_wheezy?(node)).to be_falsey
       end
     end
 
     describe '#debian_before_wheezy?' do
       it 'returns true when the version is a less than the major' do
         node = { 'platform' => 'debian', 'platform_version' => '6.5' }
-        expect(described_class.debian_before_wheezy?(node)).to be_true
+        expect(described_class.debian_before_wheezy?(node)).to be_truthy
       end
 
       it 'returns false when the version is not less than the major' do
         node = { 'platform' => 'debian', 'platform_version' => '8.0' }
-        expect(described_class.debian_before_wheezy?(node)).to be_false
+        expect(described_class.debian_before_wheezy?(node)).to be_falsey
       end
     end
   end

data/spec/unit/chef/sugar/ruby_spec.rb

@@ -6,34 +6,34 @@ describe Chef::Sugar::Ruby do
   describe '#ruby_20?' do
     it 'returns true when the ruby version is 2.0' do
       node = { 'languages' => { 'ruby' => { 'version' => '2.0.0' } } }
-      expect(described_class.ruby_20?(node)).to be_true
+      expect(described_class.ruby_20?(node)).to be_truthy
     end
 
     it 'returns true when the ruby version is less than 2.0' do
       node = { 'languages' => { 'ruby' => { 'version' => '1.9.3' } } }
-      expect(described_class.ruby_20?(node)).to be_false
+      expect(described_class.ruby_20?(node)).to be_falsey
     end
 
     it 'returns false when the ruby version is higher than 2.0' do
       node = { 'languages' => { 'ruby' => { 'version' => '3.0.0' } } }
-      expect(described_class.ruby_20?(node)).to be_false
+      expect(described_class.ruby_20?(node)).to be_falsey
     end
   end
 
   describe '#ruby_19?' do
     it 'returns true when the ruby version is 1.9' do
       node = { 'languages' => { 'ruby' => { 'version' => '1.9.1' } } }
-      expect(described_class.ruby_19?(node)).to be_true
+      expect(described_class.ruby_19?(node)).to be_truthy
     end
 
     it 'returns true when the ruby version is less than 1.9' do
       node = { 'languages' => { 'ruby' => { 'version' => '1.8.7' } } }
-      expect(described_class.ruby_19?(node)).to be_false
+      expect(described_class.ruby_19?(node)).to be_falsey
     end
 
     it 'returns false when the ruby version is higher than 1.9' do
       node = { 'languages' => { 'ruby' => { 'version' => '2.0.0' } } }
-      expect(described_class.ruby_19?(node)).to be_false
+      expect(described_class.ruby_19?(node)).to be_falsey
     end
   end
 end

data/spec/unit/chef/sugar/run_context_spec.rb

@@ -7,13 +7,13 @@ describe Chef::Sugar::RunContext do
     let(:node) { double(Chef::Node) }
 
     it 'returns true when the recipe exists' do
-      node.stub(:recipe?).and_return(true)
-      expect(described_class.includes_recipe?(node, 'foo')).to be_true
+      allow(node).to receive(:recipe?).and_return(true)
+      expect(described_class.includes_recipe?(node, 'foo')).to be_truthy
     end
 
     it 'returns false when the recipe does not exist' do
-      node.stub(:recipe?).and_return(false)
-      expect(described_class.includes_recipe?(node, 'bar')).to be_false
+      allow(node).to receive(:recipe?).and_return(false)
+      expect(described_class.includes_recipe?(node, 'bar')).to be_falsey
     end
   end
 end

data/spec/unit/chef/sugar/shell_spec.rb

@@ -3,15 +3,27 @@ require 'spec_helper'
 describe Chef::Sugar::Shell do
   describe '#which' do
     it 'returns the first executable matching the command' do
-      File.stub(:executable?).and_return(false)
-      File.stub(:executable?).with('/usr/bin/mongo').and_return(true)
+      allow(File).to receive(:executable?).and_return(false)
+      allow(File).to receive(:executable?).with('/usr/bin/mongo').and_return(true)
       expect(described_class.which('mongo')).to eq('/usr/bin/mongo')
     end
 
     it 'returns nil when no command is found' do
-      File.stub(:executable?).and_return(false)
+      allow(File).to receive(:executable?).and_return(false)
       expect(described_class.which('node')).to be_nil
     end
+
+    context 'with an absolute path' do
+      it 'returns the executable if it exists' do
+        allow(File).to receive(:executable?).with('/usr/local/bin/bash').and_return(true)
+        expect(described_class.which('/usr/local/bin/bash')).to eq('/usr/local/bin/bash')
+      end
+
+      it 'returns nil when the file is not executable' do
+        allow(File).to receive(:executable?).with('/usr/local/bin/bash').and_return(false)
+        expect(described_class.which('/usr/local/bin/bash')).to be_nil
+      end
+    end
   end
 
   describe '#dev_null' do
@@ -28,51 +40,51 @@ describe Chef::Sugar::Shell do
 
   describe '#installed?' do
     it 'returns true if the given binary exists' do
-      File.stub(:which).and_return(false)
-      File.stub(:which).with('/usr/bin/mongo').and_return(true)
-      expect(described_class.installed?('mongo')).to be_true
+      allow(described_class).to receive(:which).and_return(nil)
+      allow(described_class).to receive(:which).with('mongo').and_return(true)
+      expect(described_class.installed?('mongo')).to be_truthy
     end
 
     it 'returns false if the given binary does not exist' do
-      File.stub(:executable?).and_return(false)
-      expect(described_class.installed?('node')).to be_false
+      allow(File).to receive(:executable?).and_return(false)
+      expect(described_class.installed?('node')).to be_falsey
     end
   end
 
   describe '#installed_at_version?' do
     it 'returns true if the command is installed at the correct version' do
-      described_class.stub(:which).and_return(true)
-      described_class.stub(:version_for).and_return('1.2.3')
-      expect(described_class.installed_at_version?('mongo', '1.2.3')).to be_true
+      allow(described_class).to receive(:which).and_return(true)
+      allow(described_class).to receive(:version_for).and_return('1.2.3')
+      expect(described_class.installed_at_version?('mongo', '1.2.3')).to be_truthy
     end
 
     it 'returns true if the command is installed at the correct version and has additional output' do
-      described_class.stub(:which).and_return(true)
-      described_class.stub(:version_for).and_return('Mongo DB version 1.2.3. Some other text.')
-      expect(described_class.installed_at_version?('mongo', '1.2.3')).to be_true
+      allow(described_class).to receive(:which).and_return(true)
+      allow(described_class).to receive(:version_for).and_return('Mongo DB version 1.2.3. Some other text.')
+      expect(described_class.installed_at_version?('mongo', '1.2.3')).to be_truthy
     end
 
     it 'returns true if the command is installed at the correct version with a regex' do
-      described_class.stub(:which).and_return(true)
-      described_class.stub(:version_for).and_return('1.2.3')
-      expect(described_class.installed_at_version?('mongo', /1\.2/)).to be_true
+      allow(described_class).to receive(:which).and_return(true)
+      allow(described_class).to receive(:version_for).and_return('1.2.3')
+      expect(described_class.installed_at_version?('mongo', /1\.2/)).to be_truthy
     end
 
     it 'returns false if the command is installed at the wrong version' do
-      described_class.stub(:which).and_return(true)
-      described_class.stub(:version_for).and_return('1.2.3')
-      expect(described_class.installed_at_version?('mongo', '4.5.6')).to be_false
+      allow(described_class).to receive(:which).and_return(true)
+      allow(described_class).to receive(:version_for).and_return('1.2.3')
+      expect(described_class.installed_at_version?('mongo', '4.5.6')).to be_falsey
     end
 
     it 'returns false if the command is not installed' do
-      described_class.stub(:which).and_return(nil)
-      expect(described_class.installed_at_version?('mongo', '1.0.0')).to be_false
+      allow(described_class).to receive(:which).and_return(nil)
+      expect(described_class.installed_at_version?('mongo', '1.0.0')).to be_falsey
     end
   end
 
   describe '#version_for' do
     let(:shell_out) { double('shell_out', run_command: nil, error!: nil, stdout: '1.2.3', stderr: 'Oh no!') }
-    before { Mixlib::ShellOut.stub(:new).and_return(shell_out) }
+    before { allow(Mixlib::ShellOut).to receive(:new).and_return(shell_out) }
 
     it 'runs the thing in shellout' do
       expect(Mixlib::ShellOut).to receive(:new).with('mongo --version')

data/spec/unit/chef/sugar/vagrant_spec.rb

@@ -6,22 +6,22 @@ describe Chef::Sugar::Vagrant do
   describe '#vagrant?' do
     it 'returns true when the machine is on vagrant' do
       node = { 'vagrant' => {} }
-      expect(described_class.vagrant?(node)).to be_true
+      expect(described_class.vagrant?(node)).to be_truthy
     end
 
     it 'returns true when the domain is vagrantup.com' do
       node = { 'domain' => 'bacon.vagrantup.com' }
-      expect(described_class.vagrant?(node)).to be_true
+      expect(described_class.vagrant?(node)).to be_truthy
     end
 
     it 'returns true when the vagrant user exists on the system' do
       node = { 'etc' => { 'passwd' => { 'vagrant' => {} } } }
-      expect(described_class.vagrant?(node)).to be_true
+      expect(described_class.vagrant?(node)).to be_truthy
     end
 
     it 'returns false when the machine is not on vagrant' do
       node = {}
-      expect(described_class.vagrant?(node)).to be_false
+      expect(described_class.vagrant?(node)).to be_falsey
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-sugar
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Seth Vargo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-05 00:00:00.000000000 Z
+date: 2014-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: test-kitchen
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +90,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".hound.yml"
 - ".kitchen.yml"
 - ".travis.yml"
 - CHANGELOG.md