v0.0.14

tweakers allow the user to modify construction variables before any build is performed

build_tests/build_dir/build.rb

@@ -1,5 +1,5 @@
 Rscons::Environment.new do |env|
   env.append('CPPPATH' => Dir['src/**/*/'])
-  env.build_dir('src', 'build')
+  env.build_dir(%r{^src/([^/]+)/}, 'build_\\1/')
   env.Program('build_dir', Dir['src/**/*.c'])
 end

build_tests/build_dir/tweaker_build.rb

@@ -0,0 +1,12 @@
+Rscons::Environment.new do |env|
+  env.append('CPPPATH' => Dir['src/**/*/'])
+  env.build_dir(%r{^src/([^/]+)/}, 'build_\\1/')
+  env.add_tweaker 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('tweaker', Dir['src/**/*.c'])
+end

build_tests/custom_builder/build.rb

@@ -9,8 +9,7 @@ EOF
   end
 end
 
-Rscons::Environment.new(echo: :short) do |env|
-  env.add_builder(MySource.new)
+Rscons::Environment.new(echo: :short, builders: [MySource.new]) do |env|
   env.MySource('inc.h', [])
   env.Program('program', Dir['*.c'])
 end

lib/rscons.rb

@@ -22,4 +22,21 @@ module Rscons
 
   class BuildError < Exception
   end
+
+  # Remove all generated files
+  def self.clean
+    cache = Cache.new
+    # remove all built files
+    cache.targets.each do |target|
+      FileUtils.rm_f(target)
+    end
+    # remove all created directories if they are empty
+    cache.directories.sort {|a, b| b.size <=> a.size}.each do |directory|
+      next unless File.directory?(directory)
+      if (Dir.entries(directory) - ['.', '..']).empty?
+        Dir.rmdir(directory) rescue nil
+      end
+    end
+    Cache.clear
+  end
 end

lib/rscons/builder.rb

@@ -24,7 +24,7 @@ module Rscons
     # Return the name of the target or false on failure.
     def standard_build(short_cmd_string, target, command, sources, env, cache)
       unless cache.up_to_date?(target, command, sources)
-        FileUtils.mkdir_p(File.dirname(target))
+        cache.mkdir_p(File.dirname(target))
         FileUtils.rm_f(target)
         return false unless env.execute(short_cmd_string, command)
         cache.register_build(target, command, sources)

lib/rscons/builders/object.rb

@@ -28,6 +28,12 @@ module Rscons
         'CXXSUFFIX' => '.cc',
         'CXXDEPGEN' => ['-MMD', '-MF', '$_DEPFILE'],
         'CXXCOM' =>['$CXX', '-c', '-o', '$_TARGET', '$CXXDEPGEN', '-I$[CPPPATH]', '$CPPFLAGS', '$CXXFLAGS', '$_SOURCES'],
+
+        'DC' => 'gdc',
+        'DFLAGS' => [],
+        'DSUFFIX' => '.d',
+        'D_IMPORT_PATH' => [],
+        'DCCOM' => ['$DC', '-c', '-o', '$_TARGET', '-I$[D_IMPORT_PATH]', '$DFLAGS', '$_SOURCES'],
       }
     end
 
@@ -35,7 +41,8 @@ module Rscons
       target.has_suffix?(env['OBJSUFFIX']) and (
         source.has_suffix?(env['ASSUFFIX']) or
         source.has_suffix?(env['CSUFFIX']) or
-        source.has_suffix?(env['CXXSUFFIX']))
+        source.has_suffix?(env['CXXSUFFIX']) or
+        source.has_suffix?(env['DSUFFIX']))
     end
 
     def run(target, sources, cache, env, vars = {})
@@ -50,12 +57,14 @@ module Rscons
                      'CC'
                    elsif sources.first.has_suffix?(env['CXXSUFFIX'])
                      'CXX'
+                   elsif sources.first.has_suffix?(env['DSUFFIX'])
+                     'DC'
                    else
                      raise "Error: unknown input file type: #{sources.first.inspect}"
                    end
       command = env.build_command(env["#{com_prefix}COM"], vars)
       unless cache.up_to_date?(target, command, sources)
-        FileUtils.mkdir_p(File.dirname(target))
+        cache.mkdir_p(File.dirname(target))
         FileUtils.rm_f(target)
         return false unless env.execute("#{com_prefix} #{target}", command)
         deps = sources

lib/rscons/builders/program.rb

@@ -18,14 +18,19 @@ module Rscons
       # build sources to linkable objects
       objects = env.build_sources(sources, [env['OBJSUFFIX'], env['LIBSUFFIX']].flatten, cache, vars)
       if objects
-        use_cxx = sources.map do |s|
-          s.has_suffix?(env['CXXSUFFIX'])
-        end.any?
-        ld_alt = use_cxx ? env['CXX'] : env['CC']
+        ld = if env["LD"]
+               env["LD"]
+             elsif sources.find {|s| s.has_suffix?(env["DSUFFIX"])}
+               env["DC"]
+             elsif sources.find {|s| s.has_suffix?(env["CXXSUFFIX"])}
+               env["CXX"]
+             else
+               env["CC"]
+             end
         vars = vars.merge({
           '_TARGET' => target,
           '_SOURCES' => objects,
-          'LD' => env['LD'] || ld_alt,
+          'LD' => ld,
         })
         command = env.build_command(env['LDCOM'], vars)
         standard_build("LD #{target}", target, command, objects, env, cache)

lib/rscons/cache.rb

@@ -36,6 +36,11 @@ module Rscons
   #         ]
   #       }
   #     }
+  #     directories: {
+  #       'build' => true,
+  #       'build/one' => true,
+  #       'build/two' => true,
+  #     }
   #   }
   class Cache
     #### Constants
@@ -55,10 +60,14 @@ module Rscons
     # Create a Cache object and load in the previous contents from the cache
     # file.
     def initialize
-      @cache = YAML.load(File.read(CACHE_FILE)) rescue {
-        targets: {},
-        version: VERSION,
-      }
+      @cache = YAML.load(File.read(CACHE_FILE)) rescue {}
+      unless @cache.is_a?(Hash)
+        $stderr.puts "Warning: #{CACHE_FILE} was corrupt. Contents:\n#{@cache.inspect}"
+        @cache = {}
+      end
+      @cache[:targets] ||= {}
+      @cache[:directories] ||= {}
+      @cache[:version] ||= VERSION
       @lookup_checksums = {}
     end
 
@@ -120,18 +129,43 @@ module Rscons
     # @param command [Array] The command used to build the target.
     # @param deps [Array] List of dependencies for the target.
     def register_build(target, command, deps)
-      @cache[:targets][target] = {
+      @cache[:targets][target.encode(__ENCODING__)] = {
         command: command,
         checksum: calculate_checksum(target),
         deps: deps.map do |dep|
           {
-            fname: dep,
+            fname: dep.encode(__ENCODING__),
             checksum: lookup_checksum(dep),
           }
         end
       }
     end
 
+    # Return a list of targets that have been built
+    def targets
+      @cache[:targets].keys
+    end
+
+    # Make any needed directories and record the ones that are created for
+    # removal upon a "clean" operation.
+    def mkdir_p(path)
+      parts = path.split(/[\\\/]/)
+      (0..parts.size).each do |i|
+        subpath = File.join(*parts[0, i + 1]).encode(__ENCODING__)
+        unless File.exists?(subpath)
+          FileUtils.mkdir(subpath)
+          unless @cache[:directories].include?(subpath)
+            @cache[:directories][subpath] = true
+          end
+        end
+      end
+    end
+
+    # Return a list of directories which were created as a part of the build
+    def directories
+      @cache[:directories].keys
+    end
+
     # Private Instance Methods
     private
 

lib/rscons/environment.rb

@@ -6,7 +6,7 @@ module Rscons
   # contains a collection of construction variables, options, builders, and
   # rules for building targets.
   class Environment
-    # [Array] of {Builder} objects.
+    # [Hash] of {"builder_name" => builder_object} pairs.
     attr_reader :builders
 
     # Create an Environment object.
@@ -22,6 +22,7 @@ module Rscons
       @targets = {}
       @builders = {}
       @build_dirs = []
+      @tweakers = []
       @varset[:exclude_builders] ||= []
       unless @varset[:exclude_builders] == :all
         exclude_builders = Set.new(@varset[:exclude_builders] || [])
@@ -45,7 +46,7 @@ module Rscons
     # Make a copy of the Environment object.
     # The cloned environment will contain a copy of all environment options,
     # construction variables, builders, and build directories. It will not
-    # contain a copy of the targets.
+    # contain a copy of the targets or tweakers.
     # If a block is given, the Environment object is yielded to the block and
     # when the block returns, the {#process} method is automatically called.
     def clone(variables = {})
@@ -53,7 +54,7 @@ module Rscons
       @builders.each do |builder_name, builder|
         env.add_builder(builder)
       end
-      env.append(@varset)
+      env.append(@varset.clone)
       env.append(variables)
 
       if block_given?
@@ -74,11 +75,15 @@ module Rscons
       end
     end
 
+    # Add a tweaker block to the Environment.
+    def add_tweaker(&block)
+      @tweakers << block
+    end
+
     # Specify a build directory for this Environment.
     # Source files from src_dir will produce object files under obj_dir.
     def build_dir(src_dir, obj_dir)
       src_dir = src_dir.gsub('\\', '/') if src_dir.is_a?(String)
-      obj_dir = obj_dir.gsub('\\', '/')
       @build_dirs << [src_dir, obj_dir]
     end
 
@@ -92,11 +97,10 @@ module Rscons
         if src_dir.is_a?(Regexp)
           build_fname.sub!(src_dir, obj_dir)
         else
-          build_fname.sub!(/^#{src_dir}\//, "#{obj_dir}/")
+          build_fname.sub!(%r{^#{src_dir}/}, "#{obj_dir}/")
         end
         build_fname.gsub!('\\', '/')
       end
-      FileUtils.mkdir_p(File.dirname(build_fname))
       build_fname
     end
 
@@ -138,10 +142,10 @@ module Rscons
         if @targets[target][:source].map do |src|
           targets_processed.include?(src) or not @targets.include?(src) or process_target.call(src)
         end.all?
-          @targets[target][:builder].run(target,
+          run_builder(@targets[target][:builder],
+                      target,
                       @targets[target][:source],
                       cache,
-                                         self,
                       @targets[target][:vars] || {})
         else
           false
@@ -240,6 +244,7 @@ module Rscons
     # @param sources [Array] List of source files to build.
     # @param suffixes [Array] List of suffixes to try to convert source files into.
     # @param cache [Cache] The Cache.
+    # @param vars [Hash] Extra variables to pass to the builder.
     # Return a list of the converted file names.
     def build_sources(sources, suffixes, cache, vars = {})
       sources.map do |source|
@@ -251,7 +256,7 @@ module Rscons
             converted_fname = get_build_fname(source, suffix)
             builder = @builders.values.find { |b| b.produces?(converted_fname, source, self) }
             if builder
-              converted = builder.run(converted_fname, [source], cache, self, vars)
+              converted = run_builder(builder, converted_fname, [source], cache, vars)
               return nil unless converted
               break
             end
@@ -260,5 +265,26 @@ module Rscons
         end
       end
     end
+
+    # Invoke a builder to build the given target based on the given sources.
+    # @param builder [Builder] The Builder to use.
+    # @param target [String] The target output file.
+    # @param sources [Array] List of source files.
+    # @param cache [Cache] The Cache.
+    # @param vars [Hash] Extra variables to pass to the builder.
+    # Return the result of the builder's run() method.
+    def run_builder(builder, target, sources, cache, vars)
+      vars = @varset.merge(vars)
+      @tweakers.each do |tweaker_block|
+        build_operation = {
+          builder: builder,
+          target: target,
+          sources: sources,
+          vars: vars,
+        }
+        tweaker_block.call(build_operation)
+      end
+      builder.run(target, sources, cache, self, vars)
+    end
   end
 end

lib/rscons/varset.rb

@@ -24,9 +24,9 @@ module Rscons
     #   returned.
     def [](key, type = nil)
       val = @vars[key]
-      if type == :array and val.is_a?(String)
+      if type == :array and not val.is_a?(Array)
         [val]
-      elsif type == :string and val.is_a?(Array)
+      elsif type == :scalar and val.is_a?(Array)
         val.first
       else
         val
@@ -44,7 +44,7 @@ module Rscons
     # @param values [VarSet, Hash] New set of variables.
     def append(values)
       values = values.vars if values.is_a?(VarSet)
-      @vars.merge!(values)
+      @vars.merge!(Marshal.load(Marshal.dump(values)))
       self
     end
 

lib/rscons/version.rb

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

spec/build_tests_spec.rb

@@ -11,17 +11,35 @@ describe Rscons do
     FileUtils.rm_rf('build_tests_run')
   end
 
-  def build_testdir
-    if File.exists?("build.rb")
-      system("ruby -I #{@owd}/lib -r rscons build.rb > build.out")
+  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
-    get_build_output
   end
 
-  def test_dir(build_test_directory)
+  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_testdir(build_script)
   end
 
   def file_sub(fname)
@@ -35,10 +53,6 @@ describe Rscons do
     end
   end
 
-  def get_build_output
-    File.read('build.out').lines.map(&:strip)
-  end
-
   ###########################################################################
   # Tests
   ###########################################################################
@@ -116,8 +130,35 @@ describe Rscons do
   it 'builds object files in a different build directory' do
     lines = test_dir('build_dir')
     `./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
+    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')
+    `./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
+    Rscons.clean
+    File.exists?('build_one/one.o').should be_false
+    File.exists?('build_two/two.o').should be_false
+    File.exists?('build_one').should be_false
+    File.exists?('build_two').should be_false
+    File.exists?('src/one/one.c').should be_true
+  end
+
+  it 'does not clean created directories if other non-rscons-generated files reside there' do
+    lines = test_dir('build_dir')
+    `./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
+    File.open('build_two/tmp', 'w') { |fh| fh.puts "dum" }
+    Rscons.clean
+    File.exists?('build_one/one.o').should be_false
+    File.exists?('build_two/two.o').should be_false
+    File.exists?('build_one').should be_false
+    File.exists?('build_two').should be_true
+    File.exists?('src/one/one.c').should be_true
   end
 
   it 'allows Ruby classes as custom builders to be used to construct files' do
@@ -166,4 +207,14 @@ describe Rscons do
     File.exists?('library').should be_true
     `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"
+    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',
+    ]
+  end
 end

spec/rscons/environment_spec.rb

@@ -1,5 +1,16 @@
 module Rscons
   describe Environment do
+    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
+    end
+
     describe '.parse_makefile_deps' do
       it 'handles dependencies on one line' do
         File.should_receive(:read).with('makefile').and_return(<<EOS)

spec/rscons/monkey/module_spec.rb

@@ -0,0 +1,6 @@
+describe "Module#short_name" do
+  it "returns the inner name of the module" do
+    Rscons::Environment.short_name.should == "Environment"
+    Rscons::Object.short_name.should == "Object"
+  end
+end

spec/rscons/varset_spec.rb

@@ -0,0 +1,114 @@
+module Rscons
+  describe VarSet do
+    describe '.initialize' do
+      it "initializes variables from a Hash" do
+        v = VarSet.new({"one" => 1, "two" => :two})
+        v["one"].should == 1
+        v["two"].should == :two
+      end
+      it "initializes variables from another VarSet" do
+        v = VarSet.new({"one" => 1})
+        v2 = VarSet.new(v)
+        v2["one"].should == 1
+      end
+      it "makes a deep copy of the given VarSet" do
+        v = VarSet.new({"array" => [1, 2, 3]})
+        v2 = VarSet.new(v)
+        v["array"] << 4
+        v["array"].should == [1, 2, 3, 4]
+        v2["array"].should == [1, 2, 3]
+      end
+    end
+
+    describe :[] do
+      v = VarSet.new({"fuz" => "a string", "foo" => 42, "bar" => :baz,
+                      "qax" => [3, 6], "qux" => {a: :b}})
+      it "allows accessing a variable with its verbatim value if type is not specified" do
+        v["fuz"].should == "a string"
+        v["foo"].should == 42
+        v["bar"].should == :baz
+        v["qax"].should == [3, 6]
+        v["qux"].should == {a: :b}
+      end
+      it "allows accessing a non-array converted to an array" do
+        v["fuz", :array].should == ["a string"]
+      end
+      it "allows accessing an array as a single value" do
+        v["qax", :scalar].should == 3
+      end
+    end
+
+    describe :[]= do
+      it "allows assigning to variables" do
+        v = VarSet.new("CFLAGS" => ["-Wall", "-O3"])
+        v["CPPPATH"] = ["one", "two"]
+        v["CFLAGS"].should == ["-Wall", "-O3"]
+        v["CPPPATH"].should == ["one", "two"]
+      end
+    end
+
+    describe '.append' do
+      it "adds values from a Hash to the VarSet" do
+        v = VarSet.new("LDFLAGS" => "-lgcc")
+        v.append("LIBS" => "gcc", "LIBPATH" => ["mylibs"])
+        v.vars.keys.should =~ ["LDFLAGS", "LIBS", "LIBPATH"]
+      end
+      it "adds values from another VarSet to the VarSet" do
+        v = VarSet.new("CPPPATH" => ["mydir"])
+        v2 = VarSet.new("CFLAGS" => ["-O0"], "CPPPATH" => ["different_dir"])
+        v.append(v2)
+        v.vars.keys.should =~ ["CPPPATH", "CFLAGS"]
+        v["CPPPATH"].should == ["different_dir"]
+      end
+    end
+
+    describe '.merge' do
+      it "returns a new VarSet merged with the given Hash" do
+        v = VarSet.new("foo" => "yoda")
+        v2 = v.merge("baz" => "qux")
+        v.vars.keys.should == ["foo"]
+        v2.vars.keys.should =~ ["foo", "baz"]
+      end
+      it "returns a new VarSet merged with the given VarSet" do
+        v = VarSet.new("foo" => ["a", "b"], "bar" => 42)
+        v2 = v.merge(VarSet.new("bar" => 33, "baz" => :baz))
+        v2["foo"] << "c"
+        v["foo"].should == ["a", "b"]
+        v["bar"].should == 42
+        v2["foo"].should == ["a", "b", "c"]
+        v2["bar"].should == 33
+      end
+    end
+
+    describe '.expand_varref' do
+      v = VarSet.new("CFLAGS" => ["-Wall", "-O2"],
+                     "CC" => "gcc",
+                     "CPPPATH" => ["dir1", "dir2"],
+                     "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"]
+      end
+      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"]
+      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/
+      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/
+      end
+    end
+  end
+end

spec/spec_helper.rb

@@ -1 +1,5 @@
+require "simplecov"
+
+SimpleCov.start
+
 require "rscons"