chef-sugar 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ffd88ed3296573100935f5c32b367c0b358826c3
-  data.tar.gz: 9939836e75d3a827c143aa1de882dc476e63d117
+  metadata.gz: caa6d7d523f36a96b77fbbb6b405c77fe6245c8c
+  data.tar.gz: c300171c8b01b7664afa7660eae39417c63f26f4
 SHA512:
-  metadata.gz: 47ab4596120ad672030793e294e2939495b34a853a58972e20b56ae4b55d27dc69aef96dd647f424a992046a37f6e9c2870cd00787efb5a7f8a0536c4f15f056
-  data.tar.gz: 029757c522fd23b773022f59d3230ff7a523cbc9696f292c8abe0f11eff8e34e9c11f66c0b310d8626781ba7bc450f74a26a7b83e0b1db8ed6dab95f3be6955d
+  metadata.gz: 605a75aafd4c650900c9963afbb97dfdc0dcc064ce24737de8d59c11491360d155e18e1cc34d6182564a5d0bc49f94156add3b819559f7eaf48c87ee6b0a483e
+  data.tar.gz: 9daa3408b7a6a465c8f59df7a9043d7b726ac7dfefe00845a9113672d5e912f506fdc0156fd1ae858917d9529e8f79d7168737ffe5ddc6afe1b88c55cc2cbd41

data/CHANGELOG.md

@@ -2,6 +2,15 @@ Chef Sugar Changelog
 =========================
 This file is used to list changes made in each version of the chef-sugar cookbook and gem.
 
+v2.3.0 (2014-09-24)
+-------------------
+### Improvements
+- Add `vmware?` matcher
+- Allow the attribute DSL to access parent attributes
+
+### Bug Fixes
+- Return `true` or `false` from all Boolean methods (instead of `nil` or truthy values)
+
 v2.2.0 (2014-08-20)
 -------------------
 ### Improvements

data/README.md

@@ -380,6 +380,7 @@ end
 
 ### Virtualization
 - `lxc?`
+- `vmware?`
 
 #### Examples
 ```ruby

data/lib/chef/sugar/node.rb

@@ -149,12 +149,23 @@ EOH
     #
     # @return [nil]
     #   to prevent accidential method chaining if the block isn't closed
+    # @return [Object]
+    #   If no argument is passed in, method becomes an attribute accessor
     #
     def method_missing(m, *args, &block)
       old_method_missing(m, *args, &block)
     rescue NoMethodError
-      vivified[m.to_s] = args.size == 1 ? args.first : args
-      nil
+      # The Node Attribute's key is the method name
+      key = m.to_s
+      # If arguments are passed in, set node attribute with args as the value
+      if args.size > 0
+        vivified[key] = args.size == 1 ? args.first : args
+        return nil
+      # If no arguments are passed in, attempt to access corresponding attribute
+      else
+        deep_key = current_namespace.dup << key
+        return deep_fetch!(*deep_key)
+      end
     end
 
     private

data/lib/chef/sugar/shell.rb

@@ -83,11 +83,12 @@ class Chef
       #   otherwise
       #
       def installed_at_version?(cmd, version, flag = '--version')
-        which(cmd) && if version.is_a?(Regexp)
-                        version_for(cmd, flag) =~ version
-                      else
-                        version_for(cmd, flag).include?(version)
-                      end
+        installed?(cmd) &&
+          if version.is_a?(Regexp)
+            !version_for(cmd, flag).match(version).nil?
+          else
+            version_for(cmd, flag).include?(version)
+          end
       end
 
       #

data/lib/chef/sugar/vagrant.rb

@@ -55,7 +55,7 @@ class Chef
       # @return (see vagrant?)
       #
       def vagrant_domain?(node)
-        node['domain'] && node['domain'].include?('vagrantup.com')
+        node.key?('domain') && node['domain'].include?('vagrantup.com')
       end
 
       #
@@ -65,7 +65,7 @@ class Chef
       # @return (see vagrant?)
       #
       def vagrant_user?(node)
-        node['etc'] && node['etc']['passwd'] && node['etc']['passwd']['vagrant']
+        node.key?('etc') && node['etc'].key?('passwd') && !!node['etc']['passwd']['vagrant']
       end
     end
 

data/lib/chef/sugar/version.rb

@@ -16,6 +16,6 @@
 
 class Chef
   module Sugar
-    VERSION = '2.2.0'
+    VERSION = '2.3.0'
   end
 end

data/lib/chef/sugar/virtualization.rb

@@ -29,13 +29,29 @@ class Chef
       #   otherwise
       #
       def lxc?(node)
-        node['virtualization'] && node['virtualization']['system'] == 'lxc'
+        node.key?('virtualization') && node['virtualization']['system'] == 'lxc'
+      end
+
+      #
+      # Determine if the current node is running under VMware.
+      #
+      # @param [Chef::Node] node
+      #
+      # @return [Boolean]
+      #   true if the machine is currently running under VMware, false
+      #   otherwise
+      #
+      def vmware?(node)
+        node.key?('virtualization') && node['virtualization']['system'] == 'vmware'
       end
     end
 
     module DSL
       # @see Chef::Sugar::Virtualization#lxc?
       def lxc?; Chef::Sugar::Virtualization.lxc?(node); end
-    end
+
+      # @see Chef::Sugar::Virtualization#vmware?
+      def vmware?; Chef::Sugar::Virtualization.vmware?(node); end
+	  end
   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          '2.2.0'
+version          '2.3.0'

data/recipes/default.rb

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

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_truthy
+      expect(described_class._64_bit?(node)).to be true
     end
 
     it 'returns false when the system is not 64 bit' do
       node = { 'kernel' => { 'machine' => 'i386' } }
-      expect(described_class._64_bit?(node)).to be_falsey
+      expect(described_class._64_bit?(node)).to be false
     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_truthy
+      expect(described_class._32_bit?(node)).to be true
     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_falsey
+      expect(described_class._32_bit?(node)).to be false
     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_truthy
+      expect(described_class.cloud?(node)).to be true
     end
 
     it 'is false when the node is not on cloud' do
       node = {}
-      expect(described_class.cloud?(node)).to be_falsey
+      expect(described_class.cloud?(node)).to be false
     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_truthy
+      expect(described_class.ec2?(node)).to be true
     end
 
     it 'is false when the node is not on ec2' do
       node = {}
-      expect(described_class.ec2?(node)).to be_falsey
+      expect(described_class.ec2?(node)).to be false
     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_truthy
+      expect(described_class.gce?(node)).to be true
     end
 
     it 'is false when the node is not on gce' do
       node = {}
-      expect(described_class.gce?(node)).to be_falsey
+      expect(described_class.gce?(node)).to be false
     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_truthy
+      expect(described_class.rackspace?(node)).to be true
     end
 
     it 'is false when the node is not on rackspace' do
       node = {}
-      expect(described_class.rackspace?(node)).to be_falsey
+      expect(described_class.rackspace?(node)).to be false
     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_truthy
+      expect(described_class.eucalyptus?(node)).to be true
     end
 
     it 'is false when the node is not on eucalyptus' do
       node = {}
-      expect(described_class.eucalyptus?(node)).to be_falsey
+      expect(described_class.eucalyptus?(node)).to be false
     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_truthy
+      expect(described_class.euca?(node)).to be true
     end
 
     it 'is false when the node is not on eucalyptus' do
       node = {}
-      expect(described_class.euca?(node)).to be_falsey
+      expect(described_class.euca?(node)).to be false
     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_truthy
+      expect(described_class.linode?(node)).to be true
     end
 
     it 'is false when the node is not on linode' do
       node = {}
-      expect(described_class.linode?(node)).to be_falsey
+      expect(described_class.linode?(node)).to be false
     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_truthy
+      expect(described_class.openstack?(node)).to be true
     end
 
     it 'is false when the node is not on openstack' do
       node = {}
-      expect(described_class.openstack?(node)).to be_falsey
+      expect(described_class.openstack?(node)).to be false
     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_truthy
+      expect(described_class.cloudstack?(node)).to be true
     end
 
     it 'is false when the node is not on cloudstack' do
       node = {}
-      expect(described_class.cloudstack?(node)).to be_falsey
+      expect(described_class.cloudstack?(node)).to be false
     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_truthy
+      expect(described_class.azure?(node)).to be true
     end
 
     it 'is false when the node is not on azure' do
       node = {}
-      expect(described_class.azure?(node)).to be_falsey
+      expect(described_class.azure?(node)).to be false
     end
   end
 end

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

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

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

@@ -4,14 +4,14 @@ describe Chef::Node do
   describe '#in?' do
     it 'returns true when the node is in the environment' do
       allow(subject).to receive(:chef_environment).and_return('production')
-      expect(subject.in?('production')).to be_truthy
-      expect(subject.in?(/production$/)).to be_truthy
+      expect(subject.in?('production')).to be true
+      expect(subject.in?(/production$/)).to be true
     end
 
     it 'returns false when the node is not in the environment' do
       allow(subject).to receive(:chef_environment).and_return('staging')
-      expect(subject.in?('production')).to be_falsey
-      expect(subject.in?(/production$/)).to be_falsey
+      expect(subject.in?('production')).to be false
+      expect(subject.in?(/production$/)).to be false
     end
   end
 
@@ -99,6 +99,26 @@ describe Chef::Node do
         }
       })
     end
+
+    it 'can access attributes within itself' do
+      node.instance_eval do
+        namespace 'apache2' do
+          namespace 'config' do
+            root '/var/www'
+            ssl File.join(root, 'ssl')
+          end
+        end
+      end
+
+      expect(node.default).to eq({
+        'apache2' => {
+          'config' => {
+            'root' => '/var/www',
+            'ssl' => '/var/www/ssl',
+          }
+        }
+      })
+    end
   end
 
 end

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

@@ -6,159 +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_truthy
+      expect(described_class.arch_linux?(node)).to be true
     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_falsey
+      expect(described_class.arch_linux?(node)).to be false
     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_truthy
+      expect(described_class.debian?(node)).to be true
     end
 
     it 'returns false when the platform_family is not debian' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.debian?(node)).to be_falsey
+      expect(described_class.debian?(node)).to be false
     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_truthy
+      expect(described_class.fedora?(node)).to be true
     end
 
     it 'returns false when the platform_family is not fedora' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.fedora?(node)).to be_falsey
+      expect(described_class.fedora?(node)).to be false
     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_truthy
+      expect(described_class.freebsd?(node)).to be true
     end
 
     it 'returns false when the platform_family is not freebsd' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.freebsd?(node)).to be_falsey
+      expect(described_class.freebsd?(node)).to be false
     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_truthy
+      expect(described_class.gentoo?(node)).to be true
     end
 
     it 'returns false when the platform_family is not gentoo' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.gentoo?(node)).to be_falsey
+      expect(described_class.gentoo?(node)).to be false
     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_truthy
+      expect(described_class.mac_os_x?(node)).to be true
     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_falsey
+      expect(described_class.mac_os_x?(node)).to be false
     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_truthy
+      expect(described_class.openbsd?(node)).to be true
     end
 
     it 'returns false when the platform_family is not openbsd' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.openbsd?(node)).to be_falsey
+      expect(described_class.openbsd?(node)).to be false
     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_truthy
+      expect(described_class.rhel?(node)).to be true
     end
 
     it 'returns false when the platform_family is not rhel' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.rhel?(node)).to be_falsey
+      expect(described_class.rhel?(node)).to be false
     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_truthy
+      expect(described_class.slackware?(node)).to be true
     end
 
     it 'returns false when the platform_family is not slackware' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.slackware?(node)).to be_falsey
+      expect(described_class.slackware?(node)).to be false
     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_truthy
+      expect(described_class.suse?(node)).to be true
     end
 
     it 'returns false when the platform_family is not suse' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.suse?(node)).to be_falsey
+      expect(described_class.suse?(node)).to be false
     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_truthy
+      expect(described_class.windows?(node)).to be true
     end
 
     it 'returns false when the platform_family is not windows' do
       node = { 'platform_family' => 'debian' }
-      expect(described_class.windows?(node)).to be_falsey
+      expect(described_class.windows?(node)).to be false
     end
   end
 
   describe '#linux?' do
     it 'returns true when the platform_family is Debian' do
       node = { 'platform_family' => 'debian' }
-      expect(described_class.linux?(node)).to be_truthy
+      expect(described_class.linux?(node)).to be true
     end
 
     it 'returns true when the platform_family is RedHat' do
       node = { 'platform_family' => 'rhel' }
-      expect(described_class.linux?(node)).to be_truthy
+      expect(described_class.linux?(node)).to be true
     end
 
     it 'returns false when the platform_family is Windows' do
       node = { 'platform_family' => 'windows' }
-      expect(described_class.linux?(node)).to be_falsey
+      expect(described_class.linux?(node)).to be false
     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
+      expect(described_class.linux?(node)).to be false
     end
 
     it 'returns false when the platform_family is OpenBSD' do
       node = { 'platform_family' => 'openbsd' }
-      expect(described_class.linux?(node)).to be_falsey
+      expect(described_class.linux?(node)).to be false
     end
   end
 end

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

@@ -6,132 +6,132 @@ 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_truthy
+      expect(described_class.linux_mint?(node)).to be true
     end
 
     it 'returns false when the platform is not linux mint' do
       node = { 'platform' => 'windows' }
-      expect(described_class.linux_mint?(node)).to be_falsey
+      expect(described_class.linux_mint?(node)).to be false
     end
   end
 
   describe '#ubuntu?' do
     it 'returns true when the platform is ubuntu' do
       node = { 'platform' => 'ubuntu' }
-      expect(described_class.ubuntu?(node)).to be_truthy
+      expect(described_class.ubuntu?(node)).to be true
     end
 
     it 'returns false when the platform is not ubuntu' do
       node = { 'platform' => 'windows' }
-      expect(described_class.ubuntu?(node)).to be_falsey
+      expect(described_class.ubuntu?(node)).to be false
     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_truthy
+      expect(described_class.amazon_linux?(node)).to be true
     end
 
     it 'returns false when the platform is not amazon linux' do
       node = { 'platform' => 'windows' }
-      expect(described_class.amazon_linux?(node)).to be_falsey
+      expect(described_class.amazon_linux?(node)).to be false
     end
   end
 
   describe '#centos?' do
     it 'returns true when the platform is centos' do
       node = { 'platform' => 'centos' }
-      expect(described_class.centos?(node)).to be_truthy
+      expect(described_class.centos?(node)).to be true
     end
 
     it 'returns false when the platform is not centos' do
       node = { 'platform' => 'windows' }
-      expect(described_class.centos?(node)).to be_falsey
+      expect(described_class.centos?(node)).to be false
     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_truthy
+      expect(described_class.oracle_linux?(node)).to be true
     end
 
     it 'returns false when the platform is not oracle linux' do
       node = { 'platform' => 'windows' }
-      expect(described_class.oracle_linux?(node)).to be_falsey
+      expect(described_class.oracle_linux?(node)).to be false
     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_truthy
+      expect(described_class.scientific_linux?(node)).to be true
     end
 
     it 'returns false when the platform is not scientific linux' do
       node = { 'platform' => 'windows' }
-      expect(described_class.scientific_linux?(node)).to be_falsey
+      expect(described_class.scientific_linux?(node)).to be false
     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_truthy
+      expect(described_class.redhat_enterprise_linux?(node)).to be true
     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_falsey
+      expect(described_class.redhat_enterprise_linux?(node)).to be false
     end
   end
 
   describe '#solaris2?' do
     it 'returns true when the platform is solaris2' do
       node = { 'platform' => 'solaris2' }
-      expect(described_class.solaris2?(node)).to be_truthy
+      expect(described_class.solaris2?(node)).to be true
     end
 
     it 'returns false when the platform is not solaris2' do
       node = { 'platform' => 'windows' }
-      expect(described_class.solaris2?(node)).to be_falsey
+      expect(described_class.solaris2?(node)).to be false
     end
   end
 
   describe '#aix?' do
     it 'returns true when the platform is aix' do
       node = { 'platform' => 'aix' }
-      expect(described_class.aix?(node)).to be_truthy
+      expect(described_class.aix?(node)).to be true
     end
 
     it 'returns false when the platform is not aix' do
       node = { 'platform' => 'windows' }
-      expect(described_class.aix?(node)).to be_falsey
+      expect(described_class.aix?(node)).to be false
     end
   end
 
   describe '#smartos?' do
     it 'returns true when the platform is smartos' do
       node = { 'platform' => 'smartos' }
-      expect(described_class.smartos?(node)).to be_truthy
+      expect(described_class.smartos?(node)).to be true
     end
 
     it 'returns false when the platform is not smartos' do
       node = { 'platform' => 'windows' }
-      expect(described_class.smartos?(node)).to be_falsey
+      expect(described_class.smartos?(node)).to be false
     end
   end
 
   describe '#omnios?' do
     it 'returns true when the platform is omnios' do
       node = { 'platform' => 'omnios' }
-      expect(described_class.omnios?(node)).to be_truthy
+      expect(described_class.omnios?(node)).to be true
     end
 
     it 'returns false when the platform is not omnios' do
       node = { 'platform' => 'windows' }
-      expect(described_class.omnios?(node)).to be_falsey
+      expect(described_class.omnios?(node)).to be false
     end
   end
 
@@ -139,134 +139,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_truthy
+        expect(described_class.ubuntu_after_lucid?(node)).to be true
       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_falsey
+        expect(described_class.ubuntu_after_lucid?(node)).to be false
       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_falsey
+        expect(described_class.ubuntu_after_lucid?(node)).to be false
       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_falsey
+        expect(described_class.ubuntu_after_lucid?(node)).to be false
       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_truthy
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be true
       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_truthy
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be true
       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_truthy
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be true
       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_falsey
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be false
       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_falsey
+        expect(described_class.ubuntu_lucid?(node)).to be false
       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_truthy
+        expect(described_class.ubuntu_lucid?(node)).to be true
       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_truthy
+        expect(described_class.ubuntu_lucid?(node)).to be true
       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_falsey
+        expect(described_class.ubuntu_lucid?(node)).to be false
       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_falsey
+        expect(described_class.ubuntu_before_lucid?(node)).to be false
       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_falsey
+        expect(described_class.ubuntu_before_lucid?(node)).to be false
       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_falsey
+        expect(described_class.ubuntu_before_lucid?(node)).to be false
       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_truthy
+        expect(described_class.ubuntu_before_lucid?(node)).to be true
       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_falsey
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be false
       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_truthy
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be true
       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_truthy
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be true
       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_truthy
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be true
       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_truthy
+        expect(described_class.debian_wheezy?(node)).to be true
       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_falsey
+        expect(described_class.debian_wheezy?(node)).to be false
       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_truthy
+        expect(described_class.debian_before_wheezy?(node)).to be true
       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_falsey
+        expect(described_class.debian_before_wheezy?(node)).to be false
       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_truthy
+      expect(described_class.ruby_20?(node)).to be true
     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_falsey
+      expect(described_class.ruby_20?(node)).to be false
     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_falsey
+      expect(described_class.ruby_20?(node)).to be false
     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_truthy
+      expect(described_class.ruby_19?(node)).to be true
     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_falsey
+      expect(described_class.ruby_19?(node)).to be false
     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_falsey
+      expect(described_class.ruby_19?(node)).to be false
     end
   end
 end

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

@@ -8,12 +8,12 @@ describe Chef::Sugar::RunContext do
 
     it 'returns true when the recipe exists' do
       allow(node).to receive(:recipe?).and_return(true)
-      expect(described_class.includes_recipe?(node, 'foo')).to be_truthy
+      expect(described_class.includes_recipe?(node, 'foo')).to be true
     end
 
     it 'returns false when the recipe does not exist' do
       allow(node).to receive(:recipe?).and_return(false)
-      expect(described_class.includes_recipe?(node, 'bar')).to be_falsey
+      expect(described_class.includes_recipe?(node, 'bar')).to be false
     end
   end
 end

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

@@ -42,12 +42,12 @@ describe Chef::Sugar::Shell do
     it 'returns true if the given binary exists' do
       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
+      expect(described_class.installed?('mongo')).to be true
     end
 
     it 'returns false if the given binary does not exist' do
       allow(File).to receive(:executable?).and_return(false)
-      expect(described_class.installed?('node')).to be_falsey
+      expect(described_class.installed?('node')).to be false
     end
   end
 
@@ -55,30 +55,30 @@ describe Chef::Sugar::Shell do
     it 'returns true if the command is installed at the correct version' do
       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
+      expect(described_class.installed_at_version?('mongo', '1.2.3')).to be true
     end
 
     it 'returns true if the command is installed at the correct version and has additional output' do
       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
+      expect(described_class.installed_at_version?('mongo', '1.2.3')).to be true
     end
 
     it 'returns true if the command is installed at the correct version with a regex' do
       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
+      expect(described_class.installed_at_version?('mongo', /1\.2/)).to be true
     end
 
     it 'returns false if the command is installed at the wrong version' do
       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
+      expect(described_class.installed_at_version?('mongo', '4.5.6')).to be false
     end
 
     it 'returns false if the command is not installed' do
       allow(described_class).to receive(:which).and_return(nil)
-      expect(described_class.installed_at_version?('mongo', '1.0.0')).to be_falsey
+      expect(described_class.installed_at_version?('mongo', '1.0.0')).to be false
     end
   end
 

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_truthy
+      expect(described_class.vagrant?(node)).to be true
     end
 
     it 'returns true when the domain is vagrantup.com' do
       node = { 'domain' => 'bacon.vagrantup.com' }
-      expect(described_class.vagrant?(node)).to be_truthy
+      expect(described_class.vagrant?(node)).to be true
     end
 
     it 'returns true when the vagrant user exists on the system' do
       node = { 'etc' => { 'passwd' => { 'vagrant' => {} } } }
-      expect(described_class.vagrant?(node)).to be_truthy
+      expect(described_class.vagrant?(node)).to be true
     end
 
     it 'returns false when the machine is not on vagrant' do
       node = {}
-      expect(described_class.vagrant?(node)).to be_falsey
+      expect(described_class.vagrant?(node)).to be false
     end
   end
 end

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

@@ -6,17 +6,34 @@ describe Chef::Sugar::Virtualization do
   describe '#lxc?' do
     it 'returns true when the machine is a linux contianer' do
       node = { 'virtualization' => { 'system' => 'lxc' } }
-      expect(described_class.lxc?(node)).to be_truthy
+      expect(described_class.lxc?(node)).to be true
     end
 
     it 'returns false when the virtual machine is not lxc' do
       node = { 'virtualization' => { 'system' => 'vbox' } }
-      expect(described_class.lxc?(node)).to be_falsey
+      expect(described_class.lxc?(node)).to be false
     end
 
     it 'returns false when the machine is not virtual' do
       node = {}
-      expect(described_class.lxc?(node)).to be_falsey
+      expect(described_class.lxc?(node)).to be false
+    end
+  end
+
+  describe '#vmware?' do
+    it 'returns true when the machine is under vmware' do
+      node = { 'virtualization' => { 'system' => 'vmware' } }
+      expect(described_class.vmware?(node)).to be true
+    end
+
+    it 'returns false when the virtual machine is not under vmware' do
+      node = { 'virtualization' => { 'system' => 'vbox' } }
+      expect(described_class.vmware?(node)).to be false
+    end
+
+    it 'returns false when the machine is not virtual' do
+      node = {}
+      expect(described_class.vmware?(node)).to be false
     end
   end
 end

data/spec/unit/recipes/default_spec.rb

@@ -4,6 +4,6 @@ describe 'chef-sugar::default' do
   let(:chef_run) { ChefSpec::Runner.new.converge(described_recipe) }
 
   it 'installs the chef gem' do
-    expect(chef_run).to install_chef_gem('chef-sugar')
+    expect(chef_run).to install_chef_gem('chef-sugar').with(version: Chef::Sugar::VERSION)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-sugar
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Seth Vargo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-20 00:00:00.000000000 Z
+date: 2014-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler