crystal 0.0.10 → 0.0.12

data/lib/crystal/http.rb

@@ -0,0 +1,47 @@
+# WServer provides support for Web Servers (via Rack)
+
+require 'rack'
+require 'rack/builder'
+
+require 'crystal/conveyor'
+
+# support
+[  
+  'rack/request',
+  'rack/response',
+  'rack/rack_adapter'
+].each{|f| require "crystal/http/support/#{f}"}
+
+# http
+[
+  # 'config',
+  'http',
+  'http_adapter',
+  'processors/prepare_params',
+  'processors/http_writer',
+  'processors/http_logger',
+  'processors/evaluate_format'
+].each{|f| require "crystal/http/#{f}"}
+
+module Crystal
+  autoload :StaticFiles, 'crystal/http/middleware/static_files'
+end
+
+Crystal.metaclass_eval do
+  delegate :build_common_app, :to => Crystal::RackAdapter  
+  delegate :call, :to => Crystal::HTTPAdapter  
+  delegate :ensure_public_symlink, :to => Crystal::HTTP
+end
+
+
+# 
+# Initialization
+# 
+Crystal::Config::DEFAULTS.merge!({
+  :host => '0.0.0.0',
+  :port => 4000,
+  
+  :static => true,
+  :url_root => '',
+  :default_format => 'html',
+}.stringify_keys)

data/lib/crystal/mailer/mail.rb

@@ -0,0 +1,7 @@
+module Crystal
+  class Mail
+    def initialize options = {}
+      
+    end
+  end
+end

data/lib/crystal/mailer.rb

@@ -0,0 +1,13 @@
+gem 'mail'
+
+require 'crystal/template'
+
+[
+  'mail',
+].each{|f| require "crystal/remote/#{f}"}
+
+crystal.register :mail, :depends_on => :environment do
+  Crystal::Mail.new #TODO2 add mail config here
+end
+
+Crystal.run :mail, :after => :render

data/lib/crystal/profiles/web.rb

@@ -0,0 +1,69 @@
+require 'crystal/profiles/web_require'
+
+# 
+# Routes
+# 
+Crystal::AbstractController.include Crystal::NamedRouter::Helper
+Crystal::ControllerContext.include Crystal::NamedRouter::Helper
+
+crystal.after :environment do
+  crystal.register(:router, :depends_on => :environment) do
+    Crystal::Router.new(:class, [
+      [:named_router, Crystal::NamedRouter.new],
+      [:default_router, Crystal::DefaultRouter.new]
+    ])
+  end
+end
+
+
+# 
+# Conveyors
+# 
+module Crystal::Processors
+  crystal.after :environment do
+    crystal.conveyors.web do |web|      
+      # conveyor      
+      web.use ConveyorLogger
+    
+      # http      
+      web.use HttpWriter, :content
+      web.use PrepareParams
+      web.use EvaluateFormat
+      web.use HTTPLogger
+    
+      # html
+      web.use ScopedParams
+      
+      # controller
+      web.use ControllerErrorHandling, :content
+      
+      # router
+      web.use Router, :class, :method_name
+    
+      # controller      
+      web.use ControllerLogger
+      web.use ControllerCaller, :content
+            
+      web.build!            
+    end
+  end
+end
+
+
+# 
+# Rack
+# 
+Crystal::RackAdapter.build_common_app do |builder|
+  config = crystal.config
+  
+  # CommonLogger, ShowExceptions, Lint
+  builder.use Rack::Lint if config.development?
+  builder.use Crystal::StaticFiles, "#{config.root!}/public" if config.static? and config.root? and config.development?
+  
+  # use Rack::Session::Cookie, :key => 'rack.session', :domain => 'foo.com', :path => '/', :expire_after => 2592000, :secret => 'change_me'
+  builder.use Rack::Session::Cookie, config.session.to_hash if config.session?
+  
+  # builder.use Rack::CommonLogger
+  builder.use Rack::MethodOverride         
+  # builder.use ShowExceptions if config.show_exceptions?
+end

data/lib/crystal/profiles/web_require.rb

@@ -0,0 +1,5 @@
+require 'crystal/router'
+require 'crystal/http'
+require 'crystal/controller'
+require 'crystal/html'
+require 'crystal/html/include_into_controller'

data/lib/crystal/remote/processors/remote_caller.rb

@@ -0,0 +1,54 @@
+module Crystal
+  module Processors    
+    class RemoteCaller < Processor
+      # TODO2 :remote isn't registered with crystal[
+      inject :remote => :remote
+      
+      def initialize next_processor, result_variable = 'content'
+        super(next_processor)
+        @result_variable = result_variable
+      end
+      
+      def call                
+        return next_processor.call unless workspace.class?
+                
+        # prepare
+        klass = workspace.class
+        raise "The remote class #{klass} must be a Crystal::Remote!" unless klass.is? Crystal::Remote
+        workspace.remote_object = klass.new                  
+        method = workspace.method_name
+
+        # call
+        begin
+          result = workspace.remote_object.run_callbacks :action, :method => method do
+            workspace.remote_object.send method
+          end
+      
+          ensure_correct_result! result
+          workspace.remote_result = result                        
+
+          next_processor.call
+  
+          # write JSON as a result if format is JSON and no one else filled it
+          if workspace[@result_variable].blank?
+            workspace[@result_variable] = workspace.remote_result.to_json
+          end              
+        rescue StandardError => e
+          raise e if !workspace.params.format.json? or config.test?
+      
+          workspace[@result_variable] = {:error => e.message}.to_json
+  
+          logger.error e
+          logger.info "\n"
+        end
+      end
+      
+      private
+        def ensure_correct_result! result
+          unless result.rson?
+            raise "You can't use object of type '#{result.class}' as Remote's return value!"
+          end
+        end
+    end
+  end
+end

data/lib/crystal/remote/processors/remote_logger.rb

@@ -0,0 +1,13 @@
+module Crystal
+  module Processors
+    class RemoteLogger < Processor
+      def call
+        next_processor.call
+        
+        if (klass = workspace.class) and (method = workspace.method_name)
+          logger.info "Processing #{klass.name}.#{method} with #{workspace.params.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/crystal/remote/remote.rb

@@ -0,0 +1,15 @@
+module Crystal
+  module Remote
+    inherit Filters
+    
+    inject(
+      :workspace => :workspace,
+      :logger => :logger,
+      :config => :config
+    )
+    
+    def params
+      workspace.params
+    end
+  end
+end

data/lib/crystal/remote.rb

@@ -0,0 +1,9 @@
+require 'crystal/conveyor'
+
+[
+  'remote',  
+  'processors/remote_logger',
+  'processors/remote_caller',
+].each{|f| require "crystal/remote/#{f}"}
+
+Crystal::Config::DEFAULTS['default_method'] ||= 'call'

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/router.rb

@@ -0,0 +1,19 @@
+require 'crystal/conveyor'
+
+%w(
+  configurator
+  router
+  routing_helper
+  default_router
+  named_router
+  default_format_processor
+  processors/router
+).each{|f| require "crystal/router/#{f}"}
+
+Crystal::Config::DEFAULTS.merge!({  
+  :default_path => '/'
+}.stringify_keys)
+
+Crystal.metaclass do
+  delegate :routes, :to => Crystal::Routes::Configurator
+end

data/lib/crystal/spec/controller.rb

@@ -0,0 +1,15 @@
+require 'crystal/spec/environment'
+
+RSpec::Core::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