rubuild-core 0.0.3

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,11 @@
+=== 0.0.3 / 2011-01-01
+
+* Renamed gem from "rubuild" to "rubuild-core".
+
+=== 0.0.2 / 2010-12-31
+
+* Fixed dependency issue.
+
+=== 0.0.1 / 2010-12-31
+
+* Initial release.

data/Manifest.txt

@@ -0,0 +1,35 @@
+.autotest
+History.txt
+Manifest.txt
+Rakefile
+README.rdoc
+bin/rubuild
+examples/printargs
+lib/rubuild.rb
+lib/rubuild/build.rb
+lib/rubuild/build/context.rb
+lib/rubuild/build/dep.rb
+lib/rubuild/build/factory.rb
+lib/rubuild/build/simple.rb
+lib/rubuild/build/simple/context.rb
+lib/rubuild/build/simple/dep.rb
+lib/rubuild/build/simple/factory.rb
+lib/rubuild/env.rb
+lib/rubuild/env/location.rb
+lib/rubuild/env/provider.rb
+lib/rubuild/env/requirer.rb
+lib/rubuild/load.rb
+lib/rubuild/load/info.rb
+lib/rubuild/load/loader.rb
+lib/rubuild/load/namespace.rb
+lib/rubuild/options.rb
+lib/rubuild/util.rb
+test/test_dep.rb
+test/test_env.rb
+test/test_env_location.rb
+test/test_env_provider.rb
+test/test_env_requirer.rb
+test/test_load_info.rb
+test/test_load_loader.rb
+test/test_load_namespace.rb
+test/test_options.rb

data/README.rdoc

@@ -0,0 +1,43 @@
+= rubuild-core
+
+http://rubuild.rubyforge.org
+
+== DESCRIPTION:
+
+=== Rubuild - Source-selection polymorphic build tool.
+Rubuild is a replacement for "make", written in Ruby.
+
+Rubuild is motivated by the desire to support source-selection polymorphism -
+that is, the ability to select different tools and/or source files (which
+implement known interfaces) during the compilation process.
+
+==== Modules and Classes
+[Rubuild::Build] Classes for managing dependency actions.
+[Rubuild::Env] Classes for managing provide/require semantics for build steps.
+
+== FEATURES/PROBLEMS:
+
+
+== SYNOPSIS:
+
+
+== REQUIREMENTS:
+
+* Safer >= 0.3.0
+
+== INSTALL:
+
+* sudo gem install rubuild-core
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+This software is placed into the public domain.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'rubuild-core' do
+  developer('Aidan Cully', 'aidan@panix.com')
+
+  self.rubyforge_name = 'rubuild'
+  self.readme_file = 'README.rdoc'
+  self.extra_deps << ['safer', '~>0.3.0']
+end

data/bin/rubuild

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+
+require 'rubuild'
+
+env = Rubuild::Env.new(Rubuild::Build::Simple::Factory.new)
+options = Rubuild::Options.new(ARGV)
+l = Rubuild::Env::Location.new('options', env.build_factory)
+l.set_data(options)
+env.provide('options', l)
+loader = Rubuild::Load::Loader.new(Rubuild::Load::NameSpace::Factory.new)
+loader.inc_paths += options.inc_paths
+loader.provision(env, 'load')
+loc = File.open(options.file, 'r') do |f|
+  loader.loadString(env, f.read, options.file)
+end
+rctx = env.build_factory.create_context
+loc.found_dep.load(rctx)
+rctx.run

data/examples/printargs

@@ -0,0 +1,5 @@
+self.rubuild_info.with do
+  self.require!('options') do |options|
+    puts options.args_left.inspect
+  end
+end

data/lib/rubuild.rb

@@ -0,0 +1,14 @@
+module Rubuild
+  VERSION = "0.0.3"
+end
+
+require 'rubygems'
+gem 'safer'
+require 'safer/ivar'
+require 'safer/protocol'
+
+require 'rubuild/util'
+require 'rubuild/build'
+require 'rubuild/env'
+require 'rubuild/load'
+require 'rubuild/options'

data/lib/rubuild/build.rb

@@ -0,0 +1,4 @@
+require 'rubuild/build/dep'
+require 'rubuild/build/context'
+require 'rubuild/build/factory'
+require 'rubuild/build/simple'

data/lib/rubuild/build/context.rb

@@ -0,0 +1,78 @@
+module Rubuild
+  module Build
+    ## Rubuild::Build::Context
+    # Rubuild::Build::Context is the base class of all dependancy execution
+    # environments in Rubuild.  The Rubuild::Build::Context will trap any errors
+    # raised by associated dependancies - and only those associated dependancies -
+    # during the 'run' step, and as such provides some measure of recoverability
+    # for errors occurring in parent dependancies when trying to undertake certain
+    # actions: in order to recover from an error executing a command, create a new
+    # Rubuild::Build::Context as part of your dependancy action and run it.
+    class Context
+
+      ## Rubuild::Build::Context::Error
+      # Superclass of errors that get generated by a Build::Context.
+      class Error < StandardError
+        # The Rubuild::Build::Context which generated the error.
+        Safer::IVar.instance_variable(self, :context)
+        # Reader accessor routine for :context instance variable.
+        Safer::IVar.export_reader(self, :context)
+
+        # Create a Rubuild::Build::Context::Error.
+        # Used internally.
+        # [+context+] the Rubuild::Build::Context which generated the error.
+        # [+message+] Human-readable string describing the error.
+        def initialize(context, message)
+          super(message)
+          self.rubuild_build_context_error__context = context
+        end # Rubuild::Build::Context::Error#initialize
+
+        ## Rubuild::Build::Context::Error::Runable
+        # Attempt to make dependency runable when not loaded.
+        class Runable < Rubuild::Build::Context::Error
+          # The dependency that was made runable when not loaded into the build
+          # context.
+          Safer::IVar.instance_variable(self, :dep)
+          Safer::IVar.export_reader(self, :dep)
+
+          # Create a Rubuild::Build::Context::Error::Runable exception.
+          # [+context+] Rubuild::Build::Context which generated the exception.
+          # [+dep+] Dependency made runable when not loaded.
+          def initialize(context, dep)
+            super(
+              context,
+              "Attempt to make dependancy #{dep.name} runable when not loaded."
+              )
+            self.rubuild_build_context_error_runable__dep = dep
+          end # Rubuild::Build::Context::Error::Runable#initialize
+        end # Rubuild::Build::Context::Error::Runable
+
+        ## Rubuild::Build::Context::Error::Run
+        # Some loaded dependencies did not get run.
+        class Run < Rubuild::Build::Context::Error
+
+          # Create a Rubuild::Build::Context::Error::Run.
+          # [+context+] Rubuild::Build::Context which generated the error.
+          def initialize(context)
+            super(context, "Some loaded dependencies did not get run.")
+          end # Rubuild::Build::Context::Error::Run#initialize
+        end # Rubuild::Build::Context::Error::Run
+      end # Rubuild::Build::Context::Error
+
+      class ProtocolClass
+        # Create an exception to capture the event that not all loaded dependencies
+        # were built.
+        # Used internally.
+        # [_return_] Rubuild::Build::Context::Error::Run exception.
+        def run_error
+        end
+
+        # Execute the dependencies loaded into this build context, in dependency
+        # order.
+        def run
+        end
+      end
+      Protocol = Safer::Protocol.create_from_class(ProtocolClass)
+    end # Rubuild::Build::Context
+  end # Rubuild::Build
+end # Rubuild

data/lib/rubuild/build/dep.rb

@@ -0,0 +1,359 @@
+##Rubuild
+module Rubuild
+  ## Rubuild::Build
+  module Build
+
+    ## Rubuild::Build::Dep
+    # Base class of all dependancy objects in Rubuild.
+    # The dependancy object deals only with the maintenance of dependancy
+    # information, so subclasses are only necessary if variables
+    # are inserted into the dependancy tracking algorithms.
+    # For example, modifications to the algorithm would be necessary to
+    # support threaded operation.
+    # Clients will not usually instantiate instances of Rubuild::Build::Dep
+    # directly, but instead use the 'create_dep' method of a
+    # Rubuild::Build::DepFactory.
+    class Dep
+
+      ## Rubuild::Build::Dep::Error
+      # Superclass of errors that get generated during dependancy processing.
+      class Error < StandardError
+        # :attr_reader: dep
+        # The Rubuild::Build::Dep that caused the exception.
+        Safer::IVar.instance_variable(self, :dep)
+        Safer::IVar.export_reader(self, :dep)
+
+        # Create a Rubuild::Build::Dep::Error exception.
+        # Used internally.
+        # [+dep+] The Rubuild::Build::Dep which is the source of the
+        #         exception.
+        # [+message+] Human-readable string describing the exception.
+        def initialize(dep, message)
+          super(message)
+          self.rubuild_build_dep_error__dep = dep
+        end # Rubuild::Build::Dep::Error#initialize
+
+        ## Rubuild::Build::Dep::Error::Action
+        # Error that occurs when calling the dependency block.
+        class Action < Rubuild::Build::Dep::Error
+          # :attr_reader: error
+          # The exception that was raised executing a dependency action.
+          Safer::IVar.instance_variable(self, :error)
+          Safer::IVar.export_reader(self, :error)
+
+          # :attr_reader: build_context
+          # The Rubuild::Build::Context in which the exception occurred.
+          Safer::IVar.instance_variable(self, :build_context)
+          Safer::IVar.export_reader(self, :build_context)
+
+          # Create a Rubuild::Build::Dep::Error::Action
+          # Used internally.
+          # [+dep+] The Rubuild::Build::Dep whose action raised +error+.
+          # [+error+] Exception raised while processing a Rubuild::Build::Dep
+          #           action.
+          # [+build_context+] The Rubuild::Build::Context context in which the
+          #                   Rubuild::Build::Dep action was being executed.
+          def initialize(dep, error, build_context)
+            super(dep, error.message)
+            self.rubuild_build_dep_error_action__error = error
+            self.rubuild_build_dep_error_action__build_context = build_context
+          end # Rubuild::Build::Dep::Error::Action#intialize
+
+          def report(file)
+            if self.error.respond_to?(:report)
+              self.error.report(file)
+            end
+          end
+        end # Rubuild::Build::Dep::Error::Action
+
+        ## Rubuild::Build::Dep::Error::Parameter
+        # Parameter error (parameter modified after dependency made runable).
+        class Parameter < Rubuild::Build::Dep::Error
+          # :attr_reader: parameter
+          # The parameter which was set after the dependency was made runable.
+          Safer::IVar.instance_variable(self, :parameter)
+          Safer::IVar.export_reader(self, :parameter)
+
+          # Create a Rubuild::Build::Dep::Error::Parameter
+          # Used internally.
+          # [+dep+] The Rubuild::Build::Dep for which someone tried to modify
+          #         the parameter.
+          # [+nm+] The name of the parameter attempted modification.
+          def initialize(dep, nm)
+            super(
+              dep,
+              "Dependency parameter '#{nm}' modified after " +
+              "dep '#{dep.name}' built."
+              )
+            self.rubuild_build_dep_error_parameter__parameter = nm
+          end # Rubuild::Build::Dep::Error::Parameter#initialize
+
+          ## Rubuild::Build::Dep::Error::Parameter::Args
+          # Argument set after dependency made runable
+          class Args < Rubuild::Build::Dep::Error::Parameter
+            # Create a Rubuild::Build::Dep::Error::Parameter::Args
+            # Used internally.
+            # [+dep+] The Rubuild::Build::Dep for which someone modified the
+            #         'args' parameter when the dependency was runable.
+            def initialize(dep)
+              super(dep, 'args')
+            end # Rubuild::Build::Dep::Error::Parameter::Args#initialize
+          end # Rubuild::Build::Dep::Error::Parameter::Args
+
+          ## Rubuild::Build::Dep::Error::Parameter::Command
+          # Command set after dependency made runable
+          class Command < Rubuild::Build::Dep::Error::Parameter
+            # Create a Rubuild::Build::Dep::Error::Parameter::Command
+            # Used internally.
+            # [+dep+] The Rubuild::Build::Dep for which someone modified the
+            #         'command' parameter when the dependency was runable.
+            def initialize(dep)
+              super(dep, 'command')
+            end # Rubuild::Build::Dep::Error::Parameter::Command#initialize
+          end # Rubuild::Build::Dep::Error::Parameter::Command
+        end # Rubuild::Build::Dep::Error::Parameter
+
+        ## Rubuild::Build::Dep::Error::Runable
+        # Runable error (dependency tree modified after dependency made
+        # runable).
+        class Runable < Rubuild::Build::Dep::Error
+          # :attr_reader: parent
+          # parent dependency that attempted insertion into +dep+'s dependency
+          # tree, even though +dep+ was runable.
+          Safer::IVar.instance_variable(self, :parent)
+          Safer::IVar.export_reader(self, :parent)
+
+          # Create a Rubuild::Build::Dep::Error::Runable
+          # Used internally.
+          # [+dep+] Runable dependency against which the user attempted
+          #         dependency hierarchy manipulation.
+          # [+parent+] Putative parent dependency the user attempted to place
+          #            in +dep+'s dependency tree.
+          def initialize(dep, parent)
+            super(
+              dep,
+              "Parent dependancy #{parent} added to #{dep} " +
+                "after dependancy made runable."
+              )
+            self.rubuild_build_dep_error_runable__parent = parent
+          end # Rubuild::Build::Dep::Error::Runable#initialize
+        end # Rubuild::Build::Dep::Error::Runable
+
+        ## Rubuild::Build::Dep::Error::Load
+        # Load error (circular dependency detected).
+        class Load < Rubuild::Build::Dep::Error
+          # :attr_reader: loading
+          # Dependencies loaded when the circle was detected.
+          Safer::IVar.instance_variable(self, :loading)
+          Safer::IVar.export_reader(self, :loading)
+
+          # Create a Rubuild::Build::Dep::Error::Load
+          # Used internally.
+          # [+dep+] The dependency which blocks on its own execution.
+          # [+loading+] Dependencies loaded at the time the circle was
+          #             detected.
+          def initialize(dep, loading)
+            super(
+              dep,
+              "Circular dependency detected."
+              )
+            self.rubuild_build_dep_error_load__loading = loading
+          end # Rubuild::Build::Dep::Error::Load#initialize
+
+          def report(file)
+            file.puts("#{self.dep.name} loaded from:\n")
+            self.loading.each do |trace|
+              file.puts("  #{trace.name}")
+            end
+            file.puts("call stack:")
+            self.backtrace.each do |stack|
+              file.puts("  #{stack}")
+            end
+          end
+        end # Rubuild::Build::Dep::Error::Load
+
+        ## Rubuild::Build::Dep::Error::Build
+        # Build error (attempt to build twice).
+        class Build < Rubuild::Build::Dep::Error
+          # :attr_reader: build_context
+          # The build context in which the dep was re-built.
+          Safer::IVar.instance_variable(self, :build_context)
+          Safer::IVar.export_reader(self, :build_context)
+
+          def initialize(dep, build_context)
+            super(dep, "Attempt to build twice.")
+            self.rubuild_build_dep_error_build__build_context = build_context
+          end # Rubuild::Build::Dep::Error::Build#initialize
+        end # Rubuild::Build::Dep::Error::Build
+
+        ## Rubuild::Build::Dep::Error::DepInconsistent
+        # The parent and the child dependency do not agree about their
+        # relationship.
+        class DepInconsistent < Rubuild::Build::Dep::Error
+          # :attr_reader: parent
+          # Parent of the dependency associated with this error.
+          Safer::IVar.instance_variable(self, :parent)
+          Safer::IVar.export_reader(self, :parent)
+          def initialize(dep, parent)
+            super(
+              dep, "Parent dependency #{parent.name} thought this was child.")
+            self.rubuild_build_dep_error_depinconsistent__parent = parent
+          end
+        end
+      end # Rubuild::Build::Dep::Error
+
+      ## Rubuild::Build::Dep::ProtocolClass
+      # Used to derive Rubuild::Build::Dep::Protocol
+      class ProtocolClass
+        # [+command+] command to execute.
+        #             if supplied (i.e. non-+nil+), object must respond to
+        #             +:call+.  +command.call+ method will be invoked at time
+        #             that this dependency should be processed, with first
+        #             argument being this dependency object (+self+), and
+        #             subsequent arguments as set by the +args=+ method.
+        # [+name+] name string for dependency.  for pretty-printing dependency
+        #          errors.
+        def initialize(command, name)
+        end
+
+        # Resets the dependency action to be invoked.
+        # [+command+] New command to be invoked.
+        # [_return_] +self+.
+        def set_command(command)
+        end
+
+        # Inserts dependency between +self+ and all child dependencies of
+        # +self+.
+        # [+dep+] Dependency against which all child dependencies of +self+
+        #         should wait.
+        def surrogate(dep)
+        end
+
+        # Makes +dep+ a parent dependency of +self+ - in other words, +dep+
+        # must be run before +self+ can be run.
+        # [+dep+] Dependency that must be executed before +self+ can execute.
+        def add_parent(dep)
+        end
+
+        # Record that a child dependency has been added to +self+.
+        # Used internally.
+        # [+dep+] New child dependency.
+        def child_added(dep)
+        end
+
+        # Mark that all parent dependencies have been satisfied for +self+.
+        # Inform all build contexts that _might_ execute this dependency that
+        # this dependency is now runable.
+        # Used internally.
+        def make_runable
+        end
+
+        # Check for circular dependencies.
+        # Used internally.
+        # [+loading+] Rubuild::Build::Dep chain in progress.  Used as a
+        #             backtrace, in case a circular dependency is detected.
+        # [+check+] Array of Rubuild::Build::Dep objects to place in 'parent'
+        #           list, when searching for circular dependencies.
+        def circle_check(loading, check)
+        end
+
+        # Record that a build-context is waiting to build this dependency.
+        # Search for circular dependencies.
+        # Used internally.
+        # [+loading+] Rubuild::Build::Dep dependency chain in progress, that
+        #             lead to +self+ being loaded into a
+        #             Rubuild::Build::Context.
+        # [+buildctx+] Rubuild::Build::Context into which +self+ is being
+        #              loaded.
+        def load_self(loading, buildctx)
+        end
+
+        # Loads +self+ and all parent dependancies into the execution context
+        # +buildctx+.
+        # [+buildctx+] Rubuild::Build::Context into which +self+ is being
+        #              loaded.
+        def load(buildctx)
+        end
+
+        # Return array of all Rubuild::Build::Context objects that will build
+        # this dependency.
+        def builders
+        end
+
+        # Return the child-dependencies of +self+ that placed +self+ into the
+        # Rubuild::Build::Context +builder+.
+        # [+builder+] A Rubuild::Build::Context into which +self+ was loaded.
+        # [_return_] The dependency hierarchy in +builder+ that resulted in
+        #            +self+ being loaded, or nil if +self+ was not loaded into
+        #            +builder+.
+        def loaders(builder)
+        end
+
+        # Inform all children that a parent dependency (or +self+) failed to
+        # execute a command due to +err+.
+        # Used internally.
+        # [+err+] Exception that prevents +self+ from completing.
+        # [_return_] Rubuild::Build::Dep::Error::Action for +err+.
+        def action_error_real(err)
+        end
+
+        # Error +err+ occurred while executing +self+'s dependency command.
+        # Inform all child dependencies of the event.
+        # Used internally.
+        # [+err+] Exception that prevented +self+'s dependency command from
+        #         completing.
+        # [+runctx+] Rubuild::Build::Context used to execute +self+.
+        # [_return_] Rubuild::Build::Dep::Error::Action for +err+.
+        def action_error(err, runctx)
+        end
+
+        # Child is being informed by +parent+ that error +err+ occurred
+        # processing a dependency action.
+        # Used internally.
+        # [+parent+] Parent dependency that will not run, thus preventing
+        #            +self+ from running.
+        # [+err+] Error that prevents +parent+ from running.
+        def parent_action_error(parent, err)
+        end
+
+        # Used by a Rubuild::Build::Context to execute the dependency command
+        # for +self+.
+        # Used internally.
+        # [+runctx+] Rubuild::Build::Context used to execute +self+'s
+        #            dependency command.
+        def runctx_build(runctx)
+        end
+
+        # Record that a parent dependency has been built.
+        # Will result in this dependency being made runable, when all parent
+        # dependencies are satisfied.
+        # Used internally.
+        # [+dep+] Parent dependency that was built.
+        def parent_built(dep)
+        end
+
+        # Boolean indicates whether +self+'s dependency action has been run.
+        attr_reader :built
+
+        # Array of additional arguments to :command.call().  The first
+        # argument to :command.call() is always +self+.
+        attr_accessor :args
+
+        # Error that prevented dependency execution.
+        attr_reader :err
+
+        # Human-readable name of this dependency.
+        attr_reader :name
+      end # Rubuild::Build::Dep::ProtocolClass
+
+      ## Rubuild::Build::Dep
+
+      # Protocol object.
+      PROTOCOL = Safer::Protocol.create_from_class(ProtocolClass)
+
+
+    end # Rubuild::Build::Dep
+
+  end # Rubuild::Build
+
+end # Rubuild