rad_core 0.0.13 → 0.0.14

data/lib/rad/_support/extensions.rb

@@ -0,0 +1,20 @@
+class Micon::Core
+  def register_extension name, &block
+    name.must_be.a Symbol
+    block.must_be.defined
+    
+    raise "extension :#{name} already registered!" if extensions.include? name
+
+    extensions[name] = block
+  end
+  
+  def extension name, target = nil, *args, &default_extension    
+    name.must_be.a Symbol
+    
+    if block = extensions[name] || default_extension
+      target ? target.instance_exec(*args, &block) : block.call(*args)
+    end
+  end
+  
+  def extensions; @extensions ||= {} end
+end

data/lib/rad/_support/filters.rb

@@ -0,0 +1,32 @@
+module Rad::Filters
+  inherit Rad::Callbacks    
+        
+  module ClassMethods
+    def before *args, &block
+      opt = args.extract_options!
+      if block       
+        set_callback :action, :before, opt, &block
+      else 
+        args.each{|executor| set_callback :action, :before, executor, opt}        
+      end
+    end
+    
+    def around *args, &block
+      opt = args.extract_options!
+      if block       
+        set_callback :action, :around, opt, &block
+      else 
+        args.each{|executor| set_callback :action, :around, executor, opt}        
+      end
+    end
+    
+    def after *args, &block
+      opt = args.extract_options!
+      if block       
+        set_callback :action, :after, opt, &block
+      else 
+        args.each{|executor| set_callback :action, :after, executor, opt}        
+      end
+    end
+  end
+end

data/lib/rad/{support → _support}/mime.rb

@@ -9,5 +9,11 @@ module Mime
       type = ".#{type}" unless type =~ /^\./
       Rack::Mime.mime_type(type) || raise("Unknown MIME type: #{type}")
     end
+    
+    def image? file_name      
+      return false if file_name.blank? 
+      extension = File.extname(file_name)
+      Rack::Mime.mime_type(extension) =~ /image/
+    end
   end
 end

data/lib/rad/{support → _support}/module.rb

@@ -5,8 +5,9 @@ class Module
   # If no environment given uses non-cached version.
   # 
   def cache_method_with_params_in_production method        
-    method_with_cache, method_without_cache = "#{method}_with_cache", "#{method}_without_cache"
-    iv = "@#{method}_cache"
+    escaped_method = escape_method(method)
+    method_with_cache, method_without_cache = "#{escaped_method}_with_cache", "#{escaped_method}_without_cache"
+    iv = "@#{escaped_method}_cache"
     
     # raise "Method '#{method}' already defined!" if instance_methods.include?(method)
     if instance_methods.include?(method_with_cache) or instance_methods.include?(method_without_cache)
@@ -31,13 +32,10 @@ class Module
         result
       end
 
-      # listen to environment events
-      rad.after :config do |config|
-        if config.production?
-          alias_method method, method_with_cache
-        else
-          alias_method method, method_without_cache
-        end
+      if rad.mode == :production
+        alias_method method, method_with_cache
+      else
+        alias_method method, method_without_cache
       end
 
       # by default uses non-cached version

data/lib/rad/_support/require.rb

@@ -0,0 +1,62 @@
+#
+# ruby
+#
+raise 'ruby 1.9.2 or higher required!' unless RUBY_VERSION >= '1.9.2'
+require 'rad/_support/encoding'
+
+
+#
+# gems
+#
+require 'rad/gems'
+
+
+#
+# dependencies
+#
+require 'rad/_support/active_support'
+
+require 'ruby_ext'
+
+require 'vfs'
+
+require 'ruby_ext/more/open_constructor'
+require 'rad/_support/ruby_ext_with_active_support'
+
+require 'class_loader'
+
+require 'micon'
+require 'micon/rad'
+# require 'rad/_support/micon'
+
+require 'rad/_support/class_loader'
+
+require 'dictionary'
+
+require 'thread'
+require 'time'
+require 'uri'
+require 'json'
+
+
+require 'addressable/uri'
+require 'rad/_support/addressable'
+::Uri = Addressable::URI
+
+#
+# libraries
+#
+require 'rad/_support/hacks_and_fixes'
+
+autoload :Nokogiri, 'nokogiri'
+
+[  
+  'module',
+  'callbacks',
+  'filters',
+  'mime',  
+  'string',
+  'rson',
+  'exception',
+  'extensions'
+].each{|f| require "rad/_support/#{f}"}

data/lib/rad/{support → _support}/string.rb

@@ -3,9 +3,17 @@ class String
     ERB::Util.json_escape self
   end
   
+  HTML_ESCAPE_MAP = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
   def html_escape
+    # ERB and Rack both are replacing '/' character, and it's wrong because it destroys links (like '/default/my_item')
     # ERB::Util.html_escape self
-    Rack::Utils.escape_html self
+    # Rack::Utils.escape_html self
+    
+    gsub(/[&"><]/){|special| HTML_ESCAPE_MAP[special]}
+  end
+  
+  def url_escape    
+    CGI.escape self
   end
   
   JS_ESCAPE_MAP = {

data/lib/rad/controller/_abstract/micelaneous.rb

@@ -0,0 +1,27 @@
+module Rad::Controller::Abstract::Micelaneous
+  # 
+  # respond_to
+  # 
+  def respond_to &block
+    @_responder.must_be.nil
+    @_responder = Rad::Controller::Abstract::Responder.new
+    block.call @_responder
+    handler = @_responder.handlers[params.format]
+    raise "can't respond to '#{params.format}' format!" unless handler
+    handler.call
+  end
+
+  module ClassMethods
+    # 
+    # filter_parameter_logging
+    # 
+    inheritable_accessor :filter_parameter_logging, []
+    def filter_parameter_logging_with_sugar *parameters
+      if parameters.empty?
+        filter_parameter_logging_without_sugar
+      else
+        filter_parameter_logging_without_sugar.push *parameters.collect(&:to_s)
+      end
+    end        
+  end
+end

data/lib/rad/controller/_abstract/render.rb

@@ -0,0 +1,159 @@
+module Rad::Controller::Abstract::Render      
+  SPECIAL_FORMAT_HANDLERS = {
+    json: lambda{|o| o.to_json},
+    xml: lambda{|o| o.to_xml},
+    js: lambda{|o| o},        
+  }
+
+  def _layout *args            
+    @_layout = *args unless args.empty?
+    @_layout
+  end
+  def _layout= layout
+    @_layout = layout
+  end
+
+  def render *args        
+    options = rad.template.parse_arguments *args
+    content = render_with_parsed_arguments options, args
+    throw :halt, content
+  end
+
+  protected
+    def render_action options
+      instance_variables = {
+        action_name: (options[:action] || workspace.action).to_sym,
+        controller_name: self.class.controller_name
+      }
+      instance_variable_names.each do |name|
+        instance_variables[name[1..-1]] = instance_variable_get name unless name =~ /^@_/
+      end
+      context = self.class.context_class.new(instance_variables, self)            
+       
+      options[:template] ||= options.delete(:action)
+      options[:template].must_be.present
+      options[:template] = options[:template].to_s
+      
+      options.reverse_merge!(
+        context: context,
+        format: params.format,
+        exact_format: true,
+        prefixes: ['']
+      )
+
+      # rendering content
+      content, context = render_content options            
+
+      # rendering layout
+      options[:content] = context
+      render_layout options, content
+    end
+    
+    def render_layout options, content
+      layout = options.include?(:layout) ? options[:layout] : self._layout
+      if layout # and rad.template.exist? layout, options         
+        rad.template.render layout, options do |*args|
+          if args.empty?
+            content
+          else
+            args.size.must_be == 1
+            variable_name = args.first.to_s
+            options[:context].content_variables[variable_name]
+          end
+        end        
+      else
+        content
+      end
+    end
+
+    def render_content options          
+      rad.template.basic_render options.merge(relative_path_resolver: self.class, if_not_exist: '/rad_default_templates/blank_template')
+    end
+    
+    def render_with_parsed_arguments options, original_args
+      if special_format = SPECIAL_FORMAT_HANDLERS.keys.find{|f| options.include? f}            
+        handler = SPECIAL_FORMAT_HANDLERS[special_format]
+        if special_format.to_s != params.format
+          raise "You trying responing with '#{special_format}' to the '#{params.format}' requested format!"
+        end
+        handler.call options[special_format]
+      elsif options.include? :inline            
+        options[:inline]
+      elsif options[:template] == :nothing
+        ''
+      else                        
+        render_action options
+      end
+    end
+
+  module ClassMethods
+    def layout layout, options = {}
+      before options do |controller|
+        controller._layout = layout
+      end
+    end
+    
+    def context_class
+      unless @context_class
+        parent_context_class = nil
+        ancestors[1..-1].each do |anc|            
+          break if parent_context_class = anc.respond_to(:context_class)
+        end
+        parent_context_class ||= Rad::Controller::Context
+
+        class_name = "#{self.name}::#{self.name.split('::').last}Context"
+
+        # raise "Tempate context #{class_name} already defined!" if Object.const_defined? class_name
+        eval "class #{class_name} < #{parent_context_class}; end", TOPLEVEL_BINDING, __FILE__, __LINE__
+        @context_class = class_name.constantize
+      end
+      @context_class
+    end
+    
+    def find_relative_template *args
+      return _find_relative_template *args unless rad.production?
+      
+      # use cache
+      @relative_template ||= {}      
+      unless @relative_template.include? args        
+        @relative_template[args] = _find_relative_template *args
+      end
+      @relative_template[args]
+    end
+    
+    def _find_relative_template tname, prefixes, format, exact_format, current_dir
+      tname.must_be.present
+      
+      path = nil
+      
+      # own templates
+      ["/#{controller_name.underscore}/#{tname}", "/#{controller_name.gsub('::', '/')}/#{tname}"].each do |name|         
+        path ||= rad.template.find_file(name, prefixes, format, exact_format, rad.template.paths)
+      end
+      
+      # own :actions templates      
+      ["/#{controller_name.underscore}/actions", "/#{controller_name.gsub('::', '/')}/actions"].each do |name|
+        unless path
+          path = rad.template.find_file(name, prefixes, format, exact_format, rad.template.paths)
+          path = nil if path and (File.read(path) !~ /^.*when.+[^_a-zA-Z0-9]#{tname}[^_a-zA-Z0-9].*$/)
+        end
+      end
+      
+      # superclasses templates
+      unless path
+        parent = ancestors[1..-1].find{|a| a.respond_to?(:find_relative_template)} #  and a.instance_methods.include?(action)
+        if parent and parent != Rad::Controller::Abstract
+          path = parent.find_relative_template(tname, prefixes, format, exact_format, current_dir)
+        end
+      end
+      
+      # relative template
+      if !path and current_dir      
+        path = rad.template.relative_path_resolver.find_relative_template(tname, prefixes, format, exact_format, current_dir)
+      end
+      
+      return path
+    end
+
+  end
+end

data/lib/rad/controller/_abstract/responder.rb

@@ -0,0 +1,13 @@
+class Rad::Controller::Abstract::Responder < BasicObject
+  attr_reader :handlers
+
+  def initialize
+    @handlers = {}
+  end
+
+  protected 
+    def method_missing m, *args, &block
+      args.must_be.empty
+      handlers[m.to_s] = block || lambda{} #.must_be.defined
+    end
+end

data/lib/rad/controller/_abstract.rb

@@ -0,0 +1,37 @@
+module Rad::Controller::Abstract
+  inherit Rad::Filters
+  inherit Rad::Controller::Abstract::Render, Rad::Controller::Abstract::Micelaneous
+
+  inject workspace: :workspace, logger: :logger
+
+  def params
+    workspace.params
+  end    
+
+  # def response
+  #   workspace.response
+  # end
+
+  module ClassMethods
+    inject workspace: :workspace, logger: :logger
+  
+    def controller_name      
+      self.namespace ? "#{self.namespace.name}::#{self.alias}" : self.alias     
+    end      
+
+    def helper *args
+      args.to_a.each do |mod| 
+        mod.must_be.a Module
+        context_class.inherit mod
+      end 
+    end
+  
+    def helper_method *args
+      args = args.first if args.size == 1 and args.first.is_a?(Array)
+      # args.each{|m| m.to_s.must_be.in self.instance_methods}
+      args.each do |m|          
+        context_class.delegate m, to: :controller
+      end      
+    end
+  end    
+end

data/lib/rad/controller/_context.rb

@@ -0,0 +1,15 @@
+class Rad::Controller::Context < Rad::Template::Context
+  attr_reader :controller
+  def initialize instance_variables, controller
+    super instance_variables
+    @controller = controller
+  end
+
+  def controller_name
+    @controller_name #workspace.controller.class.controller_name
+  end
+
+  def action_name
+    @action_name #workspace.action.to_sym
+  end
+end

data/lib/rad/controller/_http.rb

@@ -0,0 +1,50 @@
+module Rad::Controller::Http
+  inherit Rad::Controller::Abstract
+
+  # def response
+  #   workspace.response
+  # end
+
+  protected
+    def render_with_parsed_arguments options, original_args                 
+      response = workspace.response
+      response.set!(
+        status: options[:status] || :ok, 
+        content_type: options[:content_type] || Mime[params.format]
+      )
+    
+      if original_args.size == 1 and (status = Rad::Http::Response.decode_status_message(original_args.first))          
+        response.set! status: status
+        throw :halt, ""
+      elsif options[:location]
+        redirect_to options[:location]
+      else          
+        super
+      end
+    end
+
+  module ClassMethods      
+    inheritable_accessor :actions_allowed_for_get_request, []
+  
+    def allow_get_for *methods
+      methods = methods.first if methods.first.is_a? Array
+      
+      enable_protection_from_get_requests!        
+      actions_allowed_for_get_request.push *(methods.collect(&:to_sym))
+    end
+  
+    private
+      def enable_protection_from_get_requests!
+        unless respond_to? :protect_from_get_request
+          define_method :protect_from_get_request do                              
+            request = workspace.request
+            get = !(request.post? or request.put? or request.delete?)                
+            if get and !self.class.actions_allowed_for_get_request.include?(workspace.action)
+              raise "GET request not allowed for :#{workspace.action} action!"
+            end            
+          end
+          before :protect_from_get_request
+        end
+      end
+  end
+end

data/lib/rad/controller/_require.rb

@@ -0,0 +1,19 @@
+# 
+# Libraries
+# 
+class Rad::Controller
+  attr_accessor :development_error_template, :production_error_template, :test_error_template
+  
+  module Abstract
+  end
+end
+
+%w(    
+  _abstract/render
+  _abstract/responder
+  _abstract/micelaneous   
+  _abstract
+  _context
+  
+  _http
+).each{|f| require "rad/controller/#{f}"}

data/lib/rad/controller/abstract.rb

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

data/lib/rad/controller/context.rb

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

data/lib/rad/controller/http.rb

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

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

@@ -1,28 +1,26 @@
-module Rad
-  module Processors    
-    class ControllerCaller < Processor
-      def call                
-        # prepare
-        response = workspace.response.must_be.defined
-        klass = workspace.class.must_be.present
-        raise "The controller class #{klass} must be a Rad::AbstractController!" unless klass.is? Rad::AbstractController
-        controller = workspace.controller = klass.new                  
-        action = workspace.action = workspace.method_name
-        format = workspace.params.format
+rad.controller
 
-        # call
-        
-        workspace.content = catch :halt_render do
-          controller.run_callbacks :action, method: action do          
-            # call controller
-            controller.send action
+class ControllerCaller < Rad::Conveyors::Processor
+  def call                
+    # prepare
+    response = workspace.response.must_be.defined
+    klass = workspace.class.must_be.present
+    raise "The controller class #{klass} must be a Rad::Controller::Abstract!" unless klass.is? Rad::Controller::Abstract
+    controller = workspace.controller = klass.new                  
+    action = workspace.action = workspace.method_name
+    format = workspace.params.format
 
-            # render view
-            controller.render action: action
-          end
-        end
-      end          
+    # call
     
-    end    
-  end
+    workspace.content = catch :halt do
+      controller.run_callbacks :action, method: action do          
+        # call controller
+        controller.send action
+
+        # render view
+        controller.render action: action
+      end
+    end
+  end          
+
 end

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

@@ -1,51 +1,49 @@
-module Rad
-  module Processors    
-    class ControllerErrorHandling < Processor      
-      def call                
-        workspace.response.must_be.defined
-        
-        begin
-          next_processor.call          
-        rescue StandardError => e
-          if config.test?
-            e.set_backtrace e.backtrace.sfilter(Exception.common_filters)
-            raise e
-          elsif config.production?
-            error_shown_to_user = StandardError.new "Internal error!"
-            error_shown_to_user.set_backtrace []
-          else
-            error_shown_to_user = e
-          end
-          
-          workspace.response.clear if workspace.response?
-          format = workspace.params.format
-          handler = SPECIAL_ERROR_HANDLERS[format] || DEFAULT_ERROR_HANDLER
-          workspace.content = handler.call error_shown_to_user, format
-          
-          
-          logger.error e
-          logger.info "\n"
-        end
-      end          
+rad.controller
+
+class ControllerErrorHandling < Rad::Conveyors::Processor      
+  def call                
+    workspace.response.must_be.defined
     
-      SPECIAL_ERROR_HANDLERS = {
-        'json' => lambda{|e, format| 
-          {error: e.message}.to_json
-        }
-      }
+    begin
+      next_processor.call          
+    rescue StandardError => e
+      if rad.test?
+        e.set_backtrace e.backtrace.sfilter(Exception.filters)
+        raise e
+      elsif rad.production?
+        error_shown_to_user = StandardError.new "Internal error!"
+        error_shown_to_user.set_backtrace []
+      else
+        error_shown_to_user = e
+      end
       
-      DEFAULT_ERROR_HANDLER = lambda{|e, format|
-        tname = rad.config["#{rad.config.environment!}_error_template", nil]
-        
-        if tname and Template.exist?(tname, format: format, exact_format: true)
-          data = Template.render(tname, 
-            format: format,               
-            locals: {error: e}
-          )
-        else
-          e.message
-        end
-      }
-    end    
-  end
+      workspace.response.clear if workspace.response?
+      format = workspace.params.format
+      handler = SPECIAL_ERROR_HANDLERS[format] || DEFAULT_ERROR_HANDLER
+      workspace.content = handler.call error_shown_to_user, format
+      
+      
+      logger.error e
+      logger.info "\n"
+    end
+  end          
+
+  SPECIAL_ERROR_HANDLERS = {
+    'json' => lambda{|e, format| 
+      {error: e.message}.to_json
+    }
+  }
+  
+  DEFAULT_ERROR_HANDLER = lambda{|e, format|       
+    tname = rad.controller.send("#{rad.mode}_error_template")
+    
+    if tname and rad.template.exist?(tname, format: format, exact_format: true)
+      data = rad.template.render(tname, 
+        format: format,               
+        locals: {error: e}
+      )
+    else
+      e.message
+    end
+  }
 end