rubuild-core 0.0.3

data/lib/rubuild/load/namespace.rb

@@ -0,0 +1,117 @@
+module Rubuild
+  module Load
+    ## Rubuild::Load::NameSpace
+    # Manage private execution contexts.
+    #
+    # Rubuild::Load::NameSpace creates private execution contexts.
+    # These contexts are sub-classed from Rubuild::Load::NameSpace::Context,
+    # and as such they can access information about how they were loaded
+    # through the Rubuild::Load::NameSpace::Context.rubuild_info method by
+    # calling Rubuild::Load::NameSpace::Context.rubuild_info.
+    class NameSpace
+
+      ## Rubuild::Load::NameSpace::Context
+      # Superclass of private execution context classes.
+      # Provides rubuild_info accessor routines.
+      class Context
+
+        ## Rubuild::Load::NameSpace::Context::Error
+        # Superclass of errors generated in context processing.
+        class Error < StandardError
+          # Private execution context against which the error was generated.
+          Safer::IVar.instance_variable(self, :context)
+          Safer::IVar.export_reader(self, :context)
+
+          # Create a new Rubuild::Load::NameSpace::Context::Error exception.
+          # [+context+] Private execution context associated with the exception.
+          # [+message+] Human-readable string describing the exception.
+          def initialize(context, message)
+            super(message)
+            self.rubuild_load_namespace_context_error__context = context
+          end # Rubuild::Load::NameSpace::Context::Error#initialize
+
+          ## Rubuild::Load::NameSpace::Context::Error::InstanceMethod
+          # Defined an instance method of private class with no instance.
+          class InstanceMethod < Rubuild::Load::NameSpace::Context::Error
+            # Name of new method.
+            Safer::IVar.instance_variable(self, :meth)
+            Safer::IVar.export_reader(self, :meth)
+
+            # Create a new Rubuild::Load::NameSpace::Context::Error::InstanceMethod
+            # exception.
+            # [+context+] Private execution context in which a user attempted
+            #             to define a method.
+            # [+meth+] Name of method the user attempted to define.
+            def initialize(context, meth)
+              super(
+                context,
+                "Defined instance method :#{meth} of private class with no " +
+                "instance."
+                )
+              self.rubuild_load_namespace_context_error_instancemethod__meth = meth
+            end # Rubuild::Load::NameSpace::Context::Error::InstanceMethod#initialize
+          end # Rubuild::Load::NameSpace::Context::Error::InstanceMethod
+        end # Rubuild::Load::NameSpace::Context::Error
+
+        ## Rubuild::Load::NameSpace::Context
+
+        # Set the load-environment information for a Rubuild::Load::NameSpace::Context
+        # subclass.
+        # Every Rubuild::Load::NameSpace executes in a unique private subclass of
+        # Rubuild::Load::NameSpace::Context, so this class method can be called by
+        # code within the namespace to set information about the load environment.
+        # Used internally directly after creating a new Rubuild::Load::NameSpace.
+        # [+info+] New load-environment information for a
+        #          Rubuild::Load::NameSpace::Context subclass.
+        def self.rubuild_info=(info)
+          # Note: this object is the 'Context' instance of the 'Class' class.
+          # This is as opposed to a variable instance of the 'Context' class.
+          # We can use @instance_variable uniquely in this class.
+          @rubuild_info = info
+        end # Rubuild::Load::NameSpace::Context.rubuild_info=
+
+        # Retrieve the load-environment information for a
+        # Rubuild::Load::NameSpace::Context subclass.
+        # Every Rubuild::Load::NameSpace executes in a unique private subclass of
+        # Rubuild::Load::NameSpace::Context, so this class method can be called by
+        # code within the namespace to set information about the load environment.
+        # Calling
+        #   self.rubuild_info
+        # retrieves information about the Rubuild::Load::NameSpace that was set when
+        # the Rubuild::Load::NameSpace was created.
+        def self.rubuild_info
+          # see above.
+          @rubuild_info
+        end # Rubuild::Load::NameSpace::Context.rubuild_info
+
+        # Override Class#method_added to raise an exception, and prevent users
+        # from defining functions that they will not then be able to call.
+        def self.method_added(meth)
+          raise(Error::InstanceMethod.new(self, meth))
+        end # Rubuild::Load::NameSpace::Context.method_added
+      end # Rubuild::Load::NameSpace::Context
+
+      ## Rubuild::Load::NameSpace::Factory
+      class Factory
+        # parent class of private exectuion contexts.
+        Safer::IVar.instance_variable(self, :load_class)
+        Safer::IVar.export_reader(self, :load_class)
+
+        # Create an private execution context factory.
+        # Execution contexts will be created on demand, from
+        # Rubuild::Load::NameSpace::Factory#create.
+        # [+load_class+] Superclass of private classes used for execution.
+        def initialize(load_class = Rubuild::Load::NameSpace::Context)
+          self.rubuild_load_namespace_factory__load_class = load_class
+        end # Rubuild::Load::NameSpace::Factory#initialize
+
+        # Create a private execution context, and return it.
+        # [_return_] A newly created private execution context, sub-classed from
+        #            Rubuild::Load::NameSpace#load_class.
+        def create
+          Class.new(self.rubuild_load_namespace_factory__load_class)
+        end # Rubuild::Load::NameSpace::Factory#create
+      end # Rubuild::Load::NameSpace::Factory
+    end # Rubuild::Load::NameSpace
+  end # Rubuild::Load
+end # Rubuild

data/lib/rubuild/options.rb

@@ -0,0 +1,34 @@
+require 'optparse'
+
+module Rubuild
+  ## Rubuild::Options
+  # Command-line processing.
+  class Options
+    Safer::IVar.instance_variable(self, :inc_paths)
+    Safer::IVar.export_reader(self, :inc_paths)
+    Safer::IVar.instance_variable(self, :file)
+    Safer::IVar.export_reader(self, :file)
+    Safer::IVar.instance_variable(self, :args_left)
+    Safer::IVar.export_reader(self, :args_left)
+    def initialize(args)
+      self.rubuild_options__inc_paths = []
+      self.rubuild_options__file = 'Rutop'
+      self.rubuild_options__args_left = args.dup
+
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: rubuild [options]'
+        opts.separator ''
+        opts.on(
+          '-f', '--file FILE',
+          "Run Rubuild script from FILE.  Defaults to #{self.file}") do |file|
+          self.rubuild_options__file = file
+        end
+        opts.on(
+          '-I', '--include-path PATH',
+          'Add PATH to the list of directories to search for Rubuild files.') do |path|
+          self.rubuild_options__inc_paths << path
+        end
+      end.order!(self.rubuild_options__args_left)
+    end
+  end # Rubuild::Options
+end # Rubuild

data/lib/rubuild/util.rb

@@ -0,0 +1,11 @@
+module Rubuild
+  module Util
+    def self.enumerable_find(enum, ifnone=nil)
+      rv = nil
+      enum.find do |el|
+        rv = yield el
+      end
+      rv || ifnone
+    end
+  end # Rubuild::Util
+end # Rubuild

data/test/test_dep.rb

@@ -0,0 +1,176 @@
+require 'rubuild'
+require 'test/unit'
+
+class TC_DepOrder < Test::Unit::TestCase
+  class TestDep
+    attr_reader :extra_args
+
+    def initialize(key, output)
+      @TestDep_key = key
+      @output = output
+      @extra_args = nil
+    end
+
+    def call(dep, *extra_args)
+      @output << self.display
+      if extra_args.size > 0
+        @extra_args = extra_args
+      end
+    end
+    def display
+      @TestDep_key
+    end
+  end
+
+  def setup
+    @rctx = Rubuild::Build::Simple::Factory.new
+    @output = Array::new
+    @tdeps = 
+      Array.new(4) do |index|
+        TestDep::new(index.to_s, @output)
+      end
+    @deps = 
+      Array.new(@tdeps.size) do |index|
+        @rctx.create_dep(@tdeps[index], @tdeps[index].display)
+      end
+  end
+
+  def teardown
+    @rctx = nil
+    @output = nil
+    @deps = nil
+  end
+
+  def create_dep_tree
+    @deps[1].add_parent(@deps[0])
+    @deps[2].add_parent(@deps[1])
+    @deps[3].add_parent(@deps[0])
+    @deps[3].add_parent(@deps[2])
+  end
+
+  def array_compare(array1, array2)
+    assert(array1.size == array2.size)
+    array1.size.times do |index|
+      assert(array1[index] == array2[index])
+    end
+  end
+
+  def test_partial_build
+    self.create_dep_tree
+    bctx = @rctx.create_context
+    @deps[1].load(bctx)
+    bctx.run
+    self.array_compare(@output, ['0', '1'])
+    @deps[2].load(bctx)
+    self.array_compare(@output, ['0', '1'])
+    bctx.run
+    self.array_compare(@output, ['0', '1', '2'])
+    @deps[3].load(bctx)
+    bctx.run
+    self.array_compare(@output, ['0', '1', '2', '3'])
+  end
+
+  def test_dep_loop1
+    self.assert_raise(Rubuild::Build::Dep::Error::Load) do
+      self.create_dep_tree
+      @deps[0].add_parent(@deps[3])
+    end
+  end
+
+  def test_dep_loop2
+    self.assert_raise(Rubuild::Build::Dep::Error::Load) do
+      self.create_dep_tree
+      @deps[0].add_parent(@deps[3])
+    end
+  end
+
+  def test_nil_cmds
+    self.create_dep_tree
+    bctx = @rctx.create_context
+    @deps[2].set_command(nil)
+    @deps[3].load(bctx)
+    bctx.run
+    self.array_compare(@output, ['0', '1', '3'])
+  end
+
+  def test_extra_args
+    self.create_dep_tree
+    bctx = @rctx.create_context
+    extraargs = ['hello', 'world']
+    @deps[2].args = extraargs
+    assert(@tdeps[2].extra_args == nil)
+    @deps[3].load(bctx)
+    assert(@tdeps[2].extra_args == nil)
+    bctx.run
+    self.array_compare(@tdeps[2].extra_args, extraargs)
+  end
+
+  def parameter_assertion(dep, errortype, parameter)
+    self.assert_block do
+      rval = false
+      begin
+        yield
+      rescue errortype
+        if $!.dep == dep and $!.parameter == parameter
+          rval = true
+        end
+      end
+      rval
+    end
+    self.assert_raise(errortype) do
+      yield
+    end
+  end
+
+  def test_loaded_actions
+    bctx = @rctx.create_context
+    @deps[1].load(bctx)
+    self.assert_block do
+      rval = false
+      begin
+        @deps[1].add_parent(@deps[0])
+      rescue Rubuild::Build::Dep::Error::Runable
+        if $!.dep == @deps[1] and $!.parent == @deps[0]
+          rval = true
+        end
+      end
+      rval
+    end
+
+    self.parameter_assertion(
+      @deps[1], Rubuild::Build::Dep::Error::Parameter::Args, 'args'
+    ) do
+      @deps[1].args = ['foo']
+    end
+
+    self.parameter_assertion(
+      @deps[1], Rubuild::Build::Dep::Error::Parameter::Command, 'command'
+    ) do
+      @deps[1].set_command(nil)
+    end
+  end
+
+  def test_surrogate
+    testarr = Array::new
+    surr = proc do |dep, count|
+      testarr << count
+      if count > 0
+        count -= 1
+        ndep = @rctx.create_dep(surr, "#{count}", count)
+        dep.surrogate(ndep)
+      end
+    end
+    d1 = @rctx.create_dep(surr, 'loop', 3)
+    child = proc do |dep|
+      testarr << -1
+    end
+    d2 = @rctx.create_dep(child, 'child')
+    d2.add_parent(d1)
+
+    bctx = @rctx.create_context
+    self.array_compare(testarr, Array::new)
+    d2.load(bctx)
+    bctx.run
+    self.array_compare(testarr, [3, 2, 1, 0, -1])
+  end
+end

data/test/test_env.rb

@@ -0,0 +1,91 @@
+require 'rubuild'
+require 'test/unit'
+
+class TC_Env < Test::Unit::TestCase
+  def setup
+    @depfactory = Rubuild::Build::Simple::Factory.new
+    @env = Rubuild::Env.new(@depfactory)
+  end
+
+  def teardown
+    @depfactory = nil
+    @env = nil
+  end
+
+  def test_errorGeneration
+    error = Rubuild::Env::Error.new(@env, "test error class")
+    assert_same(@env, error.env)
+    assert_equal("test error class", error.message)
+  end
+
+  def test_errorKeyGeneration
+    error = Rubuild::Env::Error::Key.new(@env, 'foo', 'test error message')
+    assert_same(@env, error.env)
+    assert_equal('foo', error.key)
+    assert_equal(error.message, 'test error message')
+  end
+
+  def test_errorFullGeneration
+    l1 = Rubuild::Env::Location.new('foo', @depfactory)
+    l2 = Rubuild::Env::Location.new('bar', @depfactory)
+    error = Rubuild::Env::Error::Key::Full.new(@env, 'foo', l1, l2)
+    assert_same(@env, error.env)
+    assert_same(l1, error.provided_location)
+    assert_same(l2, error.providing_location)
+    assert_equal(
+      "Key \"foo\" already exists in registry at #{l1.found_dep.name} " +
+      "while providing #{l2.found_dep.name}",
+      error.message)
+  end
+
+  def test_errorEmptyGeneration
+    l = Rubuild::Env::Location.new('foo', @depfactory)
+    error = Rubuild::Env::Error::Key::Empty.new(@env, 'foo', l)
+    assert_same(@env, error.env)
+    assert_same(l, error.requiring_location)
+    assert_equal('foo', error.key)
+    assert_equal(
+      "Key \"foo\" does not exist in registry for #{l.found_dep.name}.",
+      error.message)
+  end
+
+  def test_requireEmptyRaisesKeyEmpty
+    l = Rubuild::Env::Location.new('bar', @depfactory)
+    @env.require('foo', l)
+    fail "no error raised"
+  rescue Rubuild::Env::Error::Key::Empty => error
+    assert_equal('foo', error.key)
+  rescue Exception
+    fail "wrong error raised"
+  end
+
+  def test_provideThenRequireRaisesNoExceptions
+    l1 = Rubuild::Env::Location.new('foo', @depfactory)
+    l2 = Rubuild::Env::Location.new('bar', @depfactory)
+    @env.provide('foo', l1)
+    @env.require('foo', l2)
+  end
+
+  def test_provideTwiceRaisesKeyFull
+    l1 = Rubuild::Env::Location.new('foo', @depfactory)
+    @env.provide('foo', l1)
+    @env.provide('foo', l1)
+    fail "no error raised"
+  rescue Rubuild::Env::Error::Key::Full => error
+    assert_equal('foo', error.key)
+  rescue Exception
+    fail "wrong error raised"
+  end
+
+  def test_requireProvidedDataGetsData
+    l1 = Rubuild::Env::Location.new('foo', @depfactory)
+    l1.set_data('hello')
+    l2 = Rubuild::Env::Location.new('bar', @depfactory)
+    @env.provide('key', l1)
+    @env.require('key', l2)
+    bctx = @depfactory.create_context
+    l2.found_dep.load(bctx)
+    bctx.run
+    assert_equal('hello', l2.data)
+  end
+end

data/test/test_env_location.rb

@@ -0,0 +1,68 @@
+require 'rubuild'
+require 'test/unit'
+
+class TC_Location < Test::Unit::TestCase
+  def setup
+    @depfactory = Rubuild::Build::Simple::Factory.new
+    @location = Rubuild::Env::Location.new('location', @depfactory)
+  end
+  def teardown
+  end
+
+  def test_locationEmpty
+    bctx = @depfactory.create_context
+    @location.found_dep.load(bctx)
+    begin
+      begin
+        bctx.run
+      rescue Rubuild::Build::Dep::Error::Action => e
+        raise e.error
+      end
+      flunk("Should have raised an exception.")
+    rescue Rubuild::Env::Location::Error::BuiltEmpty => e
+      assert_same(e.location, @location)
+    end
+  end
+
+  def test_haveDataIsFalseAtFirst
+    assert(! @location.have_data)
+  end
+
+  def test_haveDataIsTrueAfterSetData
+    @location.set_data(:hello)
+    assert(@location.have_data)
+  end
+
+  def test_locationEarly
+    begin
+      @location.data
+      flunk("Should have raised an exception.")
+    rescue Rubuild::Env::Location::Error::DataEmpty => e
+      assert_same(e.location, @location)
+    end
+  end
+
+  def test_locationTwice
+    @location.set_data(:hello)
+    begin
+      @location.set_data(:goodbye)
+      flunk("Should have raised an exception.")
+    rescue Rubuild::Env::Location::Error::SetData::Already => e
+      assert_same(e.location, @location)
+      assert_same(e.newdata, :goodbye)
+      assert_same(@location.data, :hello)
+    end
+  end
+
+  def test_normal
+    block = proc do |dep|
+      @location.set_data(:hello)
+    end
+    bctx = @depfactory.create_context
+    dep = @depfactory.create_dep(block, "dep")
+    @location.found_dep.add_parent(dep)
+    @location.found_dep.load(bctx)
+    bctx.run
+    assert_same(@location.data, :hello)
+  end
+end