rad_core 0.0.13 → 0.0.14

data/lib/rad/mailer/processors/letter_builder.rb

@@ -0,0 +1,34 @@
+rad.mailer
+
+class LetterBuilder < Rad::Conveyors::Processor
+  def call                
+    # prepare
+    controller = workspace.controller.must_be.present
+    raise "The controller #{controller} must be a Rad::Mailer::MailerController!" unless controller.is_a? Rad::Mailer::MailerController
+    action = workspace.action = workspace.method_name
+
+    # call
+    content = catch :halt do
+      controller.run_callbacks :action, method: action do          
+        # call controller
+        controller.send action, *workspace.arguments
+        # render view
+        controller.render action: action          
+      end
+    end
+    
+    controller.body = content unless content.blank?
+    
+    # letter
+    workspace.letter = ::Rad::Mailer::Letter.new(
+      from: controller.from,
+      to: controller.to,
+      subject: controller.subject,
+      body: controller.body
+    )
+    workspace.letter.validate!
+    
+    next_processor.call if next_processor
+  end          
+
+end

data/lib/rad/mailer.rb

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

data/lib/rad/profiles/mailer.rb

@@ -0,0 +1,5 @@
+rad.conveyors.mail do |mail|
+  mail.use Rad::Mailer::Processors::LetterBuilder
+  
+  mail.build!            
+end

data/lib/rad/profiles/web.rb

@@ -1,68 +1,45 @@
-require 'rad/profiles/web_require'
-
 # 
-# Routes
+# Conveyors
 # 
-rad.after :environment do
-  rad.register :router, depends_on: :environment do
-    Rad::Router.new(:class, [
-      [:alias_router, Rad::AliasRouter.new],
-      [:restful_router, Rad::RestfulRouter.new],            
-      [:simple_router, Rad::SimpleRouter.new]
-    ])
-  end
-end
+rad.conveyors.web do |web|      
+  # conveyor      
+  web.use Rad::Conveyors::Processors::ConveyorLogger
 
+  # http      
+  web.use Rad::Http::Processors::HttpWriter
+  web.use Rad::Http::Processors::PrepareParams
+  web.use Rad::Http::Processors::EvaluateFormat
+  web.use Rad::Http::Processors::HttpLogger
 
-# 
-# Conveyors
-# 
-module Rad::Processors
-  rad.after :environment do
-    rad.conveyors.web do |web|      
-      # conveyor      
-      web.use ConveyorLogger
-    
-      # http      
-      web.use HttpWriter
-      web.use PrepareParams
-      web.use EvaluateFormat
-      web.use HTTPLogger
-    
-      # html
-      # web.use ScopedParams
-      web.use PrepareFlash
-      
-      # controller
-      web.use ControllerErrorHandling
-      
-      # router
-      web.use Router, :class, :method_name
-    
-      # controller      
-      web.use ControllerLogger
-      web.use ControllerCaller
-            
-      web.build!            
-    end
-  end
+  # html
+  # web.use ScopedParams
+  web.use Rad::Html::Processors::PrepareFlash
+  
+  # controller
+  web.use Rad::Controller::Processors::ControllerErrorHandling
+  
+  # router
+  web.use Rad::Router::Processors::Router, :class, :method_name
+
+  # controller      
+  web.use Rad::Controller::Processors::ControllerLogger
+  web.use Rad::Controller::Processors::ControllerCaller
+        
+  web.build!            
 end
 
 
 # 
 # Rack
 # 
-Rad.initialize_rack do |builder|
-  config = rad.config
-  
+rad.http.initialize_rack do |builder|
   # CommonLogger, ShowExceptions, Lint
-  builder.use Rack::Lint if config.development?
-  builder.use Rad::StaticFiles, config.public_dir! if config.static? and config.public_dir? and config.development?
+  builder.use Rack::Lint if rad.development?
+  # builder.use Rad::Middleware::StaticFiles if rad.http.static? and rad.http.public_path? and rad.development?
   
   # use Rack::Session::Cookie, key: 'rack.session', domain: 'foo.com', path: '/', expire_after: 2592000, secret: 'change_me'
-  builder.use Rack::Session::Cookie, config.session.to_hash if config.session?
+  builder.use Rack::Session::Cookie, rad.http.session.stringify_keys if rad.http.session
   
   # builder.use Rack::CommonLogger
-  builder.use Rack::MethodOverride         
-  # builder.use ShowExceptions if config.show_exceptions?
+  builder.use Rack::MethodOverride
 end

data/lib/rad/remote/_remote_controller.rb

@@ -0,0 +1,9 @@
+module Rad::Remote::RemoteController
+  inherit Rad::Filters
+
+  inject workspace: :workspace, logger: :logger
+
+  def params
+    workspace.params
+  end
+end

data/lib/rad/remote/_require.rb

@@ -0,0 +1,6 @@
+class Rad::Remote
+end
+
+%w(
+  _remote_controller
+).each{|f| require "rad/remote/#{f}"}

data/lib/rad/remote/processors/remote_caller.rb

@@ -1,54 +1,52 @@
-module Rad
-  module Processors    
-    class RemoteCaller < Processor
-      # TODO2 :remote isn't registered with rad[
-      inject remote: :remote
-      
-      def initialize next_processor, result_variable = 'content'
-        super(next_processor)
-        @result_variable = result_variable
+rad.remote
+
+class RemoteCaller < Rad::Conveyors::Processor
+  # TODO2 :remote isn't registered with rad[
+  inject remote: :remote
+  
+  def initialize next_processor, result_variable = 'content'
+    super(next_processor)
+    @result_variable = result_variable
+  end
+  
+  def call                        
+    return next_processor.call unless workspace.class?
+            
+    # prepare
+    klass = workspace.class
+    raise "The remote class #{klass} must be a Rad::Remote::RemoteController!" unless klass.is? Rad::Remote::RemoteController
+    workspace.remote_object = klass.new                  
+    method = workspace.method_name
+
+    # call
+    begin
+      result = workspace.remote_object.run_callbacks :action, method: method do
+        workspace.remote_object.send method
       end
-      
-      def call                
-        return next_processor.call unless workspace.class?
-                
-        # prepare
-        klass = workspace.class
-        raise "The remote class #{klass} must be a Rad::Remote!" unless klass.is? Rad::Remote
-        workspace.remote_object = klass.new                  
-        method = workspace.method_name
+  
+      ensure_correct_result! result
+      workspace.remote_result = result                        
 
-        # call
-        begin
-          result = workspace.remote_object.run_callbacks :action, method: method do
-            workspace.remote_object.send method
-          end
-      
-          ensure_correct_result! result
-          workspace.remote_result = result                        
+      next_processor.call
 
-          next_processor.call
+      # write JSON as a result if format is JSON and no one else filled it
+      if workspace[@result_variable].blank?
+        workspace[@result_variable] = workspace.remote_result.to_json
+      end              
+    rescue StandardError => e
+      raise e if !workspace.params.format == 'json' or rad.test?
   
-          # write JSON as a result if format is JSON and no one else filled it
-          if workspace[@result_variable].blank?
-            workspace[@result_variable] = workspace.remote_result.to_json
-          end              
-        rescue StandardError => e
-          raise e if !workspace.params.format == 'json' or config.test?
-      
-          workspace[@result_variable] = {error: e.message}.to_json
+      workspace[@result_variable] = {error: e.message}.to_json
+
+      logger.error e
+      logger.info "\n"
+    end
+  end
   
-          logger.error e
-          logger.info "\n"
-        end
+  private
+    def ensure_correct_result! result
+      unless result.rson?
+        raise "You can't use object of type '#{result.class}' as Remote's return value!"
       end
-      
-      private
-        def ensure_correct_result! result
-          unless result.rson?
-            raise "You can't use object of type '#{result.class}' as Remote's return value!"
-          end
-        end
     end
-  end
 end

data/lib/rad/remote/processors/remote_logger.rb

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

data/lib/rad/remote/remote_controller.rb

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

data/lib/rad/remote.rb

@@ -1,9 +1 @@
-require 'rad/conveyor'
-
-[
-  'remote',  
-  'processors/remote_logger',
-  'processors/remote_caller',
-].each{|f| require "rad/remote/#{f}"}
-
-Rad::Config::DEFAULTS['default_method'] ||= 'call'
+rad.remote

data/lib/rad/router/_abstract_router.rb

@@ -0,0 +1,50 @@
+module Rad::Router::AbstractRouter
+  
+  class Meta < Hash
+    def get_class
+      @klass ||= self[:class_name].constantize
+    end
+  end
+
+  protected
+    def parse_url_root options
+      url_root = options[:url_root]
+      url_root.must =~ /^\/.*/ if url_root
+      url_root = nil if url_root == '/'
+      url_root
+    end
+  
+    def parse_prefix options      
+      prefix = Array(options[:prefix])
+      prefix.empty? ? nil : prefix
+    end
+
+    def encode_prefix_params! path, params, prefix
+      parts = []
+      prefix.each do |name|            
+        value = params.delete(name) || (rad.workspace? && rad.workspace.params[name])
+        raise "not provided :#{name} prefix!" unless value
+        parts << value.to_param.to_s.url_escape
+      end
+      "/#{parts.join('/')}#{path}"
+    end
+  
+    # def encode_url_root! path, meta
+    #   if url_root = meta[:url_root]
+    #     "#{url_root}#{path}" 
+    #   else
+    #     path
+    #   end
+    # end
+  
+    def decode_prefix_params! parts, params, prefix
+      prefix.each do |name|            
+        params[name] = parts.shift || raise("not provided :#{name} prefix!")
+      end
+    end
+  
+    def decode_url_root! parts, url_root
+      raise 'not implemented'
+      # raise "invalid :url_root!" if meta[:url_root] and meta[:url_root] != "/#{parts.join('/')}"
+    end
+end

data/lib/rad/router/_alias_router.rb

@@ -0,0 +1,124 @@
+class Rad::Router::AliasRouter
+  include Rad::Router::AbstractRouter
+
+  class TreeHash < Hash
+    attr_accessor :meta
+  end
+    
+  def initialize
+    @route_methods, @paths, @classes = {}, TreeHash.new, {}
+  end
+
+  def add als, options = {}    
+    # parsing options      
+    # als, options = als.to_s, options.to_openobject
+    options.validate_options! :class_name, :method, :url_root, :prefix
+    
+    als = als.to_s
+    als.must =~ /^\//
+    class_name = options.delete(:class_name) || raise("no class name!")
+    class_name.must_be.a String
+    method = options.delete(:method) || raise("no method!")
+    method = method.must_be.a Symbol      
+    url_root = parse_url_root options
+    prefix = parse_prefix options
+    
+    raise "you can't use '/' alias with :url_root!" if als == '/' and url_root
+  
+    # logic      
+    meta = Meta.new
+    meta.merge!(
+      class_name: class_name, 
+      method: method,
+      path: als, 
+      url_root: url_root, 
+      prefix: prefix
+    )
+ 
+    route_methods["#{als[1..-1]}_path"] = meta      
+  
+    (classes[class_name] ||= {})[method] = meta
+  
+  
+    parts = als[1..-1].split('/')
+    parts << '' if parts.empty?
+  
+    tree_iterator = paths
+    parts.reverse.each do |part|
+      tree_iterator = (tree_iterator[part] ||= TreeHash.new)        
+      raise "alias '#{als}' conflicted with another alias ('#{tree_iterator.meta[:path]}')!" if tree_iterator.meta
+    end
+    tree_iterator.meta = meta
+  end
+
+  def encode klass, method, params      
+    if meta = classes[klass.name].try(:[], method)
+      path = meta[:path]
+    
+      # prefix
+      prefix = meta[:prefix]
+      path = encode_prefix_params! path, params, prefix if prefix
+      
+      url_root = meta[:url_root]
+      params[:url_root] = url_root if url_root
+    
+      return path, params
+    else
+      nil
+    end
+  end
+
+  def decode path, params
+    parts = path[1..-1].split('/')
+    parts << '' if parts.empty?
+  
+    tree_iterator = paths
+  
+    # checking for first part
+    part = parts.pop
+    tree_iterator = tree_iterator[part]      
+    return nil unless tree_iterator    
+
+    # checking for exact match      
+    while part = parts.pop
+      tmp = tree_iterator[part]
+      unless tmp
+        parts << part
+        break 
+      end
+      tree_iterator = tmp
+    end      
+
+    meta = tree_iterator.meta
+    
+    # url_root
+    url_root = meta[:url_root]
+    return nil if url_root and "/#{parts.shift}" != url_root
+  
+    # prefix
+    prefix = meta[:prefix]
+    decode_prefix_params! parts, params, prefix if prefix                
+  
+    return meta.get_class, meta[:method], params
+  end  
+
+  def encode_method route_method, has_id
+    if meta = route_methods[route_method]
+      return meta.get_class, meta[:method]
+    else
+      nil
+    end
+  end
+
+  protected
+    attr_accessor :paths, :route_methods, :classes
+end
+
+
+Rad::Router::Configurator.class_eval do
+  def alias *args, &block
+    alias_router = @router.routers[:alias_router]
+    raise "There's no AliasRouter (use config to add it)!" unless alias_router
+    alias_router.add *args, &block
+  end
+end

data/lib/rad/router/_basic_router.rb

@@ -0,0 +1,72 @@
+class Rad::Router::BasicRouter
+  include Rad::Router::AbstractRouter
+  inject workspace: :workspace, logger: :logger
+  
+  attr_accessor :skip_routes, :redirect_routes
+  
+  SKIP_DEFAULT = [/^#{rad.http.url_root}\/(favicon|fs|packaged)/]
+
+  def initialize        
+    self.skip_routes = SKIP_DEFAULT.clone
+    self.redirect_routes = []
+  end
+  
+  def skip path_regexp
+    path_regexp.must_be.a Regexp
+    skip_routes << path_regexp unless skip_routes.include? path_regexp
+  end
+  
+  def redirect path_regexp, processor
+    path_regexp.must_be.a Regexp
+    processor.must_be.a String, Proc
+    redirect_routes << [path_regexp, processor] unless redirect_routes.include? [path_regexp, processor]
+  end
+  
+  def encode *a
+  end
+    
+  def decode path, params
+    # skip
+    if skip_routes.any?{|path_regexp| path_regexp =~ path}
+      logger.info "RAD skipping '#{path}'"
+      throw :halt, true
+    end
+    
+    # redirect
+    if meta = redirect_routes.find{|path_regexp, processor| path_regexp =~ path}
+      path_regexp, processor = meta          
+      target = if processor.is_a? String
+        path.sub(path_regexp, processor)
+      else
+        processor.call path
+      end
+      
+      response = workspace.response
+      # content_type = Mime[params.format]
+
+      response.set!(
+        status:       :redirect, 
+        # content_type: content_type,
+        body:         %(<html><body>You are being <a href="#{target.html_escape if target}">redirected</a>.</body></html>)
+      )
+      response.headers['Location'] = target
+
+      throw :halt, true
+    end
+  end
+end
+
+
+Rad::Router::Configurator.class_eval do
+  def skip *a, &b
+    basic_router = @router.routers[:basic_router]
+    raise "There's no BasicRouter (use config to add it)!" unless basic_router
+    basic_router.skip *a, &b
+  end
+  
+  def redirect *a, &b
+    basic_router = @router.routers[:basic_router]
+    raise "There's no BasicRouter (use config to add it)!" unless basic_router
+    basic_router.redirect *a, &b
+  end
+end

data/lib/rad/router/_configurator.rb

@@ -0,0 +1,19 @@
+class Rad::Router::Configurator
+  inject router: :router
+  
+  def initialize router
+    @router = router
+  end      
+  
+  def persistent_params *args
+    args.each{|v| router.persistent_params << v}
+  end
+  
+  class << self
+    inject router: :router
+    
+    def configure &block
+      block.call Rad::Router::Configurator.new(router)
+    end          
+  end
+end

data/lib/rad/router/_core_routing_helper.rb

@@ -0,0 +1,39 @@
+module Rad::Router::CoreRoutingHelper
+  inject router: :router
+
+  delegate :url_for, :url_for_path, :persist_params, :persist_params?, :dont_persist_params, to: :router 
+
+  def default_path options = {}
+    url_for_path rad.router.default_path, options.merge(url_root: false)
+  end
+
+  def return_to_path options = {}
+    dont_persist_params do 
+      path = params[:_return_to] || workspace.request.session['return_to'] || rad.router.default_path
+      url_for_path path, options.merge(url_root: false)
+    end
+  end
+
+  def parse_routing_arguments *args
+    params = args.extract_options!
+    raise "invalid usage!" unless args.size <= 1
+    if args.size == 1
+      raise "duplicate :id pameter!" if params.include?(:id) or params.include?('id')
+      params[:id] = args.first.to_param
+    end
+    params      
+  end
+
+  protected
+    def method_missing m, *args, &block
+      m = m.to_s
+      if m =~ /path$/
+        params = parse_routing_arguments(*args)
+        klass, method = router.encode_method m, params.include?(:id)
+      
+        url_for klass, method, params
+      else
+        super m.to_sym, *args, &block
+      end
+    end
+end

data/lib/rad/router/_default_format_processor.rb

@@ -0,0 +1,10 @@
+class Rad::Router::DefaultFormatProcessor
+  def add_format path, format
+    path << ".#{format}"
+    path
+  end
+
+  def remove_format path
+    path.sub(/\.[^\.]+$/, '')
+  end
+end