crystal_ext 0.0.7 → 0.0.11

data/lib/crystal/router/configurator.rb

@@ -0,0 +1,23 @@
+module Crystal
+  module Routes
+    class Configurator
+      def initialize router
+        @router = router
+      end      
+      
+      def named_route *args, &block
+        named_router = @router.routes[:named_router]
+        raise "There's no NamedRouter (use config to add it)!" unless named_router
+        named_router.add *args, &block
+      end
+      
+      class << self
+        inject :router => :router
+        
+        def routes &block
+          block.call Configurator.new(router)
+        end          
+      end
+    end
+  end
+end

data/lib/crystal/router/default_format_processor.rb

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

data/lib/crystal/router/default_router.rb

@@ -0,0 +1,23 @@
+module Crystal
+  class DefaultRouter
+    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        
+        
+        class_path = parts.join('/')
+        class_name = class_path.camelize
+        klass = class_name.constantize
+                        
+        return klass, method, params
+      end
+    end    
+  end
+end

data/lib/crystal/router/named_router.rb

@@ -0,0 +1,63 @@
+module Crystal
+  class NamedRouter
+    attr_accessor :names, :classes
+    
+    def initialize
+      @names, @classes = {}, {}
+    end
+    
+    def add name, klass
+      name = name.to_s
+      names[name] = klass
+      classes[klass] = name
+    end
+    
+    def encode klass, method, params
+      if name = classes[klass]
+        path = "/#{name}/#{method}"      
+        return path, params
+      else
+        nil
+      end
+    end
+    
+    def decode path, params
+      parts = path[1..-1].split '/'
+      if parts.size >= 2
+        method = parts.pop                
+        name = parts.join('/')
+                        
+        if klass = names[name]
+          return klass, method, params
+        else
+          nil
+        end
+      end
+    end  
+    
+    def encode_route_method method, params = {}
+      method = method.sub(/_path$/, '')
+      names.each do |name, klass|
+        if i = method.rindex(name)
+          if method.size == i + name.size and method[(i-1)..(i-1)] == '_'
+            return encode(klass, method[0..(i-2)], params)
+          end
+        end
+      end
+      raise "Unknown route #{method}!"
+    end
+    cache_method_with_params :encode_route_method
+    
+    module Helper
+      protected
+        def method_missing m, *args, &block
+          m = m.to_s
+          if m =~ /_path$/
+            crystal[:router].routes[:named_router].encode_route_method m, *args
+          else
+            super m.to_sym, *args, &block
+          end
+        end
+    end
+  end
+end

data/lib/crystal/router/processors/router.rb

@@ -0,0 +1,22 @@
+module Crystal
+  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
+        klass, method, params = router.decode workspace.path, workspace.params
+        
+        # params.class_name, params.method_name = klass.name, method
+
+        workspace[@class_variable], workspace[@method_variable], workspace.params = klass, method, params
+        
+        next_processor.call
+      end
+    end
+  end
+end

data/lib/crystal/router/router.rb

@@ -0,0 +1,218 @@
+module Crystal
+  class Router
+    
+    inject(
+      :config => :config,
+      :workspace => :workspace
+    )
+    
+    attr_reader :routes, :format_processor
+
+    def initialize class_variable, routes = [[:default_router, DefaultRouter.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 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
+      
+      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 '#{workspace.path}' request!" unless result
+            
+      klass, method, params = result
+      method ||= config.default_method
+      params.must_be.defined
+          
+      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 '#{klass}'!" unless klass.public_instance_methods.include? method
+    
+      return klass, method, params
+    end
+    
+    def encode klass, method, params = {}
+      klass.must_be.defined
+      method, params = method.to_s, params.to_openobject
+      
+      format = params.delete :format
+      
+      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 '#{klass}'!" unless klass.public_instance_methods.include? method
+      
+      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 persist_params &block
+      before = Thread.current[:persist_params]
+      begin
+        Thread.current[:persist_params] = true
+        block.call
+      ensure
+        Thread.current[:persist_params] = before
+      end
+    end
+
+    def dont_persist_params &block
+      before = Thread.current[:persist_params]
+      begin
+        Thread.current[:persist_params] = false
+        block.call
+      ensure
+        Thread.current[:persist_params] = before
+      end
+    end
+    
+    def persist_params?
+      !!Thread.current[:persist_params]
+    end
+    
+    def global_persistent_params; @global_persistent_params ||= [] end
+    
+    protected
+      def current_class; workspace[@class_variable] 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.to_s, params
+        url = url_for_path path, params  
+        
+        url.marks.format = format.to_s if format
+        
+        url
+      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)
+        raise ":no_prefix is deprecated!" if params.no_prefix? # TODO3 now it uses :url_root instead, remove this after updating spaces
+        
+        # inject persistent params
+        inject_persistent_params! params, params.delete(:persist)
+                
+        # json
+        params = {:json => params.to_json}.to_openobject 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
+      
+      DONOT_PERSIST = ['_', '_method']
+      
+      def inject_persistent_params! params, persist
+        # global persistent params
+        unless cached_global_persistend_params = workspace.cached_global_persistend_params        
+          cached_global_persistend_params, workspace_params = {}, workspace.params
+          global_persistent_params.collect!{|k| k.to_s}
+        
+          workspace_params.each do |k, v|
+            k = k.to_s                    
+            cached_global_persistend_params[k] = v if global_persistent_params.include?(k)
+          end
+          
+          workspace.cached_global_persistend_params = cached_global_persistend_params
+        end
+        
+        cached_global_persistend_params.each do |k, v|
+          params[k] = v unless params.include? k
+        end
+        
+        # underscored persistent params
+        if persist_params? or persist
+          unless cached_persistend_params = workspace.cached_persistend_params        
+            cached_persistend_params, workspace_params = {}, workspace.params
+        
+            workspace_params.each do |k, v|
+              k = k.to_s
+              cached_persistend_params[k] = v if (k =~ /^_/) and !DONOT_PERSIST.include?(k)
+            end
+          
+            workspace.cached_persistend_params = cached_persistend_params
+          end
+        
+          cached_persistend_params.each do |k, v|
+            params[k] = v unless params.include? k
+          end
+        end          
+      end
+      
+  end
+end

data/lib/crystal/router/routing_helper.rb

@@ -0,0 +1,17 @@
+module Crystal
+  module RoutingHelper
+    inject :router => :router
+    
+    delegate :url_for, :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 = {}
+      do_not_persist_params do 
+        url_for_path params[:_return_to] || session[:return_to] || config.default_path!, options.merge(:url_root => false)
+      end
+    end
+  end
+end

data/lib/crystal/spec.rb

@@ -0,0 +1,8 @@
+require 'spec_ext'
+
+%w(
+  controller
+  environment
+  http
+  remote
+).each{|f| require "crystal/spec/#{f}"}

data/lib/crystal/spec/controller.rb

@@ -0,0 +1,15 @@
+require 'crystal/spec/environment'
+
+Spec::Example::ExampleGroup.class_eval do
+  def ccall klass, method, params = {}      
+    crystal.conveyors.web.call(
+      :class => klass, :method_name => method.to_s, :params => Crystal::Params.new(params)
+    )
+  end
+end
+
+Crystal::AbstractController.class_eval do
+  def render_ok
+    render :inline => 'ok'
+  end
+end

data/lib/crystal/spec/environment.rb

@@ -0,0 +1,41 @@
+require 'spec_ext'
+
+Spec::Example::ExampleGroup.class_eval do
+  def self.swap_metadata    
+    old_metadata = nil
+    
+    before :all do
+      old_metadata = Micon.metadata
+      Micon.swap_metadata old_metadata.deep_clone
+    end
+    
+    after :all do
+      Micon.swap_metadata old_metadata
+    end
+  end
+  
+  def self.with_environment environment = :test
+    swap_metadata
+    
+    before :each do    
+      crystal.clear
+      crystal[:config].environment = environment
+    end
+
+    after :each do
+      crystal.clear      
+    end    
+  end
+  
+  inject(
+    :config => :config, 
+    :logger => :logger
+  )
+  
+  def silence_logger!
+    self.logger = Logger.new nil
+  end  
+end
+
+# Spec::Runner.configure do |config|  
+# end