rad_core 0.0.13 → 0.0.14

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

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

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

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

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

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

@@ -1,48 +0,0 @@
-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/conveyor/conveyor.rb

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

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

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

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

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

data/lib/rad/conveyor/workspace.rb

@@ -1,36 +0,0 @@
-module Rad
-  class Workspace < OpenObject
-    def params
-      self[:params] || 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? Params
-        set_without_params :params, v
-      else
-        set_without_params :params, 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  
-end

data/lib/rad/conveyor.rb

@@ -1,29 +0,0 @@
-# Conveyor is the heart of Rad, it allows for Processors to process request and build responce.
-
-require 'rad/environment'
-
-[
-  # 'config',
-  'params',
-  'workspace',
-  'processor',
-  'conveyor',
-  'conveyors',
-  'processors/conveyor_logger',
-].each{|f| require "rad/conveyor/#{f}"}
-
-Rad.metaclass_eval do
-  inject conveyors: :conveyors
-end
-
-# 
-# Initializations
-# 
-rad do
-  register :workspace, scope: :cycle, depends_on: :environment
-  register :conveyors, depends_on: :environment do
-    Rad::Conveyors.new
-  end
-end
-
-Rad::Config::DEFAULTS[:show_exceptions] = false