rscons 0.0.14 → 0.1.0

data/spec/rscons/environment_spec.rb

@@ -1,6 +1,44 @@
 module Rscons
   describe Environment do
-    describe '.clone' do
+    describe "#initialize" do
+      it "stores the construction variables passed in" do
+        env = Environment.new("CFLAGS" => ["-g"], "CPPPATH" => ["dir"])
+        env["CFLAGS"].should == ["-g"]
+        env["CPPPATH"].should == ["dir"]
+      end
+
+      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: :all)
+        env.builders.size.should == 0
+      end
+
+      it "excludes the named builders" do
+        env = Environment.new(exclude_builders: ["Library"])
+        env.builders.size.should be > 0
+        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 be_nil
+      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"
@@ -9,15 +47,229 @@ module Rscons
         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: :all)
+        env.builders.keys.should == []
+        env.add_builder(Rscons::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
+      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
+      end
+    end
+
+    describe "#[]" do
+      it "allows reading construction variables" do
+        env = Environment.new("CFLAGS" => ["-g", "-Wall"])
+        env["CFLAGS"].should == ["-g", "-Wall"]
+      end
+    end
+
+    describe "#[]=" do
+      it "allows writing construction variables" do
+        env = Environment.new("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("CFLAGS" => ["-g"], "CPPPATH" => ["inc"])
+        env.append("CFLAGS" => ["-Wall"], "CPPPATH" => ["include"])
+        env["CFLAGS"].should == ["-Wall"]
+        env["CPPPATH"].should == ["include"]
+      end
     end
 
-    describe '.parse_makefile_deps' do
+    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(:new).and_return(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(:new).and_return(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(:new).and_return(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
+    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 "#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("a", "command", "--arg=val with spaces", opt: :val).and_return(false)
+          env.execute("short desc", ["a", "command", "--arg=val with spaces"], 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
+        env.should_receive(:orig_method_missing).with(:foobar)
+        env.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[:source].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 "#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
-        env = Environment.new
-        env.parse_makefile_deps('makefile', 'module.o').should == ['source.cc']
+        Environment.parse_makefile_deps('makefile', 'module.o').should == ['source.cc']
       end
 
       it 'handles dependencies split across many lines' do
@@ -26,8 +278,7 @@ module.o: module.c \\
   module.h \\
   other.h
 EOS
-        env = Environment.new
-        env.parse_makefile_deps('makefile', 'module.o').should == [
+        Environment.parse_makefile_deps('makefile', 'module.o').should == [
           'module.c', 'module.h', 'other.h']
       end
     end

data/spec/rscons/varset_spec.rb

@@ -84,30 +84,35 @@ module Rscons
       v = VarSet.new("CFLAGS" => ["-Wall", "-O2"],
                      "CC" => "gcc",
                      "CPPPATH" => ["dir1", "dir2"],
-                     "compiler" => "$CC",
-                     "cmd" => ["$CC", "-c", "$CFLAGS", "-I$[CPPPATH]"])
+                     "compiler" => "${CC}",
+                     "cmd" => ["${CC}", "-c", "${CFLAGS}", "-I${CPPPATH}"])
       it "expands to the string itself if the string is not a variable reference" do
         v.expand_varref("CC").should == "CC"
         v.expand_varref("CPPPATH").should == "CPPPATH"
         v.expand_varref("str").should == "str"
       end
       it "expands a single variable reference beginning with a '$'" do
-        v.expand_varref("$CC").should == "gcc"
-        v.expand_varref("$CPPPATH").should == ["dir1", "dir2"]
+        v.expand_varref("${CC}").should == "gcc"
+        v.expand_varref("${CPPPATH}").should == ["dir1", "dir2"]
       end
-      it "expands a single variable reference in $[arr] notation" do
-        v.expand_varref("prefix$[CFLAGS]suffix").should == ["prefix-Wallsuffix", "prefix-O2suffix"]
+      it "expands a single variable reference in ${arr} notation" do
+        v.expand_varref("prefix${CFLAGS}suffix").should == ["prefix-Wallsuffix", "prefix-O2suffix"]
         v.expand_varref(v["cmd"]).should == ["gcc", "-c", "-Wall", "-O2", "-Idir1", "-Idir2"]
       end
       it "expands a variable reference recursively" do
-        v.expand_varref("$compiler").should == "gcc"
-        v.expand_varref("$cmd").should == ["gcc", "-c", "-Wall", "-O2", "-Idir1", "-Idir2"]
+        v.expand_varref("${compiler}").should == "gcc"
+        v.expand_varref("${cmd}").should == ["gcc", "-c", "-Wall", "-O2", "-Idir1", "-Idir2"]
       end
-      it "raises an error when array notation is applied to a non-array variable" do
-        expect { v.expand_varref("$[CC]") }.to raise_error /Array.expected/
+      it "resolves multiple variable references in one element by enumerating all combinations" do
+        v.expand_varref("cflag: ${CFLAGS}, cpppath: ${CPPPATH}, compiler: ${compiler}").should == [
+          "cflag: -Wall, cpppath: dir1, compiler: gcc",
+          "cflag: -O2, cpppath: dir1, compiler: gcc",
+          "cflag: -Wall, cpppath: dir2, compiler: gcc",
+          "cflag: -O2, cpppath: dir2, compiler: gcc",
+        ]
       end
       it "raises an error when a variable reference refers to a non-existent variable" do
-        expect { v.expand_varref("$not_here") }.to raise_error /Could.not.find.variable..not_here/
+        expect { v.expand_varref("${not_here}") }.to raise_error /I do not know how to expand a variable reference to a NilClass/
       end
     end
   end

data/spec/rscons_spec.rb

@@ -0,0 +1,26 @@
+describe Rscons do
+  describe ".clean" do
+    it "removes all build targets and created directories" do
+      cache = "cache"
+      Rscons::Cache.should_receive(:new).and_return(cache)
+      cache.should_receive(:targets).and_return(["build/a.out", "build/main.o"])
+      FileUtils.should_receive(:rm_f).with("build/a.out")
+      FileUtils.should_receive(:rm_f).with("build/main.o")
+      cache.should_receive(:directories).and_return(["build/one", "build/one/two", "build", "other"])
+      File.should_receive(:directory?).with("build/one/two").and_return(true)
+      Dir.should_receive(:entries).with("build/one/two").and_return([".", ".."])
+      Dir.should_receive(:rmdir).with("build/one/two")
+      File.should_receive(:directory?).with("build/one").and_return(true)
+      Dir.should_receive(:entries).with("build/one").and_return([".", ".."])
+      Dir.should_receive(:rmdir).with("build/one")
+      File.should_receive(:directory?).with("build").and_return(true)
+      Dir.should_receive(:entries).with("build").and_return([".", ".."])
+      Dir.should_receive(:rmdir).with("build")
+      File.should_receive(:directory?).with("other").and_return(true)
+      Dir.should_receive(:entries).with("other").and_return([".", "..", "other.file"])
+      Rscons::Cache.should_receive(:clear)
+
+      Rscons.clean
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 require "simplecov"
 
-SimpleCov.start
+SimpleCov.start do
+  add_filter "/spec/"
+end
 
 require "rscons"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rscons
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-29 00:00:00.000000000 Z
+date: 2013-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core
@@ -167,28 +167,20 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- build_tests/build_dir/build.rb
+- Rakefile.rb
 - build_tests/build_dir/src/one/one.c
 - build_tests/build_dir/src/two/two.c
 - build_tests/build_dir/src/two/two.h
-- build_tests/build_dir/tweaker_build.rb
-- build_tests/clone_env/build.rb
 - build_tests/clone_env/src/program.c
-- build_tests/custom_builder/build.rb
 - build_tests/custom_builder/program.c
-- build_tests/header/build.rb
+- build_tests/d/main.d
 - build_tests/header/header.c
 - build_tests/header/header.h
-- build_tests/library/build.rb
 - build_tests/library/one.c
 - build_tests/library/three.c
 - build_tests/library/two.c
-- build_tests/simple/build.rb
 - build_tests/simple/simple.c
-- build_tests/simple_cc/build.rb
 - build_tests/simple_cc/simple.cc
-- build_tests/two_sources/build.rb
 - build_tests/two_sources/one.c
 - build_tests/two_sources/two.c
 - lib/rscons.rb
@@ -204,9 +196,11 @@ files:
 - lib/rscons/version.rb
 - rscons.gemspec
 - spec/build_tests_spec.rb
+- spec/rscons/cache_spec.rb
 - spec/rscons/environment_spec.rb
 - spec/rscons/monkey/module_spec.rb
 - spec/rscons/varset_spec.rb
+- spec/rscons_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/holtrop/rscons
 licenses:
@@ -223,7 +217,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 982055185
+      hash: 306135951
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -232,7 +226,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 982055185
+      hash: 306135951
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -241,8 +235,10 @@ specification_version: 3
 summary: Software construction library inspired by SCons and implemented in Ruby
 test_files:
 - spec/build_tests_spec.rb
+- spec/rscons/cache_spec.rb
 - spec/rscons/environment_spec.rb
 - spec/rscons/monkey/module_spec.rb
 - spec/rscons/varset_spec.rb
+- spec/rscons_spec.rb
 - spec/spec_helper.rb
 has_rdoc: