rad_core 0.2.6 → 0.2.7

data/lib/rad/router/_router.rb

@@ -1,41 +1,41 @@
 class Rad::Router
   inject workspace: :workspace
-  
+
   attr_reader :routers, :format_processor
   attr_accessor :default_path, :default_method
 
   def initialize (
-    class_variable = :class, 
-    routers = [[:default_router, Rad::Router::SimpleRouter.new]], 
+    class_variable = :class,
+    routers = [[:default_router, Rad::Router::SimpleRouter.new]],
     format_processor = Rad::Router::DefaultFormatProcessor.new
   )
-    @class_variable, @format_processor = class_variable, format_processor    
+    @class_variable, @format_processor = class_variable, format_processor
     self.routers = routers
-  end        
-  
+  end
+
   def routers= routers
     @routers = {}
-    routers.each do |k, v| 
+    routers.each do |k, v|
       k.must_be.present
-      v.must_be.present        
+      v.must_be.present
       v.must.respond_to(:decode)
       v.must.respond_to(:encode)
-      
+
       self.routers[k] = v
     end
   end
-  
-  def url_for *args      
+
+  def url_for *args
     if args.first.is_a?(Class)
       args.size.must_be.in 2..3
       klass, method, options = args
-      url_for_class(klass, method, (options || {}))        
+      url_for_class(klass, method, (options || {}))
     else
       first = args.first.to_s
       if first =~ /^\//
         args.size.must_be.in 1..2
         path, options = args
-        url_for_path(path, (options || {}))  
+        url_for_path(path, (options || {}))
       # elsif full_url? first
       #   args.size.must == 1
       #   return first
@@ -53,80 +53,80 @@ class Rad::Router
 
   def decode path, params
     path.first.must == '/'
-    # params = params.to_openobject      
-    
+    # params = params.to_openobject
+
     path, format = format_processor.remove_format path if format_processor
-    
+
     result = nil
-    routers.each do |name, route|      
+    routers.each do |name, route|
       result = route.decode path, params
-      break if result         
+      break if result
     end
 
     raise "no route for '#{safe_workspace.path}' request!" unless result
-          
+
     klass, method, params = result
-    method ||= default_method      
+    method ||= default_method
     params.must_be.defined
     method.must_be.a Symbol
-        
+
     raise "invalid route! No method '#{method}' for #{klass}!" unless klass.instance_methods.include? method
     raise "invalid route! You try to call protected method '#{method}' for '#{path}'!" unless klass.public_instance_methods.include? method
 
     return klass, method, params
   end
-  
+
   def encode klass, method, params = {}
     klass.must_be.defined
     method.must_be.a Symbol
     params = params.clone
     # method, params = method, params.to_openobject
-    
+
     format = params.delete(:format)
-    
+
     # raise "Invalid route! No method '#{method}' for #{klass}!" unless klass.method_defined? method
     # raise "Invalid route! You try to call protected method '#{method}' for '#{klass}'!" unless klass.method_defined? method
-    
+
     inject_persistent_params! params
-    
+
     result = nil
-    routers.each do |name, route|      
+    routers.each do |name, route|
       result = route.encode klass, method, params
       break if result
     end
-    
+
     raise "no route for '#{klass}.#{method}'!" unless result
-    
+
     path, params = result
     path.must_be.defined
     params.must_be.defined
-    
+
     path = format_processor.add_format path, format if format_processor and format
 
     return path, params
   end
-  
+
   def encode_method route_method, has_id
     # method = method
-    route_method.must_be.present      
-    
+    route_method.must_be.present
+
     result = nil
-    routers.each do |name, route|        
+    routers.each do |name, route|
       result = route.respond_to :encode_method, route_method, has_id
       break if result
     end
 
     raise "no route for '#{route_method}' route method!" unless result
-    
+
     klass, method = result
     klass.must_be.defined
     method.must_be.defined
     method.must =~ /^[_a-zA-Z0-9]+$/
-    
+
     return [klass, method]
   end
   cache_method_with_params_in_production :encode_method
-  
+
   def persist_params &block
     if block
       before = safe_workspace.persist_params?
@@ -154,90 +154,90 @@ class Rad::Router
       safe_workspace.delete :persist_params
     end
   end
-  
+
   def persist_params?
     safe_workspace.persist_params?
   end
-  
+
   def persistent_params; @persistent_params ||= [] end
-  
+
   def url_for_path path, params
     # if full_url? path
     #   params.must_be.blank
     #   return path
     # end
-    
+
     # params = params.to_openobject
-    
-    
+
+
     # url_root = params.include?(:url_root) ? params.delete(:url_root) : config.url_root!
     # if !url_root or url_root == '/'
     #   url = path.clone
     # else
     #   url = url_root + path
     # end
-    
+
     # url_root
     url_root = params.delete(:url_root)
     url = (url_root && url_root != '/') ? url_root + path : path.clone
 
     # host port
     host, port = params.delete(:host), params.delete(:port)
-    format = params.delete(:format)            
-    
+    format = params.delete(:format)
+
     # json
     params = {json: params.to_json} if params.delete :as_json #and !params.empty?
-    
+
     # format
     if format
       params[:format] = format
       url.marks.format = format.to_s
     end
-    
+
     # Delete 'nil' parameters
     to_delete = []
     params.each{|k, v| to_delete << k if v.nil?}
     to_delete.each{|k| params.delete k}
-    
+
     # build url
     delimiter = path.include?('?') ? '&' : '?'
     url << "#{delimiter}#{params.to_query}" unless params.empty?
-    
+
     if host.blank?
       url
     else
       %{http://#{host}#{":#{port}" unless port.blank?}#{url}}
     end
   end
-  
+
   def url_for_class klass, method, params
     klass ||= current_class
     # params = params.to_openobject
-    
+
     # special params
     format = params[:format]
-    
+
     path, params = encode klass, method, params
-    url = url_for_path path, params  
+    url = url_for_path path, params
 
     url.marks.format = format.to_s if format
 
     url
   end
-  
-  
-  # 
+
+
+  #
   # public helpers for :router component
-  # 
+  #
   delegate :configure, to: Rad::Router::Configurator
-  
+
   protected
     # def full_url? url
     #   url =~ /[a-z0-9]+:\/\//
     # end
-    
-    # sometimes we need access to routers outside of conveyor :cycle, 
-    # for example in spec routing helpers, in that case we just ignore workspace and it's variables
+
+    # sometimes we need access to routers outside of conveyor :cycle,
+    # for example in spec routing helpers, in that case we just ignore workspace and its variables
     def safe_workspace
       if rad.active? :cycle
         workspace
@@ -245,50 +245,50 @@ class Rad::Router
         Rad::Conveyors::Workspace.new
       end
     end
-  
-    def current_class; safe_workspace[@class_variable] end              
-    
+
+    def current_class; safe_workspace[@class_variable] end
+
     DONOT_PERSIST = [:_, :_method, :_target]
-    
+
     def inject_persistent_params! params
       persist = params.delete(:persist)
-      
+
       # global persistent params
       unless cached_global_persistend_params = safe_workspace.cached_global_persistend_params
         cached_global_persistend_params, workspace_params = {}, safe_workspace.params
         if workspace_params
           persistent_params.collect!{|k| k}
-    
-          workspace_params.each do |k, v|                    
+
+          workspace_params.each do |k, v|
             cached_global_persistend_params[k] = v if persistent_params.include?(k)
           end
-      
+
           safe_workspace.cached_global_persistend_params = cached_global_persistend_params
         end
       end
-    
+
       cached_global_persistend_params.each do |k, v|
         params[k] = v unless params.include? k
       end
-    
+
       # underscored persistent params
       if persist_params?
-        unless cached_persistend_params = safe_workspace.cached_persistend_params        
+        unless cached_persistend_params = safe_workspace.cached_persistend_params
           cached_persistend_params, workspace_params = {}, safe_workspace.params
-          
+
           if workspace_params
             workspace_params.each do |k, v|
               cached_persistend_params[k] = v if (k =~ /^_/) and !DONOT_PERSIST.include?(k)
             end
-      
+
             safe_workspace.cached_persistend_params = cached_persistend_params
           end
         end
-    
+
         cached_persistend_params.each do |k, v|
           params[k] = v unless params.include? k
         end
-      end          
+      end
     end
-    
+
 end

data/lib/rad/router/_simple_router.rb

@@ -1,8 +1,8 @@
-class Rad::Router::SimpleRouter    
+class Rad::Router::SimpleRouter
   inject logger: :logger
 
   def encode klass, method, params
-    path = "/#{klass.name.underscore}/#{method}"      
+    path = "/#{klass.name.underscore}/#{method}"
     return path, params
   end
 
@@ -10,11 +10,11 @@ class Rad::Router::SimpleRouter
     parts = path[1..-1].split '/'
     if parts.size >= 2
       method = parts.pop.to_sym
-    
+
       class_path = parts.join('/')
-      class_name = class_path.camelize        
+      class_name = class_path.camelize
       klass = class_name.constantize
-                    
+
       return klass, method, params
     end
   end

data/lib/rad/router/processors/router.rb

@@ -2,22 +2,22 @@ rad.router
 
 class Router < Rad::Conveyors::Processor
   inject router: :router
-  
+
   def initialize next_processor, class_variable = :class, method_variable = :method
     super(next_processor)
     @class_variable, @method_variable = class_variable, method_variable
   end
-  
+
   def call
     halt = catch :halt do
-      if workspace[@class_variable].blank? or workspace[@method_variable].blank?        
-        klass, method, params = router.decode workspace.path, workspace.params        
+      if workspace[@class_variable].blank? or workspace[@method_variable].blank?
+        klass, method, params = router.decode workspace.path, workspace.params
         workspace[@class_variable], workspace[@method_variable], workspace.params = klass, method, params
       end
-      
+
       nil
     end
-    
+
     next_processor.call unless halt
   end
 end

data/lib/rad/spec/controller.rb

@@ -6,35 +6,35 @@ end
 
 rspec do
   attr_accessor :response, :workspace
-  
+
   def ccall klass, method, params = {}, workspace_variables = {}, &block
     self.response = Rad::Http::Response.new
     workspace_variables = {
       class: klass, method_name: method, params: Rad::Conveyors::Params.new(params), response: response
     }.merge(workspace_variables)
-    
-    if block            
+
+    if block
       rad.conveyors.web.call workspace_variables do |c|
         self.workspace = rad.workspace
-                
+
         block.call c
       end
-    else                  
+    else
       self.workspace = rad.conveyors.web.call workspace_variables
     end
-    
+
     if klass and klass.name =~ /Http/
       response.content_type.must_be.present
       response.status.must_be.present
     end
-    
+
     workspace.content
   end
-  
+
   def self.with_abstract_controller
     before do
       rad.controller
-            
+
       rad.conveyors.web do |web|
         web.use Rad::Controller::Processors::ControllerCaller
       end

data/lib/rad/spec/environment.rb

@@ -9,27 +9,27 @@ rspec do
   def self.isolate *args
     options = args.extract_options!
     scope = options[:before] || :each
-    components = args.first.is_a?(Array) ? args.first : args    
-    
+    components = args.first.is_a?(Array) ? args.first : args
+
     old = {}
     before :all do
-      components.each do |name|      
-        old[name] = rad[name]      
+      components.each do |name|
+        old[name] = rad[name]
       end
     end
-    
+
     before scope do
       components.each do |name|
         rad[name] = old[name].deep_clone
       end
     end
-    
+
     after scope do
       components.each do |name|
         rad[name] = old[name].deep_clone
       end
     end
   end
-  
+
   inject environment: :environment, logger: :logger
 end