reactive-core 0.2.0

data/lib/reactive-core/gem_dependency.rb

@@ -0,0 +1,231 @@
+module Reactive
+  class GemDependency #:nodoc:
+    attr_accessor :name, :requirement, :version, :lib, :source
+
+    def initialize(name, options = {})
+      require 'rubygems' unless Object.const_defined?(:Gem)
+      
+      options = {:version => options} if options.is_a? String
+
+      if options[:requirement]
+        @requirement = options[:requirement]
+      elsif options[:version]
+        @requirement = Gem::Requirement.create(options[:version])
+      end
+
+      @version  = @requirement.instance_variable_get("@requirements").first.last if @requirement
+      @name     = name.to_s
+      @lib      = options[:lib]
+      @source   = options[:source]
+      @init = options[:init]
+      @loaded   = false
+    end
+
+    def dependencies
+      if spec = specification
+        all_dependencies = spec.dependencies.map do |dependency|
+          GemDependency.new(dependency.name, :requirement => dependency.version_requirements)
+        end
+        all_dependencies += all_dependencies.map(&:dependencies).flatten
+        all_dependencies.uniq
+      else
+        []
+      end
+    end
+    
+    def load
+      return if @loaded
+      args = [@name]
+      args << @requirement.to_s if @requirement
+      gem *args
+      # Now, run its reactive init code
+      init_plugin
+      @loaded = true
+    end
+    
+    def init_plugin
+      if @init == :rails
+        require(@lib) if @lib
+      else
+        require(@lib || @name) unless @lib == false
+      end
+      gem_path = File.expand_path(specification.full_gem_path)
+      specification.require_paths.map {|path| File.join(gem_path, path) }.each do |path|
+        begin
+          require File.join(path, 'reactive', 'init.rb')
+          return
+        rescue LoadError
+          # No reactive init code, let's try a Rails init code
+          if @init == :rails
+            return if load_rails_init(path)
+          end
+        end
+      end
+    end
+
+    def embedded?
+      return true if @embedded
+      return false unless specification
+      File.expand_path(specification.installation_path) == File.expand_path(Reactive.path_for('gems'))
+    end
+  
+    def installed?
+      loaded? || specification
+    end
+
+    def loaded?
+      @loaded
+    end
+  
+    def loaded_spec
+      Gem.loaded_specs[@name]
+    end
+
+    def install
+      cmd = "#{gem_command} #{install_command.join(' ')}"
+      [cmd, %x(#{cmd})]
+    end
+  
+    def embed
+      return "#{name} #{requirement} is already embedded." if embedded?
+      # If the gem is already installed, use Gem::Installer to embed because we only need gem files and the spec
+      if installed?
+        require 'rubygems/installer'
+        path = get_gem_path(name, requirement)
+        basename = File.basename(path).sub(/\.gem$/, '')
+        installer = Gem::Installer.new(path, :install_dir => Reactive.path_for('gems'))
+        installer.unpack Reactive.path_for('gems', 'gems', basename)
+        installer.write_spec
+        @embedded = true
+        "Successfully embedded #{name} #{installer.spec.version}"
+      else
+        cmd = "#{gem_command} #{install_command.join(' ')} -i #{Reactive.path_for('gems')} --ignore-dependencies"
+        [cmd, %x(#{cmd})]
+      end
+    end
+    
+    def ==(other)
+      self.name == other.name && self.requirement == other.requirement
+    end
+    alias :eql? :==
+    def hash
+      "#{name}#{requirement}".hash
+    end
+
+    protected
+
+    def specification
+      @spec ||= Gem.source_index.search(Gem::Dependency.new(@name, @requirement)).sort_by { |s| s.version }.last
+    end
+    
+    def gem_command
+      RUBY_PLATFORM =~ /win32/ ? 'gem.bat' : 'gem'
+    end
+
+    def install_command
+      cmd = %w(install) << @name
+      cmd << "--version" << %("#{@requirement.to_s}") if @requirement
+      cmd << "--source"  << @source  if @source
+      cmd
+    end
+  
+    # >> taken from rubygems/commands/unpack_command.rb <<
+    # Return the full path to the cached gem file matching the given
+    # name and version requirement.  Returns 'nil' if no match.
+    #
+    # Example:
+    #
+    #   get_path('rake', '> 0.4')   # -> '/usr/lib/ruby/gems/1.8/cache/rake-0.4.2.gem'
+    #   get_path('rake', '< 0.1')   # -> nil
+    #   get_path('rak')             # -> nil (exact name required)
+    #--
+    # TODO: This should be refactored so that it's a general service. I don't
+    # think any of our existing classes are the right place though.  Just maybe
+    # 'Cache'?
+    #
+    # TODO: It just uses Gem.dir for now.  What's an easy way to get the list of
+    # source directories?
+    def get_gem_path(gemname, version_req)
+      return gemname if gemname =~ /\.gem$/i
+      
+      specs = Gem::source_index.search(/\A#{gemname}\z/, version_req)
+      selected = specs.sort_by { |s| s.version }.last
+      return nil if selected.nil?
+
+      # We expect to find (basename).gem in the 'cache' directory.
+      # Furthermore, the name match must be exact (ignoring case).
+      if gemname =~ /^#{selected.name}$/i
+        filename = selected.full_name + '.gem'
+        path = nil
+
+        Gem.path.find do |gem_dir|
+          path = File.join gem_dir, 'cache', filename
+          File.exist? path
+        end
+
+        path
+      end
+    end
+  
+    def load_rails_init(path)
+#      define_rails_equivalence
+      if init_file = [File.join(path, 'rails', 'init.rb'), File.join(specification.full_gem_path, 'init.rb')].find {|file| File.file? file}
+        Reactive::Initializer.register("init_rails_plugin_#{specification.name}", :init_rails_plugin) do
+          Kernel.load(init_file)
+        end
+      end
+    rescue LoadError
+      # Don't care, not having init code is legal (at least in reactive).
+      false
+    end
+  
+=begin
+    @@rails_equivalence_set = false
+    def define_rails_equivalence
+      return if @@rails_equivalence_set
+      @@rails_equivalence_set = true
+      puts "defininf rials qeui"
+      Reactive::Initializer.configure :rails_equivalence do
+        puts "rails equi"
+        self.class.module_eval <<-EOC
+          module ::Rails
+            Generator = RubiGen
+          end
+        EOC
+      end
+    end
+=end
+  
+    public
+
+    def self.report_gems_state(with_dependencies = true)
+      Reactive.configuration.gems.inject('') do |report, gem|
+        installed_dependency_count = 0
+        dependencies_status = gem.dependencies.collect do |dependency|
+          if dependency.installed?
+            code = dependency.embedded? ? "E" : "I"
+            installed_dependency_count += 1
+          else
+            code = " "
+          end
+          "  [#{code}] #{dependency.name} #{dependency.requirement.to_s}\n"
+        end.uniq
+
+        code = gem.installed? ? (gem.embedded? ? "E" : "I") : " "
+        code.downcase! if installed_dependency_count != gem.dependencies.size
+        report << "[#{code}] #{gem.name} #{gem.requirement.to_s}\n"
+        report << dependencies_status.join('') if with_dependencies
+        report
+      end << "I = Installed, i = Installed but missing dependencies\nE = Embedded,  e = Embedded but missing dependencies"
+    end
+
+    # Returns an Array of missing gems
+    def self.missing_gems
+      Reactive.configuration.gems.inject([]) do |missing, gem|
+        missing << gem unless gem.installed?
+        gem.dependencies.inject(missing) {|missing, dependency| dependency.installed? ? missing : missing << dependency}
+      end.uniq
+    end
+
+  end
+end

data/lib/reactive-core/helper_module.rb

@@ -0,0 +1,14 @@
+class HelperModule < Module
+  def initialize(names, code)
+    self.class.send(:define_method, :helpers) do
+      # reverse because this array will be passed to #extend which put precedence in the first passed module
+      helpers = names.collect {|name| const_get(name.split('.').first.classify) }.reverse
+      #constants doesn't preserve the order in which they are declared! #helpers = constants.collect{|name| const_get(name)}.select{|const| const.is_a? Module}
+      # We provide ourself (which is an empty module) if no nested modules are defined because calling #extend with no argument isn't legal.
+      helpers.empty? ? self : helpers
+    end
+    @name = names.join('_')
+    class_eval(code)
+  end
+  attr_reader :name
+end

data/lib/reactive-core/initializer.rb

@@ -0,0 +1,488 @@
+require 'activesupport'
+require 'singleton'
+require 'reactive-core/core_ext'
+require 'reactive-core/version'
+require 'reactive-core/gem_dependency'
+
+module Reactive
+  class << self
+    # The reactive configuration used for the application.
+    attr_accessor :configuration
+
+    # The logger instance used by the framework. Plugins may copy this reference,
+    # thus changing it lately (after init time) may not have the desired effect.
+    attr_accessor :logger
+
+    # Returns the Reactive version as a String
+    def version
+      VERSION::STRING
+    end
+  
+    # Returns the directory for the type passed.
+    # Returns nil if no directory is configured for the passed type.
+    #
+    # Examples:
+    #   dir_for(:config)  => "/home/lambda/mysales/config"
+    #   dir_for(:views)  => "/home/lambda/mysales/app/views"
+    def dir_for(type)
+      dirs_for(type).first
+    end
+
+    # Returns an array of directories for the type passed.
+    # Returns an empty array if no directory is configured for the passed type.
+    #
+    # Examples:
+    #   dirs_for(:config)  => ["/home/lambda/mysales/config"]
+    #   dirs_for(:views)  => ["/home/lambda/mysales/app/views", "/home/lambda/mysales/app/special_views"]
+    def dirs_for(type)
+      [configuration.paths[type]].flatten.compact
+    end
+
+    # Constructs an absolute path with parts relative to the application root or relative
+    # to a typed directory.
+    #
+    # Raises an ArgumentError if no directory is configured for the passed type.
+    #
+    # Examples:
+    #   path_for("log", "production.log") # => "/home/lambda/mysales/log/production.log"
+    #   path_for(:views, "main", "run.rb") # => /home/lambda/mysales/app/views/main/run.rb"
+    def path_for(*parts)
+      root_dir = parts.first.is_a?(Symbol) ? dir_for(path_type = parts.shift) : configuration.root_dir
+      raise ArgumentError, defined?(path_type) ? "No defined path for #{path_type}" : "No root dir defined!" unless root_dir
+      File.join(root_dir, *parts)
+    end
+
+    # Returns the complete pathname for a given file (the last argument) in a given path (other parts) specified with a similar form than #path_for.
+    # You may also pass wildcards as defined in Dir#glob, when this is the case, the first matching file is returned.
+    def file_for(*parts)
+      files_for(*parts).first
+    end
+  
+    # Returns the complete pathnames for a given glob path relative to the application root, see #path_for for more information.
+    def files_for(*parts)
+      root_dirs = parts.first.is_a?(Symbol) ? dirs_for(path_type = parts.shift) : [configuration.root_dir]
+      raise ArgumentError, defined?(path_type) ? "No defined path for #{path_type}" : "No root dir defined!" if root_dirs.empty?
+      root_dirs.each do |dir|
+        pathname = File.join(dir, *parts)
+        filenames = Dir.glob(pathname).select {|item| File.file? item}
+        return filenames unless filenames.empty?
+      end
+      []
+    end
+  
+    # Returns the complete pathname for a given file (the last argument) in a given path (other parts) specified with a similar form than #path_for.
+    # Raises an Errno::ENOENT exception if none matched.
+    def file_for!(*parts)
+      file_for(*parts) or raise Errno::ENOENT
+    end
+
+    # Constructs a relative path (to the application root) with parts relative to the application root or relative
+    # to a typed directory.
+    #
+    # Examples:
+    #   relative_path_for("log", "production.log") # => "log/production.log"
+    #   relative_path_for(:views, "main", "run.rb") # => "app/views/main/run.rb"
+    def relative_path_for(*parts)
+      path_for(*parts).sub("#{configuration.root_dir}/", '')
+    end
+  end
+
+  self.logger = ActiveSupport::BufferedLogger.new(STDERR)
+  self.logger.level = (ENV['DEBUG'] || $DEBUG) ? ActiveSupport::BufferedLogger::DEBUG : ActiveSupport::BufferedLogger::WARN
+
+  #
+  # Holds the configuration of the framework and plugins.
+  #
+  # The configuration object is a hash-like object with access to values with
+  # accessors. So these are equivalent:
+  #   config[:use_donuts] = true
+  #   config.use_donuts = true
+  #
+  #
+  # It is populated by the framework itself, plugins and also the application through
+  # the config/config.rb file and its specialized config/environments/*.rb forms.
+  class Configuration < OrderedOptions
+    def initialize(*args)
+      super()
+      self[:paths] = {}
+      self[:gems] = []
+      parse(args.first) if args.first
+    end
+
+    # Merges the passed options with the configuration.
+    # Pass a hash-like object for the options. You may either pass a block which
+    # will be yielded with a fresh configuration object that will be merged after
+    # the end of the block.
+    def merge(options = nil, &block)
+      raise ArgumentError, "Pass either an options object or a block, not both!" unless options.nil? ^ block.nil?
+      block.call(options = Configuration.new) if block
+      options.each {|key, value| self[key] = value }
+      
+      # special handling for paths and gems
+      (options.paths || {}).each {|type, path| self[:paths][type] = path }
+      (options.gems || []).each {|gem| self[:gems] << gem }
+    end
+  
+    # Reverse merge the passed options with the configuration. See #merge for details about the arguments.
+    # A reverse merge is a non destructive merge, that is if a value already exists in the current configuration
+    # it has precedence over the one you pass in the arguments.
+    def reverse_merge(options = nil, &block)
+      raise ArgumentError, "Pass either an options object or a block, not both!" unless options.nil? ^ block.nil?
+      block.call(options = Configuration.new) if block
+      the_keys = self.keys
+      options.each {|key, value| self[key] = value unless the_keys.include?(key) }
+      
+      # special handling for paths and gems
+      (options.paths || {}).each {|type, path| self[:paths][type] = path unless self[:paths][type] }
+      (options.gems || []).each {|gem| self[:gems] << gem }
+    end
+    
+    # Adds a single Gem dependency to the reactive application.
+    # You may pass :init => :rails to specifiy that the plugin should
+    # be initialized through the rails init code. Note that it is not
+    # assured to work.
+    #
+    #   config.gem 'aws-s3', :lib => 'aws/s3', :version => '>= 0.4.0'
+    #   config.gem 'acts_as_tree', :init => :rails
+    #
+    def gem(name, options = {})
+      self[:gems] << Reactive::GemDependency.new(name, options)
+      
+      name = name.gsub(/\W/, '_').squeeze('_')
+      self[name] = OrderedOptions.new
+    end
+
+    def app_gem_spec(spec = nil, &block) # :nodoc:
+      @app_gem_spec = block if block
+      if @app_gem_spec
+        if spec
+          @app_gem_spec.call(spec)
+        else
+          options = OrderedOptions.new
+          @app_gem_spec.call(options)
+          options
+        end
+      end
+    end
+  
+    # Defines the application root. Normally the boot process will take care of it.
+    def root_dir=(value) # :nodoc:
+      self[:root_dir] = File.expand_path(value)
+    end
+  
+    protected
+    
+    def parse(argv)
+      if index = argv.rindex(argv.find {|arg| (arg == '-e') || (arg == '--environment')})
+        self.environment = argv[index+1]
+      end
+      if index = argv.rindex(argv.find {|arg| arg == '--root'})
+        self.root_dir = argv[index+1]
+      end
+    end
+  
+  end
+
+  # Handles Reactive initialization process.
+  #
+  # The initialization process is sliced in short parts named stages.
+  # Each stage is responsible for a specific initialization. Plugins will also
+  # register stages in this system.
+  #
+  # Running the application is a three steps process:
+  # 1. Booting: loads the reactive-core gem (see config/boot.rb)
+  # 2. Initialization (the #run method is called)
+  # 3. Dispatching the initial request (as configured in config/config.rb)
+  #
+  # The application developer may also register initialization stages by example
+  # in the files under config/initializers/*.rb like so:
+  #   Reactive::Initializer.init :donuts do
+  #     require 'donuts'
+  #     Donuts.setup_factory
+  #   end
+  #
+  # Registering stages is done with the general #register method or the more conveniant
+  # methods: #configure, #before_init, #init and #after_init.
+  #
+  # The application or any plugin may observe the initilization process by registering an
+  # observer with #add_observer. It acts like a callback triggered before processing each
+  # stage.
+  #
+  # The stages are left visible with the #stages accessor, but be careful with it.
+  class Initializer
+    STAGE_LEVELS = {:configure => -400, :before_init => -200, :init => 0, :init_rails_plugin => 100, :after_init => 200}
+    
+    include Singleton
+    
+    class << self
+      # Registers an initialization stage. Pass a _name_, then either a level or an option to specify
+      # the relation against another stage.
+      #   register(:mvc_configure, -100) { some_code }
+      #   register(:mvc_configure, :before => :init_logger) { some_code }
+      #   register(:mvc_configure, :after => :wx_configure, :proc => a_proc)
+      def register(name, options = {}, &block)
+        Initializer.instance.register(name, options, &block)
+      end
+    
+      # convenience aliases for standard priorities
+      def configure(name, options = {}, &block)
+        name = "configure_#{name}" unless name.to_s =~ /^configure_/
+        register(name, :configure, &block)
+      end
+
+      def before_init(name, options = {}, &block)
+        name = "before_init_#{name}" unless name.to_s =~ /^before_init_/
+        register(name, :before_init, &block)
+      end
+
+      def init(name, options = {}, &block)
+        name = "init_#{name}" unless name.to_s =~ /^init_/
+        register(name, :init, &block)
+      end
+
+      def after_init(name, options = {}, &block)
+        name = "after_init_#{name}" unless name.to_s =~ /^after_init_/
+        register(name, :after_init, &block)
+      end
+    
+      # Runs the initialization process.
+      #
+      # _stage_ is either a level which will also be processed or
+      # a stage name that will also be processed.
+      def run(stage = :final, configuration = Reactive.configuration || Configuration.new) # :yields: configuration
+        yield configuration if block_given?
+        Reactive.configuration = configuration
+        Initializer.instance.run_stages(stage)
+      end
+
+      def add_observer(proc = nil, &block)
+        raise ArgumentError, "Pass either a proc or a block, not both!" unless proc.nil? ^ block.nil?
+        raise ArgumentError, "Passed object is not callable!" if proc && !proc.respond_to?(:call)
+        Initializer.instance.observers << (proc || block)
+      end
+    
+      def stages
+        Initializer.instance.stages
+      end
+
+    end
+  
+    class Stage
+      attr_accessor :name, :level, :proc
+      def initialize(name, level, proc)
+        @name, @level, @proc = name, level, proc
+      end
+      # Checks equivalence based on #name.
+      def ==(other)
+        other.is_a?(Stage) ? @name == other.name : @name == other
+      end
+    end
+  
+    attr_reader :stages, :observers # :nodoc:
+    
+    def initialize # :nodoc:
+      @stages = []
+      @finished = []
+      @observers = []
+    end
+  
+    def register(name, options, &block) # :nodoc:
+      options = options.is_a?(Hash) ? options : {:level => STAGE_LEVELS[options] || options}
+      proc = options[:proc]
+      raise ArgumentError, "Pass either a proc or a block, not both!" unless proc.nil? ^ block.nil?
+      raise ArgumentError, "Proc object is not callable!" if proc && !proc.respond_to?(:call)
+      block ||= proc
+#      raise ArgumentError, "register options are mutually exclusive!" if options[:level]
+      case
+        when level = options[:level]
+          insert_index = stages.index(stages.find {|item| item.level > level}) || -1
+        when before = options[:before]
+          insert_index = stages.index(stages.find{|item| item.name == before.to_sym})
+          raise ArgumentError, "Can't insert before '#{before}', no stage of that name!" unless insert_index
+          items = [insert_index-1 < 0 ? nil : insert_index-1, insert_index].compact
+          level = stages.values_at(*items).inject {|sum, stage| sum + stage.level} / items.size
+        when after = options[:after]
+          insert_index = stages.index(stages.find{|item| item.name == after.to_sym})
+          raise ArgumentError, "Can't insert after '#{after}', no stage of that name!" unless insert_index
+          items = stages.values_at([index, index+1]).compact
+          level = items.inject {|sum, stage| sum + stage.level} / items.size
+      end
+      
+      stages.insert(insert_index, Stage.new(name, level, block))
+    end
+  
+    # last_stage is either a level which WILL also be processed or
+    # a stage name that WILL also be processed.
+    def run_stages(last_stage) # :nodoc:
+      last_stage = STAGE_LEVELS[last_stage] || last_stage
+      stage = stages.first
+      while stage
+        break if last_stage.is_a?(Integer) && stage.level > last_stage
+        unless @finished.include? stage
+          observers.each {|block| block.call(stage) }
+          benchlog("Stage: #{stage.name}") { stage.proc.call }
+          @finished << stage
+          break if stage.name == last_stage
+        end
+        stage = stages[stages.index(stage).succ]
+      end
+    end
+    
+    protected
+
+    def benchlog(caption) # :nodoc:
+      @bench_level ||= 0
+      time = Time.now.to_f
+      Reactive.logger.debug "#{' '*@bench_level}#{caption}" if @bench_level > 0
+      @bench_level += 2
+      yield if block_given?
+      seconds = Time.now.to_f - time
+      @bench_level -= 2
+      if @bench_level > 0
+        Reactive.logger.debug "#{' '*@bench_level}(#{'%.1f' % (seconds * 1000)}ms)"
+      else
+        Reactive.logger.debug "#{caption} (#{'%.1f' % (seconds * 1000)}ms)"
+      end
+    end
+    
+    # Here is the list of all initializers setup up by the framework. Listed in level order.
+    # *patch_base_gems*::          -1000, 
+    # *default_environment*::      -950,
+    # *default_config*::           -760,
+    # *load_config*::              -750
+    # *load_initializers*::        -740
+    # *require_plugins*::          -550
+    # *require_framework*::        -360
+    # *check_plugins*::            -350
+    # *init_logger*::              -160
+    # *init_depedency_mechanism*:: -150
+    # *init_framwork*::            -140
+    # *finish*::                   +1000
+    class Default < Initializer
+      register :patch_base_gems, -1000 do
+        # Patch missing activesupport features
+        ActiveSupport.const_set(:Dependencies, ::Dependencies) unless defined? ActiveSupport::Dependencies
+        require 'reactive-core/ext/object_instance' unless Object.respond_to? :instance_variable_names
+        require 'reactive-core/ext/memoizable' unless defined? ActiveSupport::Memoizable
+      end
+    
+      register :default_environment, -950 do
+        unless Reactive.configuration.environment
+          Reactive.configuration.environment = Gem.source_index.find_name('reactive-dev').empty? ? 'production' : 'development'
+        end
+        if Reactive.configuration.environment == 'development'
+    #      gem 'reactive-dev', core-gem-version
+          require 'reactive-dev'
+        end
+      end
+
+      register :default_config, -760 do
+        Reactive.configuration.reverse_merge do |config|
+          config.paths = {
+            :config => Reactive.path_for("config"),
+            :log => Reactive.path_for("log"),
+            :assets => [Reactive.path_for("assets", "default")]
+          }
+        end
+        Reactive.configuration.reverse_merge do |config|
+          config.global_configfile = Reactive.path_for(:config, "config.rb")
+          config.environment_configfile = Reactive.path_for(:config, "environments", "#{Reactive.configuration.environment}.rb")
+
+          config.log_path = Reactive.path_for(:log, "#{Reactive.configuration.environment}.log")
+          config.log_level = Reactive.configuration.environment == 'production' ? :warn : :info
+
+          config.dependency_mechanism = :load
+          config.cache_classes = false
+
+          # stubs for setting options on the framework base classes
+          config.dispatcher = OrderedOptions.new
+          config.output_handler = OrderedOptions.new
+        end
+      end
+
+      # Loads the environment configuration specified by Configuration#global_configfile and #environment_configfile
+      # which is typically one of development, test, or production.
+      register :load_config, -750 do
+        load(Reactive.configuration.global_configfile) if File.exists?(Reactive.configuration.global_configfile)
+        load(Reactive.configuration.environment_configfile) if File.exists?(Reactive.configuration.environment_configfile)
+      end
+    
+      register :load_initializers, -740 do
+        Dir[Reactive.path_for(:config, "initializers/**/*.rb")].sort.each do |initializer|
+          load(initializer)
+        end
+      end
+
+      # load all plugins gems listed in configurations.
+      register :require_plugins, -550 do
+        Reactive.configuration.gems.each do |gem|
+          begin
+            Reactive.logger.info "Loading gem #{gem.name} #{gem.requirement}"
+            gem.load
+          rescue LoadError
+          end
+        end
+      end
+
+      register :require_framework, -360 do
+        require 'reactive-core/errors'
+        require 'reactive-core/request'
+        require 'reactive-core/response'
+        require 'reactive-core/dispatcher'
+        require 'reactive-core/output_handler'
+        require 'reactive-core/meta_model'
+      end
+
+      # Abort execution if any of the configured plugins isn't loaded
+      register :check_plugins, -350 do
+        unloaded_gems = Reactive.configuration.gems.reject {|gem| gem.loaded? }
+        unless unloaded_gems.empty?
+          message = <<-EOS
+Missing these required gems:
+  #{unloaded_gems.map {|gem| "#{gem.name}  #{gem.requirement}"}.join("\n  ")}
+Run `rake gems:install` to install the missing gems.
+      EOS
+          Reactive.logger.fatal message
+          raise LoadError, message
+        end
+      end
+
+      register :init_logger, -160 do
+        begin
+          unless logger = Reactive.configuration.logger
+            Reactive.logger.info "Further logs should go to #{Reactive.configuration.log_path}"
+            logger = ActiveSupport::BufferedLogger.new(Reactive.configuration.log_path)
+            logger.level = Reactive.configuration.log_level.is_a?(Integer) ? Reactive.configuration.log_level : ActiveSupport::BufferedLogger.const_get(Reactive.configuration.log_level.to_s.upcase)
+            logger.auto_flushing = false if Reactive.configuration.environment == "production"
+          end
+          Reactive.logger = logger
+        rescue StandardError => e
+          Reactive.logger.warn "Reactive Error: Unable to access log file. Please ensure that #{Reactive.configuration.log_path} exists and is chmod 0666."
+        ensure
+          Reactive.logger.unknown "\n\nApplication initialized at #{Time.now.to_s(:db)}"
+        end
+      end
+
+      register :init_depedency_mechanism, -150 do
+        ActiveSupport::Dependencies.mechanism = Reactive.configuration.cache_classes ? :require : :load
+      end
+
+      register :init_framework, -140 do
+        [:dispatcher, :output_handler].each do |framework|
+          base_class = Reactive.const_get(framework.to_s.classify)::Base
+          base_class.logger = Reactive.logger
+          Reactive.configuration.send(framework).each do |setting, value|
+            base_class.send("#{setting}=", value)
+          end
+        end
+      end
+
+      register :finish, +1000 do
+      end
+    end
+
+  end
+
+
+end
+