vanagon 0.4.1 → 0.5.0

data/lib/vanagon/utilities/shell_utilities.rb

@@ -0,0 +1,29 @@
+class Vanagon
+  module Utilities
+    module ShellUtilities
+      module_function
+
+      # join a combination of strings and arrays of strings into a single command
+      # joined with '&&'
+      #
+      # @param commands [Array<String, Array<String>>]
+      # @return [String]
+      def andand(*commands)
+        cmdjoin(commands, " && ")
+      end
+
+      # join a combination of strings and arrays of strings into a single command
+      # joined with '&&' and broken up with newlines after each '&&'
+      #
+      # @param commands [Array<String, Array<String>>]
+      # @return [String]
+      def andand_multiline(*commands)
+        cmdjoin(commands, " && \\\n")
+      end
+
+      def cmdjoin(commands, sep)
+        commands.map { |o| Array(o) }.flatten.join(sep)
+      end
+    end
+  end
+end

data/spec/lib/makefile_spec.rb

@@ -0,0 +1,50 @@
+require 'makefile'
+
+describe Makefile::Rule do
+  describe "a rule with no dependencies and an empty recipe" do
+    subject { described_class.new("empty") }
+
+    it "creates an empty rule" do
+      expect(subject.format).to eq "empty:\n"
+    end
+  end
+
+  describe "a rule with no dependencies and a simple recipe" do
+    subject { described_class.new("simple", recipe: ["touch simple"]) }
+
+    it "creates the rule with the recipe" do
+      expect(subject.format).to eq "simple:\n\ttouch simple\n"
+    end
+  end
+
+  describe "a rule with dependencies and no recipe" do
+    subject { described_class.new("depends", dependencies: ["mydeps"]) }
+
+    it "creates the rule with the recipe" do
+      expect(subject.format).to eq "depends: mydeps\n"
+    end
+  end
+
+  describe "a rule with dependencies and a recipe" do
+    subject { described_class.new("deluxe", recipe: ["touch deluxe"], dependencies: ["mydeps"]) }
+
+    it "creates the rule with the recipe" do
+      expect(subject.format).to eq "deluxe: mydeps\n\ttouch deluxe\n"
+    end
+  end
+
+  describe "a rule with a multiline recipe" do
+    subject do
+      described_class.new("multiline") do |rule|
+        rule.recipe = [
+          "[ -d build ] || mkdir -p build",
+          "cd build &&\ncmake .. &&\nmake &&\nmake install"
+        ]
+      end
+    end
+
+    it "inserts tabs after each newline in the recipe" do
+      expect(subject.format).to eq "multiline:\n\t[ -d build ] || mkdir -p build\n\tcd build &&\n\tcmake .. &&\n\tmake &&\n\tmake install\n"
+    end
+  end
+end

data/spec/lib/vanagon/component/dsl_spec.rb

@@ -105,6 +105,21 @@ end" }
     end
   end
 
+  describe '#check' do
+    it 'sets check to the value if check is empty' do
+      comp = Vanagon::Component::DSL.new('check-test', {}, {})
+      comp.check { './check' }
+      expect(comp._component.check).to eq(['./check'])
+    end
+
+    it 'appends to the existing check if not empty' do
+      comp = Vanagon::Component::DSL.new('check-test', {}, {})
+      comp.check { 'make test' }
+      comp.check { 'make cpplint' }
+      expect(comp._component.check).to eq(['make test', 'make cpplint'])
+    end
+  end
+
   describe '#install' do
     it 'sets install to the value if install is empty' do
       comp = Vanagon::Component::DSL.new('install-test', {}, {})
@@ -136,8 +151,37 @@ end" }
       comp.apply_patch('patch_file1', fuzz: 12, strip: 1000000)
       expect(comp._component.patches.count).to eq 1
       expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.fuzz).to eq '12'
-      expect(comp._component.patches.first.strip).to eq '1000000'
+      expect(comp._component.patches.first.fuzz).to eq 12
+      expect(comp._component.patches.first.strip).to eq 1000000
+    end
+
+    it 'can specify a directory where the patch should be applied' do
+      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
+      comp.apply_patch('patch_file1', destination: 'random/install/directory')
+      expect(comp._component.patches.count).to eq 1
+      expect(comp._component.patches.first.path).to eq 'patch_file1'
+      expect(comp._component.patches.first.destination).to eq 'random/install/directory'
+    end
+
+    it 'can specify when to try to apply the patch' do
+      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
+      comp.apply_patch('patch_file1', after: 'install')
+      expect(comp._component.patches.count).to eq 1
+      expect(comp._component.patches.first.path).to eq 'patch_file1'
+      expect(comp._component.patches.first.after).to eq 'install'
+    end
+
+    it 'will default the patch timing to after the source is unpacked' do
+      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
+      comp.apply_patch('patch_file1')
+      expect(comp._component.patches.count).to eq 1
+      expect(comp._component.patches.first.path).to eq 'patch_file1'
+      expect(comp._component.patches.first.after).to eq 'unpack'
+    end
+
+    it 'will fail if the user wants to install the patch at an unsupported step' do
+      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
+      expect { comp.apply_patch('patch_file1', after: 'delivery') }.to raise_error(Vanagon::Error)
     end
   end
 
@@ -484,6 +528,21 @@ end" }
     end
   end
 
+  describe "#build_dir" do
+    it "sets the build_dir when given a relative path" do
+      comp = Vanagon::Component::DSL.new('build-dir-test', {}, platform)
+      comp.build_dir("build")
+      expect(comp._component.build_dir).to eq("build")
+    end
+
+    it "raises an error when given an absolute path" do
+      comp = Vanagon::Component::DSL.new('build-dir-test', {}, platform)
+      expect {
+        comp.build_dir("/build")
+      }.to raise_error(Vanagon::Error, %r[build_dir should be a relative path, but '/build' looks to be absolute\.])
+    end
+  end
+
   describe '#link' do
     it 'adds the correct command to the install for the component' do
       comp = Vanagon::Component::DSL.new('link-test', {}, platform)

data/spec/lib/vanagon/component/rules_spec.rb

@@ -0,0 +1,302 @@
+require 'vanagon/component'
+require 'vanagon/component/dsl'
+require 'vanagon/component/rules'
+require 'vanagon/platform/osx'
+require 'vanagon/project'
+require 'vanagon/patch'
+require 'ostruct'
+
+RSpec.shared_examples "a rule that touches the target file" do
+  it "touches the target file as the last step of the recipe" do
+    expect(rule.recipe.last).to eq "touch #{rule.target}"
+  end
+end
+
+describe Vanagon::Component::Rules do
+  let(:platform) do
+    OpenStruct.new(:patch => "/usr/bin/patch", :make => '/usr/bin/make')
+  end
+
+  let(:project) do
+    Vanagon::Project.new("cpp-project", platform)
+  end
+
+  let(:component) do
+    Vanagon::Component.new("leatherman", {}, platform).tap do |c|
+      c.dirname = "/foo/bar"
+    end
+  end
+
+  subject { described_class.new(component, project, platform) }
+
+  describe "the component rule" do
+    it "depends on the component-install rule" do
+      rule = subject.component_rule
+      expect(rule.dependencies).to eq(["leatherman-install"])
+    end
+  end
+
+  describe "the unpack rule" do
+    let(:rule) { subject.unpack_rule }
+
+    it { expect(rule.dependencies).to eq(["file-list-before-build"]) }
+
+    it "extracts the source" do
+      component.extract_with = "/usr/bin/tar"
+      expect(rule.recipe.first).to eq ": && /usr/bin/tar"
+    end
+
+    it "sets environment variables before running the unpack steps" do
+      component.extract_with = "/usr/bin/tar"
+      component.environment = {"PATH" => "/opt/pl-build-tools/bin:$$PATH"}
+      expect(rule.recipe.first).to eq(
+        [
+          "export PATH=\"/opt/pl-build-tools/bin:$$PATH\"",
+          "/usr/bin/tar"
+        ].join(" && ")
+      )
+    end
+
+    it_behaves_like "a rule that touches the target file"
+  end
+
+  describe "the patch rule" do
+    let(:rule) { subject.patch_rule }
+
+    it { expect(rule.dependencies).to eq(["leatherman-unpack"]) }
+
+    it "does nothing when there are no patches" do
+      expect(rule.recipe.size).to eq 1
+    end
+
+    it "applies each listed patch in order when patches are set" do
+      component.patches = [
+        Vanagon::Patch.new('/foo/patch0', '1', '0', 'unpack', '/foo/bar'),
+        Vanagon::Patch.new('/foo/patch1', '2', '1', 'unpack', '/foo/bar'),
+        Vanagon::Patch.new('/foo/postinstall/patch1', '2', '1', 'install', '/foo/bar')
+      ]
+      expect(rule.recipe.first).to eq(
+        [
+          "cd /foo/bar",
+          "/usr/bin/patch --strip=1 --fuzz=0 --ignore-whitespace < $(workdir)/patches/patch0",
+          "/usr/bin/patch --strip=2 --fuzz=1 --ignore-whitespace < $(workdir)/patches/patch1"
+        ].join(" && \\\n")
+      )
+    end
+
+    it_behaves_like "a rule that touches the target file"
+  end
+
+  describe "the configure rule" do
+    let(:rule) { subject.configure_rule }
+
+    # TODO: cross-component dependencies
+    it { expect(rule.dependencies).to eq(['leatherman-patch']) }
+
+    describe "when a build directory is set" do
+      before do
+        component.build_dir = "build"
+      end
+
+      it "creates the build directory" do
+        expect(rule.recipe.first).to eq("[ -d /foo/bar/build ] || mkdir -p /foo/bar/build")
+      end
+    end
+
+    it "runs all of the configure commands when given" do
+      component.configure = ["./configure", "cmake .."]
+      expect(rule.recipe[1]).to eq(
+        [
+          "cd /foo/bar",
+          ":",
+          "./configure",
+          "cmake .."
+        ].join(" && \\\n")
+      )
+    end
+
+    it "sets environment variables before running the configure steps" do
+      component.configure = ["./configure", "cmake .."]
+      component.environment = {"PATH" => "/opt/pl-build-tools/bin:$$PATH"}
+      expect(rule.recipe[1]).to eq(
+        [
+          "cd /foo/bar",
+          "export PATH=\"/opt/pl-build-tools/bin:$$PATH\"",
+          "./configure",
+          "cmake .."
+        ].join(" && \\\n")
+      )
+    end
+
+    it_behaves_like "a rule that touches the target file"
+  end
+
+  describe "the build rule" do
+    let(:rule) { subject.build_rule }
+
+    it { expect(rule.dependencies).to eq(['leatherman-configure']) }
+
+    it "does nothing when the build step is empty" do
+      expect(rule.recipe.size).to eq 1
+    end
+
+    it "runs all of the build commands when given" do
+      component.build = ["make", "make test"]
+      expect(rule.recipe.first).to eq(
+        [
+          "cd /foo/bar",
+          ":",
+          "make",
+          "make test",
+        ].join(" && \\\n")
+      )
+    end
+
+    it "sets environment variables before running the build steps" do
+      component.build = ["make", "make test"]
+      component.environment = {"PATH" => "/opt/pl-build-tools/bin:$$PATH"}
+      expect(rule.recipe.first).to eq(
+        [
+          "cd /foo/bar",
+          "export PATH=\"/opt/pl-build-tools/bin:$$PATH\"",
+          "make",
+          "make test"
+        ].join(" && \\\n")
+      )
+    end
+
+    it_behaves_like "a rule that touches the target file"
+  end
+
+  describe "the check rule" do
+    let(:rule) { subject.check_rule }
+
+    it { expect(rule.dependencies).to eq(['leatherman-build']) }
+
+    it "does nothing when the check step is empty" do
+      expect(rule.recipe.size).to eq 1
+    end
+
+    it "does nothing when the project skipcheck flag is set" do
+      component.check = ["make cpplint", "make test"]
+      project.settings[:skipcheck] = true
+      expect(rule.recipe.size).to eq 1
+    end
+
+    it "runs all of the check commands when given" do
+      component.check = ["make cpplint", "make test"]
+      expect(rule.recipe.first).to eq(
+        [
+          "cd /foo/bar",
+          ":",
+          "make cpplint",
+          "make test",
+        ].join(" && \\\n")
+      )
+    end
+
+    it "sets environment variables before running the check steps" do
+      component.check = ["make cpplint", "make test"]
+      component.environment = {"PATH" => "/opt/pl-build-tools/bin:$$PATH"}
+      expect(rule.recipe.first).to eq(
+        [
+          "cd /foo/bar",
+          "export PATH=\"/opt/pl-build-tools/bin:$$PATH\"",
+          "make cpplint",
+          "make test"
+        ].join(" && \\\n")
+      )
+    end
+
+    it_behaves_like "a rule that touches the target file"
+  end
+
+  describe "the install rule" do
+    let(:rule) { subject.install_rule }
+
+    it { expect(rule.dependencies).to eq(['leatherman-check']) }
+
+    it "does nothing when the install step is empty" do
+      expect(rule.recipe.size).to eq 1
+    end
+
+    it "runs all of the install commands when given" do
+      component.install = ["make install", "make reallyinstall"]
+      expect(rule.recipe.first).to eq(
+        [
+          "cd /foo/bar",
+          ":",
+          "make install",
+          "make reallyinstall",
+        ].join(" && \\\n")
+      )
+    end
+
+    it "sets environment variables before running the install steps" do
+      component.install = ["make install", "make reallyinstall"]
+      component.environment = {"PATH" => "/opt/pl-build-tools/bin:$$PATH"}
+      expect(rule.recipe.first).to eq(
+        [
+          "cd /foo/bar",
+          "export PATH=\"/opt/pl-build-tools/bin:$$PATH\"",
+          "make install",
+          "make reallyinstall"
+        ].join(" && \\\n")
+      )
+    end
+
+    it "applies any after-install patches" do
+      component.install = ["make install"]
+      component.patches = [
+        Vanagon::Patch.new('/foo/patch0', 1, 0, 'unpack', '/foo/bar'),
+        Vanagon::Patch.new('/foo/postinstall/patch0', 3, 9, 'install', '/foo/baz'),
+        Vanagon::Patch.new('/foo/postinstall/patch1', 4, 10, 'install', '/foo/quux'),
+      ]
+
+      expect(rule.recipe[1]).to eq("cd /foo/baz && /usr/bin/patch --strip=3 --fuzz=9 --ignore-whitespace < $(workdir)/patches/patch0")
+      expect(rule.recipe[2]).to eq("cd /foo/quux && /usr/bin/patch --strip=4 --fuzz=10 --ignore-whitespace < $(workdir)/patches/patch1")
+    end
+
+    it_behaves_like "a rule that touches the target file"
+  end
+
+  describe "the cleanup rule" do
+    let(:rule) { subject.cleanup_rule }
+
+    it { expect(rule.dependencies).to eq(['leatherman-install']) }
+
+    it "runs the component source cleanup step" do
+      component.cleanup_source = "rm -rf leatherman"
+      expect(rule.recipe.first).to eq "rm -rf leatherman"
+    end
+
+    it_behaves_like "a rule that touches the target file"
+  end
+
+  describe "the clean rule" do
+    let(:rule) { subject.clean_rule }
+
+    it { expect(rule.dependencies).to be_empty }
+
+    it "runs a `make clean` in the build dir" do
+      expect(rule.recipe.first).to eq '[ -d /foo/bar ] && cd /foo/bar && /usr/bin/make clean'
+    end
+
+    it "remotes the touch files for the configure, build, and install steps" do
+      %w[configure build install].each_with_index do |type, i|
+        touchfile = "leatherman-#{type}"
+        expect(rule.recipe[i + 1]).to eq "[ -e #{touchfile} ] && rm #{touchfile}"
+      end
+    end
+  end
+
+  describe "the clobber rule" do
+    let(:rule) { subject.clobber_rule }
+
+    it { expect(rule.dependencies).to eq(['leatherman-clean']) }
+
+    it "removes the source directory and unpack touchfile" do
+      expect(rule.recipe).to eq(["[ -d /foo/bar ] && rm -r /foo/bar", "[ -e leatherman-unpack ] && rm leatherman-unpack"])
+    end
+  end
+end