rubuild-core 0.0.3

data/lib/rubuild/build/factory.rb

@@ -0,0 +1,30 @@
+module Rubuild
+
+  module Build
+
+    ## Rubuild::Build::Factory
+    # Rubuild::Build::Factory is the interface object for creating
+    # Rubuild::Build::Dep and Rubuild::Build::Context objects.
+    class Factory
+
+      # Used to derive Rubuild::Build::Factory
+      class ProtocolClass
+        # Create a Rubuild::BuildContext object.
+        # [_return_] A new Rubuild::BuildContext for executing Rubuild::Dep
+        #            dependencies.
+        def create_context
+        end # Rubuild::Build::Factory#create_build_context
+
+        # Create a Rubuild::Dep object.
+        # [+command+] +command+ argument to Rubuild::Dep#new.
+        # [+disp+] +disp+ argument to Rubuild::Dep#new.
+        # [+args+] Additional arguments to be passed to +command+.
+        # [_return_] A new Rubuild::Dep for executing +command+.
+        def create_dep(command, disp, *args)
+        end # Rubuild::Build::Factory#create_dep
+      end # Rubuild::Build::Factory
+
+      Protocol = Safer::Protocol.create_from_class(ProtocolClass)
+    end # Rubuild::Build::Factory
+  end # Rubuild::Build
+end # Rubuild

data/lib/rubuild/build/simple.rb

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

data/lib/rubuild/build/simple/context.rb

@@ -0,0 +1,90 @@
+module Rubuild
+  module Build
+    module Simple
+      class Context
+
+        ## Rubuild::Build::Context
+        # Hash of dependencies that are loadable in this build context.
+        Safer::IVar.instance_variable(self, :loaded)
+        # Array of dependencies that are currently waiting execution in this
+        # build context.
+        Safer::IVar.instance_variable(self, :runable)
+        Safer::IVar.instance_variable(self, :debug_level, :debug_file)
+        Safer::IVar.export_accessor(self, :debug_level, :debug_file)
+
+        # Initialize +self+.
+        def initialize
+          self.rubuild_build_simple_context__loaded = Hash.new
+          self.rubuild_build_simple_context__runable = Array.new
+          self.rubuild_build_simple_context__debug_level = 0
+          self.rubuild_build_simple_context__debug_file = nil
+        end # Rubuild::Build::Context#initialize
+
+        # Mark that a Rubuild::Dep object has been loaded into +self+.
+        # Used internally.
+        # [+dep+] Rubuild::Dep object loaded into +self+ for future execution.
+        # [_return_] Return value is:
+        #            [+true+] when this is the first time the dependency is being
+        #                     loaded into +self+,
+        #            [+false+] otherwise.
+        def dep_loaded(dep)
+          rval = ! self.rubuild_build_simple_context__loaded.has_key?(dep)
+          if rval
+            self.rubuild_build_simple_context__loaded[dep] = true
+          end
+          rval
+        end # Rubuild::Build::Context#dep_loaded
+
+        # Mark that a Rubuild::Dep object is now runable within the +self+
+        # Rubuild::Build::Context.
+        # This indicates that all of the dependency's parents have been satisfied.
+        # Used internally.
+        # [+dep+] Rubuild::Dep that has become runable in +self+.
+        def dep_runable(dep)
+          if ! self.rubuild_build_simple_context__loaded.has_key?(dep)
+            raise Build::Context::Error::Runable.new(self, dep)
+          end
+          self.rubuild_build_simple_context__loaded.delete(dep)
+          self.rubuild_build_simple_context__runable << dep
+        end # Rubuild::Build::Context#dep_runable
+
+        # 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
+          Build::Context::Error::Run.new(self)
+        end # Rubuild::Build::Context#run_error
+
+        # Execute a single dependency object.  Not a supported interface in all
+        # derived classes.
+        def step
+          if self.rubuild_build_simple_context__runable.size > 0
+            dep = self.rubuild_build_simple_context__runable.shift
+            if ! dep.built
+              dep.runctx_build(self)
+            end
+          end
+        end # Rubuild::Build::Context#step
+
+        # Execute the dependencies loaded into this build context, in dependency
+        # order.
+        def run
+          while self.rubuild_build_simple_context__runable.size > 0
+            self.step
+          end
+          if self.rubuild_build_simple_context__loaded.keys.size > 0
+            raise self.run_error
+          end
+        end # Rubuild::Build::Context#run
+
+        def debug(level)
+          if (self.rubuild_build_simple_context__debug_file &&
+              level < self.rubuild_build_simple_context__debug_level)
+            yield self.rubuild_build_simple_context__debug_file
+          end
+        end
+      end # Rubuild::Build::Simple::Context
+    end # Rubuild::Build::Simple
+  end # Rubuild::Build
+end # Rubuild

data/lib/rubuild/build/simple/dep.rb

@@ -0,0 +1,367 @@
+module Rubuild
+  module Build
+    module Simple
+      class Dep
+        # count of parent dependencies preventing +self+ from executing.
+        Safer::IVar.instance_variable(self, :build_wait)
+        # Hash of parent dependencies preventing +self+ from executing.
+        Safer::IVar.instance_variable(self, :parents)
+        # Array of child dependencies waiting for +self+ to execute.
+        Safer::IVar.instance_variable(self, :children)
+        # Boolean indicates whether all parent dependencies have been satisfied,
+        # and +self+'s action can be executed.
+        Safer::IVar.instance_variable(self, :runable)
+        Safer::IVar.instance_variable(self, :built)
+        Safer::IVar.export_reader(self, :built)
+        # Hash of Rubuild::Build::Context's into which +self+ has been loaded.
+        Safer::IVar.instance_variable(self, :loaded)
+        # Boolean used to check for circular dependencies when adding parent
+        # Rubuild::Build::Dep objects.
+        Safer::IVar.instance_variable(self, :circlecheck)
+
+        # Object that responds to :call method, or nil.  Essentially +self+'s
+        # dependency action.
+        Safer::IVar.instance_variable(self, :command)
+        Safer::IVar.instance_variable(self, :args)
+        Safer::IVar.export_reader(self, :args)
+        # Pretty name of dependency object, for human consumption.
+        Safer::IVar.instance_variable(self, :name)
+
+        Safer::IVar.instance_variable(self, :err)
+        Safer::IVar.export_reader(self, :err)
+
+        def initialize(command, name)
+          self.rubuild_build_simple_dep__build_wait = 0
+          self.rubuild_build_simple_dep__parents = Hash.new
+          self.rubuild_build_simple_dep__children = Array.new
+          self.rubuild_build_simple_dep__runable = false
+          self.rubuild_build_simple_dep__built = false
+          self.rubuild_build_simple_dep__loaded = Hash.new
+          self.rubuild_build_simple_dep__circlecheck = false
+          
+          self.rubuild_build_simple_dep__command = command
+          self.rubuild_build_simple_dep__name = name
+          self.rubuild_build_simple_dep__err = nil
+          self.args = []
+        end # Rubuild::Build::Dep#initialize
+
+        # Returns a human-readable string describing the depandancy object,
+        # as set during initialization.
+        # [_return_] Human-readable string description of +self+ dependency.
+        def name
+          if self.rubuild_build_simple_dep__name
+            self.rubuild_build_simple_dep__name
+          else
+            super
+          end
+        end # Rubuild::Build::Dep#name
+
+        # Sets the list of optional arguments with which the dependency action will
+        # be invoked.
+        # [+nargs+] New arguments to dependency action.
+        # [_return_] +self+.
+        def args=(nargs)
+          if self.rubuild_build_simple_dep__runable or self.rubuild_build_simple_dep__built
+            raise Rubuild::Build::Dep::Error::Parameter::Args.new(self)
+          end
+          self.rubuild_build_simple_dep__args = nargs
+          self
+        end # Rubuild::Build::Dep#args=
+
+        # Resets the dependency action to be invoked.
+        # [+command+] New command to be invoked.
+        # [_return_] +self+.
+        def set_command(command)
+          if self.rubuild_build_simple_dep__runable or self.rubuild_build_simple_dep__built
+            raise Rubuild::Build::Dep::Error::Parameter::Command.new(self)
+          end
+          self.rubuild_build_simple_dep__command = command
+          self
+        end  # Rubuild::Build::Dep#set_command
+
+        # Inserts dependency between +self+ and all child dependencies of +self+.
+        # [+dep+] Dependency against which all child dependencies of +self+ should
+        #         wait.
+        def surrogate(dep)
+          dep.add_parent(self)
+          self.rubuild_build_simple_dep__children.each do |child|
+            if child != dep
+              child.add_parent(dep)
+            end
+          end
+          
+          self.rubuild_build_simple_dep__loaded.each_key do |buildctx|
+            dep.load(buildctx)
+          end
+        end # Rubuild::Build::Dep#surrogate
+
+        # 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)
+          if self.rubuild_build_simple_dep__runable
+            raise Rubuild::Build::Dep::Error::Runable.new(self, dep)
+          end
+          # Are we already waiting for this dependency?
+          if ! self.rubuild_build_simple_dep__parents.has_key?(dep)
+            # No, so we probably want to add him in...
+            # check that we're not creating a circular dependency.
+            self.circle_check(Array.new, [dep])
+
+            # Indicate that we want to block on parent...
+            self.rubuild_build_simple_dep__build_wait += 1
+            self.rubuild_build_simple_dep__parents[dep] = true
+            # ...and tell parent to prod us after he runs.
+            dep.child_added(self)
+          end
+          # The new parent will need to be loaded into any build context into
+          # which self is loaded.
+          self.rubuild_build_simple_dep__loaded.each_key do |bctx|
+            dep.load(bctx)
+          end
+        end # Rubuild::Build::Dep#add_parent
+
+        # Record that a child dependency has been added to +self+.
+        # Used internally.
+        # [+dep+] New child dependency.
+        def child_added(dep)
+          if self.built
+            dep.parent_built(self)
+          else
+            self.rubuild_build_simple_dep__children << dep
+          end
+        end # Rubuild::Build::Dep#child_added
+
+        # 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
+          self.rubuild_build_simple_dep__loaded.each_key do |buildctx|
+            buildctx.dep_runable(self)
+          end
+          self.rubuild_build_simple_dep__runable = true
+          self.rubuild_build_simple_dep__parents = nil
+        end # Rubuild::Build::Dep#make_runable
+
+        # 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)
+          if self.rubuild_build_simple_dep__circlecheck
+            raise Rubuild::Build::Dep::Error::Load.new(self, loading)
+          end
+          if self.built
+            return
+          end
+          self.rubuild_build_simple_dep__circlecheck = true
+          parentcheck = check.dup
+          if self.rubuild_build_simple_dep__parents
+            self.rubuild_build_simple_dep__parents.each_pair do |key, value|
+              if value
+                parentcheck << key
+              end
+            end
+          end
+          pcheck_arr = Array.new
+          loading.push(self)
+          parentcheck.each do |parent|
+            parent.circle_check(loading, pcheck_arr)
+          end
+          loading.pop
+          self.rubuild_build_simple_dep__circlecheck = false
+        end # Rubuild::Build::Dep#circle_check
+
+        # 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)
+          if self.built
+            return
+          end
+          if buildctx.dep_loaded(self) == true
+            self.rubuild_build_simple_dep__loaded[buildctx] = loading.dup
+            if self.rubuild_build_simple_dep__build_wait > 0
+              parentcheck = Array.new
+              self.rubuild_build_simple_dep__parents.each_pair do |key, value|
+                if value
+                  parentcheck << key
+                end
+              end
+              loading.push(self)
+              parentcheck.each do |parent|
+                parent.load_self(loading, buildctx)
+              end
+              loading.pop
+            elsif self.rubuild_build_simple_dep__runable
+              buildctx.dep_runable(self)
+            else
+              self.make_runable
+            end
+          end
+        end # Rubuild::Build::Dep#load_self
+
+        # Loads +self+ and all parent dependancies into the execution context
+        # +buildctx+.
+        # [+buildctx+] Rubuild::Build::Context into which +self+ is being loaded.
+        def load(buildctx)
+          self.load_self(Array.new, buildctx)
+        end
+
+        # Return array of all Rubuild::Build::Context objects that will build this
+        # dependency.
+        def builders
+          self.rubuild_build_simple_dep__loaded.keys
+        end # Rubuild::Build::Dep#builders
+
+        # 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)
+          self.rubuild_build_simple_dep__loaded[builder]
+        end # Rubuild::Build::Dep#loaders
+
+        # 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)
+          self.rubuild_build_simple_dep__err = err
+          self.rubuild_build_simple_dep__children.each do |child|
+            child.parent_action_error(self, err)
+          end
+          self.rubuild_build_simple_dep__err
+        end # Rubuild::Build::Dep#action_error_real
+
+        # 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)
+          self.action_error_real(
+            Rubuild::Build::Dep::Error::Action.new(self, err, runctx)
+            )
+        end # Rubuild::Build::Dep#action_error
+
+        # 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)
+          self.action_error_real(err)
+        end # Rubuild::Build::Dep#parent_action_error
+
+        # 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)
+          if self.rubuild_build_simple_dep__built == true
+            raise Rubuild::Build::Dep::Error::Build.new(self, runctx)
+          end
+          
+          # propogate errors from parents.  the error may have been
+          # set during the 'load' operation...
+          if self.err
+            raise self.err
+          end
+          
+          # call the command, then lose the reference, so it can be
+          # GC'ed.
+          begin
+            runctx.debug(1) do |outf|
+              outf.puts("building #{self.name}")
+            end
+            if self.rubuild_build_simple_dep__command
+              self.rubuild_build_simple_dep__command.call(
+                self, *self.rubuild_build_simple_dep__args
+                )
+            end
+          rescue Exception, NoMethodError => e
+            raise self.action_error(e, runctx)
+          end
+          
+          self.rubuild_build_simple_dep__command = nil
+          self.rubuild_build_simple_dep__args = nil
+          self.rubuild_build_simple_dep__built = true
+          self.rubuild_build_simple_dep__loaded = nil
+          self.rubuild_build_simple_dep__children.each do |child|
+            child.parent_built(self)
+            runctx.debug(1) do |outf|
+              puts(" #{child.name} is waiting for #{child.rubuild_build_simple_dep__build_wait}:")
+              runctx.debug(2) do |outf|
+                if child.rubuild_build_simple_dep__parents
+                  child.rubuild_build_simple_dep__parents.each_pair do |child_parent, count|
+                    puts("  #{child_parent.name}(#{count})")
+                  end
+                end
+              end
+            end
+          end
+          self.rubuild_build_simple_dep__children = nil
+        end # Rubuild::Build::Dep#runctx_build
+
+        # 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)
+          if ! self.rubuild_build_simple_dep__parents[dep]
+            raise(Rubuild::Build::Dep::Error::DepInconsistent.new(self, dep))
+          end
+          self.rubuild_build_simple_dep__build_wait -= 1
+          self.rubuild_build_simple_dep__parents[dep] = false
+          if (self.rubuild_build_simple_dep__build_wait == 0)
+            self.make_runable
+          end
+        end # Rubuild::Build::Dep#parent_built
+
+        def parent_tree
+          rval = Hash.new
+          if self.rubuild_build_simple_dep__parents
+            self.rubuild_build_simple_dep__parents.each_pair do |parent, is_waiting|
+              if is_waiting
+                rval["#{parent.name}"] = parent.parent_tree
+              end
+            end
+          end
+          rval
+        end
+
+        def child_tree
+          rval = Hash.new
+          if self.rubuild_build_simple_dep__children
+            self.rubuild_build_simple_dep__children.each do |child|
+              rval[child.name] = child.child_tree
+            end
+          end
+          rval
+        end
+
+        def self.print_tree(file, tree, indent = 0)
+          tree.keys.sort.each do |node|
+            file.puts(' '*indent + node)
+            self.print_tree(file, tree[node], indent+1)
+          end
+        end
+      end # Rubuild::Build::Simple::Dep
+    end # Rubuild::Build::Simple
+  end # Rubuild::Build
+end # Rubuild