rad_core 0.0.13 → 0.0.14

data/lib/rad/router/core/core_routing_helper.rb

@@ -1,41 +0,0 @@
-module Rad
-  module CoreRoutingHelper
-    inject router: :router
-    
-    delegate :url_for, :url_for_path, :persist_params, :persist_params?, :dont_persist_params, to: :router 
-    
-    def default_path options = {}
-      url_for_path config.default_path!, options.merge(url_root: false)
-    end
-
-    def return_to_path options = {}
-      dont_persist_params do 
-        path = params[:_return_to] || workspace.request.session['return_to'] || config.default_path!
-        url_for_path path, options.merge(url_root: false)
-      end
-    end
-    
-    def parse_routing_arguments *args
-      params = args.extract_options!
-      raise "invalid usage!" unless args.size <= 1
-      if args.size == 1
-        raise "duplicate :id pameter!" if params.include?(:id) or params.include?('id')
-        params[:id] = args.first.to_param
-      end
-      params      
-    end
-    
-    protected
-      def method_missing m, *args, &block
-        m = m.to_s
-        if m =~ /_path$/
-          params = parse_routing_arguments(*args)
-          klass, method = router.encode_method m
-          
-          url_for klass, method, params
-        else
-          super m.to_sym, *args, &block
-        end
-      end
-  end
-end

data/lib/rad/router/core/default_format_processor.rb

@@ -1,12 +0,0 @@
-module Rad
-  class DefaultFormatProcessor
-    def add_format path, format
-      path << ".#{format}"
-      path
-    end
-    
-    def remove_format path
-      path.sub(/\.[^\.]+$/, '')
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Rad
-  module Processors
-    class Router < 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
-        skip = catch :skip 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
-        
-        if skip
-          logger.info "  Skipping '#{workspace.path}'"        
-        else
-          next_processor.call        
-        end
-      end
-    end
-  end
-end

data/lib/rad/router/core/router.rb

@@ -1,271 +0,0 @@
-module Rad
-  class Router
-    inject(
-      config: :config,
-      workspace: :workspace
-    )
-    
-    attr_reader :routes, :format_processor
-
-    def initialize class_variable, routes = {default_router: SimpleRouter.new}, format_processor = DefaultFormatProcessor.new
-      @class_variable, @format_processor = class_variable, format_processor
-      @routes = Dictionary.new
-      routes.each do |k, v| 
-        k.must_be.present
-        v.must_be.present        
-        v.must.respond_to(:decode)
-        v.must.respond_to(:encode)
-        
-        @routes[k] = v
-      end
-    end
-    
-    def skip path_regexp=nil
-      @skip ||= []
-      if path_regexp
-        path_regexp.must_be.a Regexp
-        @skip << path_regexp unless @skip.include? path_regexp
-      else
-        @skip
-      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
-          method, options = args
-          url_for_class(nil, method, (options || {}))
-        else
-          args.size.must_be.in 1..2
-          path, options = args
-          url_for_path(path, (options || {}))
-        end
-      end
-    end
-
-    def decode path, params
-      path.first.must == '/'
-      # params = params.to_openobject
-
-      throw :skip, true if skip.any?{|path_regexp| path_regexp =~ path}
-      
-      path, format = format_processor.remove_format path if format_processor
-      
-      result = nil
-      routes.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 ||= config.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
-      routes.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
-      # method = method
-      route_method.must_be.present      
-      
-      result = nil
-      routes.each do |name, route|        
-        result = route.respond_to :encode_method, route_method
-        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
-      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
-      # params = params.to_openobject
-      
-      # special params
-      url = if params.include? :url_root
-        (params.delete(:url_root) || "") + path
-      else
-        config.url_root! + path
-      end
-      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
-    
-    protected
-      # sometimes we need access to routes 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 Micon.active? :cycle
-          workspace
-        else
-          Workspace.new
-        end
-      end
-    
-      def current_class; safe_workspace[@class_variable] end              
-      
-      DONOT_PERSIST = [:_, :_method]
-      
-      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
-end

data/lib/rad/router/core/simple_router.rb

@@ -1,23 +0,0 @@
-module Rad
-  class 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
-end

data/lib/rad/router/routers/abstract_router.rb

@@ -1,62 +0,0 @@
-module Rad
-  module AbstractRouter    
-    
-    protected
-      def parse_url_root options
-        url_root = options.delete(:url_root)      
-        url_root.must =~ /^\/.+/ if url_root
-        url_root
-      end
-      
-      def parse_prefix options        
-        prefix = options.delete(:prefix)
-        if prefix
-          prefix.must_not_be.empty
-          prefix.must_be.a Array
-          prefix = prefix.collect do |item|
-            item = Array(item)                      
-            item.size.must_be.in 1..2
-            item << item.first.to_s if item.size < 2
-            item.first.must_be.a Symbol
-            item.last.must_be.a String
-            item
-          end
-        end
-        prefix
-      end
-    
-      def encode_prefix_params! path, params, meta
-        if prefix = meta[:prefix]
-          parts = []
-          prefix.each do |name, als|            
-            parts << als
-            parts << (params.delete(name) || raise("not provided :#{name} prefix!")) # TODO 3 add url_escape
-          end
-          "/#{parts.join('/')}#{path}"
-        else
-          path
-        end
-      end
-      
-      def encode_url_root! path, meta
-        if url_root = meta[:url_root]
-          "#{url_root}#{path}" 
-        else
-          path
-        end
-      end
-      
-      def decode_prefix_params! parts, params, meta
-        if prefix = meta[:prefix]
-          prefix.reverse.each do |name, als|            
-            params[name] = parts.pop || raise("not provided :#{name} prefix!")
-            raise("incorrect url for :#{name} prefix!") unless parts.pop == als
-          end          
-        end
-      end
-      
-      def decode_url_root! parts, meta
-        raise "invalid :url_root!" if meta[:url_root] and meta[:url_root] != "/#{parts.join('/')}"
-      end
-  end
-end

data/lib/rad/router/routers/alias_router.rb

@@ -1,113 +0,0 @@
-module Rad
-  class AliasRouter
-    include AbstractRouter
-    
-    class TreeHash < Hash
-      attr_accessor :meta
-    end
-        
-    def initialize
-      @route_methods, @paths, @classes = {}, TreeHash.new, {}
-    end
-    
-    def add als, options = {}
-      # parsing options      
-      # als, options = als.to_s, options.to_openobject
-      als = als.to_s
-      als.must =~ /^\//
-      klass = options.delete(:class) || raise("no class!")
-      method = options.delete(:method) || raise("no method!")
-      method = method.must_be.a Symbol      
-      url_root = parse_url_root options
-      prefix = parse_prefix options
-      raise "unknown options :#{options.to_h.keys.join(': ')}!" unless options.empty?
-      raise "you can't use '/' alias with :url_root!" if als == '/' and url_root
-      
-      # logic      
-      meta = {
-        class: klass,
-        method: method,
-        path: als,
-        url_root: url_root,
-        prefix: prefix
-      }
-     
-      route_methods["#{als[1..-1]}_path"] = meta      
-      
-      (classes[klass] ||= {})[method] = meta
-      
-      
-      parts = als[1..-1].split('/')
-      parts << '' if parts.empty?
-      
-      tree_iterator = paths
-      parts.reverse.each do |part|
-        tree_iterator = (tree_iterator[part] ||= TreeHash.new)        
-        raise "alias '#{als}' conflicted with another alias!" if tree_iterator.meta
-      end
-      tree_iterator.meta = meta
-    end
-    
-    def encode klass, method, params      
-      if meta = classes[klass].try(:[], method)
-        path = meta[:path]
-        
-        path = encode_prefix_params! path, params, meta        
-        path = encode_url_root! path, meta
-        
-        return path, params
-      else
-        nil
-      end
-    end
-    
-    def decode path, params
-      parts = path[1..-1].split('/')
-      parts << '' if parts.empty?
-      
-      tree_iterator = paths
-      
-      # checking for first part
-      part = parts.pop
-      tree_iterator = tree_iterator[part]      
-      return nil unless tree_iterator    
-
-      # checking for exact match      
-      while part = parts.pop
-        tmp = tree_iterator[part]
-        unless tmp
-          parts << part
-          break 
-        end
-        tree_iterator = tmp
-      end      
-
-      meta = tree_iterator.meta
-      
-      decode_prefix_params! parts, params, meta      
-      decode_url_root! parts, meta
-      
-      return meta[:class], meta[:method], params
-    end  
-    
-    def encode_method route_method
-      if meta = route_methods[route_method]
-        return meta[:class], meta[:method]
-      else
-        nil
-      end
-    end
-    
-    protected
-      attr_accessor :paths, :route_methods, :classes
-  end
-end
-
-
-Rad::Routes::Configurator.class_eval do
-  def alias *args, &block
-    alias_router = @router.routes[:alias_router]
-    raise "There's no AliasRouter (use config to add it)!" unless alias_router
-    alias_router.add *args, &block
-  end
-end

data/lib/rad/router/routers/restful_router.rb

@@ -1,113 +0,0 @@
-module Rad
-  class RestfulRouter
-    include AbstractRouter
-    
-    def initialize
-      @resources, @classes = {}, {}
-    end
-    
-    def add resource, options = {}
-      # parsing options
-      resource = resource.to_s
-      resource.must_not =~ /\//      
-      raise "resource should be in plural form!" unless resource.pluralize == resource
-      klass = options.delete(:class) || raise("no class!")      
-      url_root = parse_url_root options
-      prefix = parse_prefix options
-      raise "unknown options :#{options.to_h.keys.join(': ')}!" unless options.empty?      
-      
-      # logic
-      meta = {
-        class: klass,
-        resource: resource,
-        url_root: url_root,
-        prefix: prefix
-      }
-            
-      resources.must_not.include(resource.pluralize)
-      classes.must_not.include(klass)      
-      resources[resource.pluralize] = meta
-      resources[resource.singularize] = meta
-      classes[klass] = meta
-    end
-    
-    def encode klass, method, params
-      meta = classes[klass]
-      return nil unless meta
-      
-      path = if id = params.delete(:id)
-        "/#{meta[:resource]}/#{id}/#{method}"
-      else
-        "/#{meta[:resource]}/#{method}"
-      end
-      
-      path = encode_prefix_params! path, params, meta
-      path = encode_url_root! path, meta
-      
-      [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      
-      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[:class], route_method[0..(i-2)].to_sym
-        end
-      end
-      
-      return nil
-    end
-    
-    protected
-      attr_accessor :resources, :classes
-      
-      def decode_as_object_resource path, params
-        parts = path[1..-1].split('/')
-        return nil unless parts.size >= 3
-        
-        method, id, klass = parts.pop.to_sym, parts.pop, parts.pop
-        meta = resources[klass]
-        return nil unless meta
-
-        return nil if parts.size != (meta[:url_root] ? 1 : 0) + (meta[:prefix] ? meta[:prefix].size * 2 : 0)
-        
-        decode_prefix_params! parts, params, meta      
-        decode_url_root! parts, meta
-        
-        params[:id] = id
-
-        return meta[:class], method, params
-      end
-      
-      def decode_as_static_resource path, params
-        parts = path[1..-1].split('/')
-        return nil unless parts.size >= 2
-
-        method, klass = parts.pop.to_sym, parts.pop
-        meta = resources[klass]
-        return nil unless meta
-
-        return nil if parts.size != (meta[:url_root] ? 1 : 0) + (meta[:prefix] ? meta[:prefix].size * 2 : 0)
-        
-        decode_prefix_params! parts, params, meta      
-        decode_url_root! parts, meta
-        
-        return meta[:class], method, params
-      end
-  end
-end
-
-
-Rad::Routes::Configurator.class_eval do
-  def resource *args, &block
-    restful_router = @router.routes[: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/spec/mail.rb

@@ -1,31 +0,0 @@
-module Rad
-  module RSpecHelper
-    def sent_letters
-      Rad::RSpecHelper.sent_letters
-    end
-    
-    class << self
-      attr_accessor :sent_letters
-    end    
-  end  
-end
-
-rspec do
-  def self.with_mail
-    Rad::Mailer.class_eval do
-      def deliver letter
-        Rad::RSpecHelper.sent_letters << letter
-      end
-    end
-    
-    Mail.defaults do
-      delivery_method :test
-    end
-    
-    rspec.include Rad::RSpecHelper
-    
-    before :each do
-      Rad::RSpecHelper.sent_letters = []
-    end        
-  end  
-end