rscons 0.0.1

data/lib/rscons/environment.rb

@@ -0,0 +1,227 @@
+require 'set'
+require 'fileutils'
+
+module Rscons
+  # 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
+    # [Array] of {Builder} objects.
+    attr_reader :builders
+
+    # Create an Environment object.
+    # @param variables [Hash]
+    #   The variables hash can contain both construction variables, which are
+    #   uppercase strings (such as "CC" or "LDFLAGS"), and RScons options,
+    #   which are lowercase symbols (such as :echo).
+    # 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)
+      @targets = {}
+      @builders = {}
+      @build_dirs = {}
+      @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)
+            add_builder(builder_class.new)
+          end
+        end
+      end
+      (@varset[:builders] || []).each do |builder|
+        add_builder(builder)
+      end
+      @varset[:echo] ||= :command
+
+      if block_given?
+        yield self
+        self.process
+      end
+    end
+
+    # 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.
+    # 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 = Environment.new()
+      @builders.each do |builder_name, builder|
+        env.add_builder(builder)
+      end
+      @build_dirs.each do |src_dir, obj_dir|
+        env.build_dir(src_dir, obj_dir)
+      end
+      env.append(@varset)
+      env.append(variables)
+
+      if block_given?
+        yield env
+        env.process
+      end
+      env
+    end
+
+    # Add a {Builder} object to the Environment.
+    def add_builder(builder)
+      @builders[builder.class.short_name] = builder
+      var_defs = builder.default_variables(self)
+      if var_defs
+        var_defs.each_pair do |var, val|
+          @varset[var] ||= val
+        end
+      end
+    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)
+      @build_dirs[src_dir.gsub('\\', '/')] = obj_dir.gsub('\\', '/')
+    end
+
+    # Return the file name to be built from source_fname with suffix suffix.
+    # This method takes into account the Environment's build directories.
+    # It also creates any parent directories needed to be able to open and
+    # write to the output file.
+    def get_build_fname(source_fname, suffix)
+      build_fname = source_fname.set_suffix(suffix).gsub('\\', '/')
+      @build_dirs.each do |src_dir, obj_dir|
+        build_fname.sub!(/^#{src_dir}\//, "#{obj_dir}/")
+      end
+      FileUtils.mkdir_p(File.dirname(build_fname))
+      build_fname
+    end
+
+    # Access a construction variable or environment option.
+    # @see VarSet#[]
+    def [](*args)
+      @varset.send(:[], *args)
+    end
+
+    # Set a construction variable or environment option.
+    # @see VarSet#[]=
+    def []=(*args)
+      @varset.send(:[]=, *args)
+    end
+
+    # Add a set of construction variables or environment options.
+    # @see VarSet#append
+    def append(*args)
+      @varset.send(:append, *args)
+    end
+
+    # Return a list of target file names
+    def targets
+      @targets.keys
+    end
+
+    # Return a list of sources needed to build target target.
+    def target_sources(target)
+      @targets[target][:source] rescue nil
+    end
+
+    # Build all target specified in the Environment.
+    # When a block is passed to Environment.new, this method is automatically
+    # called after the block returns.
+    def process
+      cache = Cache.new
+      targets_processed = Set.new
+      process_target = proc do |target|
+        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,
+                                         @targets[target][:source],
+                                         cache,
+                                         self,
+                                         *@targets[target][:args])
+        else
+          false
+        end
+      end
+      @targets.each do |target, info|
+        next if targets_processed.include?(target)
+        unless process_target.call(target)
+          $stderr.puts "Error: failed to build #{target}"
+          break
+        end
+      end
+      cache.write
+    end
+
+    # Build a command line from the given template, resolving references to
+    # variables using the Environment's construction variables and any extra
+    # variables specified.
+    # @param command_template [Array] template for the command with variable
+    #   references
+    # @param extra_vars [Hash, VarSet] extra variables to use in addition to
+    #   (or replace) the Environment's construction variables when building
+    #   the command
+    def build_command(command_template, extra_vars)
+      @varset.merge(extra_vars).expand_varref(command_template)
+    end
+
+    # Execute a builder command
+    # @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}.
+    def execute(short_desc, command, options = {})
+      print_command = proc do
+        puts command.map { |c| c =~ /\s/ ? "'#{c}'" : c }.join(' ')
+      end
+      if @varset[:echo] == :command
+        print_command.call
+      elsif @varset[:echo] == :short
+        puts short_desc
+      end
+      system(*command, options).tap do |result|
+        unless result or @varset[:echo] == :command
+          $stdout.write "Failed command was: "
+          print_command.call
+        end
+      end
+    end
+
+    alias_method :orig_method_missing, :method_missing
+    def method_missing(method, *args)
+      if @builders.has_key?(method.to_s)
+        target, source, *rest = args
+        source = [source] unless source.is_a?(Array)
+        @targets[target] = {
+          builder: @builders[method.to_s],
+          source: source,
+          args: rest,
+        }
+      else
+        orig_method_missing(method, *args)
+      end
+    end
+
+    # Parse dependencies for a given target from a Makefile.
+    # 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 parse_makefile_deps(mf_fname, target)
+      deps = []
+      buildup = ''
+      File.read(mf_fname).each_line do |line|
+        if line =~ /^(.*)\\\s*$/
+          buildup += ' ' + $1
+        else
+          if line =~ /^(.*): (.*)$/
+            target, tdeps = $1.strip, $2
+            if target == target
+              deps += tdeps.split(' ').map(&:strip)
+            end
+          end
+          buildup = ''
+        end
+      end
+      deps
+    end
+  end
+end

data/lib/rscons/monkey/module.rb

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

data/lib/rscons/monkey/string.rb

@@ -0,0 +1,19 @@
+# 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.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

data/lib/rscons/varset.rb

@@ -0,0 +1,83 @@
+module Rscons
+  # This class represents a collection of variables which can be accessed
+  # as certain types
+  class VarSet
+    # The underlying hash
+    attr_reader :vars
+
+    # Create a VarSet
+    # @param vars [Hash] Optional initial variables.
+    def initialize(vars = {})
+      @vars = vars
+    end
+
+    # 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 val.is_a?(String)
+        [val]
+      elsif type == :string and val.is_a?(Array)
+        val.first
+      else
+        val
+      end
+    end
+
+    # Assign a value to a variable.
+    # @param key [String, Symbol] The variable name.
+    # @param val [Object] The value.
+    def []=(key, val)
+      @vars[key] = val
+    end
+
+    # Add or overwrite a set of variables
+    # @param values [VarSet, Hash] New set of variables.
+    def append(values)
+      values = values.vars if values.is_a?(VarSet)
+      @vars.merge!(values)
+      self
+    end
+
+    # Create a new VarSet object based on the first merged with other.
+    # @param other [VarSet, Hash] Other variables to add or overwrite.
+    def merge(other = {})
+      VarSet.new(Marshal.load(Marshal.dump(@vars))).append(other)
+    end
+    alias_method :clone, :merge
+
+    # Replace "$" variable references in varref with the variables values,
+    # recursively.
+    # @param varref [String, Array] Value containing references to variables.
+    def expand_varref(varref)
+      if varref.is_a?(Array)
+        varref.map do |ent|
+          expand_varref(ent)
+        end.flatten
+      else
+        if varref =~ /^(.*)\$\[(\w+)\](.*)$/
+          # expand array with given prefix, suffix
+          prefix, varname, suffix = $1, $2, $3
+          varval = expand_varref(@vars[varname])
+          unless varval.is_a?(Array)
+            raise "Array expected for $#{varname}"
+          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
+      end
+    end
+  end
+end

data/lib/rscons/version.rb

@@ -0,0 +1,4 @@
+module Rscons
+  # gem version
+  VERSION = "0.0.1"
+end

data/rscons.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rscons/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rscons"
+  gem.version       = Rscons::VERSION
+  gem.authors       = ["Josh Holtrop"]
+  gem.email         = ["jholtrop@gmail.com"]
+  gem.description   = %q{Software construction library inspired by SCons and implemented in Ruby}
+  gem.summary       = %q{Software construction library inspired by SCons and implemented in Ruby}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rspec-core"
+  gem.add_development_dependency "rspec-mocks"
+  gem.add_development_dependency "rspec-expectations"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "json"
+  gem.add_development_dependency 'rdoc'
+  gem.add_development_dependency "yard"
+end

data/spec/build_tests_spec.rb

@@ -0,0 +1,146 @@
+require 'fileutils'
+
+describe Rscons do
+  before(:all) do
+    FileUtils.rm_rf('build_tests_run')
+    @owd = Dir.pwd
+  end
+
+  after(:each) do
+    Dir.chdir(@owd)
+    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")
+    end
+    get_build_output
+  end
+
+  def test_dir(build_test_directory)
+    FileUtils.cp_r("build_tests/#{build_test_directory}", 'build_tests_run')
+    Dir.chdir("build_tests_run")
+    build_testdir
+  end
+
+  def file_sub(fname)
+    contents = File.read(fname)
+    replaced = ''
+    contents.each_line do |line|
+      replaced += yield(line)
+    end
+    File.open(fname, 'w') do |fh|
+      fh.write(replaced)
+    end
+  end
+
+  def get_build_output
+    File.read('build.out').lines.map(&:strip)
+  end
+
+  ###########################################################################
+  # Tests
+  ###########################################################################
+
+  it 'builds a C program with one source file' do
+    test_dir('simple')
+    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')
+    lines.should == [
+      'gcc -c -o simple.o -MMD -MF simple.mf simple.c',
+      'gcc -o simple simple.o',
+    ]
+  end
+
+  it 'prints short representations of the commands being executed' do
+    lines = test_dir('header')
+    lines.should == [
+      'CC header.o',
+      'LD header',
+    ]
+  end
+
+  it 'builds a C program with one source file and one header file' do
+    test_dir('header')
+    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')
+    `./header`.should == "The value is 2\n"
+    file_sub('header.h') {|line| line.sub(/2/, '5')}
+    build_testdir
+    `./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')
+    `./header`.should == "The value is 2\n"
+    lines.should == [
+      'CC header.o',
+      'LD header',
+    ]
+    lines = build_testdir
+    lines.should == []
+  end
+
+  it "does not rebuild a C module when only the file's timestampe has changed" do
+    lines = test_dir('header')
+    `./header`.should == "The value is 2\n"
+    lines.should == [
+      'CC header.o',
+      'LD header',
+    ]
+    file_sub('header.c') {|line| line}
+    lines = build_testdir
+    lines.should == []
+  end
+
+  it 're-links a program when the link flags have changed' do
+    lines = test_dir('simple')
+    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
+    lines.should == ['gcc -o simple simple.o -lc']
+  end
+
+  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
+  end
+
+  it 'allows Ruby classes as custom builders to be used to construct files' do
+    lines = test_dir('custom_builder')
+    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')
+    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},
+      %q{gcc -c -o release/program.o -MMD -MF release/program.mf '-DSTRING="Release Version"' -O2 src/program.c},
+      %q{gcc -o program-release release/program.o},
+    ]
+  end
+
+  it 'builds a C++ program with one source file' do
+    test_dir('simple_cc')
+    File.exists?('simple.o').should be_true
+    `./simple`.should == "This is a simple C++ program\n"
+  end
+
+end