rubuild-core 0.0.3

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

@@ -0,0 +1,17 @@
+module Rubuild
+  module Build
+    module Simple
+      class Factory
+        def create_context
+          Rubuild::Build::Simple::Context.new
+        end
+
+        def create_dep(command, disp, *args)
+          dep = Rubuild::Build::Simple::Dep.new(command, disp)
+          dep.args = args
+          dep
+        end
+      end # Rubuild::Build::Simple::Factory
+    end # Rubuild::Build::Simple
+  end # Rubuild::Build
+end # Rubuild

data/lib/rubuild/env.rb

@@ -0,0 +1,113 @@
+require 'rubuild/env/location'
+require 'rubuild/env/provider'
+require 'rubuild/env/requirer'
+
+module Rubuild
+  ## Rubuild::Env
+  # Environment of Rubuild source modules.
+  class Env
+    ## Rubuild::Env::Error
+    # Superclass of all error exceptions raised by Rubuild::Env.
+    class Error < StandardError
+      # The environment associated with this error.
+      Safer::IVar.instance_variable(self, :env)
+      Safer::IVar.export_reader(self, :env)
+      def initialize(env, message)
+        super(message)
+        self.rubuild_env_error__env = env
+      end # Rubuild::Env::Error#initialize
+
+      ## Rubuild::Env::Error::Key
+      # Superclass of error exceptions having to do with environment registry.
+      class Key < Error
+        # key in environment registry.
+        Safer::IVar.instance_variable(self, :key)
+        Safer::IVar.export_reader(self, :key)
+        def initialize(env, key, message)
+          super(env, message)
+          self.rubuild_env_error_key__key = key
+        end # Rubuild::Env::Error::Key#initialize
+
+        ## Rubuild::Env::Error::Key::Full
+        # Attempt to provide the same key to the registry twice.
+        class Full < Key
+          Safer::IVar.instance_variable(self, :provided_location)
+          Safer::IVar.export_reader(self, :provided_location)
+          Safer::IVar.instance_variable(self, :providing_location)
+          Safer::IVar.export_reader(self, :providing_location)
+          def initialize(env, key, provided_location, providing_location)
+            super(
+              env, key,
+              "Key #{key.dump} already exists in registry at " +
+              "#{provided_location.found_dep.name} while providing " +
+              "#{providing_location.found_dep.name}")
+            self.rubuild_env_error_key_full__provided_location = 
+              provided_location
+            self.rubuild_env_error_key_full__providing_location = 
+              providing_location
+          end # Rubuild::Env::Error::Key::Full#initialize
+        end # Rubuild::Env::Error::Key::Full
+
+        ## Rubuild::Env::Error::Key::Empty
+        # Key does not exist in registry on require.
+        class Empty < Key
+          Safer::IVar.instance_variable(self, :requiring_location)
+          Safer::IVar.export_reader(self, :requiring_location)
+          def initialize(env, key, requiring_location)
+            super(
+              env, key,
+              "Key #{key.dump} does not exist in registry " +
+              "for #{requiring_location.found_dep.name}.")
+            self.rubuild_env_error_key_empty__requiring_location = 
+              requiring_location
+          end # Rubuild::Env::Error::Key::Empty#initialize
+        end # Rubuild::Env::Error::Key::Empty
+      end # Rubuild::Env::Error::Key
+    end # Rubuild::Env::Error
+
+    ## Rubuild::Env
+    # Rubuild::Build::Factory object for this Rubuild::Env.
+    Safer::IVar.instance_variable(self, :build_factory)
+    Safer::IVar.export_reader(self, :build_factory)
+    # Keys supplied by 'provide'
+    Safer::IVar.instance_variable(self, :providing)
+
+    # Create a Rubuild::Env object.
+    # [+build_factory+] Rubuild::Build::Factory derived object, which will
+    #                   integrate the dependency objects in this Rubuild::Env.
+    def initialize(build_factory)
+      self.rubuild_env__build_factory = build_factory
+      self.rubuild_env__providing = Hash.new
+    end # Rubuild::Env#initialize
+
+    def provide(key, providing)
+      if self.rubuild_env__providing.has_key?(key)
+        raise(
+          Error::Key::Full.new(
+            self, key, self.rubuild_env__providing[key], providing))
+      end
+      self.rubuild_env__providing[key] = providing
+    end
+    def has_provider?(key)
+      self.rubuild_env__providing.has_key?(key)
+    end
+    def require(key, requiring)
+      providing = self.rubuild_env__providing[key]
+      if not providing
+        raise(Error::Key::Empty.new(self, key, requiring))
+      end
+      reqdep = self.rubuild_env__build_factory.create_dep(
+        self.method(:_provide_require),
+        "Rubuild::Env::require(#{key.dump}," +
+        "#{providing.found_dep.name.dump}, " +
+        "#{requiring.found_dep.name.dump}",
+        providing, requiring)
+      reqdep.add_parent(providing.found_dep)
+      requiring.found_dep.add_parent(reqdep)
+    end
+
+    def _provide_require(dep, providing, requiring)
+      requiring.set_data(providing.data)
+    end
+  end # Rubuild::Env
+end # Rubuild::Env

data/lib/rubuild/env/location.rb

@@ -0,0 +1,105 @@
+module Rubuild
+  class Env
+    ## Rubuild::Env::Location
+    # A loaded interface to a source module.
+    class Location
+      ## Rubuild::Env::Location::Error
+      # Superclass of location-generated errors.
+      class Error < StandardError
+        Safer::IVar.instance_variable(self, :location)
+        Safer::IVar.export_reader(self, :location)
+        def initialize(location, message)
+          super(message)
+          self.rubuild_env_location_error__location = location
+        end
+
+        ## Rubuild::Env::Location::Error::SetData
+        # errors that occur while setting data.
+        class SetData < Error
+          Safer::IVar.instance_variable(self, :newdata)
+          Safer::IVar.export_reader(self, :newdata)
+          def initialize(location, newdata, message)
+            super(location, message)
+            self.rubuild_env_location_error_setdata__newdata = newdata
+          end
+
+          ## Rubuild::Env::Location::Error::SetData::Already
+          # attempt to set data twice.
+          class Already < SetData
+            def initialize(location, newdata)
+              super(
+                location, newdata,
+                "Attempt to set object data twice."
+                )
+            end
+          end
+        end
+
+        ## Rubuild::Env::Location::Error::BuiltEmpty
+        # Did not locate object.
+        class BuiltEmpty < Error
+          def initialize(location)
+            super(location, "Finished building, but did not obtain data.")
+          end
+        end
+
+        ## Rubuild::Env::Location::Error::DataEmpty
+        # Attempt to access non-existent data.
+        class DataEmpty < Error
+          def initialize(location)
+            super(location, "Attempt to access data before it was set.")
+          end
+        end
+      end
+
+      ## Rubuild::Env::Location
+      Safer::IVar.instance_variable(self, :found_dep)
+      Safer::IVar.export_reader(self, :found_dep)
+      Safer::IVar.instance_variable(self, :data)
+      Safer::IVar.instance_variable(self, :have_data)
+      Safer::IVar.export_reader(self, :have_data)
+      Safer::IVar.instance_variable(self, :depfactory)
+      Safer::IVar.export_reader(self, :depfactory)
+      Safer::IVar.instance_variable(self, :name)
+      Safer::IVar.export_reader(self, :name)
+      def initialize(name, depfactory)
+        self.rubuild_env_location__name = name
+        self.rubuild_env_location__depfactory = depfactory
+
+        self.rubuild_env_location__found_dep = 
+          self.rubuild_env_location__depfactory.create_dep(
+          self.method(:_found_depaction),
+          self.class.to_s + '#found#' + self.rubuild_env_location__name
+          )
+      end
+
+      def _found_depaction(dep)
+        # called when the "found_dep" is satisifed.
+        # ensure that data was found, and lose references to unneeded state
+        # variables.
+        self.rubuild_env_location__depfactory = nil
+        if ! self.rubuild_env_location__have_data
+          raise(Error::BuiltEmpty.new(self))
+        end
+      end
+
+      def set_data(data)
+        if self.rubuild_env_location__have_data
+          raise(Error::SetData::Already.new(self, data))
+        end
+        self.rubuild_env_location__data = data
+        self.rubuild_env_location__have_data = true
+        # data's found, call its routine to clean up.
+        # (this could maybe be a little cleaner)
+        self._found_depaction(self.rubuild_env_location__found_dep)
+      end
+
+      def data
+        if ! self.rubuild_env_location__have_data
+          raise(Error::DataEmpty.new(self))
+        end
+        self.rubuild_env_location__data
+      end
+    end # Rubuild::Env::Location
+  end # Rubuild::Env
+end

data/lib/rubuild/env/provider.rb

@@ -0,0 +1,51 @@
+module Rubuild
+  class Env
+    # Provider
+    class Provider
+      Safer::IVar.instance_variable(self, :location)
+      Safer::IVar.instance_variable(self, :env)
+      Safer::IVar.instance_variable(self, :arglist)
+      Safer::IVar.instance_variable(self, :exec_dep)
+      Safer::IVar.export_reader(self, :exec_dep)
+      Safer::IVar.instance_variable(self, :exec_block)
+      def initialize(env, name)
+        self.rubuild_env_provider__env = env
+        self.rubuild_env_provider__location = Rubuild::Env::Location.new(name, env.build_factory)
+        self.rubuild_env_provider__arglist = Array.new
+        self.rubuild_env_provider__exec_dep = env.build_factory.create_dep(
+          self.method(:_exec_satisfied), "#{self.class.to_s}.exec(#{name})")
+        self.rubuild_env_provider__location.found_dep.add_parent(
+          self.rubuild_env_provider__exec_dep)
+        env.provide(name, self.rubuild_env_provider__location)
+      end
+
+      def require(*args)
+        req = Rubuild::Env::Requirer.new(self.rubuild_env_provider__env, *args)
+        self.rubuild_env_provider__arglist << req
+        self.rubuild_env_provider__exec_dep.add_parent(req.location.found_dep)
+        self
+      end
+      def require_(*args)
+        req = Rubuild::Env::Requirer.new(self.rubuild_env_provider__env, *args)
+        self.rubuild_env_provider__exec_dep.add_parent(req.location.found_dep)
+        self
+      end
+      def exec(&block)
+        self.rubuild_env_provider__exec_block = block
+      end
+      def _exec_satisfied(dep)
+        exec_block = self.rubuild_env_provider__exec_block
+        self.rubuild_env_provider__exec_block = nil
+        block_args = self.rubuild_env_provider__arglist.map do |arg|
+          arg.location.data
+        end
+        self.rubuild_env_provider__arglist = nil
+        exec_block.call(self, *block_args)
+        self.rubuild_env_provider__location = nil
+      end
+      def set(object)
+        self.rubuild_env_provider__location.set_data(object)
+      end
+    end # Rubuild::Env::Provider
+  end # Rubuild::Env
+end # Rubuild

data/lib/rubuild/env/requirer.rb

@@ -0,0 +1,66 @@
+module Rubuild
+  class Env
+    ## Rubuild::Env::Requirer
+    # Look up a set of provided entries in the environment at once.
+    class Requirer
+      Safer::IVar.instance_variable(self, :location)
+      Safer::IVar.export_reader(self, :location)
+      Safer::IVar.instance_variable(self, :found)
+      Safer::IVar.instance_variable(self, :env)
+
+      def initialize(env, req_desc)
+        self.rubuild_env_requirer__location = 
+          Rubuild::Env::Location.new(req_desc.inspect, env.build_factory)
+
+        found_all = env.build_factory.create_dep(
+          self.method(:_found_all), self.rubuild_env_requirer__location.name)
+
+        self.location.found_dep.add_parent(found_all)
+
+        case req_desc
+        when String
+          finding = Rubuild::Env::Location.new(req_desc, env.build_factory)
+          env.require(req_desc, finding)
+          fill_dep = env.build_factory.create_dep(
+            self.method(:_found_only), "fill:#{finding.name}", finding)
+          fill_dep.add_parent(finding.found_dep)
+          found_all.add_parent(fill_dep)
+        when Array
+          self.rubuild_env_requirer__found = Array.new(req_desc.size)
+          req_desc.each_with_index do |path, index|
+            finding = Rubuild::Env::Location.new("#{index}:#{path}", env.build_factory)
+            env.require(path, finding)
+            fill_dep = env.build_factory.create_dep(
+              self.method(:_found_one), "fill:#{finding.name}", index, finding)
+            fill_dep.add_parent(finding.found_dep)
+            found_all.add_parent(fill_dep)
+          end
+        when Hash
+          self.rubuild_env_requirer__found = Hash.new
+          req_desc.each_pair do |key, path|
+            finding = Rubuild::Env::Location.new("#{key}:#{path}", env.build_factory)
+            env.require(path, finding)
+            fill_dep = env.build_factory.create_dep(
+              self.method(:_found_one), "fill:#{finding.name}", key, finding)
+            fill_dep.add_parent(finding.found_dep)
+            found_all.add_parent(fill_dep)
+          end
+        else
+          raise(ArgumentError, "Invalid key type for Rubuild::Env::Requirer.")
+        end
+      end # Rubuild::Env::Requirer#initialize
+
+      def _found_one(dep, key, found)
+        self.rubuild_env_requirer__found[key] = found.data
+      end
+      def _found_only(dep, found)
+        self.rubuild_env_requirer__found = found.data
+      end
+      def _found_all(dep)
+        self.location.set_data(self.rubuild_env_requirer__found)
+        self.rubuild_env_requirer__env = nil
+        self.rubuild_env_requirer__found = nil
+      end
+    end # Rubuild::Env::Requirer
+  end  # Rubuild::Env
+end # Rubuild

data/lib/rubuild/load.rb

@@ -0,0 +1,3 @@
+require 'rubuild/load/namespace'
+require 'rubuild/load/info'
+require 'rubuild/load/loader'

data/lib/rubuild/load/info.rb

@@ -0,0 +1,52 @@
+module Rubuild
+  module Load
+    ## Rubuild::Load::Info
+    class Info
+      Safer::IVar.instance_variable(self, :env)
+      Safer::IVar.export_reader(self, :env)
+      Safer::IVar.instance_variable(self, :location)
+      Safer::IVar.export_reader(self, :location)
+      Safer::IVar.instance_variable(self, :path)
+      Safer::IVar.export_reader(self, :path)
+      Safer::IVar.instance_variable(self, :commit_dep)
+      def initialize(env, path, name)
+        self.rubuild_load_info__env = env
+        self.rubuild_load_info__path = path
+        self.rubuild_load_info__location = Rubuild::Env::Location.new(name, env.build_factory)
+        self.rubuild_load_info__commit_dep = self.rubuild_load_info__env.build_factory.create_dep(
+          self.method(:_commit), "#{self.class.to_s}\#commit(#{name})")
+        self.rubuild_load_info__location.found_dep.add_parent(self.rubuild_load_info__commit_dep)
+      end # Rubuild::Load::Info#initialize
+
+      def _commit(dep)
+        self.rubuild_load_info__location.set_data(nil)
+      end # Rubuild::Load::Info#_commit
+
+      def provide(nm)
+        Rubuild::Env::Provider.new(self.rubuild_load_info__env, self.location.name + nm)
+      end # Rubuild::Load::Info#provide
+
+      def require(req_desc)
+        Rubuild::Env::Requirer.new(self.rubuild_load_info__env, req_desc)
+      end # Rubuild::Load::Info#require
+
+      def require!(req_desc, &block)
+        required = Rubuild::Env::Requirer.new(self.rubuild_load_info__env, req_desc)
+        satisfied_dep = self.rubuild_load_info__env.build_factory.create_dep(
+          self.method(:_require_satisfied),
+          "#{self.class.to_s}(#{self.location.name}).require!(#{required.location.name})",
+          required.location, block)
+        satisfied_dep.add_parent(required.location.found_dep)
+        self.rubuild_load_info__commit_dep.add_parent(satisfied_dep)
+      end # Rubuild::Load::Info#require!
+
+      def _require_satisfied(dep, required, block)
+        block.call(required.data)
+      end # Rubuild::Load::Info#require_satisfied
+
+      def with(&block)
+        self.instance_eval(&block)
+      end
+    end # Rubuild::Load::Info
+  end # Rubuild::Load
+end # Rubuild

data/lib/rubuild/load/loader.rb

@@ -0,0 +1,75 @@
+module Rubuild
+  module Load
+    ## Rubuild::Load::Loader
+    # Load code into a private execution context, referenced by a String name.
+    class Loader
+      ## Rubuild::Load::Loader::Error
+      # Superclass of errors generated by Loader.
+      class Error < StandardError
+        Safer::IVar.instance_variable(self, :loader)
+        Safer::IVar.export_reader(self, :loader)
+        def initialize(loader, message)
+          self.rubuild_load_loader_error__loader = loader
+          super(message)
+        end # Rubuild::Load::Loader::Error#initialize
+
+        ## Rubuild::Load::Loader::Error::Unprovisioned
+        # Attempt to use loader functionality prior to provisioning.
+        class Unprovisioned < Error
+          Safer::IVar.instance_variable(self, :operation)
+          Safer::IVar.export_reader(self, :operation)
+          def initialize(loader, operation)
+            self.rubuild_load_loader_error_unprovisioned__operation = operation
+            super(loader, "#{operation} method called prior to provision.")
+          end
+        end # Rubuild::Load::Loader::Error::Unprovisioned
+      end # Rubuild::Load::Loader::Error
+
+      Safer::IVar.instance_variable(self, :inc_paths)
+      Safer::IVar.export_accessor(self, :inc_paths)
+      Safer::IVar.instance_variable(self, :ns_factory)
+      Safer::IVar.export_reader(self, :ns_factory)
+
+      def initialize(ns_factory)
+        self.rubuild_load_loader__ns_factory = ns_factory
+        self.rubuild_load_loader__inc_paths = Array.new
+      end # Rubuild::Load::Loader#initialize
+
+      def provision(env, key)
+        self.freeze
+        self.rubuild_load_loader__inc_paths.freeze
+        l = Rubuild::Env::Location.new("#{self.class.to_s}\#provision(#{key})", env.build_factory)
+        l.set_data(self)
+        env.provide(key, l)
+      end # Rubuild::Load::Loader#provision
+
+      def findFile(fname)
+        if ! self.frozen?
+          raise Error::Unprovisioned.new(self, :findFile)
+        end
+        Rubuild::Util.enumerable_find(self.rubuild_load_loader__inc_paths) do |path|
+          testfile = "#{path}/#{fname}"
+          File.exists?(testfile) && testfile
+        end
+      end # Rubuild::Load::Loader#findFile
+
+      def loadFile(env, path, name = path)
+        fname = self.findFile(path)
+        text = File.open(fname, 'r') do |f| f.read end
+        self._loadInternal(env, text, path, name, fname)
+      end # Rubuild::Load::Loader#loadFile
+
+      def loadString(env, text, name)
+        self._loadInternal(env, text, name, name, name)
+      end # Rubuild::Load::Loader#loadFile
+
+      def _loadInternal(env, text, path, name, fname)
+        info = Rubuild::Load::Info.new(env, path, name)
+        ns = self.ns_factory.create
+        ns.rubuild_info = info
+        ns.class_eval(text, fname)
+        info.location
+      end
+    end # Rubuild::Load::Loader
+  end # Rubuild::Load
+end # Rubuild