reactive-core 0.2.0

data/lib/reactive-core/meta_model.rb

@@ -0,0 +1,92 @@
+module Reactive
+  module MetaModel
+    class Instance
+      def new_record?
+      end
+    
+      def changed?
+      end
+    
+      def mark_for_destruction
+      end
+      
+      # Determine if this record is marked for destruction.
+      # Destruction will occur ???
+      def marked_for_destruction?
+      end
+    
+      # Determine validness of the record.
+      # Note that it triggers the validations
+      def valid?
+      end
+      
+      # Returns an array of error object. Empty array when valid.
+      def errors
+      end
+    end
+  
+    class Column
+      attr_reader :name, :type, :primary
+      alias :primary? :primary
+    end
+  
+    class Association
+      attr_reader :name, :kind, :klass, :polymorphic
+      alias :polymorphic? :polymorphic
+      
+      # returns an array of column names that are handled by the association
+      # By default, foreign keys are in this array, counter cache and also _type columns for
+      # polymorphic assocations may be there too.
+      attr_reader :columns
+    end
+  
+    class Model
+      # registers the passed object as an observer.
+      # the object may receive notification through these methods:
+      #   (see ActiveRecord::Callbacks)
+      # Note that each of these methods will receive a unique argument which
+      # is the record that has been treated.
+      def add_observer(object)
+      end
+    
+      # remove the object from the registered observers
+      def delete_observer(object)
+      end
+      
+      def has_manys
+        @attributes.select {|name,value| value.is_a?(Association) && value.kind == :has_many}
+      end
+    
+      def has_ones
+        @attributes.select {|name,value| value.is_a?(Association) && value.kind == :has_one}
+      end
+    
+      def belong_tos
+        @attributes.select {|name,value| value.is_a?(Association) && value.kind == :belongs_to}
+      end
+    
+      def associations
+        @attributes.select {|name,value| value.is_a? Association}
+      end
+    
+      def columns
+        @attributes.select {|name,value| value.is_a? Column}
+      end
+    
+      def attributes
+        @attributes.values
+      end
+    
+      def attribute(name)
+        @attributes[name.to_sym]
+      end
+
+      def cooked_attributes
+        association_columns = associations.collect {|assoc| assoc.columns}.flatten
+        associations + columns.reject {|col| association_columns.include?(col.name) || col.primary? }
+      end
+
+    end
+  
+  end
+end

data/lib/reactive-core/output_handler.rb

@@ -0,0 +1,143 @@
+require 'reactive-core/helper_module'
+
+module Reactive
+  module OutputHandler
+    class Error < Reactive::Error #:nodoc:
+    end
+  
+    class NoHandlerFound < Error
+    end
+  
+    class Base
+      cattr_accessor :logger
+      
+      @@output_handlers = {}
+      
+      class << self
+        def register_output_handler(format, handler)
+          output_handlers(format) << handler
+        end
+      
+        def output_handlers(format)
+          @@output_handlers[format] ||= []
+        end
+      
+        def output_handler(format, name)
+          output_handlers(format).find {|handler| handler.handler_name == name}
+        end
+        
+        def helper(format, mod)
+          helper_module(format).send(:include, mod)
+        end
+      
+        def helper_module(format)
+          @@helper_modules[format] ||= Module.new
+        end
+        
+        def process(request, response)
+          # a 'false' handler is used to disable output handling
+          if response.handler_name == false
+            logger.info "Handling disabled for #{request.params.inspect}"
+            return response.body
+          end
+        
+          #
+          logger.info "Handling #{response.handler_name}/#{response.treatment} for format #{response.format}"
+          handler = pick_handler(response.format, response.handler_name)
+          raise NoHandlerFound, "Requested output handler #{response.handler_name} for format #{response.format} not available!" unless handler
+          
+          #
+          handler_instance(handler).treat(request, response)
+        rescue Exception => exception
+          log_error(exception)
+          raise exception
+        end
+      
+        protected
+      
+        def handler_instance(handler)
+          #TODO: We may cache handler instances in the future (for better performance)
+          handler.new
+        end
+      
+        def pick_handler(format, name)
+          # We will first search in the registered handlers (plugins use this form)
+          if handler = output_handler(format, name)
+            return handler
+          end
+          
+          # Nothing found, let's see in the application dirs
+          dir = Reactive.path_for(:output_handlers, format.to_s)
+          if name.nil?
+            files = Dir.entries(dir).select {|entry| File.file? entry }
+            name = File.basename(files.first) if files.size == 1
+          else
+            name = "#{name}_handler"
+          end
+          require "#{dir}/#{name}"
+          name.constantize
+        rescue LoadError
+          nil
+        end
+
+        # Overwrite to implement custom logging of errors. By default logs as fatal.
+        def log_error(exception) #:doc:
+          ActiveSupport::Deprecation.silence do
+            if exception.respond_to? :template_error
+              logger.fatal(exception.to_s)
+            else
+              logger.fatal(
+                "\n\n#{exception.class} (#{exception.message}):\n    " +
+                clean_backtrace(exception).join("\n    ") +
+                "\n\n"
+              )
+            end
+          end
+        end
+
+      end
+    
+      @@helper_modules = {}
+    
+      class ProxyModule < Module
+        def initialize(receiver)
+          @receiver = receiver
+        end
+
+        def include(*args)
+          super(*args)
+          @receiver.extend(*args)
+        end
+      end
+    
+      attr_reader :request, :response, :helpers
+
+      def treat(request, response)
+        @request, @response = request, response
+        setup_helpers
+        send(response.treatment || default_treatment)
+      end
+    
+      def controller_name
+        @request.params[:controller].to_s
+      end
+    
+      def action_name
+        @request.params[:action].to_s
+      end
+    
+      def request_name
+        "request_#{controller_name}_#{action_name}"
+      end
+    
+      protected
+      
+      def setup_helpers
+        return if @helpers
+        @helpers = ProxyModule.new(self)
+        @helpers.include(self.class.helper_module(request.format))
+      end
+    
+    end
+  end
+end

data/lib/reactive-core/request.rb

@@ -0,0 +1,27 @@
+module Reactive
+  class Request
+    attr_accessor :params
+    attr_reader :format
+    attr_accessor :treatment
+    
+    def initialize(params = {})
+      parse_params(params.dup)
+    end
+  
+    def default_format
+      nil
+    end
+
+    def default_treatment
+      nil
+    end
+
+    protected
+      def parse_params(params)
+        @format = params.delete(:format) || default_format
+        @treatment = params.delete(:treatment) || default_treatment
+        @params = params.with_indifferent_access
+      end
+    
+  end
+end

data/lib/reactive-core/response.rb

@@ -0,0 +1,14 @@
+module Reactive
+  class Response
+    attr_accessor :template, :body, :variables, :redirected_to, :handler_name, :treatment, :format
+    
+    def initialize
+      @variables = {}
+    end
+    
+    def clear
+      @body = @redirected_to = @handler_name = @treatment = @format = nil
+      @variables = {}
+    end
+  end
+end

data/lib/reactive-core/tasks/app.rake

@@ -0,0 +1,29 @@
+namespace :app do
+
+  desc "Determine if an update is available"
+  task :update? do
+    require 'rubygems/source_info_cache'
+    if spec = Gem::SourceInfoCache.search("^#{APP_NAME}$").last
+      if spec.version > Gem.loaded_specs[APP_NAME].version
+        puts "New version available: #{spec.version} (Current version: #{Gem.loaded_specs[APP_NAME].version})"
+      else
+        puts "Sorry, no new version available"
+      end
+    else
+      puts "gem #{APP_NAME} not found on gem servers"
+    end
+    
+  end
+
+  desc "Update the application gem"
+  task :update do
+    # This tasks will be run on the deployed system.
+    # It should get the gem server name from a config file, then update the app gem with --no-dependencies
+    #
+    # WARNING: Between rake app:update and the following rake commands, the current directory has to be changed. Because we are in the app root directory and it may have been update.
+    # Thus we must CD to the new app root dir. Maybe, we should have a Rakefile in the root of /path/to/myapp that will delegate to the highest version.
+    puts `gem install #{APP_NAME} -i "#{APP_PATH}" --ignore-dependencies`
+    puts "Some gem dependencies may be missing, have a look with: rake gems"
+    #puts "Some gem dependencies are missing, have a look with: rake gems.\nYou may install them with: rake gems:install or rake gems:embed" unless Reactive::GemDependency.missing_gems.empty?
+  end
+end

data/lib/reactive-core/tasks/gems.rake

@@ -0,0 +1,43 @@
+desc "List the gems that this reactive application depends on"
+task :gems => 'gems:base' do
+  puts Reactive::GemDependency.report_gems_state(false)
+end
+
+namespace :gems do
+  task :base do
+    Rake::Task[:environment].invoke
+  end
+
+  desc "List the gems and its dependencies that this reactive application depends on"
+  task :dependencies => :base do
+    puts Reactive::GemDependency.report_gems_state(true)
+  end
+  
+  desc "Installs all required gems for this application."
+  task :install => :base do
+    require 'rubygems'
+    require 'rubygems/gem_runner'
+    Reactive.configuration.gems.each { |gem| puts gem.install unless gem.installed? }
+  end
+
+  desc "Embed the specified gem into the application gems directory."
+  task :embed => :base do
+    require 'rubygems'
+    require 'rubygems/gem_runner'
+    Reactive.configuration.gems.each do |gem|
+      next unless !gem.embedded? && (ENV['GEM'].blank? || ENV['GEM'] == gem.name)
+      puts gem.embed
+    end
+  end
+  
+  namespace :embed do
+    desc "Embed the specified gems and its dependencies into the application gems directory"
+    task :dependencies => :embed do
+      require 'rubygems'
+      require 'rubygems/gem_runner'
+      Reactive.configuration.gems.inject([]) do |missing, gem|
+        gem.dependencies.inject(missing) {|missing, dependency| dependency.embedded? ? missing : missing << dependency}
+      end.uniq.each {|dependency| puts dependency.embed}
+    end
+  end
+end

data/lib/reactive-core/tasks/log.rake

@@ -0,0 +1,9 @@
+namespace :log do
+  desc "Truncates all *.log files in log/ to zero bytes"
+  task :clear do
+    FileList["log/*.log"].each do |log_file|
+      f = File.open(log_file, "w")
+      f.close
+    end
+  end
+end

data/lib/reactive-core/tasks/misc.rake

@@ -0,0 +1,5 @@
+task :default => :test
+task :environment do
+  Reactive::Initializer.run(:init)
+end
+

data/lib/reactive-core/tasks/reactive.rb

@@ -0,0 +1,18 @@
+$VERBOSE = nil
+
+# Load reactive-core rakefile extensions
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }
+
+# Load reactive-dev gem if available, the tasks will be loaded by the code below (plugins)
+if spec = Gem.source_index.search(Gem::Dependency.new('reactive-dev', "= #{Reactive::VERSION::STRING}")).first
+  Gem.activate(spec.name, "= #{spec.version}")
+  Dir["#{spec.full_gem_path}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+end
+
+# Load any custom rakefile extensions
+Dir[Reactive.path_for("lib/tasks/**/*.rake")].sort.each { |ext| load ext }
+
+# Load reactive-core rakefile extensions and also the ones from the plugins
+Reactive.configuration.gems.map(&:loaded_spec).compact.each do |spec|
+  Dir["#{spec.full_gem_path}/**/tasks/**/*.rake"].sort.each { |ext| load ext }
+end

data/lib/reactive-core/updater/base.rb

@@ -0,0 +1,24 @@
+require 'rubygems/source_info_cache'
+
+module Reactive
+  module Updater
+  
+    class Base
+      
+      def current_version
+        Gem.loaded_specs[APP_NAME].version
+      end
+      
+      def update_available?
+        (spec = Gem::SourceInfoCache.search("^#{APP_NAME}$").last) && (spec.version > current_version)
+      end
+    
+      def last_available_version
+        spec = Gem::SourceInfoCache.search("^#{APP_NAME}$").last
+        spec && spec.version
+      end
+      
+    end
+
+  end
+end

data/lib/reactive-core/updater/cli.rb

@@ -0,0 +1,54 @@
+require 'reactive-core/updater/base'
+
+module Reactive
+  module Updater
+  
+    class Cli < Base
+      def initialize(args = [])
+        args.include?('--check') ? check_update : update
+      end
+    
+      def check_update
+        if update_available?
+          puts "There's a new version available: #{} (Current version: #{}"
+        else
+          puts "No new version available (Current version: #{})"
+        end
+      end
+      
+      def update
+        if update_available?
+          puts `gem install #{APP_NAME} -i "#{APP_PATH}" --ignore-dependencies`
+          exec(File.join(APP_PATH, '__FILE__'))         # WARNING: TODO: How about windows? should we add .cmd suffix?
+        end
+      
+        puts Reactive::GemDependency.report_gems_state
+
+        Reactive::GemDependency.missing_gems.each do |gem|
+        #  gem.source = gem_source
+          case ask "#{gem.name} #{gem.requirement.to_s}: Install, embed or skip", "Ies"
+            when "i"
+              puts gem.install
+            when "e"
+              puts gem.embed
+          end
+        end
+      end
+
+      def gem_source
+        "http://localhost:8808"
+      end
+
+      def ask(question, replies)
+        begin
+          print question + " (#{replies}) ?"
+          reply = gets.chomp.downcase
+          reply = replies[/[A-Z]/] || '?' if reply.empty?
+        end until replies.downcase.include? reply.downcase
+        reply
+      end
+      
+    end
+
+  end
+end