maccman-bowline 0.1.1

data/lib/bowline/binders/collection.rb

@@ -0,0 +1,27 @@
+module Bowline
+  module Binders
+    class Collection < Base
+      cattr_accessor :items
+      class << self
+        def items=(args)
+          @@items = args
+          self.item_sync!
+          @@items
+        end
+    
+        def item_sync!
+          return unless @@items && @@elements
+          @@elements.each {|i| 
+            i.updateCollection(@@items.to_js) 
+          }
+        end
+    
+        def find(id)
+          @@items.find {|item| 
+            item.id == id if item.respond_to?(:id) 
+          }
+        end
+      end
+    end
+  end
+end

data/lib/bowline/binders/singleton.rb

@@ -0,0 +1,25 @@
+module Bowline
+  module Binders
+    class Singleton < Base
+      cattr_accessor :item
+      class << self
+        def item=(arg)
+          @@item = arg
+          self.item_sync!
+        end
+    
+        def item_sync!
+          return unless @@item && @@elements
+          # Call the chain.js function 'item' on elements
+          @@elements.each {|i| 
+            i.updateSingleton(@@item.to_js) 
+          }
+        end
+      
+        def find(*a)
+          @@item
+        end
+      end
+    end
+  end
+end

data/lib/bowline/commands/console.rb

@@ -0,0 +1,27 @@
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+
+options = { :irb => irb }
+OptionParser.new do |opt|
+  opt.banner = "Usage: console [environment] [options]"
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |v| options[:irb] = v }
+  opt.on("--debugger", 'Enable ruby-debugging for the console.') { |v| options[:debugger] = v }
+  opt.parse!(ARGV)
+end
+
+libs =  " -r irb/completion"
+libs << %( -r "#{APP_ROOT}/config/environment")
+
+if options[:debugger]
+  begin
+    require 'ruby-debug'
+    libs << " -r ruby-debug"
+    puts "=> Debugger enabled"
+  rescue Exception
+    puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
+    exit
+  end
+end
+
+exec "#{options[:irb]} #{libs} --simple-prompt"

data/lib/bowline/commands/generate.rb

@@ -0,0 +1 @@
+# todo

data/lib/bowline/commands/run.rb

@@ -0,0 +1,13 @@
+exec_path = File.join(APP_ROOT, 'build', 'osx', 'testapp.app')
+
+unless File.exist?(exec_path)
+  require 'rake'
+  require 'bowline/tasks/bowline'
+  Rake::Task['app:bundle'].invoke
+end
+
+if ENV['debug']
+  `open #{File.join(exec_path, 'Contents', 'MacOS', 'testapp')}`
+else
+  `open #{exec_path}`
+end

data/lib/bowline/ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def to_js(opts = {})
+    collect {|i| i.to_js(opts) }
+  end
+end

data/lib/bowline/ext/class.rb

@@ -0,0 +1,51 @@
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+#
+#  class Person
+#    cattr_accessor :hair_colors
+#  end
+#
+#  Person.hair_colors = [:brown, :black, :blonde, :red]
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/bowline/ext/object.rb

@@ -0,0 +1,12 @@
+class Object
+  # Aim is to convert the object in:
+  #  * A hash or
+  #  * An array of hashes
+  def to_js(opts = {})
+    if respond_to?(:attributes)
+      attributes
+    else
+      self
+    end
+  end
+end

data/lib/bowline/ext/string.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+   self.gsub(/::/, '/').
+     gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+     gsub(/([a-z\d])([A-Z])/,'\1_\2').
+     tr("-", "_").
+     downcase
+  end
+end

data/lib/bowline/gem_dependency.rb

@@ -0,0 +1,42 @@
+module Bowline
+  class GemDependency
+    attr_accessor :lib, :source
+    
+    def initialize(name, options = {})
+      require 'rubygems' unless Object.const_defined?(:Gem)
+
+      if options[:requirement]
+        req = options[:requirement]
+      elsif options[:version]
+        req = Gem::Requirement.create(options[:version])
+      else
+        req = Gem::Requirement.default
+      end
+
+      @dep = Gem::Dependency.new(name, req)
+      @lib      = options[:lib]
+      @source   = options[:source]
+    end
+    
+    def add_load_paths
+    end
+    
+    def name
+      @dep.name.to_s
+    end
+    
+    def requirement
+      r = @dep.version_requirements
+      (r == Gem::Requirement.default) ? nil : r
+    end
+    
+    def load
+      return if @loaded
+      require(@lib || name) unless @lib == false
+      @loaded = true
+    rescue LoadError
+      puts $!.to_s
+      $!.backtrace.each { |b| puts b }
+    end
+  end
+end

data/lib/bowline/generators.rb

@@ -0,0 +1,59 @@
+gem 'templater', '>= 0.3.2'
+require 'templater'
+
+module Bowline
+  module Generators
+    extend Templater::Manifold
+    
+    desc <<-DESC
+      Generate components for your application or entirely new applications.
+    DESC
+    class Generator < Templater::Generator
+      def with_modules(modules, options={}, &block)
+        indent = options[:indent] || 0
+        text = capture(&block)
+        modules.each_with_index do |mod, i|
+          concat(("  " * (indent + i)) + "module #{mod}\n", block.binding)
+        end
+        text = text.to_a.map{ |line| ("  " * modules.size) + line }.join
+        concat(text, block.binding)
+        modules.reverse.each_with_index do |mod, i|
+          concat(("  " * (indent + modules.size - i - 1)) + "end # #{mod}\n", block.binding)
+        end
+      end
+      
+      def self.source_root
+        File.join(File.dirname(__FILE__), *%w[.. .. templates])
+      end
+    end
+    
+    class NamedGenerator < Generator
+      # NOTE: Currently this is not inherited, it will have to be 
+      # declared in each generator that inherits from this.
+      first_argument :name, :required => true
+      
+      def initialize(*args)
+        super
+      end
+      
+      def class_name
+        name.gsub('-', '_').camel_case
+      end
+      alias_method :module_name, :class_name
+
+      def file_name
+        name.snake_case
+      end
+      alias_method :base_name, :file_name
+
+      def symbol_name
+        file_name.gsub('-', '_')
+      end
+    end
+  end
+end
+
+require "bowline/generators/application"
+require "bowline/generators/binder"
+require "bowline/generators/model"
+require "bowline/generators/migration"

data/lib/bowline/generators/application.rb

@@ -0,0 +1,49 @@
+module Bowline::Generators
+  class ApplicationGenerator < NamedGenerator
+    desc <<-DESC
+      Generates a new application.
+    DESC
+    
+    def app_id
+      ['bowline', name].join('.')
+    end
+    
+    def destination_root
+      File.join(@destination_root, base_name)
+    end
+    
+    first_argument :name, :required => true, :desc => "application name"
+
+    empty_directory :tmp,     "tmp"    
+    empty_directory :vendor,  "vendor"
+    empty_directory :lib,     "lib"
+    empty_directory :db,      "db"
+    empty_directory :build,   "build"
+    empty_directory :log,     "log"
+    
+    template :rakefile, "Rakefile", "Rakefile"
+    
+    file :gitignore, "gitignore", ".gitignore"
+    
+    glob! "script"
+    glob! "public"
+    
+    file :jquery,    "../assets/jquery.js",         "public/javascripts/jquery.js"
+    file :chainjs,   "../assets/jquery.chain.js",   "public/javascripts/jquery.chain.js"
+    file :bowlinejs, "../assets/jquery.bowline.js", "public/javascripts/jquery.bowline.js"
+    
+    empty_directory :app, "app"
+    empty_directory :models, "app/models"
+    empty_directory :binders, "app/binders"
+    empty_directory :config, "config"
+    
+    template :environment, "config/environment.rb", "config/environment.rb"
+    template :tiapp,       "config/tiapp.xml", "config/tiapp.xml"
+    ["application.yml", "database.yml", "manifest", "boot.rb"].each {|action|
+      action = File.join('config', action)
+      file(action.downcase.gsub(/[^a-z0-9]+/, '_').to_sym, action, action)
+    }
+  end
+  
+  add :app, ApplicationGenerator
+end

data/lib/bowline/generators/binder.rb

@@ -0,0 +1,25 @@
+module Bowline::Generators
+  class BinderGenerator < NamedGenerator
+    desc <<-DESC
+      Generates a new binder, either a collection one, or a singleton one.
+    DESC
+    
+    def class_name
+      super + " < Bowline::Binders::#{type.to_s.camel_case}"
+    end
+    
+    def modules
+      ['Binders']
+    end
+    
+    first_argument :name, :required => true, :desc => "binder name"
+    option :type, :desc => "Binder type (collection/singleton)", :default => "collection"
+    
+    template :binder do |template|
+      template.source       = "binder.rb"
+      template.destination  = "app/binders/#{file_name}.rb"
+    end
+  end
+  
+  add :binder, BinderGenerator
+end

data/lib/bowline/generators/migration.rb

@@ -0,0 +1,51 @@
+module Bowline::Generators
+  class MigrationGenerator < Generator
+    desc <<-DESC
+      Generates a new database migration.
+    DESC
+    
+    option :model, :as => :boolean, :desc => 'Specify this option to generate a migration which creates a table for the provided model'
+    
+    first_argument :name, :required => true
+    second_argument :attributes, :as => :hash, :default => {}
+    
+    def table_name
+      self.name.snake_case.pluralize
+    end
+    
+    def class_name
+      "#{self.name.camel_case}Migration"
+    end
+
+    def migration_name
+      self.name.snake_case
+    end
+    
+    def file_name
+      "#{version}_#{migration_name}_migration"
+    end
+    
+    def version
+      # TODO: handle ActiveRecord timestamped migrations
+      n = options[:delete] ? current_migration_nr : current_migration_nr + 1
+      format("%03d", n)
+    end
+    
+    template :migration do |template|
+      template.source      = "migration.rb"
+      template.destination = "db/migrate/#{file_name}.rb"
+    end
+
+    protected    
+      def destination_directory
+        File.join(destination_root, 'schema', 'migrations')
+      end
+    
+      def current_migration_nr
+        current_migration_number = Dir["#{destination_directory}/*"].map do |f|
+          File.basename(f).match(/^(\d+)/)[0].to_i
+        end.max.to_i
+      end
+  end
+  add :migration, MigrationGenerator
+end

data/lib/bowline/generators/model.rb

@@ -0,0 +1,20 @@
+module Bowline::Generators
+  class ModelGenerator < NamedGenerator
+    desc <<-DESC
+      Generates a new model.
+    DESC
+    
+    def modules
+      []
+    end
+    
+    first_argument :name, :required => true, :desc => "model name"
+    
+    template :model do |template|
+      template.source       = "model.rb"
+      template.destination  = "app/models/#{file_name}.rb"
+    end
+  end
+  
+  add :model, ModelGenerator
+end

data/lib/bowline/initializer.rb

@@ -0,0 +1,596 @@
+require 'logger'
+require 'set'
+require 'pathname'
+
+module Bowline
+  class << self
+    # The Configuration instance used to configure the Bowline environment
+    def configuration
+      @@configuration
+    end
+
+    def configuration=(configuration)
+      @@configuration = configuration
+    end
+    
+    def initialized?
+      @initialized || false
+    end
+
+    def initialized=(initialized)
+      @initialized ||= initialized
+    end
+
+    def logger
+      if defined?(BOWLINE_LOGGER)
+        BOWLINE_LOGGER
+      else
+        nil
+      end
+    end
+    
+    def root
+      Pathname.new(APP_ROOT) if defined?(APP_ROOT)
+    end
+  end
+  
+  class Initializer
+    # The Configuration instance used by this Initializer instance.
+    attr_reader :configuration
+    
+    # Runs the initializer. By default, this will invoke the #process method,
+    # which simply executes all of the initialization routines. Alternately,
+    # you can specify explicitly which initialization routine you want:
+    #
+    #   Bowline::Initializer.run(:set_load_path)
+    #
+    # This is useful if you only want the load path initialized, without
+    # incurring the overhead of completely loading the entire environment.
+    def self.run(command = :process, configuration = Configuration.new)
+      yield configuration if block_given?
+      initializer = new configuration
+      initializer.send(command)
+      initializer
+    end
+    
+    # Create a new Initializer instance that references the given Configuration
+    # instance.
+    def initialize(configuration)
+      @configuration = configuration
+      @loaded_plugins = []
+    end
+    
+    def require_frameworks
+      configuration.frameworks.each { |framework| require(framework.to_s) }
+    end
+    
+    def set_load_path
+      load_paths = configuration.load_paths + configuration.framework_paths
+      load_paths.reverse_each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) }
+      $LOAD_PATH.uniq!
+    end
+    
+    # Set the paths from which Bowline will automatically load source files, and
+    # the load_once paths.
+    def set_autoload_paths
+      ActiveSupport::Dependencies.load_paths = configuration.load_paths.uniq
+      ActiveSupport::Dependencies.load_once_paths = configuration.load_once_paths.uniq
+
+      extra = ActiveSupport::Dependencies.load_once_paths - ActiveSupport::Dependencies.load_paths
+      unless extra.empty?
+        abort <<-end_error
+          load_once_paths must be a subset of the load_paths.
+          Extra items in load_once_paths: #{extra * ','}
+        end_error
+      end
+
+      # Freeze the arrays so future modifications will fail rather than do nothing mysteriously
+      configuration.load_once_paths.freeze
+    end
+    
+    def add_plugin_load_paths
+      Dir.glob(File.join(configuration.plugin_glob, 'lib')).sort.each do |path|
+        $LOAD_PATH << path
+        ActiveSupport::Dependencies.load_paths << path
+        unless configuration.reload_plugins?
+          ActiveSupport::Dependencies.load_once_paths << path
+        end
+      end
+      $LOAD_PATH.uniq!
+    end
+    
+    def initialize_database
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.establish_connection(configuration.database_configuration)
+      end
+    end
+    
+    def initialize_logger
+      # if the environment has explicitly defined a logger, use it
+      return if Bowline.logger
+
+      unless logger = configuration.logger
+        begin
+          logger = ActiveSupport::BufferedLogger.new(configuration.log_path)
+          logger.level = ActiveSupport::BufferedLogger.const_get(configuration.log_level.to_s.upcase)
+        rescue StandardError => e
+          logger = ActiveSupport::BufferedLogger.new(STDERR)
+          logger.level = ActiveSupport::BufferedLogger::WARN
+          logger.warn(
+            "Bowline Error: Unable to access log file. Please ensure that #{configuration.log_path} exists and is chmod 0666. " +
+            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
+          )
+        end
+      end
+
+      silence_warnings { Object.const_set "BOWLINE_LOGGER", logger }
+    end
+    
+    def initialize_framework_logging
+      ActiveRecord::Base.logger ||= Bowline.logger if defined?(ActiveRecord)
+      ActiveSupport::Dependencies.logger ||= Bowline.logger
+    end
+    
+    # Loads support for "whiny nil" (noisy warnings when methods are invoked
+    # on +nil+ values) if Configuration#whiny_nils is true.
+    def initialize_whiny_nils
+      require('active_support/whiny_nil') if configuration.whiny_nils
+    end
+    
+    # Sets the default value for Time.zone, and turns on ActiveRecord::Base#time_zone_aware_attributes.
+    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
+    def initialize_time_zone
+      if configuration.time_zone
+        zone_default = Time.__send__(:get_zone, configuration.time_zone)
+
+        unless zone_default
+          raise \
+            'Value assigned to config.time_zone not recognized.' +
+            'Run "rake -D time" for a list of tasks for finding appropriate time zone names.'
+        end
+
+        Time.zone_default = zone_default
+
+        if defined?(ActiveRecord)
+          ActiveRecord::Base.time_zone_aware_attributes = true
+          ActiveRecord::Base.default_timezone = :utc
+        end
+      end
+    end
+    
+    def initialize_framework_settings
+      (configuration.frameworks - [:active_support]).each do |framework|
+        base_class = framework.to_s.camelize.constantize.const_get("Base")
+        settings = configuration.send(framework)
+        next if !settings
+        settings.each do |setting, value|
+          base_class.send("#{setting}=", value)
+        end
+      end
+      configuration.active_support.each do |setting, value|
+        ActiveSupport.send("#{setting}=", value)
+      end
+    end
+    
+    def initialize_rubygems
+      # todo - use custom rubygems on deployment
+      # $LOAD_PATH << File.join(root, 'ruby', 'rubygems')
+      # ::GEM_DIR = File.join(root, 'ruby', 'gems')
+      # $LOAD_PATH << GEM_DIR
+      # ENV['GEM_HOME'] = GEM_DIR
+      # require 'rubygems'
+      # Gem.use_paths(GEM_DIR, [GEM_DIR])
+      # Gem.source_index.refresh!
+    end
+    
+    def add_gem_load_paths
+      unless configuration.gems.empty?
+        configuration.gems.each { |gem| gem.add_load_paths }
+      end
+    end
+    
+    def load_gems
+      configuration.gems.each { |gem| gem.load }
+    end
+    
+    def load_plugins
+      Dir.glob(File.join(configuration.plugin_glob, 'init.rb')).sort.each do |path|
+        config = configuration # Need local config variable
+        eval(IO.read(path), binding, path)
+      end
+    end
+    
+    def load_application_initializers
+      Dir.glob(configuration.initializer_glob).sort.each do |initializer|
+        load(initializer)
+      end
+    end
+    
+    def after_initialize
+      configuration.after_initialize_blocks.each do |block|
+        block.call
+      end
+    end
+    
+    def load_application_classes
+      if configuration.cache_classes
+        configuration.eager_load_paths.each do |load_path|
+          matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
+          Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+            require_dependency file.sub(matcher, '\1')
+          end
+        end
+      end
+    end
+    
+    # For Ruby 1.8, this initialization sets $KCODE to 'u' to enable the
+    # multibyte safe operations. Plugin authors supporting other encodings
+    # should override this behaviour and set the relevant +default_charset+
+    # on ActionController::Base.
+    #
+    # For Ruby 1.9, this does nothing. Specify the default encoding in the Ruby
+    # shebang line if you don't want UTF-8.
+    def initialize_encoding
+      $KCODE='u' if RUBY_VERSION < '1.9'
+    end
+    
+    def initialize_name
+      unless configuration.name
+        raise "You must provide an application name in environment.rb"
+      end
+      silence_warnings { Object.const_set "APP_NAME", configuration.name }
+    end
+    
+    def load_app_config
+      app_config = configuration.app_config
+      return unless app_config
+      Object.const_set("AppConfig", Class.new {
+        app_config.keys.each do |key|
+          cattr_accessor key
+          send("#{key}=", app_config[key])
+        end
+      })
+    end
+    
+    def process
+      Bowline.configuration = configuration
+      
+      set_load_path
+      initialize_rubygems
+      add_gem_load_paths
+      
+      require_frameworks
+      set_autoload_paths
+      add_plugin_load_paths
+      
+      initialize_encoding
+      initialize_database
+      
+      initialize_logger
+      initialize_framework_logging
+      
+      initialize_whiny_nils
+
+      initialize_time_zone
+      
+      initialize_framework_settings
+      
+      initialize_name
+      load_app_config
+      
+      load_gems
+      load_plugins
+            
+      load_application_initializers
+      
+      after_initialize
+      
+      load_application_classes
+      
+      Bowline.initialized = true
+    end
+    
+  end
+  
+  # The Configuration class holds all the parameters for the Initializer and
+   # ships with defaults that suites most Bowline applications. But it's possible
+   # to overwrite everything. Usually, you'll create an Configuration file
+   # implicitly through the block running on the Initializer, but it's also
+   # possible to create the Configuration instance in advance and pass it in
+   # like this:
+   #
+   #   config = Bowline::Configuration.new
+   #   Bowline::Initializer.run(:process, config)
+   class Configuration
+     # The application's base directory.
+     attr_reader :root_path
+    
+     # A stub for setting options on ActiveRecord::Base.
+     attr_accessor :active_record
+
+     # A stub for setting options on ActiveResource::Base.
+     attr_accessor :active_resource
+
+     # A stub for setting options on ActiveSupport.
+     attr_accessor :active_support
+     
+     attr_accessor :bowline
+     
+     attr_accessor :frameworks
+     
+     attr_accessor :framework_paths
+
+     # Whether or not classes should be cached (set to false if you want
+     # application classes to be reloaded on each request)
+     attr_accessor :cache_classes
+     
+     attr_accessor :binder_paths
+     
+     # The path to the database configuration file to use. (Defaults to
+     # <tt>config/database.yml</tt>.)
+     attr_accessor :database_configuration_file
+     
+     attr_accessor :app_config_file
+     
+     # An array of additional paths to prepend to the load path. By default,
+     # all +app+, +lib+, +vendor+ and mock paths are included in this list.
+     attr_accessor :load_paths
+
+     # An array of paths from which Bowline will automatically load from only once.
+     # All elements of this array must also be in +load_paths+.
+     attr_accessor :load_once_paths
+     
+     # An array of paths from which Bowline will eager load on boot if cache
+     # classes is enabled. All elements of this array must also be in
+     # +load_paths+.
+     attr_accessor :eager_load_paths
+     
+     # The log level to use for the default Bowline logger. 
+     attr_accessor :log_level
+
+     # The path to the log file to use. Defaults to log/#{environment}.log
+     # (e.g. log/development.log or log/production.log).
+     attr_accessor :log_path
+     
+     # The specific logger to use. By default, a logger will be created and
+     # initialized using #log_path and #log_level, but a programmer may
+     # specifically set the logger to use via this accessor and it will be
+     # used directly.
+     attr_accessor :logger
+     
+     # Set to +true+ if you want to be warned (noisily) when you try to invoke
+     # any method of +nil+. Set to +false+ for the standard Ruby behavior.
+     attr_accessor :whiny_nils
+     
+     attr_accessor :reload_plugins
+     # Returns true if plugin reloading is enabled.
+     def reload_plugins?
+       !!@reload_plugins
+     end
+
+     # An array of gems that this Bowline application depends on.  Bowline will automatically load
+     # these gems during installation, and allow you to install any missing gems with:
+     #
+     #   rake gems:install
+     #
+     # You can add gems with the #gem method.
+     attr_accessor :gems
+     
+     # Adds a single Gem dependency to the Bowline application. By default, it will require
+     # the library with the same name as the gem. Use :lib to specify a different name.
+     #
+     #   # gem 'aws-s3', '>= 0.4.0'
+     #   # require 'aws/s3'
+     #   config.gem 'aws-s3', :lib => 'aws/s3', :version => '>= 0.4.0', \
+     #     :source => "http://code.whytheluckystiff.net"
+     #
+     # To require a library be installed, but not attempt to load it, pass :lib => false
+     #
+     #   config.gem 'qrp', :version => '0.4.1', :lib => false
+     def gem(name, options = {})
+       # todo
+       @gems << Bowline::GemDependency.new(name, options)
+     end
+     
+     # Sets the default +time_zone+.  Setting this will enable +time_zone+
+     # awareness for Active Record models and set the Active Record default
+     # timezone to <tt>:utc</tt>.
+     attr_accessor :time_zone
+     
+     attr_accessor :plugin_glob
+     
+     attr_accessor :initializer_glob
+     
+     attr_accessor :name
+     
+     # Create a new Configuration instance, initialized with the default
+     # values.
+     def initialize
+       set_root_path!
+       
+       self.frameworks                   = default_frameworks
+       self.framework_paths              = default_framework_paths
+       self.load_paths                   = default_load_paths
+       self.load_once_paths              = default_load_once_paths
+       self.eager_load_paths             = default_eager_load_paths
+       self.log_path                     = default_log_path
+       self.log_level                    = default_log_level
+       self.binder_paths                 = default_binder_paths
+       self.cache_classes                = default_cache_classes
+       self.whiny_nils                   = default_whiny_nils
+       self.database_configuration_file  = default_database_configuration_file
+       self.app_config_file              = default_app_config_file
+       self.gems                         = default_gems
+       self.plugin_glob                  = default_plugin_glob
+       self.initializer_glob             = default_initalizer_glob
+       
+       for framework in default_frameworks
+         self.send("#{framework}=", Bowline::OrderedOptions.new)
+       end
+     end
+     
+     # Set the root_path to APP_ROOT and canonicalize it.
+     def set_root_path!
+       raise 'APP_ROOT is not set' unless defined?(::APP_ROOT)
+       raise 'APP_ROOT is not a directory' unless File.directory?(::APP_ROOT)
+
+       @root_path =
+         # Pathname is incompatible with Windows, but Windows doesn't have
+         # real symlinks so File.expand_path is safe.
+         if RUBY_PLATFORM =~ /(:?mswin|mingw)/
+           File.expand_path(::APP_ROOT)
+
+         # Otherwise use Pathname#realpath which respects symlinks.
+         else
+           Pathname.new(::APP_ROOT).realpath.to_s
+         end
+
+       Object.const_set(:RELATIVE_APP_ROOT, ::APP_ROOT.dup) unless defined?(::RELATIVE_APP_ROOT)
+       ::APP_ROOT.replace @root_path
+     end
+     
+     def app_config
+       require 'erb'
+       YAML::load(ERB.new(IO.read(app_config_file)).result) if File.exists?(app_config_file)
+     end
+     
+     # Loads and returns the contents of the #database_configuration_file. The
+     # contents of the file are processed via ERB before being sent through
+     # YAML::load.
+     def database_configuration
+       require 'erb'
+       YAML::load(ERB.new(IO.read(database_configuration_file)).result) if File.exists?(database_configuration_file)
+     end
+     
+     # Adds a block which will be executed after bowline has been fully initialized.
+     # Useful for per-environment configuration which depends on the framework being
+     # fully initialized.
+     def after_initialize(&after_initialize_block)
+       after_initialize_blocks << after_initialize_block if after_initialize_block
+     end
+     
+     # Returns the blocks added with Configuration#after_initialize
+     def after_initialize_blocks
+       @after_initialize_blocks ||= []
+     end
+     
+   private
+   
+     def default_frameworks
+       [:active_support, :bowline]
+     end
+   
+     def default_framework_paths
+       [
+         File.join(root_path, 'vendor', 'bowline', 'lib'),
+         File.join(root_path, 'vendor', 'rails', 'activesupport',  'lib'),
+         File.join(root_path, 'vendor', 'rails', 'activerecord',   'lib'),
+         File.join(root_path, 'vendor', 'rails', 'activeresource', 'lib')
+        ]
+     end
+     
+     def default_load_paths
+       paths = []
+
+       # Followed by the standard includes.
+       paths.concat %w(
+         app
+         app/binders
+         app/models
+         app/remote
+         lib
+         vendor
+       ).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
+
+       paths
+     end
+     
+     # Doesn't matter since plugins aren't in load_paths yet.
+     def default_load_once_paths
+       []
+     end
+
+     def default_eager_load_paths
+       %w(
+         app/models
+         app/remote
+         app/binders
+       ).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
+     end
+     
+     def default_log_path
+       File.join(root_path, 'log', "application.log")
+     end
+     
+     def default_log_level
+       :info
+     end
+     
+     def default_database_configuration_file
+       File.join(root_path, 'config', 'database.yml')
+     end
+     
+     def default_app_config_file
+       File.join(root_path, 'config', 'application.yml')
+     end
+     
+     def default_binder_paths
+       File.join(root_path, 'app', 'binders')
+     end
+
+     def default_cache_classes
+       true
+     end
+
+     def default_whiny_nils
+       false
+     end
+     
+     def default_gems
+       []
+     end
+     
+     def default_plugin_glob
+       File.join(root_path, *%w{ vendor plugins * })
+     end
+     
+     def default_initalizer_glob
+       File.join(root_path, *%w{ config initializers **/*.rb })
+     end
+  end
+end
+
+# Needs to be duplicated from Active Support since its needed before Active
+# Support is available. Here both Options and Hash are namespaced to prevent
+# conflicts with other implementations AND with the classes residing in Active Support.
+class Bowline::OrderedOptions < Array #:nodoc:
+  def []=(key, value)
+    key = key.to_sym
+
+    if pair = find_pair(key)
+      pair.pop
+      pair << value
+    else
+      self << [key, value]
+    end
+  end
+
+  def [](key)
+    pair = find_pair(key.to_sym)
+    pair ? pair.last : nil
+  end
+
+  def method_missing(name, *args)
+    if name.to_s =~ /(.*)=$/
+      self[$1.to_sym] = args.first
+    else
+      self[name]
+    end
+  end
+
+  private
+    def find_pair(key)
+      self.each { |i| return i if i.first == key }
+      return false
+    end
+end