halite 1.0.0.rc.1 → 1.0.0

data/lib/halite/spec_helper/patcher.rb

@@ -0,0 +1,130 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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/resource'
+
+
+module Halite
+  module SpecHelper
+    # Utility methods to patch a resource or provider class in to Chef for the
+    # duration of a block.
+    #
+    # @since 1.0.0
+    # @api private
+    module Patcher
+      # Patch a class in to Chef for the duration of a block.
+      #
+      # @param name [String, Symbol] Name to create in snake-case (eg. :my_name).
+      # @param klass [Class] Class to patch in.
+      # @param mod [Module] Optional module to create a constant in.
+      # @param block [Proc] Block to execute while the patch is available.
+      # @return [void]
+      def self.patch(name, klass, mod=nil, &block)
+        patch_descendants_tracker(klass) do
+          patch_node_map(name, klass) do
+            patch_recipe_dsl(name, klass) do
+              if mod
+                patch_module(mod, name, klass, &block)
+              else
+                block.call
+              end
+            end
+          end
+        end
+      end
+
+      # Patch an object in to a global namespace for the duration of a block.
+      #
+      # @param mod [Module] Namespace to patch in to.
+      # @param name [String, Symbol] Name to create in snake-case (eg. :my_name).
+      # @param obj Object to patch in.
+      # @param block [Proc] Block to execute while the name is available.
+      # @return [void]
+      def self.patch_module(mod, name, obj, &block)
+        class_name = Chef::Mixin::ConvertToClassName.convert_to_class_name(name.to_s)
+        if mod.const_defined?(class_name, false)
+          old_class = mod.const_get(class_name, false)
+          # We are only allowed to patch over things installed by patch_module
+          raise "#{mod.name}::#{class_name} is already defined" if !old_class.instance_variable_get(:@poise_patch_module)
+          # Remove it before setting to avoid the redefinition warning
+          mod.send(:remove_const, class_name)
+        end
+        # Tag our objects so we know we are allowed to overwrite those, but not other stuff.
+        obj.instance_variable_set(:@poise_patch_module, true)
+        mod.const_set(class_name, obj)
+        begin
+          block.call
+        ensure
+          # Same as above, have to remove before set because warnings
+          mod.send(:remove_const, class_name)
+          mod.const_set(class_name, old_class) if old_class
+        end
+      end
+
+      # Patch an object in to Chef's DescendantsTracker system for the duration
+      # of a code block.
+      #
+      # @param klass [Class] Class to patch in.
+      # @param block [Proc] Block to execute while the patch is available.
+      # @return [void]
+      def self.patch_descendants_tracker(klass, &block)
+        begin
+          # Re-add to tracking.
+          Chef::Mixin::DescendantsTracker.store_inherited(klass.superclass, klass)
+          block.call
+        ensure
+          # Clean up after ourselves.
+          Chef::Mixin::DescendantsTracker.direct_descendants(klass.superclass).delete(klass)
+        end
+      end
+
+      # Patch a class in to its node_map.
+      #
+      # @param name [Symbol] Name to patch in.
+      # @param klass [Class] Resource class to patch in.
+      # @param block [Proc] Block to execute while the patch is available.
+      # @return [void]
+      def self.patch_node_map(name, klass, &block)
+        begin
+          # Technically this is set to true on >=12.4, but this should work.
+          klass.node_map.set(name, klass)
+          block.call
+        ensure
+          # Sigh.
+          klass.node_map.instance_variable_get(:@map).delete(name)
+        end
+      end
+
+      # Patch a resource in to Chef's recipe DSL for the duration of a code
+      # block. This is a no-op before Chef 12.4.
+      #
+      # @param name [Symbol] Name to patch in.
+      # @param klass [Class] Resource class to patch in.
+      # @param block [Proc] Block to execute while the patch is available.
+      # @return [void]
+      def self.patch_recipe_dsl(name, klass, &block)
+        return block.call unless defined?(Chef::DSL::Resources.add_resource_dsl) && klass < Chef::Resource
+        begin
+          Chef::DSL::Resources.add_resource_dsl(name)
+          block.call
+        ensure
+          Chef::DSL::Resources.remove_resource_dsl(name)
+        end
+      end
+
+    end
+  end
+end

data/lib/halite/spec_helper/runner.rb

@@ -14,28 +14,76 @@
 # limitations under the License.
 #
 
+require 'chef/mixin/shell_out' # ಠ_ಠ Missing upstream require
 require 'chef/recipe'
+require 'chefspec/mixins/normalize' # ಠ_ಠ Missing upstream require
+require 'chefspec/solo_runner'
+
+require 'halite/error'
+require 'halite/gem'
+
 
 module Halite
   module SpecHelper
+    # ChefSpec runner class with Halite customizations. This adds attribute
+    # options, Halite synthetic cookbook injection, and block-based recipes.
+    #
+    # @since 1.0.0
     class Runner < ChefSpec::SoloRunner
-      def self.converge(&block)
-        new.tap do |instance|
-          instance.converge(&block)
+      def self.converge(*recipe_names, &block)
+        options = if recipe_names.last.is_a?(Hash)
+          # Was called with options
+          recipe_names.pop
+        else
+          {}
+        end
+        new(options).tap do |instance|
+          instance.converge(*recipe_names, &block)
+        end
+      end
+
+      def initialize(options={})
+        super(options) do |node|
+          # Allow inserting arbitrary attribute data in to the node
+          node.attributes.default = Chef::Mixin::DeepMerge.merge(node.attributes.default, options[:default_attributes]) if options[:default_attributes]
+          node.attributes.normal = Chef::Mixin::DeepMerge.merge(node.attributes.normal, options[:normal_attributes]) if options[:normal_attributes]
+          node.attributes.override = Chef::Mixin::DeepMerge.merge(node.attributes.override, options[:override_attributes]) if options[:override_attributes]
+          # Store the gemspec for later use
+          @halite_gemspec = options[:halite_gemspec]
         end
       end
 
-      def converge(&block)
-        super do
-          recipe = Chef::Recipe.new(nil, nil, run_context)
-          recipe.instance_exec(&block)
+      def converge(*recipe_names, &block)
+        raise Halite::Error.new('Cannot pass both recipe names and a recipe block to converge') if !recipe_names.empty? && block
+        super(*recipe_names) do
+          add_halite_cookbook(node, @halite_gemspec) if @halite_gemspec
+          if block
+            recipe = Chef::Recipe.new(nil, nil, run_context)
+            recipe.instance_exec(&block)
+          end
         end
       end
 
       private
 
-      # Don't try to autodetect
-      def calling_cookbook_path(kaller)
+      def add_halite_cookbook(node, gemspec)
+        gem_data = Halite::Gem.new(gemspec)
+        # Catch any dependency loops.
+        return if run_context.cookbook_collection.include?(gem_data.cookbook_name)
+        run_context.cookbook_collection[gem_data.cookbook_name] = gem_data.as_cookbook_version
+        gem_data.cookbook_dependencies.each do |dep|
+          add_halite_cookbook(node, dep.spec) if dep.spec
+        end
+        # Load attributes if any.
+        gem_data.each_file('chef/attributes') do |_full_path, rel_path|
+          raise Halite::Error.new("Chef does not support nested attribute files: #{rel_path}") if rel_path.include?(File::SEPARATOR)
+          name = File.basename(rel_path, '.rb')
+          node.include_attribute("#{gem_data.cookbook_name}::#{name}")
+        end
+      end
+
+      # Don't try to autodetect the calling cookbook.
+      def calling_cookbook_path(_kaller)
         File.expand_path('../empty', __FILE__)
       end
     end

data/lib/halite/version.rb

@@ -1,3 +1,21 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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.
+#
+
+
 module Halite
-  VERSION = '1.0.0.rc.1'
+  # Halite version.
+  VERSION = '1.0.0'
 end

data/spec/converter/chef_spec.rb

@@ -0,0 +1,54 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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'
+
+describe Halite::Converter::Chef do
+  describe '#write' do
+    let(:files) { [] }
+    let(:gem_data) do
+      instance_double('Halite::Gem').tap do |d|
+        allow(d).to receive(:each_file) do |&block|
+          files.each {|path| block.call(File.join('/source', path), path) }
+        end
+      end
+    end
+    subject { described_class.write(gem_data, '/test') }
+
+    context 'with a single file' do
+      let(:files) { ['recipes/default.rb'] }
+
+      it do
+        expect(FileUtils).to receive(:mkdir_p).with('/test/recipes')
+        expect(FileUtils).to receive(:copy).with('/source/recipes/default.rb', '/test/recipes/default.rb', preserve: true)
+        subject
+      end
+    end # /context with a single file
+
+    context 'with multiple files' do
+      let(:files) { ['attributes.rb', 'recipes/default.rb', 'templates/default/conf.erb'] }
+
+      it do
+        expect(FileUtils).to receive(:mkdir_p).with('/test/recipes')
+        expect(FileUtils).to receive(:mkdir_p).with('/test/templates/default')
+        expect(FileUtils).to receive(:copy).with('/source/attributes.rb', '/test/attributes.rb', preserve: true)
+        expect(FileUtils).to receive(:copy).with('/source/recipes/default.rb', '/test/recipes/default.rb', preserve: true)
+        expect(FileUtils).to receive(:copy).with('/source/templates/default/conf.erb', '/test/templates/default/conf.erb', preserve: true)
+        subject
+      end
+    end # /context with multiple files
+  end # /describe #write
+end

data/spec/converter/libraries_spec.rb

@@ -1,152 +1,160 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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 'halite/converter/libraries'
 
 describe Halite::Converter::Libraries do
+  describe '#generate_bootstrap' do
+    let(:gem_data) { instance_double('Halite::Gem', license_header: '') }
+    let(:entry_points) { [] }
+    subject { described_class.generate_bootstrap(gem_data, entry_points) }
 
-  describe '#generate' do
-    let(:data) { '' }
-    let(:entry_point) { false }
-    let(:cookbook_dependencies) { [] }
-    subject { described_class.generate(double(name: 'mygem', cookbook_dependencies: cookbook_dependencies.map {|dep| Halite::Dependencies::Dependency.new(dep, nil, :dependencies) }), data, entry_point) }
-
-    context 'with a single require' do
-      let(:data) { "x = 1\nrequire 'mygem/version'\n" }
+    context 'with defaults' do
       it { is_expected.to eq <<-EOH }
-if ENV['HALITE_LOAD']; x = 1
-require_relative 'mygem__version'
-end
+raise 'Halite is not compatible with no_lazy_load false, please set no_lazy_load true in your Chef configuration file.' unless Chef::Config[:no_lazy_load]
+$LOAD_PATH << File.expand_path('../../files/halite_gem', __FILE__)
 EOH
-    end # /context with a single require
+    end # /context with defaults
 
-    context 'with two requires' do
-      let(:data) { "require 'mygem/foo/bar'\nrequire 'another'" }
+    context 'with a license header' do
+      before do
+        allow(gem_data).to receive(:license_header).and_return("# Copyright me.\n")
+      end
       it { is_expected.to eq <<-EOH }
-if ENV['HALITE_LOAD']; require_relative 'mygem__foo__bar'
-require 'another'
-end
+# Copyright me.
+raise 'Halite is not compatible with no_lazy_load false, please set no_lazy_load true in your Chef configuration file.' unless Chef::Config[:no_lazy_load]
+$LOAD_PATH << File.expand_path('../../files/halite_gem', __FILE__)
 EOH
-    end # /context with two requires
+    end
 
-    context 'with an entry point' do
-      let(:data) { "x = 1\nrequire 'mygem/version'\n" }
-      let(:entry_point) { true }
-      it { is_expected.to eq <<-EOH }
-ENV['HALITE_LOAD'] = '1'; begin; x = 1
-require_relative 'mygem__version'
-ensure; ENV.delete('HALITE_LOAD'); end
-EOH
-    end # /context with an entry point
-
-    context 'with a big script' do
-      let(:data) { <<-EOH }
-require 'mygem/something'
-require 'mygem/utils'
-require 'activesupport' # ಠ_ಠ
-class Resource
-  attribute :source
-end
-EOH
-      it { is_expected.to eq <<-EOH }
-if ENV['HALITE_LOAD']; require_relative 'mygem__something'
-require_relative 'mygem__utils'
-require 'activesupport' # ಠ_ಠ
-class Resource
-  attribute :source
-end
-end
-EOH
-    end # /context with a big script
-
-    context 'with external dependencies' do
-      let(:cookbook_dependencies) { ['other'] }
-      let(:data) { <<-EOH }
-require 'mygem/something'
-require 'mygem/utils'
-require "mygem"
-require 'other'
-class Resource
-  attribute :source
-end
-EOH
+    context 'with entry points' do
+      let(:entry_points) { %w{mygem/one mygem/two} }
       it { is_expected.to eq <<-EOH }
-if ENV['HALITE_LOAD']; require_relative 'mygem__something'
-require_relative 'mygem__utils'
-require_relative 'mygem'
-require_relative '../../other/libraries/other'
-class Resource
-  attribute :source
-end
-end
+raise 'Halite is not compatible with no_lazy_load false, please set no_lazy_load true in your Chef configuration file.' unless Chef::Config[:no_lazy_load]
+$LOAD_PATH << File.expand_path('../../files/halite_gem', __FILE__)
+require "mygem/one"
+require "mygem/two"
 EOH
-    end # /context with a big script
-  end # /describe #generate
+    end # /context with entry points
+  end # /describe #generate_bootstrap
 
-  describe '#write' do
+  describe '#write_libraries' do
     let(:library_files) { [] }
-    let(:output) { [] }
-    let(:spec) do
-      spec = double(name: 'mygem')
-      allow(spec).to receive(:each_library_file) do |&block|
-        library_files.each {|path| block.call(File.join('/source', path), path) }
-      end
-      spec
-    end
-    before do
-      first = true
-      library_files.each do |path|
-        input_sentinel = double("content of #{path}")
-        output_sentinel = double("generated output for #{path}")
-        allow(IO).to receive(:read).with(File.join('/source', path)).and_return(input_sentinel)
-        allow(described_class).to receive(:generate).with(spec, input_sentinel, first).and_return(output_sentinel)
-        first = false
-        output << output_sentinel
+    let(:gem_data) do
+      instance_double('Halite::Gem').tap do |d|
+        allow(d).to receive(:each_library_file) do |&block|
+          library_files.each {|path| block.call(File.join('/source', path), path) }
+        end
       end
-      allow(File).to receive(:directory?).and_return(false) # Always blank
     end
+    subject { described_class.write_libraries(gem_data, '/test') }
 
     context 'with a single file' do
-      let(:library_files) { ['mygem.rb'] }
-
-      it 'writes a single file' do
-        expect(Dir).to receive(:mkdir).with('/test/libraries')
-        expect(IO).to receive(:write).with('/test/libraries/mygem.rb', output[0])
-        described_class.write(spec, '/test')
+      let(:library_files) { %w{mygem.rb} }
+      it do
+        expect(FileUtils).to receive(:mkdir_p).with('/test/files/halite_gem')
+        expect(FileUtils).to receive(:copy).with('/source/mygem.rb', '/test/files/halite_gem/mygem.rb', preserve: true)
+        subject
       end
     end # /context with a single file
 
-    context 'with multiple files' do
-      let(:library_files) { ['mygem.rb', 'mygem/one.rb', 'mygem/two.rb'] }
-
-      it 'writes multiple files' do
-        expect(Dir).to receive(:mkdir).with('/test/libraries')
-        expect(IO).to receive(:write).with('/test/libraries/mygem.rb', output[0])
-        expect(IO).to receive(:write).with('/test/libraries/mygem__one.rb', output[1])
-        expect(IO).to receive(:write).with('/test/libraries/mygem__two.rb', output[2])
-        described_class.write(spec, '/test')
+    context 'with a multiple files' do
+      let(:library_files) { %w{mygem.rb mygem/one.rb mygem/two.rb} }
+      it do
+        expect(FileUtils).to receive(:mkdir_p).with('/test/files/halite_gem')
+        expect(FileUtils).to receive(:mkdir_p).with('/test/files/halite_gem/mygem').twice
+        expect(FileUtils).to receive(:copy).with('/source/mygem.rb', '/test/files/halite_gem/mygem.rb', preserve: true)
+        expect(FileUtils).to receive(:copy).with('/source/mygem/one.rb', '/test/files/halite_gem/mygem/one.rb', preserve: true)
+        expect(FileUtils).to receive(:copy).with('/source/mygem/two.rb', '/test/files/halite_gem/mygem/two.rb', preserve: true)
+        subject
       end
-    end # /context with multiple files
-
-    context 'with an explicit entry point name' do
-      let(:library_files) { ['mygem.rb', 'other.rb'] }
+    end # /context with a multiple files
+  end # /describe #write_libraries
 
-      it 'selects the correct entry point' do
-        expect(Dir).to receive(:mkdir).with('/test/libraries')
-        expect(IO).to receive(:write).with('/test/libraries/mygem.rb', output[0])
-        expect(IO).to receive(:write).with('/test/libraries/other.rb', output[1])
-        described_class.write(spec, '/test', 'mygem')
+  describe '#find_default_entry_points' do
+    let(:library_files) { [] }
+    let(:gem_data) do
+      instance_double('Halite::Gem').tap do |d|
+        allow(d).to receive(:each_library_file) do |&block|
+          library_files.each {|path| block.call(File.join('/source', path), path) }
+        end
       end
-    end # /context with an explicit entry point name
-
-    context 'with an explicit entry point name ending in .rb' do
-      let(:library_files) { ['mygem.rb', 'other.rb'] }
-
-      it 'selects the correct entry point' do
-        expect(Dir).to receive(:mkdir).with('/test/libraries')
-        expect(IO).to receive(:write).with('/test/libraries/mygem.rb', output[0])
-        expect(IO).to receive(:write).with('/test/libraries/other.rb', output[1])
-        described_class.write(spec, '/test', 'mygem.rb')
+    end
+    subject { described_class.find_default_entry_points(gem_data) }
+
+    context 'with no default entry points' do
+      let(:library_files) { %w{mygem.rb} }
+      it { is_expected.to eq [] }
+    end # /context with no default entry points
+
+    context 'with a single entry point' do
+      let(:library_files) { %w{mygem.rb mygem/cheftie.rb} }
+      it { is_expected.to eq ['mygem/cheftie'] }
+    end # /context with a single entry point
+
+    context 'with multiple entry points' do
+      let(:library_files) { %w{mygem.rb mygem/cheftie.rb mygem/other.rb mygem/other/cheftie.rb} }
+      it { is_expected.to eq ['mygem/cheftie', 'mygem/other/cheftie'] }
+    end # /context with multiple entry points
+  end # /describe #find_default_entry_points
+
+  describe '#write_bootstrap' do
+    let(:entry_point) { nil }
+    let(:spec) { instance_double('Gem::Specification', metadata: {})}
+    let(:gem_data) { instance_double('Halite::Gem', spec: spec) }
+    let(:output) { double('output sentinel') }
+    subject { described_class.write_bootstrap(gem_data, '/test', entry_point) }
+
+    context 'with defaults' do
+      it do
+        expect(described_class).to receive(:find_default_entry_points).with(gem_data).and_return([])
+        expect(FileUtils).to receive(:mkdir_p).with('/test/libraries')
+        expect(described_class).to receive(:generate_bootstrap).with(gem_data, []).and_return(output)
+        expect(IO).to receive(:write).with('/test/libraries/default.rb', output)
+        subject
       end
-    end # /context with an explicit entry point name
+    end # /context with defaults
+
+    context 'with an explicit entry point' do
+      let(:entry_point) { 'mygem/one' }
+      it do
+        expect(FileUtils).to receive(:mkdir_p).with('/test/libraries')
+        expect(described_class).to receive(:generate_bootstrap).with(gem_data, ['mygem/one']).and_return(output)
+        expect(IO).to receive(:write).with('/test/libraries/default.rb', output)
+        subject
+      end
+    end # /context with an explicit entry point
+
+    context 'with metadata entry points' do
+      it do
+        allow(spec).to receive(:metadata).and_return({'halite_entry_point' => 'mygem/one mygem/two'})
+        expect(FileUtils).to receive(:mkdir_p).with('/test/libraries')
+        expect(described_class).to receive(:generate_bootstrap).with(gem_data, ['mygem/one', 'mygem/two']).and_return(output)
+        expect(IO).to receive(:write).with('/test/libraries/default.rb', output)
+        subject
+      end
+    end # /context with metadata entry points
+  end # /describe #write_bootstrap
 
+  describe '#write' do
+    it do
+      expect(described_class).to receive(:write_libraries)
+      expect(described_class).to receive(:write_bootstrap)
+      described_class.write(nil, nil)
+    end
   end # /describe #write
 end