rscons 0.0.14 → 0.1.0

data/lib/rscons/varset.rb

@@ -64,20 +64,16 @@ module Rscons
           expand_varref(ent)
         end.flatten
       else
-        if varref =~ /^(.*)\$\[(\w+)\](.*)$/
-          # expand array with given prefix, suffix
+        if varref =~ /^(.*)\$\{([^}]+)\}(.*)$/
           prefix, varname, suffix = $1, $2, $3
           varval = expand_varref(@vars[varname])
-          unless varval.is_a?(Array)
-            raise "Array expected for $#{varname}"
+          if varval.is_a?(String)
+            expand_varref("#{prefix}#{varval}#{suffix}")
+          elsif varval.is_a?(Array)
+            varval.map {|vv| expand_varref("#{prefix}#{vv}#{suffix}")}.flatten
+          else
+            raise "I do not know how to expand a variable reference to a #{varval.class.name}"
           end
-          varval.map {|e| "#{prefix}#{e}#{suffix}"}
-        elsif varref =~ /^\$(.*)$/
-          # expand a single variable reference
-          varname = $1
-          varval = expand_varref(@vars[varname])
-          varval or raise "Could not find variable #{varname.inspect}"
-          expand_varref(varval)
         else
           varref
         end

data/lib/rscons/version.rb

@@ -1,4 +1,4 @@
 module Rscons
   # gem version
-  VERSION = "0.0.14"
+  VERSION = "0.1.0"
 end

data/spec/build_tests_spec.rb

@@ -1,45 +1,31 @@
 require 'fileutils'
 
 describe Rscons do
+  BUILD_TEST_RUN_DIR = "build_test_run"
+
   before(:all) do
-    FileUtils.rm_rf('build_tests_run')
+    FileUtils.rm_rf(BUILD_TEST_RUN_DIR)
     @owd = Dir.pwd
   end
 
-  after(:each) do
-    Dir.chdir(@owd)
-    FileUtils.rm_rf('build_tests_run')
+  before(:each) do
+    @output = ""
+    $stdout.stub(:write) do |content|
+      @output += content
+    end
+    $stderr.stub(:write) do |content|
+      @output += content
+    end
   end
 
-  def build_testdir(build_script = "build.rb")
-    if File.exists?(build_script)
-      build_rb = File.read(build_script)
-      File.open(build_script, "w") do |fh|
-        fh.puts(<<EOF + build_rb)
-require "simplecov"
-
-SimpleCov.start do
-  root("#{@owd}")
-  command_name("build_test_#{@build_test_name}")
-  add_filter("spec")
-end
-
-require "rscons"
-EOF
-      end
-      IO.popen(%{ruby -I #{@owd}/lib #{build_script}}) do |io|
-        io.readlines.reject do |line|
-          line =~ /^Coverage report/
-        end
-      end.map(&:strip)
-    end
+  after(:each) do
+    Dir.chdir(@owd)
+    FileUtils.rm_rf(BUILD_TEST_RUN_DIR)
   end
 
-  def test_dir(build_test_directory, build_script = "build.rb")
-    @build_test_name = build_test_directory
-    FileUtils.cp_r("build_tests/#{build_test_directory}", 'build_tests_run')
-    Dir.chdir("build_tests_run")
-    build_testdir(build_script)
+  def test_dir(build_test_directory)
+    FileUtils.cp_r("build_tests/#{build_test_directory}", BUILD_TEST_RUN_DIR)
+    Dir.chdir(BUILD_TEST_RUN_DIR)
   end
 
   def file_sub(fname)
@@ -53,18 +39,31 @@ EOF
     end
   end
 
+  def lines
+    @output.lines.map(&:rstrip).tap do |v|
+      @output = ""
+    end
+  end
+
   ###########################################################################
   # Tests
   ###########################################################################
 
   it 'builds a C program with one source file' do
     test_dir('simple')
+    Rscons::Environment.new do |env|
+      env.Program('simple', Dir['*.c'])
+    end
     File.exists?('simple.o').should be_true
     `./simple`.should == "This is a simple C program\n"
   end
 
   it 'prints commands as they are executed' do
-    lines = test_dir('simple')
+    test_dir('simple')
+    Rscons::Environment.new(echo: :command) do |env|
+      env["LD"] = "gcc"
+      env.Program('simple', Dir['*.c'])
+    end
     lines.should == [
       'gcc -c -o simple.o -MMD -MF simple.mf simple.c',
       'gcc -o simple simple.o',
@@ -72,7 +71,10 @@ EOF
   end
 
   it 'prints short representations of the commands being executed' do
-    lines = test_dir('header')
+    test_dir('header')
+    Rscons::Environment.new do |env|
+      env.Program('header', Dir['*.c'])
+    end
     lines.should == [
       'CC header.o',
       'LD header',
@@ -81,61 +83,88 @@ EOF
 
   it 'builds a C program with one source file and one header file' do
     test_dir('header')
+    Rscons::Environment.new do |env|
+      env.Program('header', Dir['*.c'])
+    end
     File.exists?('header.o').should be_true
     `./header`.should == "The value is 2\n"
   end
 
   it 'rebuilds a C module when a header it depends on changes' do
     test_dir('header')
+    env = Rscons::Environment.new do |env|
+      env.Program('header', Dir['*.c'])
+    end
     `./header`.should == "The value is 2\n"
     file_sub('header.h') {|line| line.sub(/2/, '5')}
-    build_testdir
+    env.process
     `./header`.should == "The value is 5\n"
   end
 
   it 'does not rebuild a C module when its dependencies have not changed' do
-    lines = test_dir('header')
+    test_dir('header')
+    env = Rscons::Environment.new do |env|
+      env.Program('header', Dir['*.c'])
+    end
     `./header`.should == "The value is 2\n"
     lines.should == [
       'CC header.o',
       'LD header',
     ]
-    lines = build_testdir
+    env.process
     lines.should == []
   end
 
   it "does not rebuild a C module when only the file's timestampe has changed" do
-    lines = test_dir('header')
+    test_dir('header')
+    env = Rscons::Environment.new do |env|
+      env.Program('header', Dir['*.c'])
+    end
     `./header`.should == "The value is 2\n"
     lines.should == [
       'CC header.o',
       'LD header',
     ]
     file_sub('header.c') {|line| line}
-    lines = build_testdir
+    env.process
     lines.should == []
   end
 
   it 're-links a program when the link flags have changed' do
-    lines = test_dir('simple')
+    test_dir('simple')
+    Rscons::Environment.new(echo: :command) do |env|
+      env.Program('simple', Dir['*.c'])
+    end
     lines.should == [
       'gcc -c -o simple.o -MMD -MF simple.mf simple.c',
       'gcc -o simple simple.o',
     ]
-    file_sub('build.rb') {|line| line.sub(/.*CHANGE.FLAGS.*/, '  env["LIBS"] += ["c"]')}
-    lines = build_testdir
+    Rscons::Environment.new(echo: :command) do |env|
+      env["LIBS"] += ["c"]
+      env.Program('simple', Dir['*.c'])
+    end
     lines.should == ['gcc -o simple simple.o -lc']
   end
 
   it 'builds object files in a different build directory' do
-    lines = test_dir('build_dir')
+    test_dir('build_dir')
+    Rscons::Environment.new do |env|
+      env.append('CPPPATH' => Dir['src/**/*/'])
+      env.build_dir(%r{^src/([^/]+)/}, 'build_\\1/')
+      env.Program('build_dir', Dir['src/**/*.c'])
+    end
     `./build_dir`.should == "Hello from two()\n"
     File.exists?('build_one/one.o').should be_true
     File.exists?('build_two/two.o').should be_true
   end
 
   it 'cleans built files' do
-    lines = test_dir('build_dir')
+    test_dir('build_dir')
+    Rscons::Environment.new do |env|
+      env.append('CPPPATH' => Dir['src/**/*/'])
+      env.build_dir(%r{^src/([^/]+)/}, 'build_\\1/')
+      env.Program('build_dir', Dir['src/**/*.c'])
+    end
     `./build_dir`.should == "Hello from two()\n"
     File.exists?('build_one/one.o').should be_true
     File.exists?('build_two/two.o').should be_true
@@ -148,7 +177,12 @@ EOF
   end
 
   it 'does not clean created directories if other non-rscons-generated files reside there' do
-    lines = test_dir('build_dir')
+    test_dir('build_dir')
+    Rscons::Environment.new do |env|
+      env.append('CPPPATH' => Dir['src/**/*/'])
+      env.build_dir(%r{^src/([^/]+)/}, 'build_\\1/')
+      env.Program('build_dir', Dir['src/**/*.c'])
+    end
     `./build_dir`.should == "Hello from two()\n"
     File.exists?('build_one/one.o').should be_true
     File.exists?('build_two/two.o').should be_true
@@ -162,14 +196,44 @@ EOF
   end
 
   it 'allows Ruby classes as custom builders to be used to construct files' do
-    lines = test_dir('custom_builder')
+   test_dir('custom_builder')
+    class MySource < Rscons::Builder
+      def run(target, sources, cache, env, vars = {})
+        File.open(target, 'w') do |fh|
+          fh.puts <<EOF
+    #define THE_VALUE 5678
+EOF
+        end
+        target
+      end
+    end
+
+    Rscons::Environment.new do |env|
+      env.add_builder(MySource.new)
+      env.MySource('inc.h', [])
+      env.Program('program', Dir['*.c'])
+    end
+
     lines.should == ['CC program.o', 'LD program']
     File.exists?('inc.h').should be_true
     `./program`.should == "The value is 5678\n"
   end
 
   it 'allows cloning Environment objects' do
-    lines = test_dir('clone_env')
+    test_dir('clone_env')
+
+    debug = Rscons::Environment.new(echo: :command) do |env|
+      env.build_dir('src', 'debug')
+      env['CFLAGS'] = '-O2'
+      env['CPPFLAGS'] = '-DSTRING="Debug Version"'
+      env.Program('program-debug', Dir['src/*.c'])
+    end
+
+    release = debug.clone('CPPFLAGS' => '-DSTRING="Release Version"') do |env|
+      env.build_dir('src', 'release')
+      env.Program('program-release', Dir['src/*.c'])
+    end
+
     lines.should == [
       %q{gcc -c -o debug/program.o -MMD -MF debug/program.mf '-DSTRING="Debug Version"' -O2 src/program.c},
       %q{gcc -o program-debug debug/program.o},
@@ -180,12 +244,19 @@ EOF
 
   it 'builds a C++ program with one source file' do
     test_dir('simple_cc')
+    Rscons::Environment.new do |env|
+      env.Program('simple', Dir['*.cc'])
+    end
     File.exists?('simple.o').should be_true
     `./simple`.should == "This is a simple C++ program\n"
   end
 
   it 'allows overriding construction variables for individual builder calls' do
-    lines = test_dir('two_sources')
+    test_dir('two_sources')
+    Rscons::Environment.new(echo: :command) do |env|
+      env.Object("one.o", "one.c", 'CPPFLAGS' => ['-DONE'])
+      env.Program('two_sources', ['one.o', 'two.c'])
+    end
     lines.should == [
       'gcc -c -o one.o -MMD -MF one.mf -DONE one.c',
       'gcc -c -o two.o -MMD -MF two.mf two.c',
@@ -196,7 +267,11 @@ EOF
   end
 
   it 'builds a static library archive' do
-    lines = test_dir('library')
+    test_dir('library')
+    Rscons::Environment.new(echo: :command) do |env|
+      env.Program('library', ['lib.a', 'three.c'])
+      env.Library("lib.a", ['one.c', 'two.c'], 'CPPFLAGS' => ['-Dmake_lib'])
+    end
     lines.should == [
       'gcc -c -o one.o -MMD -MF one.mf -Dmake_lib one.c',
       'gcc -c -o two.o -MMD -MF two.mf -Dmake_lib two.c',
@@ -208,13 +283,39 @@ EOF
     `ar t lib.a`.should == "one.o\ntwo.o\n"
   end
 
-  it 'supports tweakers to override construction variables' do
-    lines = test_dir("build_dir", "tweaker_build.rb")
-    `./tweaker`.should == "Hello from two()\n"
+  it 'supports build hooks to override construction variables' do
+    test_dir("build_dir")
+    Rscons::Environment.new(echo: :command) do |env|
+      env.append('CPPPATH' => Dir['src/**/*/'])
+      env.build_dir(%r{^src/([^/]+)/}, 'build_\\1/')
+      env.add_build_hook do |build_op|
+        if build_op[:target] =~ %r{build_one/.*\.o}
+          build_op[:vars]["CFLAGS"] << "-O1"
+        elsif build_op[:target] =~ %r{build_two/.*\.o}
+          build_op[:vars]["CFLAGS"] << "-O2"
+        end
+      end
+      env.Program('build_hook', Dir['src/**/*.c'])
+    end
+    `./build_hook`.should == "Hello from two()\n"
     lines.should =~ [
       'gcc -c -o build_one/one.o -MMD -MF build_one/one.mf -Isrc/one/ -Isrc/two/ -O1 src/one/one.c',
       'gcc -c -o build_two/two.o -MMD -MF build_two/two.mf -Isrc/one/ -Isrc/two/ -O2 src/two/two.c',
-      'gcc -o tweaker build_one/one.o build_two/two.o',
+      'gcc -o build_hook build_one/one.o build_two/two.o',
     ]
   end
+
+  unless ENV["omit_gdc_tests"]
+    it "supports building D sources" do
+      test_dir("d")
+      Rscons::Environment.new(echo: :command) do |env|
+        env.Program("hello-d", Dir["*.d"])
+      end
+      lines.should == [
+        "gdc -c -o main.o main.d",
+        "gdc -o hello-d main.o",
+      ]
+      `./hello-d`.rstrip.should == "Hello from D!"
+    end
+  end
 end

data/spec/rscons/cache_spec.rb

@@ -0,0 +1,204 @@
+module Rscons
+  describe Cache do
+    before do
+      File.stub(:read) { nil }
+    end
+
+    def build_from(cache)
+      YAML.should_receive(:load).and_return(cache)
+      Cache.new
+    end
+
+    describe ".clear" do
+      it "removes the cache file" do
+        FileUtils.should_receive(:rm_f).with(Cache::CACHE_FILE)
+        Cache.clear
+      end
+    end
+
+    describe "#initialize" do
+      context "when corrupt" do
+        it "prints a warning and defaults to an empty hash" do
+          YAML.should_receive(:load).and_return("string")
+          $stderr.should_receive(:puts).with(/Warning:.*was.corrupt/)
+          Cache.new.instance_variable_get(:@cache).is_a?(Hash).should be_true
+        end
+      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
+      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", []).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", []).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", []).should be_false
+      end
+
+      it "returns false when the build command has changed" do
+        _cache = {targets: {"target" => {checksum: "abc", command: "old command"}}}
+        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", []).should be_false
+      end
+
+      it "returns false when there is a new dependency" do
+        _cache = {targets: {"target" => {checksum: "abc",
+                                         command: "command",
+                                         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"]).should be_false
+      end
+
+      it "returns false when a dependency's checksum has changed" do
+        _cache = {targets: {"target" => {checksum: "abc",
+                                         command: "command",
+                                         deps: [{fname: "dep.1",
+                                                 checksum: "dep.1.chk"},
+                                                {fname: "dep.2",
+                                                 checksum: "dep.2.chk"},
+                                                {fname: "extra.dep",
+                                                 checksum: "extra.dep.chk"}]}}}
+        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"]).should be_false
+      end
+
+      it "returns false with strict_deps=true when cache has an extra dependency" do
+        _cache = {targets: {"target" => {checksum: "abc",
+                                         command: "command",
+                                         deps: [{fname: "dep.1",
+                                                 checksum: "dep.1.chk"},
+                                                {fname: "dep.2",
+                                                 checksum: "dep.2.chk"},
+                                                {fname: "extra.dep",
+                                                 checksum: "extra.dep.chk"}]}}}
+        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"], strict_deps: true).should be_false
+      end
+
+      it "returns true when no condition for false is met" do
+        _cache = {targets: {"target" => {checksum: "abc",
+                                         command: "command",
+                                         deps: [{fname: "dep.1",
+                                                 checksum: "dep.1.chk"},
+                                                {fname: "dep.2",
+                                                 checksum: "dep.2.chk"},
+                                                {fname: "extra.dep",
+                                                 checksum: "extra.dep.chk"}]}}}
+        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"]).should be_true
+      end
+    end
+
+    describe "#register_build" do
+      it "stores the given information in the cache" do
+        _cache = {}
+        cache = build_from(_cache)
+        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.register_build("the target", "the command", ["dep 1", "dep 2"])
+        cached_target = cache.instance_variable_get(:@cache)[:targets]["the target"]
+        cached_target.should_not be_nil
+        cached_target[:command].should == "the command"
+        cached_target[:checksum].should == "the checksum"
+        cached_target[:deps].should == [
+          {fname: "dep 1", checksum: "dep 1 checksum"},
+          {fname: "dep 2", checksum: "dep 2 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
+    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