rad_core 0.0.13 → 0.0.14

data/lib/rad/controller/processors/controller_logger.rb

@@ -1,12 +1,10 @@
-module Rad
-  module Processors
-    class ControllerLogger < Processor
-      def call                
-        if (klass = workspace.class) and (method = workspace.method_name)
-          logger.info "  Processing #{klass.name}.#{method} with #{workspace.params.inspect}"
-        end
-        next_processor.call
-      end
+rad.controller
+
+class ControllerLogger < Rad::Conveyors::Processor
+  def call                
+    if (klass = workspace.class) and (method = workspace.method_name)
+      logger.info "RAD processing #{klass.name}.#{method} with #{workspace.params.inspect}"
     end
+    next_processor.call
   end
 end

data/lib/rad/controller.rb

@@ -1,28 +1 @@
-require 'rad/conveyor'
-require 'rad/template'
-
-%w(  
-  abstract_controller/render
-  abstract_controller/responder
-  abstract_controller/micelaneous
-  abstract_controller
-  controller_context
-  
-  processors/controller_logger
-  processors/controller_caller  
-  processors/controller_error_handling
-).each{|f| require "rad/controller/#{f}"}
-
-module Rad
-  autoload :HttpController, 'rad/controller/http_controller'
-end
-
-# 
-# Initialization
-# 
-Rad::Config::DEFAULTS.merge!(
-  development_error_template: "/rad_default_templates/development/error",
-  production_error_template: nil,
-  test_error_template: "/rad_default_templates/development/error",
-)
-Rad::Config::DEFAULTS[:default_method] ||= 'call'
+rad.controller

data/lib/rad/conveyors/_conveyor.rb

@@ -0,0 +1,73 @@
+class Rad::Conveyors::Conveyor
+  inject workspace: :workspace
+
+  def definitions
+    @definitions ||= []
+  end
+    
+  def use processor_class, *initialization_arguments
+    definitions << [processor_class, initialization_arguments]
+  end
+
+  def build!
+    @chain = lambda{}      
+    definitions.reverse.collect do |klass, args| 
+      klass.must_be.a Class
+      @chain = klass.new @chain, *args
+    end
+  end
+
+  def call workspace_content = {}, &block
+    build! unless @chain
+  
+    scope = (rad.custom_scopes[:cycle] || {}).clone
+    rad.activate :cycle, scope do
+      self.workspace = ::Rad::Conveyors::Workspace.new unless self.workspace?
+      workspace.merge! workspace_content 
+    
+      if block
+        block.call(@chain)
+      else
+        @chain.call
+      end
+    
+      workspace
+    end
+  end
+
+  def inspect
+    definitions.inspect
+  end
+
+  # def trace name, &block
+  #   start_time = Time.now
+  #   block.call
+  #   (workspace.trace ||= []) << [name, Time.now - start_time]
+  # end       
+
+  protected
+    # def build_chain
+    #   next_processor_call = nil
+    #   chain = reverse.collect do |processor|
+    #     next_processor_call = if next_processor_call
+    #       lambda{processor.call next_processor}
+    #     else
+    #       lambda{processor.call lambda{}}
+    #     end
+    #   end
+    #   next_processor_call
+    # end
+
+
+  # def add_before key, *processors
+  #   index = index{|processor| processor.name == key or processor.class == key}
+  #   raise "Can't find Processor '#{name}'!" unless index
+  #   insert index, *Array(processors)
+  # end
+  # 
+  # def add_after key, *processors
+  #   index = rindex{|processor| processor.name == key or processor.class == key}
+  #   raise "Can't find Processor '#{name}'!" unless index
+  #   insert index + 1, *Array(processors)
+  # end
+end

data/lib/rad/conveyors/_conveyors.rb

@@ -0,0 +1,19 @@
+class Rad::Conveyors  
+  def initialize
+    @hash = {}
+  end
+  
+  def [] conveyor_name
+    @hash[conveyor_name.to_s] ||= Conveyor.new
+  end
+  
+  def size; @hash.size end
+  
+  def method_missing m, &block
+    if block
+      block.call self[m]
+    else
+      self[m]
+    end
+  end
+end

data/lib/rad/conveyors/_params.rb

@@ -0,0 +1,10 @@
+class Rad::Conveyors::Params < OpenObject    
+  def initialize h = nil      
+    update h if h
+  end
+    
+  def inspect      
+    h = to_h
+    h.inspect
+  end    
+end

data/lib/rad/conveyors/_processor.rb

@@ -0,0 +1,13 @@
+class Rad::Conveyors::Processor
+  inject workspace: :workspace, logger: :logger
+
+  attr_accessor :next_processor
+
+  def initialize next_processor
+    @next_processor = next_processor
+  end      
+
+  def self.inspect
+    self.name.split('::').last
+  end    
+end

data/lib/rad/conveyors/_require.rb

@@ -0,0 +1,10 @@
+class Rad::Conveyors
+end
+
+%w(
+  _params
+  _workspace
+  _processor
+  _conveyor
+  _conveyors
+).each{|f| require "rad/conveyors/#{f}"}

data/lib/rad/conveyors/_workspace.rb

@@ -0,0 +1,34 @@
+class Rad::Conveyors::Workspace < OpenObject
+  def params
+    self[:params] || ::Rad::Conveyors::Params.new
+  end
+
+  def params?
+    !!params
+  end
+        
+  alias_method :set_without_params, :[]=
+  def []= k, v      
+    if k.to_s == 'params'
+      self.params = v
+    else
+      set_without_params k, v
+    end
+  end  
+
+  def params= v
+    if v.is_a? ::Rad::Conveyors::Params
+      set_without_params :params, v
+    else
+      set_without_params :params, ::Rad::Conveyors::Params.new(v)
+    end
+  end
+    
+  def inspect
+    h = {}
+    each{|k, v| h[k] = v}
+    h['env'] = "..." if h.include? 'env'      
+    h['request'] = "..." if h.include? 'request'
+    h.inspect
+  end
+end

data/lib/rad/conveyors/params.rb

@@ -0,0 +1 @@
+rad.conveyors

data/lib/rad/conveyors/processor.rb

@@ -0,0 +1 @@
+rad.conveyors

data/lib/rad/conveyors/processors/conveyor_logger.rb

@@ -0,0 +1,23 @@
+rad.conveyors
+
+class ConveyorLogger < Rad::Conveyors::Processor            
+  def call
+    begin
+      start_time = Time.now
+      next_processor.call
+      
+      # if workspace.trace?
+      #   total_time = workspace.trace.inject(0){|memo, pair| memo += pair.last}
+      #   max_pair = workspace.trace.max_by{|pair| pair.last}
+      #   logger.info "Completed in #{(total_time * 1000).round} ms (#{(max_pair.last * 1000).round} ms taken by #{max_pair.first})\n\n"
+      # else
+      logger.info "RAD completed in #{((Time.now - start_time) * 1000).round} ms\n"
+      # end
+    rescue StandardError => e
+      raise e if rad.test?
+        
+      logger.error e
+      logger.info "\n"
+    end
+  end
+end

data/lib/rad/conveyors/workspace.rb

@@ -0,0 +1 @@
+rad.conveyors

data/lib/rad/conveyors.rb

@@ -0,0 +1 @@
+rad.conveyors

data/lib/rad/core_web/_controller_micelaneous_helper.rb

@@ -0,0 +1,17 @@
+module Rad::ControllerMicelaneousHelper
+  def reload_page
+    params = workspace.params
+    params.format.must_be.in 'html', 'js'
+    
+    keep_flash!      
+    if params.format == 'js'
+      workspace.response.set!(
+        status: :ok, 
+        content_type: Mime[params.format]
+      )
+      throw :halt, "window.location.reload();"
+    else
+      redirect_to workspace.request.env["HTTP_REFERER"]
+    end              
+  end    
+end

data/lib/rad/core_web/_require.rb

@@ -0,0 +1,25 @@
+%w(
+  _controller_micelaneous_helper
+  
+  _router/abstract_routing_helper
+  _router/view_routing_helper    
+  _router/controller_routing_helper        
+).each{|f| require "rad/core_web/#{f}"}
+
+
+# View helpers
+[
+  Rad::Html::HtmlHelper,
+  Rad::Router::CoreRoutingHelper, Rad::ViewRoutingHelper
+].each do |helper|
+  Rad::Template::Context.inherit helper
+end
+  
+# Controller helpers
+[    
+  Rad::Html::FlashHelper,
+  Rad::Router::CoreRoutingHelper, Rad::ControllerRoutingHelper,  
+  Rad::ControllerMicelaneousHelper  
+].each do |helper|
+  Rad::Controller::Abstract.inherit helper
+end

data/lib/rad/core_web/_router/abstract_routing_helper.rb

@@ -0,0 +1,20 @@
+module Rad::AbstractRoutingHelper
+  protected            
+    def special_url key
+      return nil unless (key.is_a?(Symbol) or key.is_a?(String))
+            
+      if key == :back
+        workspace.request.env["HTTP_REFERER"] || 'javascript:history.back()'
+      elsif key == '#'
+        '#'
+      # elsif key =~ /^http:\/\// # /^[\/0-9_a-z]+$/i
+      #   key
+      else
+        nil
+      end
+    end      
+    
+    def keep_flash!
+      rad[:flash].keep! if rad.include? :flash
+    end
+end

data/lib/rad/core_web/_router/controller_routing_helper.rb

@@ -0,0 +1,56 @@
+module Rad::ControllerRoutingHelper
+  inherit Rad::AbstractRoutingHelper
+  
+  module ClassMethods
+    
+    # 
+    # persist_params controller filters
+    # 
+    def persist_params *args
+      if args.empty?
+        before :persist_params
+      elsif args.first.is_a? Hash
+        before :persist_params, args.first
+      else
+        before :persist_params, only: args.first
+      end
+    end
+  end
+  
+  # 
+  # redirect_to
+  # 
+  def redirect_to *args
+    params, response = workspace.params, workspace.response
+    params.format.must_be.in 'html', 'js'
+
+    if url = special_url(args.first)
+      args.size.must_be <= 1
+    else
+      url = url_for(*args)
+    end
+    content_type = Mime[params.format]
+
+    content = if params.format == 'js'
+      response.set!(
+        status: :ok, 
+        content_type: content_type
+      )
+      
+      "window.location = '#{url}';"
+    else
+      response.set!(
+        status: :redirect, 
+        content_type: content_type
+      )
+      response.headers['Location'] = url                        
+      
+      %(<html><body>You are being <a href="#{url.html_escape if url}">redirected</a>.</body></html>)
+    end
+    
+    # Flash need to know if we using redirect
+    keep_flash!
+    
+    throw :halt, content
+  end    
+end

data/lib/rad/core_web/_router/view_routing_helper.rb

@@ -0,0 +1,57 @@
+module Rad::ViewRoutingHelper
+  inherit Rad::AbstractRoutingHelper
+  
+  def link_to *args, &block      
+    # content
+    content = if block
+      capture(&block)
+    else
+      args.shift
+    end
+          
+    # url, html_options
+    if args.first.is_a? String
+      args.size.must_be.in 1..2
+      url, html_options = args
+      html_options ||= {}
+    else
+      if url = special_url(args.first)
+        args.size.must_be <= 2
+        html_options = args[1] || {}
+      else          
+        html_options = if args[-1].is_a?(Hash) and args[-2].is_a?(Hash)
+          args.pop
+        else
+          {}
+        end
+        
+        args << {} unless args[-1].is_a?(Hash)
+        url = url_for(*args)
+      end
+    end
+    
+    # add javascript
+    html_options[:href] = url
+    add_js_link_options! url, html_options      
+    tag :a, content, html_options
+  end    
+  
+  protected
+    def add_js_link_options! url, html_options
+      remote = html_options.delete(:remote) || rad.html.remote_link_formats.include?(url.marks.format)
+      method = html_options.delete(:method)
+      
+      if remote or method
+        action = html_options.delete(:href).must_be.defined
+        html_options[:href] = '#'
+                  
+        html_options['data-action'] = action
+        html_options['data-remote'] = 'true' if remote
+        html_options['data-method'] = method || 'post'
+      end
+      
+      if confirm = html_options.delete(:confirm)
+        html_options['data-confirm'] = confirm
+      end
+    end
+end

data/lib/rad/environment/_config.rb

@@ -0,0 +1,27 @@
+class Rad::Config  
+  def subset; raise "you probably mistuped, it's config, not hash" end
+  
+  def initialize hash = {}
+    hash.each do |k, v|
+      instance_variable_set :"@#{k}", v
+    end
+  end
+  
+  def deep_clone
+    clone = Rad::Config.new
+    instance_variable_names.each do |k|
+      clone.instance_variable_set k, instance_variable_get(k).deep_clone
+    end
+    clone
+  end
+  alias_method :clone, :deep_clone
+    
+  protected
+    def method_missing m, *args
+      if m =~ /=$/
+        instance_variable_set :"@#{m[0..-2]}", args.first
+      else
+        instance_variable_get :"@#{m}"
+      end
+    end
+end

data/lib/rad/environment/_environment.rb

@@ -0,0 +1,17 @@
+# 
+# Environment
+# 
+class Rad::Environment
+  inherit Rad::Environment::FilesHelper
+  
+  inject logger: :logger
+    
+  attr_writer :available_languages
+  def available_languages; @available_languages ||= [] end
+  
+  attr_accessor :language
+  
+  class << self      
+    inject logger: :logger
+  end    
+end

data/lib/rad/environment/_files_helper.rb

@@ -0,0 +1,55 @@
+module Rad::Environment::FilesHelper    
+  def directories
+    $LOAD_PATH
+  end
+
+  def file_exist? path, directories = nil
+    find_files(path, directories).size > 0
+  end
+
+  def find_files fname, directories = nil
+    directories ||= self.directories
+    Rad::Environment::FilesHelper.find_files fname, directories
+  end
+
+  def find_files_without_cache fname, directories = nil
+    # directories ||= self.directories
+    Rad::Environment::FilesHelper.find_files_without_cache fname, directories
+  end
+
+  def find_file fname, directories = nil
+    files = find_files(fname, directories)
+    raise "Found multiple files for '#{fname}'" if files.size > 1
+    files.first
+  end
+  
+  def find_file! fname, directories = nil
+    find_file(fname, directories) || raise("File '#{fname}' not found!")
+  end
+
+  def find_files_by_pattern_without_cache pattern, directories = nil
+    directories ||= self.directories
+    patterns = directories.to_a.collect{|d| "#{d}#{pattern}"}
+    Dir.glob patterns
+  end
+  alias_method :find_files_by_pattern, :find_files_by_pattern_without_cache
+
+  def find_file_by_pattern pattern
+    files = find_files_by_pattern(pattern)
+    raise "File '#{pattern}' not found!" if files.size == 0
+    raise "Found multiple files for '#{pattern}'" if files.size > 1
+    files.first
+  end
+
+  class << self
+    # don't move this class method to module, because there will be then 
+    # multiple cache for every object that includes it.      
+    def find_files fname, directories
+      fname.must =~ /\//
+      directories.must_be.present # || raise('directories ')= self.directories
+      files = directories.collect{|dir| "#{dir}#{fname}"}
+      files.select{|f| File.exist? f}
+    end
+    cache_method_with_params_in_production :find_files
+  end
+end

data/lib/rad/environment/_logger.rb

@@ -0,0 +1,53 @@
+class Rad::Logger        
+  def initialize stream
+    @stream = stream
+  end
+  
+  def silence &b
+    begin
+      @silence = true
+      b.call
+    ensure
+      @silence = false
+    end    
+  end
+  
+  def info obj
+    !@silence && stream && stream.write(indent(obj_to_string(obj)) + "\n")
+  end
+
+  def warn obj
+    !@silence && stream && stream.write(indent("WARN: " + obj_to_string(obj)) + "\n")
+  end
+
+  def error obj
+    !@silence && stream && stream.write(indent("ERROR: " + obj_to_string(obj)) + "\n")
+  end
+  
+  def debug obj
+    if !@silence && stream 
+      # cutting annoying BSON::ObjectId('4dec6a8d360501476d000004') stuff
+      stream.write(indent(obj_to_string(obj).gsub(/BSON::ObjectId\(([a-z0-9'"]+)\)/, "\\1")) + "\n")
+    end
+  end
+
+  protected
+    IDENTATION = "  "
+    attr_reader :stream
+          
+    def indent string
+      IDENTATION + string.gsub("\n", "\n" + IDENTATION)
+    end
+    
+    def obj_to_string obj
+      if obj.is_a? Exception
+        backtrace = (obj.backtrace && obj.backtrace.sfilter(Exception.filters)) || []
+        %{\
+#{obj.message}
+  #{backtrace.join("\n  ")}
+} 
+      else
+        obj.to_s
+      end
+    end
+end

data/lib/rad/environment/_require.rb

@@ -0,0 +1,24 @@
+class Rad::Environment
+end
+
+%w(
+  _config
+  _logger
+  _files_helper
+  _environment
+).each{|f| require "rad/environment/#{f}"}
+
+
+# 
+# Handy mehtods 
+# 
+class Micon::Core
+
+  def development?; mode == :development end
+  def production?; mode == :production end
+  def test?; mode == :test end    
+
+  def development █ block.call if development? end
+  def production █ block.call if production? end
+  def test █ block.call if test? end
+end