rscons 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+build_tests_run

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rscons.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Josh Holtrop
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# Rscons
+
+Software construction library inspired by SCons and implemented in Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rscons'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rscons
+
+## Usage
+
+    RScons::Environment.new do |env|
+      env.Program('program', Dir['*.c'])
+    end
+
+    main_env = RScons::Environment.new do |env|
+      env.build_dir('src', 'build/main')
+      env.Program('program', Dir['src/**/*.cc'])
+    end
+
+    debug_env = main_env.clone do |env|
+      env.build_dir('src', 'build/debug')
+      env['CFLAGS'] = ['-g', '-O0']
+      env.Program('program-debug', Dir['src/**/*.cc'])
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler"
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  raise LoadError.new("Unable to setup Bundler; you might need to `bundle install`: #{e.message}")
+end
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/clean"
+require "yard"
+
+CLEAN.include 'build_tests_run'
+
+RSpec::Core::RakeTask.new(:spec)
+
+YARD::Rake::YardocTask.new do |yard|
+  yard.files = ['lib/**/*.rb']
+end
+
+task :default => :spec

data/build_tests/build_dir/build.rb

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

data/build_tests/build_dir/src/one/one.c

@@ -0,0 +1,6 @@
+#include "two.h"
+
+int main(int argc, char *argv[])
+{
+    two();
+}

data/build_tests/build_dir/src/two/two.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include "two.h"
+
+void two(void)
+{
+    printf("Hello from two()\n");
+}

data/build_tests/build_dir/src/two/two.h

@@ -0,0 +1,6 @@
+#ifndef TWO_H
+#define TWO_H
+
+void two(void);
+
+#endif

data/build_tests/clone_env/build.rb

@@ -0,0 +1,11 @@
+debug = Rscons::Environment.new 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

data/build_tests/clone_env/src/program.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    printf("Hello, %s\n", STRING);
+}

data/build_tests/custom_builder/build.rb

@@ -0,0 +1,16 @@
+class MySource < Rscons::Builder
+  def run(target, sources, cache, env)
+    File.open(target, 'w') do |fh|
+      fh.puts <<EOF
+#define THE_VALUE 5678
+EOF
+    end
+    target
+  end
+end
+
+Rscons::Environment.new(echo: :short) do |env|
+  env.add_builder(MySource.new)
+  env.MySource('inc.h', [])
+  env.Program('program', Dir['*.c'])
+end

data/build_tests/custom_builder/program.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include "inc.h"
+
+int main(int argc, char *argv[])
+{
+    printf("The value is %d\n", THE_VALUE);
+}

data/build_tests/header/build.rb

@@ -0,0 +1,3 @@
+Rscons::Environment.new(echo: :short) do |env|
+  env.Program('header', Dir['*.c'])
+end

data/build_tests/header/header.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include "header.h"
+
+int main(int argc, char *argv[])
+{
+    printf("The value is %d\n", VALUE);
+}

data/build_tests/header/header.h

@@ -0,0 +1,6 @@
+#ifndef HEADER_H
+#define HEADER_H
+
+#define VALUE 2
+
+#endif

data/build_tests/simple/build.rb

@@ -0,0 +1,4 @@
+Rscons::Environment.new do |env|
+  # CHANGE FLAGS
+  env.Program('simple', Dir['*.c'])
+end

data/build_tests/simple/simple.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    printf("This is a simple C program\n");
+}

data/build_tests/simple_cc/build.rb

@@ -0,0 +1,4 @@
+Rscons::Environment.new do |env|
+  # CHANGE FLAGS
+  env.Program('simple', Dir['*.cc'])
+end

data/build_tests/simple_cc/simple.cc

@@ -0,0 +1,8 @@
+#include <iostream>
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+    cout << "This is a simple C++ program" << endl;
+}

data/lib/rscons.rb

@@ -0,0 +1,20 @@
+require "rscons/builder"
+require "rscons/cache"
+require "rscons/environment"
+require "rscons/varset"
+require "rscons/version"
+
+require "rscons/monkey/module"
+require "rscons/monkey/string"
+
+# default builders
+require "rscons/builders/object"
+require "rscons/builders/program"
+
+# Namespace module for rscons classes
+module Rscons
+  DEFAULT_BUILDERS = [
+    Object,
+    Program,
+  ]
+end

data/lib/rscons/builder.rb

@@ -0,0 +1,20 @@
+module Rscons
+  # Class to hold an object that knows how to build a certain type of file.
+  class Builder
+    # Return a set of default variable values for the Environment to use
+    # unless the user overrides any.
+    # @param env [Environment] The Environment.
+    def default_variables(env)
+      {}
+    end
+
+    # Return whether this builder object is capable of producing a given target
+    # file name from a given source file name.
+    # @param target [String] The target file name.
+    # @param source [String, Array] The source file name(s).
+    # @param env [Environment] The Environment.
+    def produces?(target, source, env)
+      false
+    end
+  end
+end

data/lib/rscons/builders/object.rb

@@ -0,0 +1,69 @@
+module Rscons
+  # A default RScons builder which knows how to produce an object file from
+  # various types of source files.
+  class Object < Builder
+    def default_variables(env)
+      {
+        'OBJSUFFIX' => '.o',
+
+        'AS' => '$CC',
+        'ASFLAGS' => [],
+        'ASSUFFIX' => '.S',
+        'ASPPPATH' => '$CPPPATH',
+        'ASPPFLAGS' => '$CPPFLAGS',
+        'ASDEPGEN' => ['-MMD', '-MF', '$DEPFILE'],
+        'ASCOM' => ['$AS', '-c', '-o', '$TARGET', '$ASDEPGEN', '-I$[ASPPPATH]', '$ASPPFLAGS', '$ASFLAGS', '$SOURCES'],
+
+        'CPPFLAGS' => [],
+        'CPPPATH' => [],
+
+        'CC' => 'gcc',
+        'CFLAGS' => [],
+        'CSUFFIX' => '.c',
+        'CCDEPGEN' => ['-MMD', '-MF', '$DEPFILE'],
+        'CCCOM' => ['$CC', '-c', '-o', '$TARGET', '$CCDEPGEN', '-I$[CPPPATH]', '$CPPFLAGS', '$CFLAGS', '$SOURCES'],
+
+        'CXX' => 'g++',
+        'CXXFLAGS' => [],
+        'CXXSUFFIX' => '.cc',
+        'CXXDEPGEN' => ['-MMD', '-MF', '$DEPFILE'],
+        'CXXCOM' =>['$CXX', '-c', '-o', '$TARGET', '$CXXDEPGEN', '-I$[CPPPATH]', '$CPPFLAGS', '$CXXFLAGS', '$SOURCES'],
+      }
+    end
+
+    def produces?(target, source, env)
+      target.has_suffix?(env['OBJSUFFIX']) and (
+        source.has_suffix?(env['ASSUFFIX']) or
+        source.has_suffix?(env['CSUFFIX']) or
+        source.has_suffix?(env['CXXSUFFIX']))
+    end
+
+    def run(target, sources, cache, env)
+      vars = {
+        'TARGET' => target,
+        'SOURCES' => sources,
+        'DEPFILE' => target.set_suffix('.mf'),
+      }
+      com_prefix = if sources.first.has_suffix?(env['ASSUFFIX'])
+                     'AS'
+                   elsif sources.first.has_suffix?(env['CSUFFIX'])
+                     'CC'
+                   elsif sources.first.has_suffix?(env['CXXSUFFIX'])
+                     'CXX'
+                   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)
+        return false unless env.execute("#{com_prefix} #{target}", command)
+        deps = sources
+        if File.exists?(vars['DEPFILE'])
+          deps += env.parse_makefile_deps(vars['DEPFILE'], target)
+          FileUtils.rm_f(vars['DEPFILE'])
+        end
+        cache.register_build(target, command, deps.uniq)
+      end
+      target
+    end
+  end
+end

data/lib/rscons/builders/program.rb

@@ -0,0 +1,48 @@
+module Rscons
+  # A default RScons builder that knows how to link object files into an
+  # executable program.
+  class Program < Builder
+    def default_variables(env)
+      {
+        'LD' => nil,
+        'OBJSUFFIX' => '.o',
+        'LIBSUFFIX' => '.a',
+        'LDFLAGS' => [],
+        'LIBPATHS' => [],
+        'LIBS' => [],
+        'LDCOM' => ['$LD', '-o', '$TARGET', '$LDFLAGS', '$SOURCES', '-L$[LIBPATHS]', '-l$[LIBS]']
+      }
+    end
+
+    def run(target, sources, cache, env)
+      # convert sources to object file names
+      objects = sources.map do |source|
+        if source.has_suffix?([env['OBJSUFFIX'], env['LIBSUFFIX']])
+          source
+        else
+          o_file = env.get_build_fname(source, env['OBJSUFFIX', :string])
+          builder = env.builders.values.find { |b| b.produces?(o_file, source, env) }
+          builder or raise "No builder found to convert input source #{source.inspect} to an object file."
+          builder.run(o_file, [source], cache, env) or break
+        end
+      end
+      if objects
+        use_cxx = sources.map do |s|
+          s.has_suffix?(env['CXXSUFFIX'])
+        end.any?
+        ld_alt = use_cxx ? env['CXX'] : env['CC']
+        vars = {
+          'TARGET' => target,
+          'SOURCES' => objects,
+          'LD' => env['LD'] || ld_alt,
+        }
+        command = env.build_command(env['LDCOM'], vars)
+        unless cache.up_to_date?(target, command, objects)
+          return false unless env.execute("LD #{target}", command)
+          cache.register_build(target, command, objects)
+        end
+        target
+      end
+    end
+  end
+end

data/lib/rscons/cache.rb

@@ -0,0 +1,147 @@
+require 'yaml'
+require 'fileutils'
+require 'digest/md5'
+require 'set'
+require 'rscons/version'
+
+module Rscons
+  # The Cache class keeps track of file checksums, build target commands and
+  # dependencies in a YAML file which persists from one invocation to the next.
+  # Example cache:
+  #   {
+  #     version: '1.2.3',
+  #     targets: {
+  #       'program' => {
+  #         'checksum' => 'A1B2C3D4',
+  #         'command' => ['gcc', '-o', 'program', 'program.o'],
+  #         'deps' => [
+  #           {
+  #             'fname' => 'program.o',
+  #             'checksum' => '87654321',
+  #           }
+  #         ],
+  #       }
+  #       'program.o' => {
+  #         'checksum' => '87654321',
+  #         'command' => ['gcc', '-c', '-o', 'program.o', 'program.c'],
+  #         'deps' => [
+  #           {
+  #             'fname' => 'program.c',
+  #             'checksum' => '456789ABC',
+  #           },
+  #           {
+  #             'fname' => 'program.h',
+  #             'checksum' => '7979764643',
+  #           }
+  #         ]
+  #       }
+  #     }
+  #   }
+  class Cache
+    #### Constants
+
+    # Name of the file to store cache information in
+    CACHE_FILE = '.rsconscache'
+
+    #### Class Methods
+
+    # Remove the cache file
+    def self.clear
+      FileUtils.rm_f(CACHE_FILE)
+    end
+
+    #### Instance Methods
+
+    # 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,
+      }
+      @lookup_checksums = {}
+    end
+
+    # Write the cache to disk to be loaded next time.
+    def write
+      File.open(CACHE_FILE, 'w') do |fh|
+        fh.puts(YAML.dump(@cache))
+      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.
+    # @param deps [Array] List of the target's dependency files.
+    # @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:
+    #   - the target exists on disk
+    #   - the cache has information for the target
+    #   - the command used to build the target is the same as last time
+    #   - all dependencies listed are also listed in the cache, or, if
+    #     :strict_deps was given in options, the list of dependencies is
+    #     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 = {})
+      # target file must exist on disk
+      return false unless File.exists?(target)
+
+      # target must be registered in the cache
+      return false unless @cache[:targets].has_key?(target)
+
+      # 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] }
+      if options[:strict_deps]
+        # depedencies passed in must exactly equal those in the cache
+        return false unless deps == cached_deps
+      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?
+      end
+
+      # all cached dependencies must have their checksums match
+      @cache[:targets][target][:deps].map do |dep_cache|
+        dep_cache[:checksum] == lookup_checksum(dep_cache[:fname])
+      end.all?
+    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.
+    # @param deps [Array] List of dependencies for the target.
+    def register_build(target, command, deps)
+      @cache[:targets][target] = {
+        command: command,
+        checksum: calculate_checksum(target),
+        deps: deps.map do |dep|
+          {
+            fname: dep,
+            checksum: lookup_checksum(dep),
+          }
+        end
+      }
+    end
+
+    # Private Instance Methods
+    private
+
+    # Return a file's checksum, or the previously calculated checksum for
+    # the same file
+    # @param file [String] The file name.
+    def lookup_checksum(file)
+      @lookup_checksums[file] || calculate_checksum(file)
+    end
+
+    # Calculate and return a file's checksum
+    # @param file [String] The file name.
+    def calculate_checksum(file)
+      @lookup_checksums[file] = Digest::MD5.hexdigest(File.read(file)).encode(__ENCODING__) rescue ''
+    end
+  end
+end