rscons 1.4.3 → 1.5.0

data/spec/rscons/builders/cfile_spec.rb

@@ -1,28 +0,0 @@
-module Rscons
-  module Builders
-    describe CFile do
-      let(:env) {Environment.new}
-      subject {CFile.new}
-
-      it "invokes bison to create a .c file from a .y file" do
-        subject.should_receive(:standard_build).with("YACC parser.c", "parser.c", ["bison", "-d", "-o", "parser.c", "parser.y"], ["parser.y"], env, :cache)
-        subject.run("parser.c", ["parser.y"], :cache, env, {})
-      end
-
-      it "invokes a custom lexer to create a .cc file from a .ll file" do
-        env["LEX"] = "custom_lex"
-        subject.should_receive(:standard_build).with("LEX lexer.cc", "lexer.cc", ["custom_lex", "-o", "lexer.cc", "parser.ll"], ["parser.ll"], env, :cache)
-        subject.run("lexer.cc", ["parser.ll"], :cache, env, {})
-      end
-
-      it "supports overriding construction variables" do
-        subject.should_receive(:standard_build).with("LEX lexer.c", "lexer.c", ["hi", "parser.l"], ["parser.l"], env, :cache)
-        subject.run("lexer.c", ["parser.l"], :cache, env, "LEX_CMD" => ["hi", "${_SOURCES}"])
-      end
-
-      it "raises an error when an unknown source file is specified" do
-        expect {subject.run("file.c", ["foo.bar"], :cache, env, {})}.to raise_error /Unknown source file .foo.bar. for CFile builder/
-      end
-    end
-  end
-end

data/spec/rscons/builders/disassemble_spec.rb

@@ -1,17 +0,0 @@
-module Rscons
-  module Builders
-    describe Disassemble do
-      let(:env) {Environment.new}
-      subject {Disassemble.new}
-
-      it "supports overriding DISASM_CMD construction variable" do
-        cache = "cache"
-        cache.stub(:up_to_date?) { false }
-        cache.stub(:mkdir_p) { }
-        cache.stub(:register_build) { }
-        env.should_receive(:execute).with("Disassemble a_file.txt", ["my_disasm", "a_file.exe"], anything).and_return(true)
-        subject.run("a_file.txt", ["a_file.exe"], cache, env, "DISASM_CMD" => ["my_disasm", "${_SOURCES}"])
-      end
-    end
-  end
-end

data/spec/rscons/builders/library_spec.rb

@@ -1,18 +0,0 @@
-module Rscons
-  module Builders
-    describe Library do
-      let(:env) {Environment.new}
-      subject {Library.new}
-
-      it "supports overriding AR construction variable" do
-        subject.should_receive(:standard_build).with("AR prog.a", "prog.a", ["sp-ar", "rcs", "prog.a", "prog.o"], ["prog.o"], env, :cache)
-        subject.run("prog.a", ["prog.o"], :cache, env, "AR" => "sp-ar")
-      end
-
-      it "supports overriding ARCMD construction variable" do
-        subject.should_receive(:standard_build).with("AR prog.a", "prog.a", ["special", "AR!", "prog.o"], ["prog.o"], env, :cache)
-        subject.run("prog.a", ["prog.o"], :cache, env, "ARCMD" => ["special", "AR!", "${_SOURCES}"])
-      end
-    end
-  end
-end

data/spec/rscons/builders/object_spec.rb

@@ -1,23 +0,0 @@
-module Rscons
-  module Builders
-    describe Object do
-      let(:env) {Environment.new}
-      subject {Object.new}
-
-      it "supports overriding CCCMD construction variable" do
-        cache = "cache"
-        cache.stub(:up_to_date?) { false }
-        cache.stub(:mkdir_p) { }
-        cache.stub(:register_build) { }
-        FileUtils.stub(:rm_f) { }
-        File.stub(:exists?) { false }
-        env.should_receive(:execute).with("CC mod.o", ["llc", "mod.c"]).and_return(true)
-        subject.run("mod.o", ["mod.c"], cache, env, "CCCMD" => ["llc", "${_SOURCES}"])
-      end
-
-      it "raises an error when given a source file with an unknown suffix" do
-        expect { subject.run("mod.o", ["mod.xyz"], :cache, env, {}) }.to raise_error /unknown input file type: "mod.xyz"/
-      end
-    end
-  end
-end

data/spec/rscons/builders/preprocess_spec.rb

@@ -1,18 +0,0 @@
-module Rscons
-  module Builders
-    describe Preprocess do
-      let(:env) {Environment.new}
-      subject {Preprocess.new}
-
-      it "supports overriding CC construction variable" do
-        subject.should_receive(:standard_build).with("Preprocess module.pp", "module.pp", ["my_cpp", "-E", "-o", "module.pp", "module.c"], ["module.c"], env, :cache)
-        subject.run("module.pp", ["module.c"], :cache, env, "CC" => "my_cpp")
-      end
-
-      it "supports overriding CPP_CMD construction variable" do
-        subject.should_receive(:standard_build).with("Preprocess module.pp", "module.pp", ["my_cpp", "module.c"], ["module.c"], env, :cache)
-        subject.run("module.pp", ["module.c"], :cache, env, "CPP_CMD" => ["my_cpp", "${_SOURCES}"])
-      end
-    end
-  end
-end

data/spec/rscons/builders/program_spec.rb

@@ -1,18 +0,0 @@
-module Rscons
-  module Builders
-    describe Program do
-      let(:env) {Environment.new}
-      subject {Program.new}
-
-      it "supports overriding CC construction variable" do
-        subject.should_receive(:standard_build).with("LD prog", "prog", ["sp-c++", "-o", "prog", "prog.o"], ["prog.o"], env, :cache)
-        subject.run("prog", ["prog.o"], :cache, env, "CC" => "sp-c++")
-      end
-
-      it "supports overriding LDCMD construction variable" do
-        subject.should_receive(:standard_build).with("LD prog", "prog", ["special", "LD!", "prog.o"], ["prog.o"], env, :cache)
-        subject.run("prog", ["prog.o"], :cache, env, "LDCMD" => ["special", "LD!", "${_SOURCES}"])
-      end
-    end
-  end
-end

data/spec/rscons/cache_spec.rb

@@ -1,271 +0,0 @@
-module Rscons
-  describe Cache do
-    before do
-      File.stub(:read) { nil }
-    end
-
-    def build_from(cache)
-      JSON.stub(:load) do
-        cache
-      end
-      Cache.instance.tap do |cache|
-        cache.send(:initialize!)
-      end
-    end
-
-    describe "#initialize" do
-      context "when corrupt" do
-        it "prints a warning and defaults to an empty hash" do
-          JSON.should_receive(:load).and_return("string")
-          $stderr.should_receive(:puts).with(/Warning:.*was.corrupt/)
-          c = Cache.instance
-          c.send(:initialize!)
-          c.instance_variable_get(:@cache).is_a?(Hash).should be_true
-        end
-      end
-    end
-
-    describe "#clear" do
-      it "removes the cache file" do
-        FileUtils.should_receive(:rm_f).with(Cache::CACHE_FILE)
-        JSON.stub(:load) {{}}
-        Cache.instance.clear
-      end
-    end
-
-    describe "#write" do
-      it "should fill in 'version' and write to file" do
-        cache = {}
-        fh = $stdout
-        fh.should_receive(:puts)
-        File.should_receive(:open).and_yield(fh)
-        build_from(cache).write
-        cache["version"].should == Rscons::VERSION
-      end
-    end
-
-    describe "#up_to_date?" do
-      empty_env = "env"
-      before do
-        empty_env.stub(:get_user_deps) { nil }
-      end
-
-      it "returns false when target file does not exist" do
-        File.should_receive(:exists?).with("target").and_return(false)
-        build_from({}).up_to_date?("target", "command", [], empty_env).should be_false
-      end
-
-      it "returns false when target is not registered in the cache" do
-        File.should_receive(:exists?).with("target").and_return(true)
-        build_from({}).up_to_date?("target", "command", [], empty_env).should be_false
-      end
-
-      it "returns false when the target's checksum does not match" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc"}}}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("def")
-        cache.up_to_date?("target", "command", [], empty_env).should be_false
-      end
-
-      it "returns false when the build command has changed" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc", "command" => Digest::MD5.hexdigest("old command".inspect)}}}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("abc")
-        cache.up_to_date?("target", "command", [], empty_env).should be_false
-      end
-
-      it "returns false when there is a new dependency" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc",
-                                         "command" => Digest::MD5.hexdigest("command".inspect),
-                                         "deps" => [{"fname" => "dep.1"}]}}}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("abc")
-        cache.up_to_date?("target", "command", ["dep.1", "dep.2"], empty_env).should be_false
-      end
-
-      it "returns false when a dependency's checksum has changed" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc",
-                                         "command" => Digest::MD5.hexdigest("command".inspect),
-                                         "deps" => [{"fname" => "dep.1",
-                                                 "checksum" => "dep.1.chk"},
-                                                {"fname" => "dep.2",
-                                                 "checksum" => "dep.2.chk"},
-                                                {"fname" => "extra.dep",
-                                                 "checksum" => "extra.dep.chk"}],
-                                         "user_deps" => []}}}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("abc")
-        cache.should_receive(:calculate_checksum).with("dep.1").and_return("dep.1.chk")
-        cache.should_receive(:calculate_checksum).with("dep.2").and_return("dep.2.changed")
-        cache.up_to_date?("target", "command", ["dep.1", "dep.2"], empty_env).should be_false
-      end
-
-      it "returns false with strict_deps=true when cache has an extra dependency" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc",
-                                         "command" => Digest::MD5.hexdigest("command".inspect),
-                                         "deps" => [{"fname" => "dep.1",
-                                                 "checksum" => "dep.1.chk"},
-                                                {"fname" => "dep.2",
-                                                 "checksum" => "dep.2.chk"},
-                                                {"fname" => "extra.dep",
-                                                 "checksum" => "extra.dep.chk"}],
-                                         "user_deps" => []}}}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("abc")
-        cache.up_to_date?("target", "command", ["dep.1", "dep.2"], empty_env, strict_deps: true).should be_false
-      end
-
-      it "returns false when there is a new user dependency" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc",
-                                         "command" => Digest::MD5.hexdigest("command".inspect),
-                                         "deps" => [{"fname" => "dep.1"}],
-                                         "user_deps" => []}}}
-        cache = build_from(_cache)
-        env = "env"
-        env.should_receive(:get_user_deps).with("target").and_return(["file.ld"])
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("abc")
-        cache.up_to_date?("target", "command", ["dep.1"], env).should be_false
-      end
-
-      it "returns false when a user dependency checksum has changed" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc",
-                                         "command" => Digest::MD5.hexdigest("command".inspect),
-                                         "deps" => [{"fname" => "dep.1",
-                                                 "checksum" => "dep.1.chk"},
-                                                {"fname" => "dep.2",
-                                                 "checksum" => "dep.2.chk"},
-                                                {"fname" => "extra.dep",
-                                                 "checksum" => "extra.dep.chk"}],
-                                         "user_deps" => [{"fname" => "user.dep",
-                                                      "checksum" => "user.dep.chk"}]}}}
-        cache = build_from(_cache)
-        env = "env"
-        env.should_receive(:get_user_deps).with("target").and_return(["user.dep"])
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("abc")
-        cache.should_receive(:calculate_checksum).with("dep.1").and_return("dep.1.chk")
-        cache.should_receive(:calculate_checksum).with("dep.2").and_return("dep.2.chk")
-        cache.should_receive(:calculate_checksum).with("extra.dep").and_return("extra.dep.chk")
-        cache.should_receive(:calculate_checksum).with("user.dep").and_return("INCORRECT")
-        cache.up_to_date?("target", "command", ["dep.1", "dep.2"], env).should be_false
-      end
-
-      it "returns true when no condition for false is met" do
-        _cache = {"targets" => {"target" => {"checksum" => "abc",
-                                         "command" => Digest::MD5.hexdigest("command".inspect),
-                                         "deps" => [{"fname" => "dep.1",
-                                                 "checksum" => "dep.1.chk"},
-                                                {"fname" => "dep.2",
-                                                 "checksum" => "dep.2.chk"},
-                                                {"fname" => "extra.dep",
-                                                 "checksum" => "extra.dep.chk"}],
-                                         "user_deps" => []}}}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("target").and_return(true)
-        cache.should_receive(:calculate_checksum).with("target").and_return("abc")
-        cache.should_receive(:calculate_checksum).with("dep.1").and_return("dep.1.chk")
-        cache.should_receive(:calculate_checksum).with("dep.2").and_return("dep.2.chk")
-        cache.should_receive(:calculate_checksum).with("extra.dep").and_return("extra.dep.chk")
-        cache.up_to_date?("target", "command", ["dep.1", "dep.2"], empty_env).should be_true
-      end
-    end
-
-    describe "#register_build" do
-      it "stores the given information in the cache" do
-        _cache = {}
-        cache = build_from(_cache)
-        env = "env"
-        env.should_receive(:get_user_deps).with("the target").and_return(["user.dep"])
-        cache.should_receive(:calculate_checksum).with("the target").and_return("the checksum")
-        cache.should_receive(:calculate_checksum).with("dep 1").and_return("dep 1 checksum")
-        cache.should_receive(:calculate_checksum).with("dep 2").and_return("dep 2 checksum")
-        cache.should_receive(:calculate_checksum).with("user.dep").and_return("user.dep checksum")
-        cache.register_build("the target", "the command", ["dep 1", "dep 2"], env)
-        cached_target = cache.instance_variable_get(:@cache)["targets"]["the target"]
-        cached_target.should_not be_nil
-        cached_target["command"].should == Digest::MD5.hexdigest("the command".inspect)
-        cached_target["checksum"].should == "the checksum"
-        cached_target["deps"].should == [
-          {"fname" => "dep 1", "checksum" => "dep 1 checksum"},
-          {"fname" => "dep 2", "checksum" => "dep 2 checksum"},
-        ]
-        cached_target["user_deps"].should == [
-          {"fname" => "user.dep", "checksum" => "user.dep checksum"},
-        ]
-      end
-    end
-
-    describe "#targets" do
-      it "returns a list of targets that are cached" do
-        cache = {"targets" => {"t1" => {}, "t2" => {}, "t3" => {}}}
-        build_from(cache).targets.should == ["t1", "t2", "t3"]
-      end
-    end
-
-    describe "#mkdir_p" do
-      it "makes directories and records any created in the cache" do
-        _cache = {}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("one").and_return(true)
-        File.should_receive(:exists?).with("one/two").and_return(false)
-        FileUtils.should_receive(:mkdir).with("one/two")
-        File.should_receive(:exists?).with("one/two/three").and_return(false)
-        FileUtils.should_receive(:mkdir).with("one/two/three")
-        File.should_receive(:exists?).with("one").and_return(true)
-        File.should_receive(:exists?).with("one/two").and_return(true)
-        File.should_receive(:exists?).with("one/two/four").and_return(false)
-        FileUtils.should_receive(:mkdir).with("one/two/four")
-        cache.mkdir_p("one/two/three")
-        cache.mkdir_p("one\\two\\four")
-        cache.directories.should == ["one/two", "one/two/three", "one/two/four"]
-      end
-
-      it "handles absolute paths" do
-        _cache = {}
-        cache = build_from(_cache)
-        File.should_receive(:exists?).with("/one").and_return(true)
-        File.should_receive(:exists?).with("/one/two").and_return(false)
-        FileUtils.should_receive(:mkdir).with("/one/two")
-        cache.mkdir_p("/one/two")
-        cache.directories.should == ["/one/two"]
-      end
-    end
-
-    describe "#directories" do
-      it "returns a list of directories that are cached" do
-        _cache = {"directories" => {"dir1" => true, "dir2" => true}}
-        build_from(_cache).directories.should == ["dir1", "dir2"]
-      end
-    end
-
-    describe "#lookup_checksum" do
-      it "does not re-calculate the checksum when it is already cached" do
-        cache = build_from({})
-        cache.instance_variable_set(:@lookup_checksums, {"f1" => "f1.chk"})
-        cache.should_not_receive(:calculate_checksum)
-        cache.send(:lookup_checksum, "f1").should == "f1.chk"
-      end
-
-      it "calls calculate_checksum when the checksum is not cached" do
-        cache = build_from({})
-        cache.should_receive(:calculate_checksum).with("f1").and_return("ck")
-        cache.send(:lookup_checksum, "f1").should == "ck"
-      end
-    end
-
-    describe "#calculate_checksum" do
-      it "calculates the MD5 of the file contents" do
-        contents = "contents"
-        File.should_receive(:read).with("fname", mode: "rb").and_return(contents)
-        Digest::MD5.should_receive(:hexdigest).with(contents).and_return("the_checksum")
-        build_from({}).send(:calculate_checksum, "fname").should == "the_checksum"
-      end
-    end
-  end
-end

data/spec/rscons/environment_spec.rb

@@ -1,361 +0,0 @@
-module Rscons
-  describe Environment do
-    describe "#initialize" do
-      it "adds the default builders when they are not excluded" do
-        env = Environment.new
-        env.builders.size.should be > 0
-        env.builders.map {|name, builder| builder.is_a?(Builder)}.all?.should be_true
-        env.builders.find {|name, builder| name == "Object"}.should_not be_nil
-        env.builders.find {|name, builder| name == "Program"}.should_not be_nil
-        env.builders.find {|name, builder| name == "Library"}.should_not be_nil
-      end
-
-      it "excludes the default builders with exclude_builders: :all" do
-        env = Environment.new(exclude_builders: true)
-        env.builders.size.should == 0
-      end
-
-      context "when a block is given" do
-        it "yields self and invokes #process()" do
-          env = Environment.new do |env|
-            env.should_receive(:process)
-          end
-        end
-      end
-    end
-
-    describe "#clone" do
-      it 'should create unique copies of each construction variable' do
-        env = Environment.new
-        env["CPPPATH"] << "path1"
-        env2 = env.clone
-        env2["CPPPATH"] << "path2"
-        env["CPPPATH"].should == ["path1"]
-        env2["CPPPATH"].should == ["path1", "path2"]
-      end
-
-      context "when a block is given" do
-        it "yields self and invokes #process()" do
-          env = Environment.new
-          env.clone do |env2|
-            env2.should_receive(:process)
-          end
-        end
-      end
-    end
-
-    describe "#add_builder" do
-      it "adds the builder to the list of builders" do
-        env = Environment.new(exclude_builders: true)
-        env.builders.keys.should == []
-        env.add_builder(Rscons::Builders::Object.new)
-        env.builders.keys.should == ["Object"]
-      end
-    end
-
-    describe "#get_build_fname" do
-      context "with no build directories" do
-        it "returns the name of the source file with suffix changed" do
-          env = Environment.new
-          env.get_build_fname("src/dir/file.c", ".o").should == "src/dir/file.o"
-          env.get_build_fname("src\\dir\\other.d", ".a").should == "src/dir/other.a"
-          env.get_build_fname("source.cc", ".o").should == "source.o"
-        end
-
-        context "with a build_root" do
-          it "uses the build_root unless the path is absolute" do
-            env = Environment.new
-            env.build_root = "build/proj"
-            env.get_build_fname("src/dir/file.c", ".o").should == "build/proj/src/dir/file.o"
-            env.get_build_fname("/some/lib.c", ".a").should == "/some/lib.a"
-            env.get_build_fname("C:\\abspath\\mod.cc", ".o").should == "C:/abspath/mod.o"
-            env.get_build_fname("build\\proj\\generated.c", ".o").should == "build/proj/generated.o"
-            env.get_build_fname("build/proj.XX", ".yy").should == "build/proj/build/proj.yy"
-          end
-        end
-      end
-
-      context "with build directories" do
-        it "uses the build directories to create the output file name" do
-          env = Environment.new
-          env.build_dir("src", "bld")
-          env.build_dir(%r{^libs/([^/]+)}, 'build/libs/\1')
-          env.get_build_fname("src/input.cc", ".o").should == "bld/input.o"
-          env.get_build_fname("libs/lib1/some/file.c", ".o").should == "build/libs/lib1/some/file.o"
-          env.get_build_fname("libs/otherlib/otherlib.cc", ".o").should == "build/libs/otherlib/otherlib.o"
-          env.get_build_fname("other_directory/o.d", ".a").should == "other_directory/o.a"
-        end
-
-        context "with a build_root" do
-          it "uses the build_root unless a build directory matches or the path is absolute" do
-            env = Environment.new
-            env.build_dir("src", "bld")
-            env.build_dir(%r{^libs/([^/]+)}, 'build/libs/\1')
-            env.build_root = "bldit"
-
-            env.get_build_fname("src/input.cc", ".o").should == "bld/input.o"
-            env.get_build_fname("libs/lib1/some/file.c", ".o").should == "build/libs/lib1/some/file.o"
-            env.get_build_fname("libs/otherlib/otherlib.cc", ".o").should == "build/libs/otherlib/otherlib.o"
-            env.get_build_fname("other_directory/o.d", ".a").should == "bldit/other_directory/o.a"
-            env.get_build_fname("bldit/some/mod.d", ".a").should == "bldit/some/mod.a"
-          end
-        end
-      end
-    end
-
-    describe "#[]" do
-      it "allows reading construction variables" do
-        env = Environment.new
-        env["CFLAGS"] = ["-g", "-Wall"]
-        env["CFLAGS"].should == ["-g", "-Wall"]
-      end
-    end
-
-    describe "#[]=" do
-      it "allows writing construction variables" do
-        env = Environment.new
-        env["CFLAGS"] = ["-g", "-Wall"]
-        env["CFLAGS"] -= ["-g"]
-        env["CFLAGS"] += ["-O3"]
-        env["CFLAGS"].should == ["-Wall", "-O3"]
-        env["other_var"] = "val33"
-        env["other_var"].should == "val33"
-      end
-    end
-
-    describe "#append" do
-      it "allows adding many construction variables at once" do
-        env = Environment.new
-        env["CFLAGS"] = ["-g"]
-        env["CPPPATH"] = ["inc"]
-        env.append("CFLAGS" => ["-Wall"], "CPPPATH" => ["include"])
-        env["CFLAGS"].should == ["-Wall"]
-        env["CPPPATH"].should == ["include"]
-      end
-    end
-
-    describe "#process" do
-      it "runs builders for all of the targets specified" do
-        env = Environment.new
-        env.Program("a.out", "main.c")
-
-        cache = "cache"
-        Cache.should_receive(:instance).and_return(cache)
-        cache.should_receive(:clear_checksum_cache!)
-        env.should_receive(:run_builder).with(anything, "a.out", ["main.c"], cache, {}).and_return(true)
-        cache.should_receive(:write)
-
-        env.process
-      end
-
-      it "builds dependent targets first" do
-        env = Environment.new
-        env.Program("a.out", "main.o")
-        env.Object("main.o", "other.cc")
-
-        cache = "cache"
-        Cache.should_receive(:instance).and_return(cache)
-        cache.should_receive(:clear_checksum_cache!)
-        env.should_receive(:run_builder).with(anything, "main.o", ["other.cc"], cache, {}).and_return("main.o")
-        env.should_receive(:run_builder).with(anything, "a.out", ["main.o"], cache, {}).and_return("a.out")
-        cache.should_receive(:write)
-
-        env.process
-      end
-
-      it "raises a BuildError when building fails" do
-        env = Environment.new
-        env.Program("a.out", "main.o")
-        env.Object("main.o", "other.cc")
-
-        cache = "cache"
-        Cache.should_receive(:instance).and_return(cache)
-        cache.should_receive(:clear_checksum_cache!)
-        env.should_receive(:run_builder).with(anything, "main.o", ["other.cc"], cache, {}).and_return(false)
-        cache.should_receive(:write)
-
-        expect { env.process }.to raise_error BuildError, /Failed.to.build.main.o/
-      end
-
-      it "writes the cache when the Builder raises an exception" do
-        env = Environment.new
-        env.Object("module.o", "module.c")
-
-        cache = "cache"
-        Cache.should_receive(:instance).and_return(cache)
-        cache.should_receive(:clear_checksum_cache!)
-        env.stub(:run_builder) do |builder, target, sources, cache, vars|
-          raise "Ruby exception thrown by builder"
-        end
-        cache.should_receive(:write)
-
-        expect { env.process }.to raise_error RuntimeError, /Ruby exception thrown by builder/
-      end
-    end
-
-    describe "#clear_targets" do
-      it "resets @targets to an empty hash" do
-        env = Environment.new
-        env.Program("a.out", "main.o")
-        expect(env.instance_variable_get(:@targets).keys).to eq(["a.out"])
-
-        env.clear_targets
-
-        expect(env.instance_variable_get(:@targets).keys).to eq([])
-      end
-    end
-
-    describe "#build_command" do
-      it "returns a command based on the variables in the Environment" do
-        env = Environment.new
-        env["path"] = ["dir1", "dir2"]
-        env["flags"] = ["-x", "-y", "${specialflag}"]
-        env["specialflag"] = "-z"
-        template = ["cmd", "-I${path}", "${flags}", "${_source}", "${_dest}"]
-        cmd = env.build_command(template, "_source" => "infile", "_dest" => "outfile")
-        cmd.should == ["cmd", "-Idir1", "-Idir2", "-x", "-y", "-z", "infile", "outfile"]
-      end
-    end
-
-    describe "#expand_varref" do
-      it "returns the fully expanded variable reference" do
-        env = Environment.new
-        env["path"] = ["dir1", "dir2"]
-        env["flags"] = ["-x", "-y", "${specialflag}"]
-        env["specialflag"] = "-z"
-        env["foo"] = {}
-        env.expand_varref(["-p${path}", "${flags}"]).should == ["-pdir1", "-pdir2", "-x", "-y", "-z"]
-        env.expand_varref("foo").should == "foo"
-        expect {env.expand_varref("${foo}")}.to raise_error /expand.a.variable.reference/
-        env.expand_varref("${specialflag}").should == "-z"
-        env.expand_varref("${path}").should == ["dir1", "dir2"]
-      end
-    end
-
-    describe "#execute" do
-      context "with echo: :short" do
-        context "with no errors" do
-          it "prints the short description and executes the command" do
-            env = Environment.new(echo: :short)
-            env.should_receive(:puts).with("short desc")
-            env.should_receive(:system).with("a", "command").and_return(true)
-            env.execute("short desc", ["a", "command"])
-          end
-        end
-
-        context "with errors" do
-          it "prints the short description, executes the command, and prints the failed command line" do
-            env = Environment.new(echo: :short)
-            env.should_receive(:puts).with("short desc")
-            env.should_receive(:system).with("a", "command").and_return(false)
-            $stdout.should_receive(:write).with("Failed command was: ")
-            env.should_receive(:puts).with("a command")
-            env.execute("short desc", ["a", "command"])
-          end
-        end
-      end
-
-      context "with echo: :command" do
-        it "prints the command executed and executes the command" do
-          env = Environment.new(echo: :command)
-          env.should_receive(:puts).with("a command '--arg=val with spaces'")
-          env.should_receive(:system).with({modified: :environment}, "a", "command", "--arg=val with spaces", {opt: :val}).and_return(false)
-          env.execute("short desc", ["a", "command", "--arg=val with spaces"], env: {modified: :environment}, options: {opt: :val})
-        end
-      end
-    end
-
-    describe "#method_missing" do
-      it "calls the original method missing when the target method is not a known builder" do
-        env = Environment.new
-        expect {env.foobar}.to raise_error /undefined method .foobar./
-      end
-
-      it "records the target when the target method is a known builder" do
-        env = Environment.new
-        env.instance_variable_get(:@targets).should == {}
-        env.Program("target", ["src1", "src2"], var: "val")
-        target = env.instance_variable_get(:@targets)["target"]
-        target.should_not be_nil
-        target[:builder].is_a?(Builder).should be_true
-        target[:sources].should == ["src1", "src2"]
-        target[:vars].should == {var: "val"}
-        target[:args].should == []
-      end
-
-      it "raises an error when vars is not a Hash" do
-        env = Environment.new
-        expect { env.Program("a.out", "main.c", "other") }.to raise_error /Unexpected construction variable set/
-      end
-    end
-
-    describe "#depends" do
-      it "records the given dependencies in @user_deps" do
-        env = Environment.new
-        env.depends("foo", "bar", "baz")
-        env.instance_variable_get(:@user_deps).should == {"foo" => ["bar", "baz"]}
-      end
-      it "records user dependencies only once" do
-        env = Environment.new
-        env.instance_variable_set(:@user_deps, {"foo" => ["bar"]})
-        env.depends("foo", "bar", "baz")
-        env.instance_variable_get(:@user_deps).should == {"foo" => ["bar", "baz"]}
-      end
-    end
-
-    describe "#build_sources" do
-      class ABuilder < Builder
-        def produces?(target, source, env)
-          target =~ /\.ab_out$/ and source =~ /\.ab_in$/
-        end
-      end
-
-      it "finds and invokes a builder to produce output files with the requested suffixes" do
-        cache = "cache"
-        env = Environment.new
-        env.add_builder(ABuilder.new)
-        env.builders["Object"].should_receive(:run).with("mod.o", ["mod.c"], cache, env, anything).and_return("mod.o")
-        env.builders["ABuilder"].should_receive(:run).with("mod2.ab_out", ["mod2.ab_in"], cache, env, anything).and_return("mod2.ab_out")
-        env.build_sources(["precompiled.o", "mod.c", "mod2.ab_in"], [".o", ".ab_out"], cache, {}).should == ["precompiled.o", "mod.o", "mod2.ab_out"]
-      end
-    end
-
-    describe "#run_builder" do
-      it "modifies the construction variables using given build hooks and invokes the builder" do
-        env = Environment.new
-        env.add_build_hook do |build_op|
-          if build_op[:sources].first =~ %r{src/special}
-            build_op[:vars]["CFLAGS"] += ["-O3", "-DSPECIAL"]
-          end
-        end
-        env.builders["Object"].stub(:run) do |target, sources, cache, env, vars|
-          vars["CFLAGS"].should == []
-        end
-        env.run_builder(env.builders["Object"], "build/normal/module.o", ["src/normal/module.c"], "cache", {})
-        env.builders["Object"].stub(:run) do |target, sources, cache, env, vars|
-          vars["CFLAGS"].should == ["-O3", "-DSPECIAL"]
-        end
-        env.run_builder(env.builders["Object"], "build/special/module.o", ["src/special/module.c"], "cache", {})
-      end
-    end
-
-    describe ".parse_makefile_deps" do
-      it 'handles dependencies on one line' do
-        File.should_receive(:read).with('makefile').and_return(<<EOS)
-module.o: source.cc
-EOS
-        Environment.parse_makefile_deps('makefile', 'module.o').should == ['source.cc']
-      end
-
-      it 'handles dependencies split across many lines' do
-        File.should_receive(:read).with('makefile').and_return(<<EOS)
-module.o: module.c \\
-  module.h \\
-  other.h
-EOS
-        Environment.parse_makefile_deps('makefile', 'module.o').should == [
-          'module.c', 'module.h', 'other.h']
-      end
-    end
-  end
-end