rad_core 0.0.13 → 0.0.14

data/lib/rad/router/_object_router.rb

@@ -0,0 +1,184 @@
+class Rad::Router::ObjectRouter
+  include Rad::Router::AbstractRouter      
+
+  def initialize
+    self.class_to_resource = -> klass      {raise ':class_to_resource not specified!'}
+    self.resource_to_class = -> resource   {raise ':resource_to_class not specified!'}
+    self.id_to_class       = -> id, params {raise ':id_to_class not specified!'}
+    
+    self.default_class_method = :all
+    self.default_object_method    = :show
+    
+    @cached_class_to_resource, @cached_resource_to_class = {}, {}
+  end
+
+  def configure options = {}
+    raise "can't configure ObjectRouter twice!" if configured?
+    self.configured = true
+    
+    # parsing options
+    options.validate_options! :default_class_name, :class_to_resource, :resource_to_class, :id_to_class, :url_root, :prefix
+    
+    self.default_class_name     = options[:default_class_name] || raise(':default_class_name not provided!')
+    
+    self.class_to_resource = options[:class_to_resource] if options.include? :class_to_resource
+    self.resource_to_class = options[:resource_to_class] if options.include? :resource_to_class
+    self.id_to_class       = options[:id_to_class]       if options.include? :id_to_class
+    
+    self.url_root = parse_url_root options
+    self.prefix   = parse_prefix options
+  end
+
+  def encode klass, method, params
+    return nil unless configured?
+    
+    id = params[:id]                
+    
+    # id and resource
+    path = if id
+      raise ":id can be used with :default_class only (#{klass}, '#{id}')!" if klass != default_class
+      
+      params.delete :id
+      raise ":id must not start from capital letter ('#{id}')!" if id =~ /^[A-Z]/                    
+      
+      path = if !method or method == default_object_method
+        "/#{id}"
+      else
+        "/#{id}/#{method}"
+      end
+    else          
+      resource = cached_class_to_resource klass                            
+      raise "no resource for #{klass}!" unless resource                              
+      raise "resource must start from capital letter (class: #{klass}, resource: '#{resource}')!" unless resource =~ /^[A-Z]/
+
+      path = if !method or method == default_class_method
+        "/#{resource}"
+      else
+        "/#{resource}/#{method}"
+      end          
+    end
+    
+    # prefix
+    path = encode_prefix_params! path, params, prefix if prefix
+  
+    # url_root
+    params[:url_root] = url_root if url_root
+  
+    [path, params]
+  end
+
+  def decode path, params        
+    return nil unless configured?
+    
+    parts = path[1..-1].split('/')
+
+    # checking 'size' of path
+    extra_size = (prefix ? prefix.size : 0) + (url_root ? 1 : 0)
+    valid_range = (1 + extra_size)..(2 + extra_size)
+    raise "invalid 'size' of path, must be in #{valid_range}!" unless valid_range.include? parts.size
+
+    # url_root
+    if url_root
+      raise "invalid :url_root ('/#{parts.first}' should be equal to '#{url_root}')!" unless "/#{parts.first}" == url_root
+      parts.shift
+    end
+
+    # prefix
+    decode_prefix_params! parts, params, prefix if prefix
+
+    # id, resource and method
+    if parts.first =~ /^[A-Z]/
+      resource, method = parts
+      method ||= default_class_method                              
+      method = method.to_sym
+      
+      raise "resource must be in plural form ('#{resource}')!" unless resource.pluralize == resource
+      
+      klass = cached_resource_to_class resource                    
+      
+      raise "no class for '#{resource}' resource!" unless klass
+    else
+      id, method = parts
+
+      method ||= default_object_method
+      method = method.to_sym
+
+      # sometimes we need params inside of :id_to_class block, 
+      # for example to find out Space before finding Item
+      klass = id_to_class.call id, params
+      
+      raise "no class for '#{id}' id!" unless klass
+      
+      params[:id] = id
+    end            
+
+    klass.must_be.a Class
+    return klass, method, params
+  end  
+      
+  def encode_method route_method, has_id        
+    return nil unless configured?
+    
+    token = route_method.sub(/_?path$/, '')
+
+    if has_id
+      method = token.empty? ? default_object_method : token
+      method = method.to_sym
+                
+      return [default_class, method]
+    else
+      token = route_method.sub(/_path$/, '')
+      parts = token.split '_'
+      resource = parts.pop
+      method = parts.empty? ? default_class_method : parts.join('_')
+      
+      # class
+      resource = resource.pluralize.camelize
+      klass = cached_resource_to_class resource
+      raise "no class for '#{resource}' resource!" unless klass
+      klass.must_be.a Class
+
+      # method
+      method = method.to_sym if method
+                
+      return [klass, method]
+    end
+  end
+
+  protected
+    attr_accessor :class_to_resource, :resource_to_class, :id_to_class, :default_class_method, :default_object_method,
+      :prefix, :url_root, :configured, :default_class_name
+      
+    def default_class
+      @default_class ||= default_class_name.constantize
+    end
+      
+    def configured?; !!@configured end
+    
+    def cached_class_to_resource klass
+      unless @cached_class_to_resource.include? klass
+        resource = class_to_resource.call klass
+        resource.must_not =~ /\//
+        raise 'resource name must be in plural form' unless resource.pluralize == resource
+        @cached_class_to_resource[klass] = resource
+      end
+      @cached_class_to_resource[klass]
+    end
+    
+    def cached_resource_to_class resource
+      unless @cached_resource_to_class.include? resource
+        klass = resource_to_class.call resource
+        @cached_resource_to_class[resource] = klass
+      end
+      @cached_resource_to_class[resource]
+    end
+end
+
+      
+Rad::Router::Configurator.class_eval do
+  def objects *args, &block
+    object_router = @router.routers[:object_router]        
+    raise "There's no ObjectRouter (use config to add it)!" unless object_router        
+    object_router.configure *args, &block
+  end
+end

data/lib/rad/router/_require.rb

@@ -0,0 +1,31 @@
+class Rad::Router
+end
+
+# 
+# Libraries
+# 
+%w(
+  _configurator
+  _simple_router
+  _router
+  _default_format_processor  
+  
+  _core_routing_helper
+).each{|f| require "rad/router/#{f}"}
+
+
+# 
+# Routers
+# 
+%w(
+  _abstract_router
+  _basic_router
+  _alias_router
+  _restful_router
+  _object_router  
+).each{|f| require "rad/router/#{f}"}
+
+
+# 
+# Helpers
+#

data/lib/rad/router/_restful_router.rb

@@ -0,0 +1,124 @@
+class Rad::Router::RestfulRouter
+  include Rad::Router::AbstractRouter
+
+  def initialize
+    @resources, @class_names = {}, {}
+  end
+
+  def add resource, options = {}
+    # parsing options
+    options.validate_options! :class_name, :url_root, :prefix
+    resource = resource.to_s
+    resource.must_not =~ /\//      
+    raise "resource should be in plural form!" unless resource.pluralize == resource
+    class_name = options.delete(:class_name) || raise("no class name!")
+    class_name.must_be.a String
+    url_root = parse_url_root options
+    prefix = parse_prefix options
+  
+    # logic
+    meta = Meta.new
+    meta.merge!(
+      class_name: class_name, 
+      resource: resource, 
+      url_root: url_root, 
+      prefix: prefix
+    )        
+              
+    resources.must_not.include(resource.pluralize)
+    class_names.must_not.include(class_name)      
+    resources[resource.pluralize] = meta
+    resources[resource.singularize] = meta
+    class_names[class_name] = meta
+  end
+
+  def encode klass, method, params
+    meta = class_names[klass.name]
+    return nil unless meta
+  
+    path = if id = params.delete(:id)
+      "/#{meta[:resource]}/#{id}/#{method}"
+    else
+      "/#{meta[:resource]}/#{method}"
+    end
+
+    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
+    
+    [path, params]
+  end
+
+  def decode path, params
+    decode_as_object_resource(path, params) || decode_as_static_resource(path, params)
+  end  
+
+  def encode_method route_method, has_id
+    token = route_method.sub(/_path$/, '')
+
+    resources.each do |name, meta|
+      if i = token.rindex(name)
+        route_method.size == i + name.size and route_method[(i-1)..(i-1)] == '_'
+        return meta.get_class, route_method[0..(i-2)].to_sym
+      end
+    end
+  
+    return nil
+  end
+
+  protected
+    attr_accessor :resources, :class_names
+  
+    def decode_as_object_resource path, params
+      parts = path[1..-1].split('/')
+      return nil unless parts.size >= 3
+    
+      method, id, resource = parts.pop.to_sym, parts.pop, parts.pop
+      meta = resources[resource]
+      return nil unless meta
+      
+      # url_root
+      url_root = meta[:url_root]
+      return nil if url_root and "/#{parts.shift}" != url_root          
+    
+      # prefix
+      return nil if parts.size != (meta[:prefix] ? meta[:prefix].size : 0)
+      prefix = meta[:prefix]
+      decode_prefix_params! parts, params, prefix if prefix
+    
+      params[:id] = id
+
+      return meta.get_class, method, params
+    end
+  
+    def decode_as_static_resource path, params
+      parts = path[1..-1].split('/')          
+      return nil unless parts.size >= 2
+      
+      # method & class
+      method, resource = parts.pop.to_sym, parts.pop
+      meta = resources[resource]
+      return nil unless meta
+      
+      # url_root
+      url_root = meta[:url_root]
+      return nil if url_root and "/#{parts.shift}" != url_root          
+
+      # prefix
+      return nil if parts.size != (meta[:prefix] ? meta[:prefix].size : 0)
+      prefix = meta[:prefix]
+      decode_prefix_params! parts, params, prefix if prefix          
+
+      return meta.get_class, method, params
+    end
+end
+
+Rad::Router::Configurator.class_eval do
+  def resource *args, &block
+    restful_router = @router.routers[:restful_router]
+    raise "There's no RestfulRouter (use config to add it)!" unless restful_router
+    restful_router.add *args, &block
+  end
+end

data/lib/rad/router/_router.rb

@@ -0,0 +1,294 @@
+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]], 
+    format_processor = Rad::Router::DefaultFormatProcessor.new
+  )
+    @class_variable, @format_processor = class_variable, format_processor    
+    self.routers = routers
+  end        
+  
+  def routers= routers
+    @routers = Dictionary.new
+    routers.each do |k, v| 
+      k.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      
+    if args.first.is_a?(Class)
+      args.size.must_be.in 2..3
+      klass, method, options = args
+      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 || {}))  
+      # elsif full_url? first
+      #   args.size.must == 1
+      #   return first
+      elsif first =~ /^http:\/\//
+        args.size.must_be.in 1..2
+        raise "can't use option with full url (#{first})" if args.size == 2 and !args.last.blank?
+        first
+      else
+        args.size.must_be.in 1..2
+        method, options = args
+        url_for_class(nil, method, (options || {}))
+      end
+    end
+  end
+
+  def decode path, params
+    path.first.must == '/'
+    # params = params.to_openobject      
+    
+    path, format = format_processor.remove_format path if format_processor
+    
+    result = nil
+    routers.each do |name, route|      
+      result = route.decode path, params
+      break if result         
+    end
+
+    raise "no route for '#{safe_workspace.path}' request!" unless result
+          
+    klass, method, params = result
+    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|      
+      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      
+    
+    result = nil
+    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?
+      begin
+        safe_workspace[:persist_params] = true
+        block.call
+      ensure
+        safe_workspace.delete :persist_params unless before
+      end
+    else
+      safe_workspace[:persist_params] = true
+    end
+  end
+
+  def dont_persist_params &block
+    if block
+      before = safe_workspace.persist_params?
+      begin
+        safe_workspace.delete :persist_params
+        block.call
+      ensure
+        safe_workspace[:persist_params] = true if before
+      end
+    else
+      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)            
+    
+    # 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.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
+    def safe_workspace
+      if rad.active? :cycle
+        workspace
+      else
+        Rad::Conveyors::Workspace.new
+      end
+    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|                    
+            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        
+          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

data/lib/rad/router/_simple_router.rb

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

data/lib/rad/router/abstract_router.rb

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

data/lib/rad/router/alias_router.rb

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

data/lib/rad/router/configurator.rb

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

data/lib/rad/router/micelaneous_router.rb

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

data/lib/rad/router/object_router.rb

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

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

@@ -0,0 +1,23 @@
+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        
+        workspace[@class_variable], workspace[@method_variable], workspace.params = klass, method, params
+      end
+      
+      nil
+    end
+    
+    next_processor.call unless halt
+  end
+end

data/lib/rad/router/restful_router.rb

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