rad_core 0.0.13

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+require 'rad/conveyor'
+
+%w(
+  configurator
+  simple_router
+  router
+  default_format_processor  
+  
+  core_routing_helper  
+  
+  processors/router  
+).each{|f| require "rad/router/core/#{f}"}
+
+# {AliasRouter: 'alias_router', RestfulRouter: 'restful_router'}.each do |klass, path|
+#   Rad.autoload klass, "rad/router/routers/#{path}"
+# end
+%w(
+  abstract_router
+  alias_router
+  restful_router
+).each{|f| require "rad/router/routers/#{f}"}
+
+Rad::Config::DEFAULTS.merge!(
+  default_path: '/'
+)
+
+Rad.metaclass do
+  delegate :routes, to: Rad::Routes::Configurator
+end

data/lib/rad/spec/controller.rb

@@ -0,0 +1,41 @@
+require 'rad/spec/environment'
+
+rspec do
+  attr_accessor :response, :workspace
+
+  def self.with_controller
+    before :each do
+      self.response = nil
+    end
+  end
+  
+  def ccall klass, method, params = {}, workspace_variables = {}, &block
+    self.response = Rad::Response.new
+    workspace_variables = {
+      class: klass, method_name: method, params: Rad::Params.new(params), response: response
+    }.merge(workspace_variables)
+    
+    if block            
+      rad.conveyors.web.call workspace_variables do |c|
+        self.workspace = rad.workspace
+                
+        block.call c
+      end
+    else                  
+      self.workspace = rad.conveyors.web.call workspace_variables
+    end
+    
+    if Rad.const_defined?(:HttpController) and klass and klass.is?(::Rad::HttpController)
+      response.content_type.must_be.present
+      response.status.must_be.present
+    end
+    
+    workspace.content
+  end
+end
+
+Rad::AbstractController.class_eval do
+  def render_ok
+    render inline: 'ok'
+  end
+end

data/lib/rad/spec/environment.rb

@@ -0,0 +1,51 @@
+require 'rspec_ext'
+
+rspec do
+  def self.swap_metadata scope = :all
+    old_metadata = nil
+    
+    before scope do
+      old_metadata = Micon.metadata
+      Micon.swap_metadata old_metadata.deep_clone
+    end
+    
+    after scope do
+      Micon.swap_metadata old_metadata
+    end
+  end
+  
+  def self.with_environment options = {}, &block
+    options = options.to_openobject    
+    runtime_dir = options.delete(:runtime_dir) || './tmp'
+    scope = options.delete(:before) || :each
+    environment = options.delete(:environment) || :test
+    raise "Invalid options :#{options.to_hash.keys.join(', :')}!" unless options.empty?
+    
+    swap_metadata
+    
+    before scope do
+      rad.clear      
+      Micon.after :config do |config|        
+        config.set! environment: environment, runtime_dir: runtime_dir
+      end
+      
+      block.call if block
+      
+      silence_logger!
+      # Rad.initialize_plugin runtime_dir, environment
+    end
+
+    after scope do
+      rad.clear  
+    end    
+  end
+  
+  inject(
+    config: :config, 
+    logger: :logger
+  )
+  
+  def silence_logger!
+    self.logger = Logger.new nil
+  end  
+end