omnibus 5.4.0 → 5.5.0

data/spec/unit/builder_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Omnibus
   describe Builder do
     let(:software) do
       double(Software,
-        name: 'chefdk',
+        name: "chefdk",
         install_dir: project_dir,
-        project_dir: project_dir,
+        project_dir: project_dir
       )
     end
 
-    let(:project_dir) { on_windows ? 'C:/opscode/chefdk' : '/opt/chefdk' }
+    let(:project_dir) { on_windows ? "C:/opscode/chefdk" : "/opt/chefdk" }
     let(:on_windows) { false }
     let(:msys_bash) { "C:\\opscode\\chefdk\\embedded\\msys\\1.0\\bin\\bash.exe" }
 
@@ -29,115 +29,115 @@ module Omnibus
     end
 
     describe '#command' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:command)
       end
     end
 
     describe '#workers' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:workers)
       end
     end
 
     describe '#ruby' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:ruby)
       end
     end
 
     describe '#gem' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:gem)
       end
     end
 
     describe '#bundle' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:bundle)
       end
     end
 
     describe '#appbundle' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:appbundle)
       end
     end
 
     describe '#block' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:block)
       end
     end
 
     describe '#erb' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:erb)
       end
     end
 
     describe '#mkdir' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:mkdir)
       end
     end
 
     describe '#touch' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:touch)
       end
     end
 
     describe '#delete' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:delete)
       end
     end
 
     describe '#copy' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:copy)
       end
     end
 
     describe '#move' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:move)
       end
     end
 
     describe '#link' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:link)
       end
     end
 
     describe '#sync' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:sync)
       end
     end
 
     describe '#update_config_guess' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:update_config_guess)
       end
     end
 
     describe '#windows_safe_path' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:windows_safe_path)
       end
     end
 
     describe '#project_dir' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:project_dir)
       end
     end
 
     describe '#install_dir' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:install_dir)
       end
     end
@@ -147,60 +147,60 @@ module Omnibus
         allow(subject).to receive(:command)
       end
 
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:make)
       end
 
-      context 'when :bin is present' do
-        it 'uses the custom bin' do
+      context "when :bin is present" do
+        it "uses the custom bin" do
           expect(subject).to receive(:command)
-            .with('/path/to/make', in_msys_bash: true)
-          subject.make(bin: '/path/to/make')
+            .with("/path/to/make", in_msys_bash: true)
+          subject.make(bin: "/path/to/make")
         end
       end
 
-      context 'when gmake is present' do
+      context "when gmake is present" do
         before do
           allow(Omnibus).to receive(:which)
-            .with('gmake')
-            .and_return('/bin/gmake')
+            .with("gmake")
+            .and_return("/bin/gmake")
         end
 
-        it 'uses gmake and sets MAKE=gmake' do
+        it "uses gmake and sets MAKE=gmake" do
           expect(subject).to receive(:command)
-            .with('gmake', env: { 'MAKE' => 'gmake' }, in_msys_bash: true)
+            .with("gmake", env: { "MAKE" => "gmake" }, in_msys_bash: true)
           subject.make
         end
       end
 
-      context 'when gmake is not present' do
+      context "when gmake is not present" do
         before do
           allow(Omnibus).to receive(:which)
             .and_return(nil)
         end
 
-        it 'uses make' do
+        it "uses make" do
           expect(subject).to receive(:command)
-            .with('make', in_msys_bash: true)
+            .with("make", in_msys_bash: true)
           subject.make
         end
       end
 
-      it 'accepts 0 options' do
+      it "accepts 0 options" do
         expect(subject).to receive(:command)
-          .with('make', in_msys_bash: true)
+          .with("make", in_msys_bash: true)
         expect { subject.make }.to_not raise_error
       end
 
-      it 'accepts an additional command string' do
+      it "accepts an additional command string" do
         expect(subject).to receive(:command)
-          .with('make install', in_msys_bash: true)
-        expect { subject.make('install') }.to_not raise_error
+          .with("make install", in_msys_bash: true)
+        expect { subject.make("install") }.to_not raise_error
       end
 
-      it 'persists given options' do
+      it "persists given options" do
         expect(subject).to receive(:command)
-          .with('make', timeout: 3600, in_msys_bash: true)
+          .with("make", timeout: 3600, in_msys_bash: true)
         subject.make(timeout: 3600)
       end
     end
@@ -210,11 +210,11 @@ module Omnibus
         allow(subject).to receive(:command)
       end
 
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:configure)
       end
 
-      context 'on 64-bit windows' do
+      context "on 64-bit windows" do
         let(:on_windows) { true }
         let(:windows_i386) { false }
 
@@ -223,48 +223,64 @@ module Omnibus
             .and_return(windows_i386)
         end
 
-        it 'invokes appends platform host to the options' do
+        it "appends platform host to the options" do
           expect(subject).to receive(:command)
-            .with("./configure --host=x86_64-w64-mingw32 --prefix=#{project_dir}/embedded", in_msys_bash: true)
+            .with("./configure --build=x86_64-w64-mingw32 --prefix=#{project_dir}/embedded", in_msys_bash: true)
           subject.configure()
         end
       end
 
-      context 'when :bin is present' do
-        it 'uses the custom bin' do
+      context "on 32-bit windows" do
+        let(:on_windows) { true }
+        let(:windows_i386) { true }
+
+        before do
+          allow(subject).to receive(:windows_arch_i386?)
+            .and_return(windows_i386)
+        end
+
+        it "appends platform host to the options" do
+          expect(subject).to receive(:command)
+            .with("./configure --build=i686-w64-mingw32 --prefix=#{project_dir}/embedded", in_msys_bash: true)
+          subject.configure()
+        end
+      end
+
+      context "when :bin is present" do
+        it "uses the custom bin" do
           expect(subject).to receive(:command)
             .with("/path/to/configure --prefix=#{project_dir}/embedded", in_msys_bash: true)
-          subject.configure(bin: '/path/to/configure')
+          subject.configure(bin: "/path/to/configure")
         end
       end
 
-      context 'when :prefix is present' do
-        it 'emits non-empty prefix' do
+      context "when :prefix is present" do
+        it "emits non-empty prefix" do
           expect(subject).to receive(:command)
             .with("./configure --prefix=/some/prefix", in_msys_bash: true)
-          subject.configure(prefix: '/some/prefix')
+          subject.configure(prefix: "/some/prefix")
         end
 
-        it 'omits prefix if empty' do
+        it "omits prefix if empty" do
           expect(subject).to receive(:command)
             .with("./configure", in_msys_bash: true)
-          subject.configure(prefix: '')
+          subject.configure(prefix: "")
         end
       end
 
-      it 'accepts 0 options' do
+      it "accepts 0 options" do
         expect(subject).to receive(:command)
           .with("./configure --prefix=#{project_dir}/embedded", in_msys_bash: true)
         expect { subject.configure }.to_not raise_error
       end
 
-      it 'accepts an additional command string' do
+      it "accepts an additional command string" do
         expect(subject).to receive(:command)
           .with("./configure --prefix=#{project_dir}/embedded --myopt", in_msys_bash: true)
-        expect { subject.configure('--myopt') }.to_not raise_error
+        expect { subject.configure("--myopt") }.to_not raise_error
       end
 
-      it 'persists given options' do
+      it "persists given options" do
         expect(subject).to receive(:command)
           .with("./configure --prefix=#{project_dir}/embedded", timeout: 3600, in_msys_bash: true)
         subject.configure(timeout: 3600)
@@ -274,39 +290,39 @@ module Omnibus
     describe '#patch' do
       before do
         allow(subject).to receive(:find_file)
-          .with('config/patches', 'good_patch')
+          .with("config/patches", "good_patch")
           .and_return(
             [ ["#{project_dir}/patch_location1/good_patch", "#{project_dir}/patch_location2/good_patch"],
               "#{project_dir}/patch_location2/good_patch" ])
       end
 
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:patch)
       end
 
-      it 'invokes patch with patch level 1 unless specified' do
-        expect { subject.patch(source: 'good_patch') }.to_not raise_error
+      it "invokes patch with patch level 1 unless specified" do
+        expect { subject.patch(source: "good_patch") }.to_not raise_error
         expect(subject).to receive(:shellout!)
           .with("patch -p1 -i #{project_dir}/patch_location2/good_patch", in_msys_bash: true)
         run_build_command
       end
 
-      it 'invokes patch with patch level provided' do
-        expect { subject.patch(source: 'good_patch', plevel: 0) }.to_not raise_error
+      it "invokes patch with patch level provided" do
+        expect { subject.patch(source: "good_patch", plevel: 0) }.to_not raise_error
         expect(subject).to receive(:shellout!)
           .with("patch -p0 -i #{project_dir}/patch_location2/good_patch", in_msys_bash: true)
         run_build_command
       end
 
-      it 'invokes patch differently if target is provided' do
-        expect { subject.patch(source: 'good_patch', target: 'target/path') }.to_not raise_error
+      it "invokes patch differently if target is provided" do
+        expect { subject.patch(source: "good_patch", target: "target/path") }.to_not raise_error
         expect(subject).to receive(:shellout!)
           .with("cat #{project_dir}/patch_location2/good_patch | patch -p1 target/path", in_msys_bash: true)
         run_build_command
       end
 
-      it 'persists other options' do
-        expect { subject.patch(source: 'good_patch', timeout:3600) }.to_not raise_error
+      it "persists other options" do
+        expect { subject.patch(source: "good_patch", timeout: 3600) }.to_not raise_error
         expect(subject).to receive(:shellout!)
           .with("patch -p1 -i #{project_dir}/patch_location2/good_patch", timeout: 3600, in_msys_bash: true)
         run_build_command
@@ -327,7 +343,7 @@ module Omnibus
 
       let(:software) do
         double(Software,
-               name: 'chefdk',
+               name: "chefdk",
                install_dir: tmp_dir,
                project_dir: tmp_dir,
                overridden?: false)

data/spec/unit/changelog_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Omnibus
   describe ChangeLog do
@@ -18,7 +18,7 @@ module Omnibus
         repo = double(GitRepository, :commit_messages => ["ChangeLog-Entry: foobar\n",
                                                           "ChangeLog-Entry: wombat\n"])
         changelog = ChangeLog.new("0.0.1", "0.0.2", repo)
-        expect(changelog.changelog_entries).to eq(["foobar\n", "wombat\n"])
+        expect(changelog.changelog_entries).to eq(%W{foobar\n wombat\n})
       end
 
       it "returns an empty array if there were no changelog entries" do
@@ -28,13 +28,13 @@ module Omnibus
       end
 
       it "does not return git messages without a ChangeLog: tag" do
-        repo = double(GitRepository, :commit_messages => ["foobar\n", "wombat\n"])
+        repo = double(GitRepository, :commit_messages => %W{foobar\n wombat\n})
         changelog = ChangeLog.new("0.0.1", "0.0.2", repo)
         expect(changelog.changelog_entries).to eq([])
       end
 
       it "does not return blank lines" do
-        repo = double(GitRepository, :commit_messages => ["\n", "\n"])
+        repo = double(GitRepository, :commit_messages => %W{\n \n})
         changelog = ChangeLog.new("0.0.1", "0.0.2", repo)
         expect(changelog.changelog_entries).to eq([])
       end

data/spec/unit/changelogprinter_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+require "omnibus/changelog_printer"
+require "omnibus/manifest_diff"
+
+module Omnibus
+  describe ChangeLogPrinter do
+    describe "#print" do
+      def manifest_entry_for(name, dv, lv, source_type = :local)
+        Omnibus::ManifestEntry.new(name, { :described_version => dv,
+                                           :locked_version => lv,
+                                           :locked_source => {
+                                             :git => "git://#{name}@example.com" },
+                                           :source_type => source_type,
+        })
+      end
+
+      let(:changelog) { double(ChangeLog,
+                               changelog_entries: %w{entry1 entry2},
+                               authors: %w{alice bob}) }
+      let(:git_changelog) { double(ChangeLog,
+                                   changelog_entries:
+                                   %w{sub-entry1 sub-entry2}) }
+      let(:now) { double(Time) }
+      let(:emptydiff) { EmptyManifestDiff.new }
+      let(:old_manifest) {
+        m = Manifest.new()
+        m.add("updated-comp", manifest_entry_for("updated-comp", "v9", "v9"))
+        m.add("updated-comp-2", manifest_entry_for("updated-comp-2", "someref0", "someref0", :git))
+        m.add("removed-comp", manifest_entry_for("removed-comp", "v9", "v9"))
+        m.add("removed-comp-2", manifest_entry_for("removed-comp-2", "v10", "v10"))
+        m
+      }
+      let(:new_manifest) {
+        m = Manifest.new()
+        m.add("updated-comp", manifest_entry_for("updated-comp", "v10", "v10"))
+        m.add("updated-comp-2", manifest_entry_for("updated-comp-2", "someotherref", "someotherref", :git))
+        m.add("added-comp", manifest_entry_for("added-comp", "v100", "v100"))
+        m.add("added-comp-2", manifest_entry_for("added-comp-2", "v101", "v101"))
+        m
+      }
+      let(:diff) { ManifestDiff.new(old_manifest, new_manifest) }
+
+      it "starts with a changelog version header including the time" do
+        expect(Time).to receive(:now).and_return(now)
+        expect(now).to receive(:strftime).with("%Y-%m-%d")
+          .and_return("1970-01-01")
+
+        expect { ChangeLogPrinter.new(changelog, diff).print("v1.0.1") }
+          .to output(/## v1\.0\.1 \(1970-01-01\)/).to_stdout
+      end
+
+      it "outputs the list of changelog entries" do
+        [ /entry1/, /entry2/ ].each do |re|
+          expect { ChangeLogPrinter.new(changelog, diff).print("v1") }
+            .to output(re).to_stdout
+        end
+      end
+
+      it "outputs the component sections when there are changes" do
+        expect { ChangeLogPrinter.new(changelog, diff).print("v1") }
+          .to output(/### Components/).to_stdout
+      end
+
+      it "does not output a component sections when there are no changes" do
+        expect { ChangeLogPrinter.new(changelog, emptydiff).print("v1") }
+          .not_to output(/### Components/).to_stdout
+      end
+
+      it "outputs the list of new components" do
+        [
+          /New Components/,
+          /added-comp \(v100\)/,
+          /added-comp-2 \(v101\)/,
+        ].each do |re|
+          expect { ChangeLogPrinter.new(changelog, diff).print("v1") }
+            .to output(re).to_stdout
+        end
+      end
+
+      it "outputs the list of updated components" do
+        source_path = "path/to/source/"
+        allow(File).to receive(:directory?).with("#{source_path}updated-comp-2/.git")
+          .and_return(false)
+
+        [ /Updated Components/,
+          /updated-comp \(v9 -> v10\)/,
+          /updated-comp-2 \(someref0 -> someothe\)/,
+        ].each do |re|
+          expect { ChangeLogPrinter.new(changelog, diff, source_path).print("v1") }
+            .to output(re).to_stdout
+        end
+      end
+
+      it "uses git commit log for components in git repositories" do
+        git_repo = double(GitRepository)
+        source_path = "path/to/source/"
+        allow(File).to receive(:directory?).with("#{source_path}updated-comp-2/.git")
+          .and_return(true)
+        allow(GitRepository).to receive(:new).with("#{source_path}updated-comp-2")
+          .and_return(git_repo)
+        allow(ChangeLog).to receive(:new).with("someref0", "someotherref", git_repo)
+          .and_return(git_changelog)
+
+        [ /  \* sub-entry1/,
+          /  \* sub-entry2/,
+        ].each do |re|
+          expect { ChangeLogPrinter.new(changelog, diff, source_path).print("v1") }
+            .to output(re).to_stdout
+        end
+      end
+
+      it "outputs the list of removed components" do
+        [ /Removed Components/,
+          /removed-comp \(v9\)/,
+          /removed-comp-2 \(v10\)/,
+        ].each do |re|
+          expect { ChangeLogPrinter.new(changelog, diff).print("v1") }
+            .to output(re).to_stdout
+        end
+      end
+
+      it "outputs the list of contributors" do
+        [ /### Contributors/, /alice/, /bob/ ].each do |re|
+          expect { ChangeLogPrinter.new(changelog, diff).print("v1") }
+            .to output(re).to_stdout
+        end
+      end
+    end
+  end
+end

data/spec/unit/cleanroom_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Omnibus
   describe Cleanroom do
@@ -18,43 +18,43 @@ module Omnibus
     let(:instance) { klass.new }
 
     describe '#evaluate' do
-      it 'exposes public methods' do
+      it "exposes public methods" do
         expect {
-          instance.evaluate('exposed_method')
+          instance.evaluate("exposed_method")
         }.to_not raise_error
       end
 
-      it 'calls exposed methods on the instance' do
-        instance.evaluate('exposed_method')
+      it "calls exposed methods on the instance" do
+        instance.evaluate("exposed_method")
         expect(instance.instance_variable_get(:@called)).to be_truthy
       end
 
-      it 'does not expose unexposed methods' do
+      it "does not expose unexposed methods" do
         expect {
-          instance.evaluate('unexposed_method')
+          instance.evaluate("unexposed_method")
         }.to raise_error(NameError)
       end
     end
 
     describe '#evaluate_file' do
       let(:contents) do
-        <<-EOH.gsub(/^ {10}/, '')
+        <<-EOH.gsub(/^ {10}/, "")
           exposed_method
         EOH
       end
 
-      let(:filepath) { File.join(tmp_path, '/file/path') }
+      let(:filepath) { File.join(tmp_path, "/file/path") }
 
       before do
         allow(IO).to receive(:read).and_call_original
         allow(IO).to receive(:read).with(filepath).and_return(contents)
       end
 
-      it 'evaluates the file and exposes public methods' do
+      it "evaluates the file and exposes public methods" do
         expect { instance.evaluate_file(filepath) }.to_not raise_error
       end
 
-      it 'calls exposed methods on the instance' do
+      it "calls exposed methods on the instance" do
         instance.evaluate_file(filepath)
         expect(instance.instance_variable_get(:@called)).to be_truthy
       end

data/spec/unit/compressor_spec.rb

@@ -1,41 +1,41 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Omnibus
   describe Compressor do
-    describe '.for_current_system' do
-      context 'on Mac OS X' do
-        before { stub_ohai(platform: 'mac_os_x', version: '10.9.2') }
+    describe ".for_current_system" do
+      context "on Mac OS X" do
+        before { stub_ohai(platform: "mac_os_x", version: "10.9.2") }
 
-        context 'when :dmg is activated' do
-          it 'prefers dmg' do
+        context "when :dmg is activated" do
+          it "prefers dmg" do
             expect(described_class.for_current_system([:tgz, :dmg])).to eq(Compressor::DMG)
           end
         end
 
-        context 'when :dmg is not activated' do
-          it 'prefers tgz' do
+        context "when :dmg is not activated" do
+          it "prefers tgz" do
             expect(described_class.for_current_system([:tgz, :foo])).to eq(Compressor::TGZ)
           end
         end
 
-        context 'when nothing is given' do
-          it 'returns null' do
+        context "when nothing is given" do
+          it "returns null" do
             expect(described_class.for_current_system([])).to eq(Compressor::Null)
           end
         end
       end
 
-      context 'on Ubuntu' do
-        before { stub_ohai(platform: 'ubuntu', version: '14.04') }
+      context "on Ubuntu" do
+        before { stub_ohai(platform: "ubuntu", version: "14.04") }
 
-        context 'when :tgz activated' do
-          it 'prefers tgz' do
+        context "when :tgz activated" do
+          it "prefers tgz" do
             expect(described_class.for_current_system([:tgz, :foo])).to eq(Compressor::TGZ)
           end
         end
 
-        context 'when nothing is given' do
-          it 'returns null' do
+        context "when nothing is given" do
+          it "returns null" do
             expect(described_class.for_current_system([])).to eq(Compressor::Null)
           end
         end