reactive-core 0.2.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2009 Pascal Hurni
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,30 @@
+LICENSE
+Manifest
+README
+Rakefile
+lib/reactive-core.rb
+lib/reactive-core/console_app.rb
+lib/reactive-core/core_ext.rb
+lib/reactive-core/dispatcher.rb
+lib/reactive-core/errors.rb
+lib/reactive-core/ext/memoizable.rb
+lib/reactive-core/ext/object.rb
+lib/reactive-core/ext/object_instance.rb
+lib/reactive-core/ext/ordered_options.rb
+lib/reactive-core/ext/rubygems_activate_patch.rb
+lib/reactive-core/gem_dependency.rb
+lib/reactive-core/helper_module.rb
+lib/reactive-core/initializer.rb
+lib/reactive-core/meta_model.rb
+lib/reactive-core/output_handler.rb
+lib/reactive-core/request.rb
+lib/reactive-core/response.rb
+lib/reactive-core/tasks/app.rake
+lib/reactive-core/tasks/gems.rake
+lib/reactive-core/tasks/log.rake
+lib/reactive-core/tasks/misc.rake
+lib/reactive-core/tasks/reactive.rb
+lib/reactive-core/updater/base.rb
+lib/reactive-core/updater/cli.rb
+lib/reactive-core/updater/gui.rb
+lib/reactive-core/version.rb

data/README

@@ -0,0 +1,25 @@
+== Welcome to Reactive
+
+Reactive is a desktop application framework that gives everything
+needed to create n-tiers applications which includes database-backed
+applications.
+
+The application can leverage the use of an object server made with Rails
+or any other system. It may also use local machinery according to the
+Model-View-Control pattern of separation.
+
+Please visit www.ruby-reactive.org for further informations.
+
+== Description
+
+This is reactive-core which as its names suggest is the core system for any
+reactive application.
+
+Application developers will only be interested in the configuration and initialization
+process, look in Reactive::Initializer.
+
+Plugin developers may also be interested in either the Reactive::Dispatcher system or the
+Reactive::OutputHandler.
+
+Please get the *reactive-dev* gem for further developer information like code
+generators.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rubygems'
+require './lib/reactive-core/version'
+
+@spec = Gem::Specification.new do |s|
+  s.name         = "reactive-core"
+  s.version      = Reactive::VERSION::STRING
+  s.author       = "Pascal Hurni"
+  s.email        = "phi@ruby-reactive.org"
+  s.homepage     = "http://www.ruby-reactive.org"
+  s.summary      = "Reactive - The desktop application framework"
+  s.description  = "reactive-core\nRuntime for reactive applications"
+  s.rubyforge_project = "reactive-core"
+  s.add_dependency 'rake', '>= 0.7.0'
+  s.add_dependency 'activesupport', '>= 2.0.0'
+end
+
+unless Gem.source_index.find_name('reactive-dev').empty?
+  require 'reactive-dev/tasks/plugin'
+end

data/lib/reactive-core.rb

@@ -0,0 +1,8 @@
+#require 'active_support'
+# Plugins will simply require 'reactive', so we must provide the base classes
+require 'reactive-core/core_ext'
+require 'reactive-core/version'
+require 'reactive-core/errors'
+require 'reactive-core/request'
+require 'reactive-core/response'
+require 'reactive-core/meta_model'

data/lib/reactive-core/console_app.rb

@@ -0,0 +1,9 @@
+boot_location = [
+  ["#{File.expand_path('.')}/config/boot.rb", "."],
+  ["#{File.expand_path('.')}/boot.rb", "."],
+  ["#{File.expand_path('.')}/../config/boot.rb", ".."],
+  ["#{File.expand_path('.')}/../boot.rb", ".."]
+].find{|path, root| File.file? path}
+
+require boot_location.first
+Reactive.init(:final, ['--root', File.expand_path(boot_location.last)])

data/lib/reactive-core/core_ext.rb

@@ -0,0 +1,3 @@
+require 'reactive-core/ext/object'
+require 'reactive-core/ext/rubygems_activate_patch' if Gem::RubyGemsVersion < '1.4'
+require 'reactive-core/ext/ordered_options'

data/lib/reactive-core/dispatcher.rb

@@ -0,0 +1,63 @@
+module Reactive
+  module Dispatcher
+  
+    class AssetNotFound < Error
+    end
+  
+    class NoAvailableDispatcher < Error
+    end
+  
+    class Base
+      cattr_accessor :logger
+      cattr_accessor :default_dispatcher
+      
+      attr_accessor :request, :response
+
+      @@dispatchers = {}
+      class << self
+        def dispatch(request)
+          name, dispatcher = @@dispatchers.find {|name, item| item.candidate?(request)}
+          unless dispatcher ||= default_dispatcher
+            msg = "No dispatcher found for request #{request.inspect} (did you specify an initial_request in config.rb?)\nYou may choose a default dispatcher in config.rb with: config.default_dispatcher = :the_one"
+            logger.error msg
+            raise NoAvailableDispatcher, msg
+          end
+          dispatcher.instance_for(request).dispatch(request)
+=begin
+          # choose the matching registered dispatcher
+          #TODO: the request has to pass in a "candidate" method in each registered dispatcher. The first that replies YES will be used for that
+          # request. So a Route mechanism may be setup up and thus the dispatcher chooser may be route oriented.
+=end
+        end
+      
+        def default_dispatcher
+          @@default_dispatcher.is_a?(Symbol) ? @@dispatchers[@@default_dispatcher] : @@default_dispatcher
+        end
+      
+        def register(name, klass)
+          @@dispatchers[name.to_sym] = klass
+        end
+      end
+    
+      def log_processing(caption = nil)
+        caption ||= "#{request.params.inspect}"
+        logger.info "\n\nDispatching #{caption} at #{Time.now.to_s(:db)}"
+      end
+    
+      def dispatch(request)
+        raise NotImplementedError
+      end
+    
+      def handle_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
+          self.class.dispatch(Request.new(response.redirected_to))
+        else
+          # handle the response,
+          OutputHandler::Base.process(request, response)
+        end
+      end
+    end
+  
+  end
+end

data/lib/reactive-core/errors.rb

@@ -0,0 +1,99 @@
+module Reactive
+  # The root class for all Reactive exceptions
+  class Error < StandardError
+  end
+
+  # For all kind of errors that may occur in eval'ed code, include this module
+  # This allow for a more precise diagnostic
+  module TemplateError
+    SOURCE_CODE_RADIUS = 5
+
+    attr_reader :original_exception, :file_name, :template_error  # the last accessor is a duck typing check for TemplateError identification
+
+    def initialize(file_name, source_code, original_exception)
+      @file_name, @source_code, @original_exception = file_name, source_code, original_exception
+      @backtrace = compute_backtrace
+    end
+
+    def message
+      ActiveSupport::Deprecation.silence { original_exception.message }
+    end
+
+    def clean_backtrace
+      original_exception.clean_backtrace
+    end
+
+    def sub_template_message
+      if @sub_templates
+        "Trace of template inclusion: #{@sub_templates.join(", ")}"
+      else
+        ""
+      end
+    end
+
+    def source_extract(indentation = 0)
+      return unless num = line_number
+      num = num.to_i
+
+      source_code = @source_code.split("\n")
+
+      start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
+      end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
+
+      indent = ' ' * indentation
+      line_counter = start_on_line
+      return unless source_code = source_code[start_on_line..end_on_line]
+
+      source_code.sum do |line|
+        line_counter += 1
+        "#{indent}#{line_counter}: #{line}\n"
+      end
+    end
+
+    def sub_template_of(template_path)
+      @sub_templates ||= []
+      @sub_templates << template_path
+    end
+
+    def line_number
+      @line_number ||=
+        if file_name
+          regexp = /#{Regexp.escape File.basename(file_name)}:(\d+)/
+
+          $1 if message =~ regexp or clean_backtrace.find { |line| line =~ regexp }
+        end
+    end
+
+    def to_s
+      "\n\n#{self.class} (#{message}) #{source_location}:\n" +
+        "#{source_extract}\n    #{clean_backtrace.join("\n    ")}\n\n"
+    end
+
+    # don't do anything nontrivial here. Any raised exception from here becomes fatal 
+    # (and can't be rescued).
+    def backtrace
+      @backtrace
+    end
+
+    private
+      def compute_backtrace
+        [
+          "#{source_location.capitalize}\n\n#{source_extract(4)}\n    " +
+          clean_backtrace.join("\n    ")
+        ]
+      end
+
+      def source_location
+        if line_number
+          "on line ##{line_number} of "
+        else
+          'in '
+        end + file_name
+      end
+  end
+
+  if defined?(Exception::TraceSubstitutions)
+    Exception::TraceSubstitutions << [/:in\s+`_run_.*'\s*$/, '']
+    Exception::TraceSubstitutions << [%r{^\s*#{Regexp.escape Reactive.configuration.root_dir}/}, '']
+  end
+end

data/lib/reactive-core/ext/memoizable.rb

@@ -0,0 +1,6 @@
+module ActiveSupport #:nodoc: all
+  module Memoizable
+    def memoize(*args)
+    end
+  end
+end

data/lib/reactive-core/ext/object.rb

@@ -0,0 +1,14 @@
+class Object
+  # Runs the block for every object passed.
+  # Pass either a single object or a collection of objects (that must respond to #each)
+  # The block may accept a single argument or none. If it accepts one it is the object,
+  # if none, then the block is run in the context of the object (self is the object)
+  def with(*objects, &block)
+    if block.arity == 0
+      objects.each {|object| object.instance_eval(&block) }
+    else
+      objects.each {|object| yield object }
+    end
+  end
+
+end

data/lib/reactive-core/ext/object_instance.rb

@@ -0,0 +1,9 @@
+class Object
+  if RUBY_VERSION >= '1.9'
+    def instance_variable_names #:nodoc:
+      instance_variables.map { |var| var.to_s }
+    end
+  else
+    alias_method :instance_variable_names, :instance_variables
+  end
+end

data/lib/reactive-core/ext/ordered_options.rb

@@ -0,0 +1 @@
+OrderedOptions = ActiveSupport::OrderedOptions unless defined? OrderedOptions

data/lib/reactive-core/ext/rubygems_activate_patch.rb

@@ -0,0 +1,140 @@
+# Monkey patch rubygems to let Gem.activate activate gems matching version requirements but not necessary the latest version
+
+module Gem #:nodoc: all
+
+$indent = 0
+def self.puts(*args)
+  return nil
+  args.each do |item|
+    Kernel.puts item.to_s.gsub(/^/, " "*($indent*2))
+  end
+end
+def self.activate(gem, *version_requirements)
+  $indent += 1
+  puts ">>activating #{gem.inspect}"
+  _activate(gem, *version_requirements)
+  puts "<<activated #{gem.inspect}"
+ensure
+  $indent -= 1
+end
+
+  def self._activate(gem, *version_requirements)
+    if version_requirements.empty? then
+      version_requirements = Gem::Requirement.default
+    end
+
+    unless gem.respond_to?(:name) and
+           gem.respond_to?(:version_requirements) then
+      gem = Gem::Dependency.new(gem, version_requirements)
+    end
+puts "gem #{gem.inspect}"
+
+    matches = Gem.source_index.find_name(gem.name, gem.version_requirements)
+    report_activate_error(gem) if matches.empty?
+
+    if @loaded_specs[gem.name] then
+      # This gem is already loaded.  If the currently loaded gem is not in the
+      # list of candidate gems, then we have a version conflict.
+      existing_spec = @loaded_specs[gem.name]
+
+      unless matches.any? { |spec| spec.version == existing_spec.version } then
+        raise Gem::Exception,
+              "can't activate #{gem}, already activated #{existing_spec.full_name}"
+      end
+
+      return false
+    end
+
+    unhonored = nil
+    spec = matches.reverse.find do |candidate|
+      # Job done if Gem already loaded
+      puts "LOADED #{candidate}" and return false if candidate.loaded?
+      puts "candidate #{candidate}"
+
+      candidate.loaded = true
+      @loaded_specs[candidate.name] = candidate
+      
+      # Push the candidate to the stack
+      @dependency_stack ||= Array.new
+      @dependency_stack << candidate
+      mark = @dependency_stack.size - 1
+
+      # Load dependent gems first
+      begin
+        candidate.runtime_dependencies.each do |dep_gem|
+          activate dep_gem
+        end
+        # Clean up stack
+        @dependency_stack.pop
+        # We found a valid candidate
+        true
+      rescue Gem::Exception => e
+        unhonored = e.message
+        # Deactivate every stacked gem until mark
+        @dependency_stack.slice!(mark..-1).each {|spec| deactivate(spec) }
+        # Continue with the previous version
+        false
+      end
+    end
+    raise Gem::Exception, "can't activate #{gem}, one of its dependencies can't be honored, the last was:\n  #{unhonored}\n#{matches.join("\n")}" if spec.nil?
+
+    # bin directory must come before library directories
+    spec.require_paths.unshift spec.bindir if spec.bindir
+
+    require_paths = spec.require_paths.map do |path|
+      File.join spec.full_gem_path, path
+    end
+
+    sitelibdir = ConfigMap[:sitelibdir]
+
+    # gem directories must come after -I and ENV['RUBYLIB']
+    insert_index = load_path_insert_index
+
+    if insert_index then
+      # gem directories must come after -I and ENV['RUBYLIB']
+      $LOAD_PATH.insert(insert_index, *require_paths)
+    else
+      # we are probably testing in core, -I and RUBYLIB don't apply
+      $LOAD_PATH.unshift(*require_paths)
+    end
+
+    return true
+  end
+
+  # deactivate a gem. This method is used internally to rollback a gem activation after a dependency mismatch.
+  def self.deactivate(spec)
+    require_paths = spec.require_paths.map do |path|
+      File.join spec.full_gem_path, path
+    end
+  
+    $LOAD_PATH.reject! {|path| require_paths.include? path}
+    
+    spec.loaded = false
+    @loaded_specs.delete(spec.name)
+  end
+
+end
+
+module Kernel #:nodoc:
+
+  def require(path) # :doc:
+    gem_original_require path
+  rescue LoadError => load_error
+    if load_error.message =~ /#{Regexp.escape path}\z/ and
+       !(specs = Gem.searcher.find_all(path)).blank? then
+      exception = specs.inject(nil) do |except, spec|
+        begin
+          Gem.activate(spec.name, "= #{spec.version}")
+          break nil
+        rescue Gem::Exception => e
+          e
+        end
+      end
+      raise exception if exception === Exception
+      gem_original_require path
+    else
+      raise load_error
+    end
+  end
+
+end