reactive 0.1.0

data/lib/dispatcher.rb

@@ -0,0 +1,46 @@
+
+module Reactive
+
+  class Dispatcher
+    class << self
+      def dispatch(request)
+        if request == :init
+          new.initial_dispatch
+        else
+          new.dispatch(request)
+        end
+      end
+    end
+    
+    def dispatch(request)
+      controller = recognize(request.params)
+      response = Response.new
+      controller.process(request, response)
+
+      handle_response(response)
+    end
+  
+    def recognize(params)
+      "#{params[:controller].camelize}Controller".constantize
+    end
+    
+    def handle_response(response)
+      if response.redirected_to
+        # This recursive call is intended, do not refactor in a loop. This way when a redirect cycle occurs, it will end up in a stack overflow
+        dispatch(Request.new(response.redirected_to))
+      else
+        response.result        # This does nothing, Should we treat the result in some ways? We already have Exceptions for handling errors, so... what should the result be?
+      end
+    end
+  
+    def initial_dispatch
+      controller_class = ApplicationController
+      # controller_class.class_eval { helper :application }             Not need, already done in initializer.rb
+      response = Response.new
+      controller_class.process(Request.new, response, :perform_init)
+
+      handle_response(response)
+    end
+  end
+
+end

data/lib/generated_attribute.rb

@@ -0,0 +1,40 @@
+require 'optparse'
+
+module Reactive
+    class GeneratedAttribute
+      attr_accessor :name, :type, :column
+
+      def initialize(name, type)
+        @name, @type = name, type.to_sym
+        @column = ActiveRecord::ConnectionAdapters::Column.new(name, nil, @type)
+      end
+
+      def field_type
+        @field_type ||= case type
+          when :integer, :float, :decimal   then :text_field
+          when :datetime, :timestamp, :time then :datetime_select
+          when :date                        then :date_select
+          when :string                      then :text_field
+          when :text                        then :text_area
+          when :boolean                     then :check_box
+          else
+            :text_field
+        end      
+      end
+
+      def default
+        @default ||= case type
+          when :integer                     then 1
+          when :float                       then 1.5
+          when :decimal                     then "9.99"
+          when :datetime, :timestamp, :time then Time.now.to_s(:db)
+          when :date                        then Date.today.to_s(:db)
+          when :string                      then "MyString"
+          when :text                        then "MyText"
+          when :boolean                     then false
+          else
+            ""
+        end      
+      end
+    end
+end

data/lib/initializer.rb

@@ -0,0 +1,425 @@
+require 'activesupport'
+
+REACTIVE_ENV = (ENV['REACTIVE_ENV'] || 'development').dup unless defined?(REACTIVE_ENV)
+
+module Reactive
+  class NoViewProvider < StandardError; end
+
+  class Initializer
+    attr_reader :configuration
+    
+    def self.run(command = :process, configuration = Configuration.new)
+      yield configuration if block_given?
+      initializer = new(configuration)
+      initializer.send(command)
+      initializer
+    end
+    
+    def initialize(config)
+      @configuration = config
+    end
+  
+    def process
+      set_load_paths
+      
+      set_autoload_paths
+      load_environment
+      require_frameworks
+      require_view_provider
+      
+      #load_or_require_plugins
+      
+      #initialize_encoding
+      initialize_database
+      initialize_logger
+      initialize_framework_logging
+      initialize_framework_views
+      initialize_dependency_mechanism
+      #initialize_whiny_nils
+      initialize_framework_settings
+      
+      after_initialize
+      load_application_initializers
+      
+      # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
+      load_observers
+    end
+  
+    # Set the <tt>$LOAD_PATH</tt> based on the value of
+    # Configuration#load_paths. Duplicates are removed.
+    def set_load_paths
+      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 Reactive will automatically load source files, and
+    # the load_once paths.
+    def set_autoload_paths
+      Dependencies.load_paths = configuration.load_paths.uniq
+      Dependencies.load_once_paths = configuration.load_once_paths.uniq
+
+      extra = Dependencies.load_once_paths - 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
+  
+    # Requires all frameworks specified by the Configuration#frameworks list
+    # By default, Controller, View, Dispatcher and ActiveRecord are loaded.
+    def require_frameworks
+      configuration.frameworks.each { |framework| require(framework.to_s) }
+    end
+
+    def require_view_provider
+      provider = configuration.view_provider
+      raise NoViewProvider, "You need to setup a view provider. This is usually done in config/environment.rb with config.view_provider = :your_view_provider" unless provider
+      if provider.is_a?(Class)
+        @view_provider = provider
+      else
+        provider_name = provider.to_s
+        long_name = (provider_name =~ /^reactive_view_/i ? provider_name : "reactive_view_#{provider_name}")
+        short_name = /^reactive_view_(.+)/i.match(long_name)[1]
+        
+        require long_name
+        @view_provider = "Reactive::View::#{short_name.camelize}".constantize
+      end
+    end
+
+    # Loads the environment specified by Configuration#environment_path, which
+    # is typically one of development, test, or production.
+    def load_environment
+      return if @environment_loaded
+      @environment_loaded = true
+      
+      config = configuration
+      constants = self.class.constants
+      
+      eval(IO.read(configuration.global_environment_path), binding, configuration.global_environment_path) if File.exists?(configuration.global_environment_path)
+      eval(IO.read(configuration.environment_path), binding, configuration.environment_path) if File.exists?(configuration.environment_path)
+      
+      (self.class.constants - constants).each do |const|
+        Object.const_set(const, self.class.const_get(const))
+      end
+    end
+  
+    def load_observers
+      if configuration.frameworks.include?(:active_record)
+        ActiveRecord::Base.instantiate_observers
+      end
+    end
+  
+    # TODO: initialize_encoding
+  
+    # This initialization routine does nothing unless <tt>:active_record</tt>
+    # is one of the frameworks to load (Configuration#frameworks). If it is,
+    # this sets the database configuration from Configuration#database_configuration
+    # and then establishes the connection.
+    def initialize_database
+      if configuration.frameworks.include?(:active_record)
+        ActiveRecord::Base.configurations = configuration.database_configuration
+        ActiveRecord::Base.establish_connection(configuration.environment)
+      end
+    end
+
+    # If the +REACTIVE_DEFAULT_LOGGER+ constant is already set, this initialization
+    # routine does nothing. If the constant is not set, and Configuration#logger
+    # is not +nil+, this also does nothing. Otherwise, a new logger instance
+    # is created at Configuration#log_path, with a default log level of
+    # Configuration#log_level.
+    #
+    # If the log could not be created, the log will be set to output to
+    # +STDERR+, with a log level of +WARN+.
+    def initialize_logger
+      # if the environment has explicitly defined a logger, use it
+      return if defined?(REACTIVE_DEFAULT_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)
+          logger.auto_flushing = false if configuration.environment == "production"
+        rescue StandardError =>e
+          logger = ActiveSupport::BufferedLogger.new(STDERR)
+          logger.level = ActiveSupport::BufferedLogger::WARN
+          logger.warn(
+            "Reactive 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 "REACTIVE_DEFAULT_LOGGER", logger }
+    end
+
+    # Sets the logger for ActiveRecord and ActionMailer
+    # (but only for those frameworks that are to be loaded). If the framework's
+    # logger is already set, it is not changed, otherwise it is set to use
+    # +REACTIVE_DEFAULT_LOGGER+.
+    def initialize_framework_logging
+      for framework in ([:controller, :active_record, :action_mailer ] & configuration.frameworks)
+        framework_constantize(framework).const_get("Base").logger ||= REACTIVE_DEFAULT_LOGGER
+      end
+    end
+
+    # Sets +Reactive::View::Base#view_paths+ and +ActionMailer::Base#template_root+
+    # (but only for those frameworks that are to be loaded). If the framework's
+    # paths have already been set, it is not changed, otherwise it is
+    # set to use Configuration#view_path.
+    def initialize_framework_views
+      ActionMailer::Base.template_root ||= configuration.view_path  if configuration.frameworks.include?(:action_mailer)
+      
+      raise NoViewProvider, "You need to setup a view provider. This is usually done in config/environment.rb with config.view_provider = :your_view_provider" unless @view_provider
+#      initialize_framework_settings([@view_provider])
+      
+      Controller::Base.template_class = @view_provider::Base.template_class
+      Controller::Base.view_paths = View::Base.view_paths = [configuration.view_path] if View::Base.view_paths.empty?
+      Controller::Base.class_eval { helper :application }
+      View::Base.asset_paths = [configuration.asset_path] if View::Base.asset_paths.empty?
+    end
+  
+    # Sets the dependency loading mechanism based on the value of
+    # Configuration#cache_classes.
+    def initialize_dependency_mechanism
+      Dependencies.mechanism = configuration.cache_classes ? :require : :load
+    end
+
+    # Initializes framework-specific settings for each of the loaded frameworks
+    # (Configuration#frameworks). The available settings map to the accessors
+    # on each of the corresponding Base classes.
+    def initialize_framework_settings(frameworks = configuration.frameworks)
+      (frameworks - [:dispatcher]).each do |framework|
+        base_class = (framework.is_a?(Module) ? framework : framework_constantize(framework)).const_get("Base")
+
+        configuration.send(framework).each do |setting, value|
+          base_class.send("#{setting}=", value)
+        end
+      end
+    end
+
+    # Fires the user-supplied after_initialize block (Configuration#after_initialize)
+    def after_initialize
+      configuration.after_initialize_blocks.each do |block|
+        block.call
+      end
+    end
+  
+    def load_application_initializers
+      Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
+        load(initializer)
+      end
+    end
+
+    protected
+      def framework_constantize(framework)
+        framework.to_s.camelize.constantize
+      rescue NameError
+        "reactive/#{framework}".camelize.constantize
+      end
+    
+  end
+
+  class Configuration
+    # The application's base directory.
+    attr_reader :root_path
+
+    # A stub for setting options on Reactive::Controller::Base
+    attr_accessor :controller
+
+    # A stub for setting options on Reactive::View::Base
+    attr_accessor :view
+    
+    # A stub for setting options on ActionMailer::Base
+    attr_accessor :action_mailer
+
+    # A stub for setting options on ActiveRecord::Base
+    attr_accessor :active_record
+
+    # A stub for setting options on ActiveRecord::Base
+    attr_accessor :active_resource
+
+    # Whether or not classes should be cached (set to false if you want
+    # application classes to be reloaded on each event)
+    attr_accessor :cache_classes
+
+    # The view provider name
+    attr_accessor :view_provider
+    
+    # The path to the database configuration file to use. (Defaults to
+    # <tt>config/database.yml</tt>.)
+    attr_accessor :database_configuration_file
+    
+    # The list of framework components that should be loaded. (Defaults
+    # to <tt>:active_record</tt>, <tt>:action_mailer</tt>, and
+    # <tt>:active_resource</tt>).
+    attr_accessor :frameworks
+    
+    # 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 Reactive will automatically load from only once.
+    # All elements of this array must also be in +load_paths+.
+    attr_accessor :load_once_paths
+    
+    # The log level to use for the default Reactive logger. In production mode,
+    # this defaults to <tt>:info</tt>. In development mode, it defaults to
+    # <tt>:debug</tt>.
+    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
+
+    # Some paths
+    attr_accessor :controller_path
+    attr_accessor :model_path
+    attr_accessor :view_path
+    attr_accessor :asset_path
+    
+    
+    def initialize
+      set_root_path!
+      
+      self.frameworks                   = default_frameworks
+      self.load_paths                   = default_load_paths
+      self.load_once_paths              = []
+      self.log_path                     = default_log_path
+      self.log_level                    = default_log_level
+      self.view_path = default_view_path      
+      self.controller_path = default_controller_path
+      self.model_path = default_model_path
+      self.asset_path = default_asset_path
+      self.database_configuration_file  = default_database_configuration_file
+      self.cache_classes                = default_cache_classes
+      
+      for framework in default_frameworks
+        self.send("#{framework}=", OrderedOptions.new)
+      end
+    end
+  
+    def set_root_path!
+      @root_path = File.expand_path(::REACTIVE_ROOT)
+    end
+      
+    # Loads and returns the contents of the #database_configuration_file.
+    def database_configuration
+      YAML::load(IO.read(database_configuration_file))
+    end
+  
+    # The path to the current environment's file (development.rb, etc.). By
+    # default the file is at <tt>config/environments/#{environment}.rb</tt>.
+    def environment_path
+      "#{root_path}/config/environments/#{environment}.rb"
+    end
+
+    # The path to the global environment's file. By
+    # default the file is at <tt>config/environment.rb</tt>.
+    def global_environment_path
+      "#{root_path}/config/environment.rb"
+    end
+
+    # Return the currently selected environment. By default, it returns the
+    # value of the +REACTIVE_ENV+ constant.
+    def environment
+      ::REACTIVE_ENV
+    end
+  
+    # Adds a block which will be executed after rails 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
+  
+    def framework_paths
+      paths = %w(activesupport/lib)
+      # TODO: Add the provider path here
+      
+      [:active_record, :action_mailer, :active_resource, :action_web_service].each do |framework|
+        paths << "#{framework.to_s.gsub('_', '')}/lib" if frameworks.include? framework
+      end
+      
+      paths.select { |dir| File.directory?(dir) }
+    end
+  
+  protected
+      # Dummy setter. Because dispatcher is in the frameworks list but has no Base class and thus no configuration (at least for now ;-)
+      def dispatcher=(v)
+      end
+  
+      def default_log_path
+        File.join(root_path, 'log', "#{environment}.log")
+      end
+
+      def default_log_level
+        environment == 'production' ? :info : :debug
+      end
+    
+      def default_frameworks
+        [ :controller, :view, :dispatcher, :active_record ]
+      end
+    
+      def default_load_paths
+        %w(
+          app
+          app/models
+          app/controllers
+          app/helpers
+          app/services
+          config
+          lib
+        ).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
+      end
+
+      def default_database_configuration_file
+        File.join(root_path, 'config', 'database.yml')
+      end
+
+      # Default controller files load path. This can be changed in configuration.
+      def default_controller_path
+        @controller_path ||= File.join(root_path, 'app', 'controllers')
+      end
+      
+      # Default model files load path. This can be changed in configuration.
+      def default_model_path
+        @model_path ||= File.join(root_path, 'app', 'models')
+      end
+     
+      # Default view files load path. This can be changed in configuration. 
+      def default_view_path
+        @view_path ||= File.join(root_path, 'app', 'views')
+      end
+
+      # Default asset files load path. This can be changed in configuration. 
+      def default_asset_path
+        @asset_path ||= File.join(root_path, 'assets')
+      end
+
+      def default_dependency_mechanism
+        :load
+      end
+
+      def default_cache_classes
+        false
+      end
+
+  end
+end