rad_core 0.0.13

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake_ext'
+
+project(
+  name: 'rad_core',
+  version: '0.0.13',
+  summary: 'Ruby Web Framework',
+
+  author: 'Alexey Petrushin',
+  homepage: 'http://github.com/alexeypetrushin/rad_core'
+)

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

@@ -0,0 +1,31 @@
+module Rad
+  module AbstractController
+    module Micelaneous
+      # 
+      # respond_to
+      # 
+      def respond_to &block
+        @_responder.must_be.nil
+        @_responder = 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
+  end
+end

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

@@ -0,0 +1,160 @@
+module Rad
+  module AbstractController
+    module Render
+      SPECIAL_FORMAT_HANDLERS = {
+        json: lambda{|o| o.to_json},
+        xml: lambda{|o| o.to_xml},
+        js: lambda{|o| o},        
+      }
+      
+      # SPECIAL_CASES_HANDLERS = [
+      #   ['inline', lambda{|o| o}],
+      # ]
+      
+      def _layout tname = nil        
+        if tname
+          @_layout = tname
+        else          
+          @_layout
+        end
+      end
+      def _layout= layout
+        @_layout = layout
+      end
+      
+      def render *args        
+        options = Template.parse_arguments *args
+        content = render_with_parsed_arguments options, args
+        throw :halt_render, content
+      end
+      
+      protected
+        def render_action options        
+          options = options.to_openobject
+          options.format ||= params.format
+
+          render_options = {
+            context_class: self.class.controller_context_class,
+            format: params.format,
+            action: true # this willn't allow to render partial starting with _          
+          }.to_openobject
+
+          # rendering content
+          content, context = render_content render_options, options
+
+          render_options.merge!(
+            content: content,
+            context: context
+          )
+
+          # rendering layout
+          render_layout render_options, options
+        end
+      
+        def render_layout render_options, options          
+          layout = options.include?(:layout) ? options.layout : self._layout
+          if layout
+            Template.render_layout layout, render_options
+          else
+            render_options.content
+          end
+        end
+      
+        def render_content render_options, options          
+          template = options.template || self.class.template_name_for(options.action, options)            
+          template = '/rad_default_templates/blank_template' unless Template.exist? template, format: options.format
+          
+          instance_variables = {}
+          instance_variable_names.each do |name|
+            instance_variables[name[1..-1]] = instance_variable_get name unless name =~ /^@_/
+          end
+          
+          instance_variables.merge!(
+            action_name: (options.action || workspace.action).to_sym,
+            controller_name: self.class.controller_name
+          )
+
+          render_options.merge!(             
+            template: template,
+            instance_variables: instance_variables                
+          )
+
+          content, context = Template.basic_render render_options              
+          return content, context
+        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 special_format_handler = SPECIAL_CASES_HANDLERS.find{|key, handler| options.include? key}
+          #   key, handler = special_format_handler
+          #   handler.call options[key]
+          else                        
+            render_action options
+            # Template.basic_render(options).first
+          end
+        end
+        
+        
+      
+      module ClassMethods
+        def layout layout, options = {}
+          before options do |controller|
+            controller._layout = layout
+          end
+        end
+        
+        def template_name_for action, options = {}
+          action.must_be.a Symbol
+
+          return _template_name_for(action, options) if config.development?
+
+          @template_name_for ||= {}          
+
+          key = %(#{action}#{":#{options[:format]}" if options[:format]})
+          unless tname = @template_name_for[key]          
+            tname = _template_name_for(action, options)
+            @template_name_for[key] = tname
+          end
+
+          tname
+        end    
+
+        protected
+          def _template_name_for action, options = {}
+            # instance_methods.must.include(action)
+            own_tnames = [
+              "/#{controller_name.gsub('::', '/')}/#{action}",
+              "/#{controller_name.underscore}/#{action}"
+            ]          
+
+            own_actions_tnames = [
+              "/#{controller_name.gsub('::', '/')}/actions",
+              "/#{controller_name.underscore}/actions"
+            ]
+
+            action_template_exist = lambda do |tname| 
+              Rad::Template.exist?(tname) and
+                (Rad::Template.read(tname) =~ /^.*when.+[^_a-zA-Z0-9]#{action}[^_a-zA-Z0-9].*$/)
+            end
+            
+            if existing_template = own_tnames.find{|tname| Rad::Template.exist?(tname, format: options[:format])}
+              existing_template
+            elsif existing_action_template = own_actions_tnames.find(&action_template_exist)
+              existing_action_template
+            elsif parent = ancestors[1..-1].find{|a| a.respond_to?(:template_name_for) and a.instance_methods.include?(action)}
+              parent.template_name_for(action, options)
+            else
+              own_tnames.first
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Rad
+  module AbstractController
+    class 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.must_be.defined
+        end
+    end
+  end
+end

data/lib/rad/controller/abstract_controller.rb

@@ -0,0 +1,64 @@
+module Rad
+  module AbstractController
+    inherit Filters
+    inherit AbstractController::Render, AbstractController::Micelaneous
+    
+    inject(
+      workspace: :workspace,
+      logger: :logger,
+      config: :config
+    )
+    
+    def params
+      workspace.params
+    end    
+    
+    # def response
+    #   workspace.response
+    # end
+    
+    module ClassMethods
+      inject(
+        workspace: :workspace,
+        logger: :logger,
+        config: :config
+      )
+      
+      def controller_name
+        self.namespace ? "#{self.namespace.name}::#{self.alias}" : self.alias        
+      end
+      
+      def controller_context_class
+        unless @controller_context_class
+          parent_context_class = nil
+          ancestors[1..-1].each do |anc|            
+            break if parent_context_class = anc.respond_to(:controller_context_class)
+          end
+          parent_context_class ||= Rad::ControllerContext
+
+          class_name = "#{self.name}::#{self.name.split('::').last}ControllerContext"
+
+          # 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__
+          @controller_context_class = class_name.constantize
+        end
+        @controller_context_class
+      end
+
+      def helper *args
+        args.to_a.each do |mod| 
+          mod.must_be.a Module
+          controller_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|          
+          controller_context_class.delegate m, to: :controller
+        end      
+      end
+    end    
+  end
+end

data/lib/rad/controller/controller_context.rb

@@ -0,0 +1,15 @@
+module Rad
+  class ControllerContext < TemplateContext
+    def controller
+      workspace.controller.must_be.defined
+    end    
+    
+    def controller_name
+      @controller_name #workspace.controller.class.controller_name
+    end
+    
+    def action_name
+      @action_name #workspace.action.to_sym
+    end
+  end
+end

data/lib/rad/controller/http_controller.rb

@@ -0,0 +1,48 @@
+module Rad
+  module HttpController
+    inherit AbstractController
+    
+    # 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::Response.decode_status_message(original_args.first))          
+          response.set! status: status
+          throw :halt_render, ""
+        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
+        enable_protection_from_get_requests!        
+        actions_allowed_for_get_request.push *methods
+      end
+      
+      private
+        def enable_protection_from_get_requests!
+          unless respond_to? :protect_from_get_request
+            define_method :protect_from_get_request do
+              if workspace.request.get? and !self.class.actions_allowed_for_get_request.include?(workspace.action)
+                raise "Get requests not allowed for :#{workspace.action} action!"
+              end            
+            end
+            before :protect_from_get_request
+          end
+        end
+    end
+  end
+end    

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

@@ -0,0 +1,28 @@
+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
+
+        # call
+        
+        workspace.content = catch :halt_render do
+          controller.run_callbacks :action, method: action do          
+            # call controller
+            controller.send action
+
+            # render view
+            controller.render action: action
+          end
+        end
+      end          
+    
+    end    
+  end
+end

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

@@ -0,0 +1,51 @@
+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          
+    
+      SPECIAL_ERROR_HANDLERS = {
+        'json' => lambda{|e, format| 
+          {error: e.message}.to_json
+        }
+      }
+      
+      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
+end

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

@@ -0,0 +1,12 @@
+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
+    end
+  end
+end

data/lib/rad/controller.rb

@@ -0,0 +1,28 @@
+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'

data/lib/rad/conveyor/conveyor.rb

@@ -0,0 +1,74 @@
+module Rad
+  class 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
+      
+      rad.activate :cycle, {} do        
+        self.workspace = Workspace.new
+        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
+end

data/lib/rad/conveyor/conveyors.rb

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

data/lib/rad/conveyor/params.rb

@@ -0,0 +1,14 @@
+module Rad
+  class Params < OpenObject
+    # include OpenConstructor
+    
+    def initialize h = nil      
+      update h if h
+    end
+        
+    def inspect      
+      h = to_h
+      h.inspect
+    end    
+  end
+end

data/lib/rad/conveyor/processor.rb

@@ -0,0 +1,68 @@
+module Rad  
+  class Processor
+    inject(
+      config: :config,
+      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
+end
+#       
+#     # def call            
+#     #   if workspace.error?
+#     #     respond_to :on_error
+#     #   else
+#     #     begin
+#     #       trace self.inspect do
+#     #         respond_to :process
+#     #       end
+#     #     rescue Exception => e
+#     #       workspace.error = e
+#     #       respond_to :on_error          
+#     #     end
+#     #   end
+#     # end
+#     
+#     
+#     
+#     # 
+#     # Unwrapping Call Stack
+#     # 
+#     def result_error= error
+#       @result_error = error
+#     end
+#     
+#     def result!
+#       @result_called.must_be.false
+#       @result_called = true
+#       raise @result_error if @result_error      
+#     end
+#     
+#     def result_called?      
+#       @result_called
+#     end
+#     attr_writer :result_called
+# 
+#     attr_accessor :after_block
+#     def after &block
+#       # @after_called.must_be.false
+#       @after_block = block.must_be.defined
+#       # @after_called = true
+#     end
+#     
+#     # def after_called?
+#     #   @after_called
+#     # end
+#     
+#   end
+# end

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

@@ -0,0 +1,25 @@
+module Rad
+  module Processors
+    class ConveyorLogger < 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 "  Completed in #{((Time.now - start_time) * 1000).round} ms\n\n"
+          # end
+        rescue StandardError => e
+          raise e if config.test?
+            
+          logger.error e
+          logger.info "\n"
+        end
+      end
+    end
+  end
+end