v1.3.0

README.md

@@ -27,7 +27,7 @@ called from your Rakefile.
 ### Example: Building a C Program
 
 ```ruby
-RScons::Environment.new do |env|
+Rscons::Environment.new do |env|
   env["CFLAGS"] << "-Wall"
   env.Program("program", Dir["**/*.c"])
 end
@@ -36,7 +36,7 @@ end
 ### Example: Building a D Program
 
 ```ruby
-RScons::Environment.new do |env|
+Rscons::Environment.new do |env|
   env["DFLAGS"] << "-Wall"
   env.Program("program", Dir["**/*.d"])
 end
@@ -45,7 +45,7 @@ end
 ### Example: Cloning an Environment
 
 ```ruby
-main_env = RScons::Environment.new do |env|
+main_env = Rscons::Environment.new do |env|
   # Store object files from sources under "src" in "build/main"
   env.build_dir("src", "build/main")
   env["CFLAGS"] = ["-DSOME_DEFINE", "-O3"]
@@ -64,23 +64,96 @@ end
 
 ### Example: Custom Builder
 
+Custom builders are implemented as classes which extend from `Rscons::Builder`.
+The builder must have a `run` method which is called to invoke the builder.
+The `run` method should return the name of the target built on success, and
+`false` on failure.
+
 ```ruby
 class GenerateFoo < Rscons::Builder
   def run(target, sources, cache, env, vars)
+    cache.mkdir_p(File.dirname(target))
     File.open(target, "w") do |fh|
       fh.puts <<EOF
 #define GENERATED 42
 EOF
     end
+    target
   end
 end
 
 Rscons::Environment.new do |env|
+  env.add_builder(GenerateFoo.new)
   env.GenerateFoo("foo.h", [])
   env.Program("a.out", Dir["*.c"])
 end
 ```
 
+### Example: Custom Builder That Only Regenerates When Necessary
+
+```ruby
+class CmdBuilder < Rscons::Builder
+  def run(target, sources, cache, env, vars)
+    cmd = ["cmd", "-i", sources.first, "-o", target]
+    unless cache.up_to_date?(target, cmd, sources, env)
+      cache.mkdir_p(File.dirname(target))
+      system(cmd)
+      cache.register_build(target, cmd, sources, env)
+    end
+    target
+  end
+end
+
+Rscons::Environment.new do |env|
+  env.add_builder(CmdBuilder.new)
+  env.CmdBuilder("foo.gen", "foo_gen.cfg")
+end
+```
+
+### Example: Custom Builder That Generates Multiple Output Files
+
+```ruby
+class CModuleGenerator < Rscons::Builder
+  def run(target, sources, cache, env, vars)
+    c_fname = target
+    h_fname = target.sub(/\.c$/, ".h")
+    cmd = ["generate_c_and_h", sources.first, c_fname, h_fname]
+    unless cache.up_to_date?([c_fname, h_fname], cmd, sources, env)
+      cache.mkdir_p(File.dirname(target))
+      system(cmd)
+      cache.register_build([c_fname, h_fname], cmd, sources, env)
+    end
+    target
+  end
+end
+
+Rscons::Environment.new do |env|
+  env.add_builder(CModuleGenerator.new)
+  env.CModuleGenerator("build/foo.c", "foo_gen.cfg")
+end
+```
+
+### Example: Custom Builder Using Builder#standard_build()
+
+The `standard_build` method from the `Rscons::Builder` base class can be used
+when the builder needs to execute a system command to produce the target file.
+The `standard_build` method will return the correct value so its return value
+can be used as the return value from the `run` method.
+
+```ruby
+class CmdBuilder < Rscons::Builder
+  def run(target, sources, cache, env, vars)
+    cmd = ["cmd", "-i", sources.first, "-o", target]
+    standard_build("CmdBld #{target}", target, cmd, sources, env, cache)
+  end
+end
+
+Rscons::Environment.new do |env|
+  env.add_builder(CmdBuilder.new)
+  env.CmdBuilder("foo.gen", "foo_gen.cfg")
+end
+```
+
 ### Example: Using different compilation flags for some sources
 
 ```ruby
@@ -96,6 +169,19 @@ Rscons::Environment.new do |env|
 end
 ```
 
+Each build hook block will be invoked for every build operation, so the block
+should test the target or sources if its action should only apply to some
+subset of build targets or source files.
+
+The `build_op` parameter to the build hook block is a Hash describing the
+build operation with the following keys:
+* `:builder` - `Builder` instance in use
+* `:target` - `String` name of the target file
+* `:sources` - `Array` of the source files
+* `:vars` - `Rscons::VarSet` containing the construction variables to use
+The build hook can overwrite entries in `build_op[:vars]` to alter the
+construction variables in use for this specific build operation.
+
 ### Example: Creating a static library
 
 ```ruby
@@ -114,8 +200,8 @@ Rscons ships with a number of default builders:
 * Object, which compiles source files to produce an object file
 * Program, which links object files to produce an executable
 
-If you want to create an Environment that does not contain any (or select)
-builders, you can use the `exclude_builders` key to the Environment constructor.
+If you want to create an Environment that does not contain any builders,
+you can use the `exclude_builders` key to the Environment constructor.
 
 ### Managing Environments
 
@@ -123,7 +209,8 @@ An Rscons::Environment consists of:
 
 * a collection of construction variables
 * a collection of builders
-* a mapping of build directories
+* a mapping of build directories from source directories
+* a default build root to apply if no build directories are matched
 * a collection of targets to build
 * a collection of build hooks
 
@@ -143,12 +230,34 @@ cloned_env["CPPPATH"] << "three"
 
 `base_env["CPPPATH"]` will not include "three".
 
-### Construction Variables
+### Construction Variable Naming
 
-The default construction variables that Rscons uses are named using uppercase
-strings.
-Rscons options are lowercase symbols.
-Lowercase strings are reserved as user-defined construction variables.
+* uppercase strings - the default construction variables that Rscons uses
+* lowercase symbols - Rscons options
+* lowercase strings - reserved as user-defined construction variables
+
+### API documentation
+
+Documentation for the complete Rscons API can be found at
+http://rubydoc.info/github/holtrop/rscons/frames.
+
+## Release Notes
+
+### v1.3.0
+
+- change Environment#execute() options parameter to accept the following options keys:
+  - :env to pass an environment Hash to Kernel#system
+  - :options to pass an options Hash to Kernel#system
+
+### v1.2.0
+
+- add :clone option to Environment#clone to control exactly which Environment attributes are cloned
+- allow nil to be passed in to Environment#build_root=
+
+### v1.1.0
+
+- Change Cache#up_to_date?() and #register_build() to accept a single target
+  file or an array of target file names
 
 ## Contributing
 

lib/rscons.rb

@@ -1,27 +1,23 @@
-require "rscons/builder"
-require "rscons/cache"
-require "rscons/environment"
-require "rscons/varset"
-require "rscons/version"
-
-require "rscons/monkey/module"
-require "rscons/monkey/string"
+require_relative "rscons/builder"
+require_relative "rscons/cache"
+require_relative "rscons/environment"
+require_relative "rscons/varset"
+require_relative "rscons/version"
 
 # default builders
-require "rscons/builders/library"
-require "rscons/builders/object"
-require "rscons/builders/program"
+require_relative "rscons/builders/library"
+require_relative "rscons/builders/object"
+require_relative "rscons/builders/program"
 
 # Namespace module for rscons classes
 module Rscons
   DEFAULT_BUILDERS = [
-    Library,
-    Object,
-    Program,
+    :Library,
+    :Object,
+    :Program,
   ]
 
-  class BuildError < Exception
-  end
+  class BuildError < RuntimeError; end
 
   # Remove all generated files
   def self.clean
@@ -39,4 +35,17 @@ module Rscons
     end
     Cache.clear
   end
+
+  # Return whether the given path is an absolute filesystem path or not
+  # @param path [String] the path to examine
+  def self.absolute_path?(path)
+    path =~ %r{^(/|\w:[\\/])}
+  end
+
+  # Return a new path by changing the suffix in path to suffix.
+  # @param path [String] the path to alter
+  # @param suffix [String] the new filename suffix
+  def self.set_suffix(path, suffix)
+    path.sub(/\.[^.]*$/, suffix)
+  end
 end

lib/rscons/builder.rb

@@ -1,8 +1,17 @@
 require "fileutils"
 
 module Rscons
+  # Namespace module in which to store builders for convenient grouping
+  module Builders; end
+
   # Class to hold an object that knows how to build a certain type of file.
   class Builder
+    # Return the name of the builder.
+    # If not overridden this defaults to the last component of the class name.
+    def name
+      self.class.name.split(":").last
+    end
+
     # Return a set of default variable values for the Environment to use
     # unless the user overrides any.
     # @param env [Environment] The Environment.
@@ -23,11 +32,11 @@ module Rscons
     # build command.
     # 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)
+      unless cache.up_to_date?(target, command, sources, env)
         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)
+        cache.register_build(target, command, sources, env)
       end
       target
     end

lib/rscons/builders/library.rb

@@ -1,8 +1,7 @@
-require 'fileutils'
-
 module Rscons
-  # A default RScons builder that produces a static library archive.
-  class Library < Builder
+  module Builders
+    # A default Rscons builder that produces a static library archive.
+    class Rscons::Builders::Library < Rscons::Builder
       def default_variables(env)
         {
           'AR' => 'ar',
@@ -12,7 +11,7 @@ module Rscons
         }
       end
 
-    def run(target, sources, cache, env, vars = {})
+      def run(target, sources, cache, env, vars)
         # build sources to linkable objects
         objects = env.build_sources(sources, [env['OBJSUFFIX'], env['LIBSUFFIX']].flatten, cache, vars)
         if objects
@@ -26,3 +25,4 @@ module Rscons
       end
     end
   end
+end

lib/rscons/builders/object.rb

@@ -1,5 +1,6 @@
 module Rscons
-  # A default RScons builder which knows how to produce an object file from
+  module Builders
+    # A default Rscons builder which knows how to produce an object file from
     # various types of source files.
     class Object < Builder
       KNOWN_SUFFIXES = {
@@ -45,24 +46,24 @@ module Rscons
       end
 
       def produces?(target, source, env)
-      target.has_suffix?(env['OBJSUFFIX']) and KNOWN_SUFFIXES.find do |compiler, suffix_var|
-        source.has_suffix?(env[suffix_var])
+        target.end_with?(*env['OBJSUFFIX']) and KNOWN_SUFFIXES.find do |compiler, suffix_var|
+          source.end_with?(*env[suffix_var])
         end
       end
 
-    def run(target, sources, cache, env, vars = {})
+      def run(target, sources, cache, env, vars)
         vars = vars.merge({
           '_TARGET' => target,
           '_SOURCES' => sources,
-        '_DEPFILE' => target.set_suffix('.mf'),
+          '_DEPFILE' => Rscons.set_suffix(target, '.mf'),
         })
         com_prefix = KNOWN_SUFFIXES.find do |compiler, suffix_var|
-        sources.first.has_suffix?(env[suffix_var])
+          sources.first.end_with?(*env[suffix_var])
         end.tap do |v|
           v.nil? and raise "Error: unknown input file type: #{sources.first.inspect}"
         end.first
         command = env.build_command(env["#{com_prefix}CMD"], vars)
-      unless cache.up_to_date?(target, command, sources)
+        unless cache.up_to_date?(target, command, sources, env)
           cache.mkdir_p(File.dirname(target))
           FileUtils.rm_f(target)
           return false unless env.execute("#{com_prefix} #{target}", command)
@@ -71,9 +72,10 @@ module Rscons
             deps += Environment.parse_makefile_deps(vars['_DEPFILE'], target)
             FileUtils.rm_f(vars['_DEPFILE'])
           end
-        cache.register_build(target, command, deps.uniq)
+          cache.register_build(target, command, deps.uniq, env)
         end
         target
       end
     end
   end
+end

lib/rscons/builders/program.rb

@@ -1,7 +1,8 @@
 module Rscons
-  # A default RScons builder that knows how to link object files into an
+  module Builders
+    # A default Rscons builder that knows how to link object files into an
     # executable program.
-  class Program < Builder
+    class Rscons::Builders::Program < Rscons::Builder
       def default_variables(env)
         {
           'LD' => nil,
@@ -14,14 +15,15 @@ module Rscons
         }
       end
 
-    def run(target, sources, cache, env, vars = {})
+      def run(target, sources, cache, env, vars)
         # build sources to linkable objects
         objects = env.build_sources(sources, [env['OBJSUFFIX'], env['LIBSUFFIX']].flatten, cache, vars)
+        return false unless objects
         ld = if env["LD"]
                env["LD"]
-           elsif sources.find {|s| s.has_suffix?(env["DSUFFIX"])}
+             elsif sources.find {|s| s.end_with?(*env["DSUFFIX"])}
                env["DC"]
-           elsif sources.find {|s| s.has_suffix?(env["CXXSUFFIX"])}
+             elsif sources.find {|s| s.end_with?(*env["CXXSUFFIX"])}
                env["CXX"]
              else
                env["CC"]
@@ -36,3 +38,4 @@ module Rscons
       end
     end
   end
+end

lib/rscons/cache.rb

@@ -18,9 +18,15 @@ module Rscons
   #           {
   #             'fname' => 'program.o',
   #             'checksum' => '87654321',
-  #           }
+  #           },
   #         ],
-  #       }
+  #         'user_deps' => [
+  #           {
+  #             'fname' => 'lscript.ld',
+  #             'checksum' => '77551133',
+  #           },
+  #         ],
+  #       },
   #       'program.o' => {
   #         'checksum' => '87654321',
   #         'command' => ['gcc', '-c', '-o', 'program.o', 'program.c'],
@@ -32,15 +38,16 @@ module Rscons
   #           {
   #             'fname' => 'program.h',
   #             'checksum' => '7979764643',
+  #           },
+  #         ],
+  #         'user_deps' => [],
   #       }
-  #         ]
-  #       }
-  #     }
+  #     },
   #     directories: {
   #       'build' => true,
   #       'build/one' => true,
   #       'build/two' => true,
-  #     }
+  #     },
   #   }
   class Cache
     #### Constants
@@ -78,15 +85,17 @@ module Rscons
       end
     end
 
-    # Check if a target is up to date
-    # @param target [String] The name of the target file.
-    # @param command [Array] The command used to build the target.
+    # Check if target(s) are up to date
+    # @param targets [String, Array] The name(s) of the target file(s).
+    # @param command [String, Array] The command used to build the target.
     # @param deps [Array] List of the target's dependency files.
+    # @param env [Environment] The Rscons::Environment.
     # @param options [Hash] Optional options. Can contain the following keys:
     #   :strict_deps::
     #     Only consider a target up to date if its list of dependencies is
     #     exactly equal (including order) to the cached list of dependencies
-    # @return true value if the target is up to date, meaning that:
+    # @return true if the targets are all up to date, meaning that,
+    #   for each target:
     #   - the target exists on disk
     #   - the cache has information for the target
     #   - the target's checksum matches its checksum when it was last built
@@ -96,7 +105,8 @@ module Rscons
     #     exactly equal to those cached
     #   - each cached dependency file's current checksum matches the checksum
     #     stored in the cache file
-    def up_to_date?(target, command, deps, options = {})
+    def up_to_date?(targets, command, deps, env, options = {})
+      Array(targets).each do |target|
         # target file must exist on disk
         return false unless File.exists?(target)
 
@@ -109,28 +119,38 @@ module Rscons
         # command used to build target must be identical
         return false unless @cache[:targets][target][:command] == command
 
-      cached_deps = @cache[:targets][target][:deps].map { |dc| dc[:fname] }
+        cached_deps = @cache[:targets][target][:deps] || []
+        cached_deps_fnames = cached_deps.map { |dc| dc[:fname] }
         if options[:strict_deps]
           # depedencies passed in must exactly equal those in the cache
-        return false unless deps == cached_deps
+          return false unless deps == cached_deps_fnames
         else
           # all dependencies passed in must exist in cache (but cache may have more)
-        return false unless (Set.new(deps) - Set.new(cached_deps)).empty?
+          return false unless (Set.new(deps) - Set.new(cached_deps_fnames)).empty?
         end
 
+        # set of user dependencies must match
+        user_deps = env.get_user_deps(target) || []
+        cached_user_deps = @cache[:targets][target][:user_deps] || []
+        cached_user_deps_fnames = cached_user_deps.map { |dc| dc[:fname] }
+        return false unless user_deps == cached_user_deps_fnames
+
         # all cached dependencies must have their checksums match
-      @cache[:targets][target][:deps].each do |dep_cache|
+        (cached_deps + cached_user_deps).each do |dep_cache|
           return false unless dep_cache[:checksum] == lookup_checksum(dep_cache[:fname])
         end
+      end
 
       true
     end
 
-    # Store cache information about a target built by a builder
-    # @param target [String] The name of the target.
-    # @param command [Array] The command used to build the target.
+    # Store cache information about target(s) built by a builder
+    # @param targets [String, Array] The name of the target(s) built.
+    # @param command [String, Array] The command used to build the target.
     # @param deps [Array] List of dependencies for the target.
-    def register_build(target, command, deps)
+    # @param env [Environment] The Rscons::Environment.
+    def register_build(targets, command, deps, env)
+      Array(targets).each do |target|
         @cache[:targets][target.encode(__ENCODING__)] = {
           command: command,
           checksum: calculate_checksum(target),
@@ -139,8 +159,15 @@ module Rscons
               fname: dep.encode(__ENCODING__),
               checksum: lookup_checksum(dep),
             }
-        end
+          end,
+          user_deps: (env.get_user_deps(target) || []).map do |dep|
+            {
+              fname: dep.encode(__ENCODING__),
+              checksum: lookup_checksum(dep),
             }
+          end,
+        }
+      end
     end
 
     # Return a list of targets that have been built

lib/rscons/environment.rb

@@ -2,40 +2,47 @@ require 'set'
 require 'fileutils'
 
 module Rscons
-  # The Environment class is the main programmatic interface to RScons. It
+  # The Environment class is the main programmatic interface to Rscons. It
   # contains a collection of construction variables, options, builders, and
   # rules for building targets.
   class Environment
     # Hash of +{"builder_name" => builder_object}+ pairs.
     attr_reader :builders
 
+    # :command, :short, or :off
+    attr_accessor :echo
+
     # String or +nil+
-    attr_accessor :build_root
+    attr_reader :build_root
+    def build_root=(build_root)
+      @build_root = build_root
+      @build_root.gsub!('\\', '/') if @build_root
+    end
 
     # Create an Environment object.
-    # @param variables [Hash]
-    #   The variables hash can contain construction variables, which are
-    #   uppercase strings (such as "CC" or "LDFLAGS"), user variables, which
-    #   are lowercase strings (such as "sources"), and RScons options, which
-    #   are lowercase symbols (such as :echo).
+    # @param options [Hash]
+    # Possible options keys:
+    #   :echo => :command, :short, or :off (default :short)
+    #   :build_root => String specifying build root directory (default nil)
+    #   :exclude_builders => true to omit adding default builders (default false)
     # 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 initialize(variables = {})
-      @varset = VarSet.new(variables)
+    def initialize(options = {})
+      @varset = VarSet.new
       @targets = {}
+      @user_deps = {}
       @builders = {}
       @build_dirs = []
       @build_hooks = []
-      @varset[:exclude_builders] ||= []
-      unless @varset[:exclude_builders] == :all
-        exclude_builders = Set.new(@varset[:exclude_builders] || [])
-        DEFAULT_BUILDERS.each do |builder_class|
-          unless exclude_builders.include?(builder_class.short_name)
+      unless options[:exclude_builders]
+        DEFAULT_BUILDERS.each do |builder_class_name|
+          builder_class = Builders.const_get(builder_class_name)
+          builder_class or raise "Could not find builder class #{builder_class_name}"
           add_builder(builder_class.new)
         end
       end
-      end
-      @varset[:echo] ||= :short
+      @echo = options[:echo] || :short
+      @build_root = options[:build_root]
 
       if block_given?
         yield self
@@ -44,18 +51,53 @@ module Rscons
     end
 
     # Make a copy of the Environment object.
-    # The cloned environment will contain a copy of all environment options,
-    # construction variables, and builders. It will not contain a copy of the
-    # targets, build hooks, build directories, or the build root.  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 = {})
-      env = self.class.new
+    #
+    # By default, a cloned environment will contain a copy of all environment
+    # options, construction variables, and builders, but not a copy of the
+    # targets, build hooks, build directories, or the build root.
+    #
+    # Exactly which items are cloned are controllable via the optional :clone
+    # parameter, which can be :none, :all, or a set or array of any of the
+    # following:
+    # - :variables to clone construction variables (on by default)
+    # - :builders to clone the builders (on by default)
+    # - :build_root to clone the build root (off by default)
+    # - :build_dirs to clone the build directories (off by default)
+    # - :build_hooks to clone the build hooks (off by default)
+    #
+    # If a block is given, the Environment object is yielded to the block and
+    # when the block returns, the {#process} method is automatically called.
+    #
+    # Any options that #initialize receives can also be specified here.
+    #
+    # @return a new {Environment} object.
+    def clone(options = {})
+      clone = options[:clone] || Set[:variables, :builders]
+      clone = Set[:variables, :builders, :build_root, :build_dirs, :build_hooks] if clone == :all
+      clone = Set[] if clone == :none
+      clone = Set.new(clone) if clone.is_a?(Array)
+      clone.delete(:builders) if options[:exclude_builders]
+      env = self.class.new(
+        echo: options[:echo] || @echo,
+        build_root: options[:build_root],
+        exclude_builders: true)
+      if clone.include?(:builders)
         @builders.each do |builder_name, builder|
           env.add_builder(builder)
         end
-      env.append(@varset.clone)
-      env.append(variables)
+      end
+      env.append(@varset.clone) if clone.include?(:variables)
+      env.build_root = @build_root if clone.include?(:build_root)
+      if clone.include?(:build_dirs)
+        @build_dirs.each do |src_dir, obj_dir|
+          env.build_dir(src_dir, obj_dir)
+        end
+      end
+      if clone.include?(:build_hooks)
+        @build_hooks.each do |build_hook_block|
+          env.add_build_hook(&build_hook_block)
+        end
+      end
 
       if block_given?
         yield env
@@ -66,7 +108,7 @@ module Rscons
 
     # Add a {Builder} object to the Environment.
     def add_builder(builder)
-      @builders[builder.class.short_name] = builder
+      @builders[builder.name] = builder
       var_defs = builder.default_variables(self)
       if var_defs
         var_defs.each_pair do |var, val|
@@ -90,7 +132,7 @@ module Rscons
     # Return the file name to be built from source_fname with suffix suffix.
     # This method takes into account the Environment's build directories.
     def get_build_fname(source_fname, suffix)
-      build_fname = source_fname.set_suffix(suffix).gsub('\\', '/')
+      build_fname = Rscons.set_suffix(source_fname, suffix).gsub('\\', '/')
       found_match = @build_dirs.find do |src_dir, obj_dir|
         if src_dir.is_a?(Regexp)
           build_fname.sub!(src_dir, obj_dir)
@@ -99,7 +141,7 @@ module Rscons
         end
       end
       if @build_root and not found_match
-        unless source_fname.start_with?('/') or source_fname =~ %r{^\w:[\\/]}
+        unless Rscons.absolute_path?(source_fname) or build_fname.start_with?("#{@build_root}/")
           build_fname = "#{@build_root}/#{build_fname}"
         end
       end
@@ -156,6 +198,11 @@ module Rscons
       cache.write
     end
 
+    # Clear all targets registered for the Environment.
+    def clear_targets
+      @targets = {}
+    end
+
     # Build a command line from the given template, resolving references to
     # variables using the Environment's construction variables and any extra
     # variables specified.
@@ -168,22 +215,31 @@ module Rscons
       @varset.merge(extra_vars).expand_varref(command_template)
     end
 
+    # Expand a construction variable reference (String or Array)
+    def expand_varref(varref)
+      @varset.expand_varref(varref)
+    end
+
     # Execute a builder command
-    # @param short_desc [String] Message to print if the Environment's :echo
+    # @param short_desc [String] Message to print if the Environment's echo
     #   mode is set to :short
     # @param command [Array] The command to execute.
-    # @param options [Hash] Optional options to pass to Kernel#system.
+    # @param options [Hash] Optional options, possible keys:
+    #   - :env - environment Hash to pass to Kernel#system.
+    #   - :options - options Hash to pass to Kernel#system.
     def execute(short_desc, command, options = {})
       print_command = proc do
         puts command.map { |c| c =~ /\s/ ? "'#{c}'" : c }.join(' ')
       end
-      if @varset[:echo] == :command
+      if @echo == :command
         print_command.call
-      elsif @varset[:echo] == :short
+      elsif @echo == :short
         puts short_desc
       end
-      system(*command, options).tap do |result|
-        unless result or @varset[:echo] == :command
+      env_args = options[:env] ? [options[:env]] : []
+      options_args = options[:options] ? [options[:options]] : []
+      system(*env_args, *command, *options_args).tap do |result|
+        unless result or @echo == :command
           $stdout.write "Failed command was: "
           print_command.call
         end
@@ -209,17 +265,30 @@ module Rscons
       end
     end
 
+    # Manually record a given target as depending on the specified
+    # dependency files.
+    def depends(target, *user_deps)
+      @user_deps[target] ||= []
+      @user_deps[target] = (@user_deps[target] + user_deps).uniq
+    end
+
+    # Return the list of user dependencies for a given target, or +nil+ for
+    # none.
+    def get_user_deps(target)
+      @user_deps[target]
+    end
+
     # Build a list of source files into files containing one of the suffixes
     # given by suffixes.
-    # This method is used internally by RScons builders.
+    # This method is used internally by Rscons builders.
     # @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 = {})
+    def build_sources(sources, suffixes, cache, vars)
       sources.map do |source|
-        if source.has_suffix?(suffixes)
+        if source.end_with?(*suffixes)
           source
         else
           converted = nil
@@ -259,7 +328,7 @@ module Rscons
     end
 
     # Parse dependencies for a given target from a Makefile.
-    # This method is used internally by RScons builders.
+    # This method is used internally by Rscons builders.
     # @param mf_fname [String] File name of the Makefile to read.
     # @param target [String] Name of the target to gather dependencies for.
     def self.parse_makefile_deps(mf_fname, target)

lib/rscons/monkey/module.rb

@@ -1,7 +0,0 @@
-# Standard Ruby Module class.
-class Module
-  # @return the base module name (not the fully qualified name)
-  def short_name
-    name.split(':').last
-  end
-end

lib/rscons/monkey/string.rb

@@ -1,20 +0,0 @@
-# Standard Ruby String class.
-class String
-  # Check if the given string ends with any of the supplied suffixes
-  # @param suffix [String, Array] The suffix to look for.
-  # @return a true value if the string ends with one of the suffixes given.
-  def has_suffix?(suffix)
-    if suffix
-      suffix = [suffix] if suffix.is_a?(String)
-      suffix = suffix.flatten
-      suffix.find {|s| self.end_with?(s)}
-    end
-  end
-
-  # Return a new string with the suffix (dot character and extension) changed
-  # to the given suffix.
-  # @param suffix [String] The new suffix.
-  def set_suffix(suffix = '')
-    sub(/\.[^.]*$/, suffix)
-  end
-end

lib/rscons/varset.rb

@@ -17,20 +17,8 @@ module Rscons
 
     # Access the value of variable as a particular type
     # @param key [String, Symbol] The variable name.
-    # @param type [Symbol, nil] Optional specification of the type desired.
-    #   If the variable is a String and type is :array, a 1-element array with
-    #   the variable value will be returned. If the variable is an Array and
-    #   type is :string, the first element from the variable value will be
-    #   returned.
-    def [](key, type = nil)
-      val = @vars[key]
-      if type == :array and not val.is_a?(Array)
-        [val]
-      elsif type == :scalar and val.is_a?(Array)
-        val.first
-      else
-        val
-      end
+    def [](key)
+      @vars[key]
     end
 
     # Assign a value to a variable.
@@ -72,7 +60,7 @@ module Rscons
           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}"
+            raise "I do not know how to expand a variable reference to a #{varval.class.name} (from #{varname.inspect} => #{@vars[varname].inspect})"
           end
         else
           varref

lib/rscons/version.rb

@@ -1,4 +1,4 @@
 module Rscons
   # gem version
-  VERSION = "0.2.1"
+  VERSION = "1.3.0"
 end

spec/build_tests_spec.rb

@@ -220,7 +220,7 @@ describe Rscons do
   it 'allows Ruby classes as custom builders to be used to construct files' do
     test_dir('custom_builder')
     class MySource < Rscons::Builder
-      def run(target, sources, cache, env, vars = {})
+      def run(target, sources, cache, env, vars)
         File.open(target, 'w') do |fh|
           fh.puts <<EOF
     #define THE_VALUE 5678
@@ -241,6 +241,39 @@ EOF
     `./program`.should == "The value is 5678\n"
   end
 
+  it 'supports custom builders with multiple targets' do
+    test_dir('custom_builder')
+    class CHGen < Rscons::Builder
+      def run(target, sources, cache, env, vars)
+        c_fname = target
+        h_fname = target.sub(/\.c$/, ".h")
+        unless cache.up_to_date?([c_fname, h_fname], "", sources, env)
+          puts "CHGen #{c_fname}"
+          File.open(c_fname, "w") {|fh| fh.puts "int THE_VALUE = 42;"}
+          File.open(h_fname, "w") {|fh| fh.puts "extern int THE_VALUE;"}
+          cache.register_build([c_fname, h_fname], "", sources, env)
+        end
+        target
+      end
+    end
+
+    env = Rscons::Environment.new do |env|
+      env.add_builder(CHGen.new)
+      env.CHGen("inc.c", ["program.c"])
+      env.Program("program", Dir["*.c"] + ["inc.c"])
+    end
+
+    lines.should == ["CHGen inc.c", "CC program.o", "CC inc.o", "LD program"]
+    File.exists?("inc.c").should be_true
+    File.exists?("inc.h").should be_true
+    `./program`.should == "The value is 42\n"
+
+    File.open("inc.c", "w") {|fh| fh.puts "int THE_VALUE = 33;"}
+    env.process
+    lines.should == ["CHGen inc.c"]
+    `./program`.should == "The value is 42\n"
+  end
+
   it 'allows cloning Environment objects' do
     test_dir('clone_env')
 
@@ -251,7 +284,8 @@ EOF
       env.Program('program-debug', Dir['src/*.c'])
     end
 
-    release = debug.clone('CPPFLAGS' => '-DSTRING="Release Version"') do |env|
+    release = debug.clone do |env|
+      env["CPPFLAGS"] = '-DSTRING="Release Version"'
       env.build_dir('src', 'release')
       env.Program('program-release', Dir['src/*.c'])
     end
@@ -264,6 +298,29 @@ EOF
     ]
   end
 
+  it 'allows cloning all attributes of an Environment object' do
+    test_dir('clone_env')
+
+    env1 = Rscons::Environment.new(echo: :command) do |env|
+      env.build_dir('src', 'build')
+      env['CFLAGS'] = '-O2'
+      env.add_build_hook do |build_op|
+        build_op[:vars]['CPPFLAGS'] = '-DSTRING="Hello"'
+      end
+      env.Program('program', Dir['src/*.c'])
+    end
+
+    env2 = env1.clone(clone: :all) do |env|
+      env.Program('program2', Dir['src/*.c'])
+    end
+
+    lines.should == [
+      %q{gcc -c -o build/program.o -MMD -MF build/program.mf -DSTRING="Hello" -O2 src/program.c},
+      %q{gcc -o program build/program.o},
+      %q{gcc -o program2 build/program.o},
+    ]
+  end
+
   it 'builds a C++ program with one source file' do
     test_dir('simple_cc')
     Rscons::Environment.new do |env|
@@ -327,6 +384,37 @@ EOF
     ]
   end
 
+  it 'rebuilds when user-specified dependencies change' do
+    test_dir('simple')
+    Rscons::Environment.new do |env|
+      env.Program('simple', Dir['*.c'])
+      File.open("file.ld", "w") do |fh|
+        fh.puts("foo")
+      end
+      env.depends('simple', 'file.ld')
+    end
+    lines.should == ["CC simple.o", "LD simple"]
+    File.exists?('simple.o').should be_true
+    `./simple`.should == "This is a simple C program\n"
+    Rscons::Environment.new do |env|
+      env.Program('simple', Dir['*.c'])
+      File.open("file.ld", "w") do |fh|
+        fh.puts("bar")
+      end
+      env.depends('simple', 'file.ld')
+    end
+    lines.should == ["LD simple"]
+    Rscons::Environment.new do |env|
+      env.Program('simple', Dir['*.c'])
+      File.unlink("file.ld")
+    end
+    lines.should == ["LD simple"]
+    Rscons::Environment.new do |env|
+      env.Program('simple', Dir['*.c'])
+    end
+    lines.should == []
+  end
+
   unless ENV["omit_gdc_tests"]
     it "supports building D sources" do
       test_dir("d")

spec/rscons/cache_spec.rb

@@ -38,14 +38,19 @@ module Rscons
     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", []).should be_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", []).should be_false
+        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
@@ -53,7 +58,7 @@ module Rscons
         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
+        cache.up_to_date?("target", "command", [], empty_env).should be_false
       end
 
       it "returns false when the build command has changed" do
@@ -61,7 +66,7 @@ module Rscons
         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
+        cache.up_to_date?("target", "command", [], empty_env).should be_false
       end
 
       it "returns false when there is a new dependency" do
@@ -71,7 +76,7 @@ module Rscons
         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
+        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
@@ -82,13 +87,14 @@ module Rscons
                                                 {fname: "dep.2",
                                                  checksum: "dep.2.chk"},
                                                 {fname: "extra.dep",
-                                                 checksum: "extra.dep.chk"}]}}}
+                                                 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"]).should be_false
+        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
@@ -99,11 +105,48 @@ module Rscons
                                                 {fname: "dep.2",
                                                  checksum: "dep.2.chk"},
                                                 {fname: "extra.dep",
-                                                 checksum: "extra.dep.chk"}]}}}
+                                                 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"], strict_deps: true).should be_false
+        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: "command",
+                                         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: "command",
+                                         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
@@ -114,14 +157,15 @@ module Rscons
                                                 {fname: "dep.2",
                                                  checksum: "dep.2.chk"},
                                                 {fname: "extra.dep",
-                                                 checksum: "extra.dep.chk"}]}}}
+                                                 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"]).should be_true
+        cache.up_to_date?("target", "command", ["dep.1", "dep.2"], empty_env).should be_true
       end
     end
 
@@ -129,10 +173,13 @@ module Rscons
       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.register_build("the target", "the command", ["dep 1", "dep 2"])
+        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 == "the command"
@@ -141,6 +188,9 @@ module Rscons
           {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
 

spec/rscons/environment_spec.rb

@@ -1,12 +1,6 @@
 module Rscons
   describe Environment 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
@@ -17,18 +11,10 @@ module Rscons
       end
 
       it "excludes the default builders with exclude_builders: :all" do
-        env = Environment.new(exclude_builders: :all)
+        env = Environment.new(exclude_builders: true)
         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|
@@ -60,9 +46,9 @@ module Rscons
 
     describe "#add_builder" do
       it "adds the builder to the list of builders" do
-        env = Environment.new(exclude_builders: :all)
+        env = Environment.new(exclude_builders: true)
         env.builders.keys.should == []
-        env.add_builder(Rscons::Object.new)
+        env.add_builder(Rscons::Builders::Object.new)
         env.builders.keys.should == ["Object"]
       end
     end
@@ -75,6 +61,18 @@ module Rscons
           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
@@ -87,19 +85,36 @@ module Rscons
           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("CFLAGS" => ["-g", "-Wall"])
+        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("CFLAGS" => ["-g", "-Wall"])
+        env = Environment.new
+        env["CFLAGS"] = ["-g", "-Wall"]
         env["CFLAGS"] -= ["-g"]
         env["CFLAGS"] += ["-O3"]
         env["CFLAGS"].should == ["-Wall", "-O3"]
@@ -110,7 +125,9 @@ module Rscons
 
     describe "#append" do
       it "allows adding many construction variables at once" do
-        env = Environment.new("CFLAGS" => ["-g"], "CPPPATH" => ["inc"])
+        env = Environment.new
+        env["CFLAGS"] = ["-g"]
+        env["CPPPATH"] = ["inc"]
         env.append("CFLAGS" => ["-Wall"], "CPPPATH" => ["include"])
         env["CFLAGS"].should == ["-Wall"]
         env["CPPPATH"].should == ["include"]
@@ -158,6 +175,18 @@ module Rscons
       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
@@ -170,13 +199,27 @@ module Rscons
       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.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.should_receive(:system).with("a", "command").and_return(true)
             env.execute("short desc", ["a", "command"])
           end
         end
@@ -185,7 +228,7 @@ module Rscons
           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)
+            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"])
@@ -197,8 +240,8 @@ module Rscons
         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)
+          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
@@ -228,6 +271,20 @@ module Rscons
       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)

spec/rscons/monkey/module_spec.rb

@@ -1,6 +0,0 @@
-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

@@ -30,12 +30,6 @@ module Rscons
         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