halite 1.0.0.rc.1

data/lib/halite/rake_tasks.rb

@@ -0,0 +1,2 @@
+require 'halite/rake_helper'
+::Halite::RakeHelper.install_tasks

data/lib/halite/spec_helper.rb

@@ -0,0 +1,134 @@
+#
+# 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 'halite/spec_helper/runner'
+
+module Halite
+  module SpecHelper
+    extend RSpec::SharedContext
+    let(:step_into) { [] }
+
+    # An alias for slightly more semantic meaning, just forces the lazy #subject to run.
+    def run_chef
+      subject
+    end
+
+    private
+
+    def 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_spec_helper)
+        # Remove it before setting to avoid the redefinition warning
+        mod.send(:remove_const, class_name)
+      end
+      # Tag our objects so we know we are allows to overwrite those, but not other stuff.
+      obj.instance_variable_set(:@poise_spec_helper, 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
+
+    module ClassMethods
+      def recipe(&block)
+        # Keep the actual logic in a let in case I want to define the subject as something else
+        let(:chef_run) { Halite::SpecHelper::Runner.new(step_into: step_into).converge(&block) }
+        subject { chef_run }
+      end
+
+      # A note about the :parent option below: You can't use resources that
+      # are defined via these helpers because they don't have a global const
+      # name until the actual tests are executing.
+
+      def resource(name, options={}, &block)
+        options = {auto: true, parent: Chef::Resource}.merge(options)
+        # Create the resource class
+        resource_class = Class.new(options[:parent]) do
+          class_exec(&block) if block
+          # Wrap some stuff around initialize because I'm lazy
+          if options[:auto]
+            old_init = instance_method(:initialize)
+            define_method(:initialize) do |*args|
+              # Fill in the resource name because I know it
+              @resource_name = name.to_sym
+              old_init.bind(self).call(*args)
+              # ChefSpec doesn't seem to work well with action :nothing
+              if @action == :nothing
+                @action = :run
+                @allowed_actions |= [:run]
+              end
+            end
+          end
+        end
+
+        # Figure out the available actions
+        resource_class.new(nil, nil).allowed_actions.each do |action|
+          define_method("#{action}_#{name}") do |resource_name|
+            ChefSpec::Matchers::ResourceMatcher.new(name, action, resource_name)
+          end
+        end
+
+        around do |ex|
+          # Automatically step in to our new resource
+          step_into << name
+          # Patch the resource in to Chef
+          patch_module(Chef::Resource, name, resource_class) { ex.run }
+        end
+      end
+
+      def provider(name, options={}, &block)
+        options = {auto: true, rspec: true, parent: Chef::Provider}.merge(options)
+        provider_class = Class.new(options[:parent]) do
+          # Pull in RSpec expectations
+          if options[:rspec]
+            include RSpec::Matchers
+            include RSpec::Mocks::ExampleMethods
+          end
+
+          if options[:auto]
+            # Default blank impl to avoid error
+            def load_current_resource
+            end
+
+            # Blank action because I do that so much
+            def action_run
+            end
+          end
+
+          class_exec(&block) if block
+        end
+
+        around do |ex|
+          patch_module(Chef::Provider, name, provider_class) { ex.run }
+        end
+      end
+
+      def included(klass)
+        super
+        klass.extend ClassMethods
+      end
+    end
+
+    extend ClassMethods
+  end
+end

data/lib/halite/spec_helper/empty/README.md

@@ -0,0 +1 @@
+This folder is intentionally empty except for this README. It is used by Halite::SpecHelper::Runner.

data/lib/halite/spec_helper/runner.rb

@@ -0,0 +1,43 @@
+#
+# 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/recipe'
+
+module Halite
+  module SpecHelper
+    class Runner < ChefSpec::SoloRunner
+      def self.converge(&block)
+        new.tap do |instance|
+          instance.converge(&block)
+        end
+      end
+
+      def converge(&block)
+        super do
+          recipe = Chef::Recipe.new(nil, nil, run_context)
+          recipe.instance_exec(&block)
+        end
+      end
+
+      private
+
+      # Don't try to autodetect
+      def calling_cookbook_path(kaller)
+        File.expand_path('../empty', __FILE__)
+      end
+    end
+  end
+end

data/lib/halite/version.rb

@@ -0,0 +1,3 @@
+module Halite
+  VERSION = '1.0.0.rc.1'
+end

data/spec/converter/libraries_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'halite/converter/libraries'
+
+describe Halite::Converter::Libraries do
+
+  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" }
+      it { is_expected.to eq <<-EOH }
+if ENV['HALITE_LOAD']; x = 1
+require_relative 'mygem__version'
+end
+EOH
+    end # /context with a single require
+
+    context 'with two requires' do
+      let(:data) { "require 'mygem/foo/bar'\nrequire 'another'" }
+      it { is_expected.to eq <<-EOH }
+if ENV['HALITE_LOAD']; require_relative 'mygem__foo__bar'
+require 'another'
+end
+EOH
+    end # /context with two requires
+
+    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
+      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
+EOH
+    end # /context with a big script
+  end # /describe #generate
+
+  describe '#write' 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
+      end
+      allow(File).to receive(:directory?).and_return(false) # Always blank
+    end
+
+    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')
+      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')
+      end
+    end # /context with multiple files
+
+    context 'with an explicit entry point name' 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')
+      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
+    end # /context with an explicit entry point name
+
+  end # /describe #write
+end

data/spec/converter/metadata_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'halite/converter/metadata'
+require 'halite/dependencies'
+
+describe Halite::Converter::Metadata do
+  describe '#generate' do
+    let(:gem_name) { 'mygem' }
+    let(:cookbook_name) { gem_name }
+    let(:version) { '1.0.0' }
+    let(:license_header) { '' }
+    let(:cookbook_dependencies) { [] }
+    let(:spec) { double(name: gem_name, cookbook_name: cookbook_name, version: version, license_header: license_header, cookbook_dependencies: cookbook_dependencies.map {|dep| Halite::Dependencies::Dependency.new(*dep) }) }
+    subject { described_class.generate(spec) }
+
+    context 'with simple data' do
+      it { is_expected.to eq <<-EOH }
+name "mygem"
+version "1.0.0"
+EOH
+    end # /context with simple data
+
+    context 'with a license header' do
+      let(:license_header) { "# header\n" }
+      it { is_expected.to eq <<-EOH }
+# header
+name "mygem"
+version "1.0.0"
+EOH
+    end # /context with a license header
+
+    context 'with one dependency' do
+      let(:cookbook_dependencies) { [['other', '>= 0']] }
+      it { is_expected.to eq <<-EOH }
+name "mygem"
+version "1.0.0"
+depends "other", ">= 0"
+EOH
+    end # /context with one dependency
+
+    context 'with two dependencies' do
+      let(:cookbook_dependencies) { [['other', '~> 1.0'], ['another', '~> 2.0.0']] }
+      it { is_expected.to eq <<-EOH }
+name "mygem"
+version "1.0.0"
+depends "other", "~> 1.0"
+depends "another", "~> 2.0.0"
+EOH
+    end # /context with two dependencies
+  end # /describe #generate
+
+  describe '#write' do
+    let(:output) { double('output') } # sentinel
+    before { allow(described_class).to receive(:generate).and_return(output) }
+
+    it 'should write out metadata' do
+      expect(IO).to receive(:write).with('/test/metadata.rb', output)
+      described_class.write(nil, '/test')
+    end
+  end # /describe #write
+end

data/spec/converter/other_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'halite/converter/other'
+
+describe Halite::Converter::Other do
+
+  describe '#write' do
+    let(:files) { [] }
+    let(:input) { [] }
+    let(:output) { [] }
+    let(:spec) do
+      spec = double(name: 'mygem')
+      allow(spec).to receive(:each_file) do |&block|
+        files.each {|path| block.call(File.join('/source', path), path) }
+      end
+      spec
+    end
+    before do
+      files.each do |path|
+        input_sentinel = double("content of #{path}")
+        output_sentinel = double("generated output for #{path}")
+        allow(File).to receive(:open).with(File.join('/source', path), 'rb').and_yield(input_sentinel)
+        input << input_sentinel
+        output << output_sentinel
+      end
+    end
+
+    context 'with a single file' do
+      let(:files) { ['recipes/default.rb'] }
+
+      it 'writes a single file' do
+        expect(FileUtils).to receive(:mkdir_p).with('/test/recipes')
+        expect(File).to receive(:open).with('/test/recipes/default.rb', 'wb').and_yield(output[0])
+        expect(IO).to receive(:copy_stream).with(input[0], output[0])
+        described_class.write(spec, '/test')
+      end
+    end # /context with a single file
+
+    context 'with multiple files' do
+      let(:files) { ['attributes.rb', 'recipes/default.rb', 'templates/default/conf.erb'] }
+
+      it 'writes multiple files' do
+        expect(FileUtils).to receive(:mkdir_p).with('/test/recipes')
+        expect(FileUtils).to receive(:mkdir_p).with('/test/templates/default')
+        expect(File).to receive(:open).with('/test/attributes.rb', 'wb').and_yield(output[0])
+        expect(IO).to receive(:copy_stream).with(input[0], output[0])
+        expect(File).to receive(:open).with('/test/recipes/default.rb', 'wb').and_yield(output[1])
+        expect(IO).to receive(:copy_stream).with(input[1], output[1])
+        expect(File).to receive(:open).with('/test/templates/default/conf.erb', 'wb').and_yield(output[2])
+        expect(IO).to receive(:copy_stream).with(input[2], output[2])
+        described_class.write(spec, '/test')
+      end
+    end # /context with a single file
+
+  end # /describe #write
+
+end