crystal_ext 0.0.7 → 0.0.11

data/lib/crystal/http/processors/http_logger.rb

@@ -0,0 +1,15 @@
+module Crystal
+  module Processors
+    class HTTPLogger < Processor
+      def call
+        if workspace.request? and workspace.params?        
+          method, path, ip, time, format = workspace.request.request_method, workspace.path, 
+            workspace.request.ip, (workspace.start_time || Time.now), workspace.params.format
+          logger.info "Started '#{path}' as '#{format}' (for #{ip} at #{time.to_s} with #{method})"
+        end
+        
+        next_processor.call
+      end
+    end
+  end
+end

data/lib/crystal/http/processors/http_writer.rb

@@ -0,0 +1,48 @@
+module Crystal
+  module Processors    
+    class HttpWriter < Processor
+      attr_accessor :result_variable
+      
+      def initialize next_processor, result_variable = 'content'
+        super(next_processor)
+        @result_variable = result_variable
+      end
+      
+      def call
+        response = workspace.response.must_be.defined
+        
+        begin
+          next_processor.call
+          
+          result = workspace[result_variable]
+          response.body = result if response.body.blank? and result.present?
+          response.content_type ||= Mime[workspace.params.format]
+        rescue StandardError => e            
+          raise e if config.test?
+          
+          # if workspace.error_processed?
+          #   result = workspace[@result_variable]
+          # 
+          #   response.body << result if result
+          #   response.content_type = Mime[workspace.params.format]
+          # else
+          
+          if workspace.params.format? and workspace.params.format.json?
+            response.body << {:error => (config.production? ? "Internal error!" : e.message)}.to_json
+            response.content_type = Mime.json
+          else
+            response.body << (config.production? ? "Internal error!" : e.message)
+            response.content_type = Mime.text
+          end
+          
+          logger.error e
+          logger.info "\n"
+          
+          # end
+          
+          # response.error = e # for RSpec helpers
+        end
+      end
+    end 
+  end
+end

data/lib/crystal/http/processors/prepare_params.rb

@@ -0,0 +1,24 @@
+module Crystal
+  module Processors    
+    class PrepareParams < Processor
+      def call
+        workspace.env.must_be.defined
+
+        workspace.request = Crystal::Request.new(workspace.env)
+        workspace.path = workspace.request.path
+        params = workspace.params = Crystal::Params.new(workspace.request.params)
+
+        if params.json?
+          json_params = JSON.load params['json']
+          json_params.must_be.a Hash
+          json_params.keys.each do |k|
+            logger.warn "Parameter :#{k} will be overwriden from JSON!" if params.include?(k)
+          end
+          params.merge! json_params
+        end
+        
+        next_processor.call
+      end
+    end 
+  end
+end

data/lib/crystal/http/rack_config.rb

@@ -0,0 +1,15 @@
+# module Crystal
+#   module RackConfig
+#     def run_common_app rack_config_file_path
+#       $APP_DIR = File.expand_path(File.dirname(rack_config_file_path))
+# 
+#       require "#{$APP_DIR}/config/init"
+# 
+#       Crystal::Config::DEFAULTS['environment'] = $CENV || 'production'
+#       Micon[:environment]
+# 
+#       Crystal.build_common_app self
+#       run Crystal
+#     end
+#   end
+# end

data/lib/crystal/http/support/rack/rack_adapter.rb

@@ -0,0 +1,65 @@
+module Crystal
+  class RackAdapter
+    SERVERS = %w{mongrel thin webrick}
+    
+    # class Callback
+    #   def initialize app; end
+    #   def self.call env; Crystal::Adapter.call env end
+    # end
+    
+    class << self
+      inject(
+        :logger => :logger,
+        :config => :config
+      )
+      
+      def build_common_app builder = nil, &block
+        if block
+          @build_common_app = block
+        else
+          unless @build_common_app
+            raise "Common App not defined! Use profiles (like crystal/profiles/web), define it by yourself or use your own configuration!"
+          end
+          @build_common_app.call builder
+        end
+      end
+      
+      def parse_config
+        app, options = Rack::Builder.parse_file 'config.ru'
+        app
+      end
+      
+      def run app
+        handler = detect_rack_handler
+        handler_name = handler.name.gsub(/.*::/, '')
+        # unless handler_name =~/cgi/i
+        logger.info "Crystal #{Crystal::VERSION} started on #{config.port!} in :#{config.environment!} mode (at #{Time.now.to_s})\n\n"
+        handler.run app, :Host => config.host!, :Port => config.port! do |server|
+          [:INT, :TERM].each {|sig| trap(sig){quit!(server, handler_name)}}
+        end
+      rescue Errno::EADDRINUSE => e
+        logger.error "Port #{config.port!} taken!"
+      end
+      
+      def quit!(server, handler_name)
+        ## Use thins' hard #stop! if available, otherwise just #stop
+        server.respond_to?(:stop!) ? server.stop! : server.stop
+        puts "\nCrystal stopped" unless handler_name =~/cgi/i        
+      end
+      
+      protected        
+        def detect_rack_handler
+          return Rack::Handler.get('mongrel')
+          SERVERS.each do |server_name|
+            begin
+              return Rack::Handler.get(server_name.downcase)
+            rescue LoadError
+            rescue NameError
+            end
+          end
+          fail "  Server handler (#{SERVERS.join(', ')}) not found."
+        end
+        
+    end
+  end
+end

data/lib/crystal/http/support/rack/request.rb

@@ -0,0 +1,12 @@
+module Crystal
+  class Request < Rack::Request
+    # Returns an array of acceptable media types for the response
+    # def accept
+    #   @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.split(';')[0].strip }
+    # end
+    # 
+    # def secure?
+    #   (@env['HTTP_X_FORWARDED_PROTO'] || @env['rack.url_scheme']) == 'https'
+    # end
+  end
+end

data/lib/crystal/http/support/rack/response.rb

@@ -0,0 +1,39 @@
+module Crystal
+  class Response
+    attr_accessor :status, :headers, :body
+    # attr_accessor :error # for specs
+    
+    def initialize
+      @status, @headers, @body = 200, {}, ""
+    end
+    
+    def write str
+      body << str
+    end      
+
+    def content_type= type; headers["Content-Type"] = type end
+    def content_type; headers["Content-Type"] end
+    def content_type?; !!content_type end
+    
+    def location; headers['Location'] end
+    def location= location; headers['Location'] = location end
+    
+    def to_a
+      [status, headers, body]
+    end 
+    
+    def inspect
+      to_a.inspect
+    end
+    
+    def == other
+      super(other) || to_a == other
+    end
+    
+    def empty?
+      body.empty?
+    end
+    alias_method :blank?, :empty?
+    
+  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/mailer/mail.rb

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

data/lib/{crystal_ext/profiles/web_ext.rb → crystal/profiles/web.rb}

@@ -1,16 +1,16 @@
-require 'crystal_ext/profiles/web_ext_require'
+require 'crystal/profiles/web_require'
 
 # 
 # Routes
 # 
-Crystal::HttpController.include Crystal::NamedRouter::Helper
+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]   
+      [:default_router, Crystal::DefaultRouter.new]
     ])
   end
 end
@@ -19,9 +19,9 @@ end
 # 
 # Conveyors
 # 
-module Crystal::Processors  
+module Crystal::Processors
   crystal.after :environment do
-    crystal.conveyors.web do |web|
+    crystal.conveyors.web do |web|      
       # conveyor      
       web.use ConveyorLogger
     
@@ -30,12 +30,6 @@ module Crystal::Processors
       web.use PrepareParams
       web.use EvaluateFormat
       web.use HTTPLogger
-      
-      # forgery protection
-      web.use PrepareAutenticityToken
-      
-      # ensure no www
-      web.use EnsureNoWww
     
       # html
       web.use ScopedParams
@@ -49,15 +43,15 @@ module Crystal::Processors
       # controller      
       web.use ControllerLogger
       web.use ControllerCaller, :content
-    
-      web.build!
+            
+      web.build!            
     end
   end
 end
 
 
 # 
-# RackAdapter
+# Rack
 # 
 Crystal::RackAdapter.build_common_app do |builder|
   config = crystal.config
@@ -66,7 +60,7 @@ Crystal::RackAdapter.build_common_app do |builder|
   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'  
+  # 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

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