crystal 0.0.10 → 0.0.12

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake_ext'
+
+gem_spec(
+  :name => "crystal",
+  :version => "0.0.12",
+  :summary => "Ruby Web Framework",
+  :dependencies => %w(
+    activesupport
+
+    haml
+    tilt    
+    dictionary
+    json
+    addressable
+    nokogiri
+
+    rack
+    
+    facets
+    ruby-ext
+  ),
+
+  :author => "Alexey Petrushin",
+  :homepage => "http://github.com/alexeypetrushin/crystal"
+)

data/lib/crystal/controller/abstract_controller/micelaneous.rb

@@ -0,0 +1,31 @@
+module Crystal
+  module AbstractController
+    module Micelaneous
+      # 
+      # respond_to
+      # 
+      def respond_to &block
+        @_responder.must_be.nil
+        @_responder = Responder.new
+        block.call @_responder
+        handler = @_responder.handlers[params.format]
+        raise "Can't respond to #{params.format} format!" unless handler
+        handler.call
+      end
+      
+      module ClassMethods
+        # 
+        # filter_parameter_logging
+        # 
+        inheritable_accessor :filter_parameter_logging, []
+        def filter_parameter_logging_with_sugar *parameters
+          if parameters.empty?
+            filter_parameter_logging_without_sugar
+          else
+            filter_parameter_logging_without_sugar.push *parameters.collect(&:to_s)
+          end
+        end        
+      end
+    end
+  end
+end

data/lib/crystal/controller/abstract_controller/render.rb

@@ -0,0 +1,133 @@
+module Crystal
+  module AbstractController
+    module Render
+      SPECIAL_FORMAT_HANDLERS = [
+        ['json', lambda{|o| o.to_json}],
+        ['xml', lambda{|o| o.to_xml}],
+        ['js', lambda{|o| o}],        
+      ]
+      
+      SPECIAL_CASES_HANDLERS = [
+        ['inline', lambda{|o| o}],
+      ]
+      
+      def layout tname = nil        
+        if tname
+          @_layout = tname
+        else          
+          @_layout
+        end
+      end
+      def layout= layout
+        @_layout = layout
+      end
+      
+      def render *args
+        options = Template.parse_arguments *args
+        render_with_parsed_arguments options
+      end
+      
+      def render_action options
+        options = options.to_openobject
+        
+        template = self.class.template_name_for options.action
+        return "" unless Template.exist? template
+                    
+        instance_variables = {}
+        instance_variable_names.each do |name|
+          instance_variables[name[1..-1]] = instance_variable_get name unless name =~ /^@_/
+        end
+        
+        render_options = {             
+          :template => template,
+          :instance_variables => instance_variables,
+          :context_class => self.class.controller_context_class,
+          :format => params.format,
+          :action => true # this willn't allow to render partial starting with _
+        }.to_openobject
+                
+        content, context = Template.basic_render render_options
+
+        layout = options.include?(:layout) ? options.layout : self.layout
+        if layout
+          content = Template.render_layout layout, :content => content, :context => context
+        end
+        
+        content        
+      end
+      
+      protected
+        def render_with_parsed_arguments options
+          content = if options.action?
+            render_action options
+          elsif special_format_handler = SPECIAL_FORMAT_HANDLERS.find{|format, handler| options.include? format}
+            format, handler = special_format_handler
+            if format != params.format
+              raise "You trying responing with :#{format} to the :#{params.format} requested format!"
+            end
+            handler.call options[format]
+          elsif special_format_handler = SPECIAL_CASES_HANDLERS.find{|key, handler| options.include? key}
+            key, handler = special_format_handler
+            handler.call options[key]
+          else
+            Template.basic_render(options).first
+          end        
+                
+          throw :special_result, content
+        end
+      
+      module ClassMethods
+        def layout layout, options = {}
+          before options do |controller|
+            controller.layout = layout
+          end
+        end
+        
+        def template_name_for action
+          action = action.to_s
+
+          return _template_name_for(action) if config.development?
+
+          @template_name_for ||= {}
+
+          unless tname = @template_name_for[action]          
+            tname = _template_name_for(action)
+            @template_name_for[action] = tname
+          end
+
+          tname
+        end    
+
+        protected
+          def _template_name_for action
+            instance_methods.must.include(action)
+
+            own_tnames = [
+              "/#{controller_name.gsub('::', '/')}/#{action}",
+              "/#{controller_name.underscore}/#{action}"
+            ]          
+
+            own_actions_tnames = [
+              "/#{controller_name.gsub('::', '/')}/actions",
+              "/#{controller_name.underscore}/actions"
+            ]
+
+            action_template_exist = lambda do |tname| 
+              Crystal::Template.exist?(tname) and
+                Crystal::Template.read(tname) =~ /^.+when.+:#{action}.+$/
+            end
+
+            if existing_template = own_tnames.find{|tname| Crystal::Template.exist? tname}
+              existing_template
+            elsif existing_action_template = own_actions_tnames.find(&action_template_exist)
+              existing_action_template
+            elsif parent = ancestors[1..-1].find{|a| a.respond_to?(:template_name_for) and a.instance_methods.include?(action)}
+              parent.template_name_for(action)
+            else
+              own_tnames.first
+            end
+          end
+      end
+    end
+  end
+end

data/lib/crystal/controller/abstract_controller/responder.rb

@@ -0,0 +1,17 @@
+module Crystal
+  module AbstractController
+    class Responder < BasicObject
+      attr_reader :handlers
+
+      def initialize
+        @handlers = {}
+      end
+      
+      protected 
+        def method_missing m, *args, &block
+          args.must_be.empty
+          handlers[m.to_s] = block.must_be.defined
+        end
+    end
+  end
+end

data/lib/crystal/controller/abstract_controller.rb

@@ -0,0 +1,60 @@
+module Crystal
+  module AbstractController
+    inherit Filters
+    inherit AbstractController::Render, AbstractController::Micelaneous
+    
+    inject(
+      :workspace => :workspace,
+      :logger => :logger,
+      :config => :config
+    )
+    
+    def params
+      workspace.params
+    end    
+    
+    module ClassMethods
+      inject(
+        :workspace => :workspace,
+        :logger => :logger,
+        :config => :config
+      )
+      
+      def controller_name
+        self.namespace ? "#{self.namespace.name}/#{self.alias}" : self.alias
+      end
+      
+      def controller_context_class
+        unless @controller_context_class
+          parent_context_class = nil
+          ancestors[1..-1].each do |anc|            
+            break if parent_context_class = anc.respond_to(:controller_context_class)
+          end
+          parent_context_class ||= Crystal::ControllerContext
+
+          class_name = "#{self.name}::#{self.name.split('::').last}ControllerContext"
+
+          # raise "Tempate context #{class_name} already defined!" if Object.const_defined? class_name
+          eval "class #{class_name} < #{parent_context_class}; end", TOPLEVEL_BINDING, __FILE__, __LINE__
+          @controller_context_class = class_name.constantize
+        end
+        @controller_context_class
+      end
+
+      def helper *args
+        args.to_a.each do |mod| 
+          mod.must_be.a Module
+          controller_context_class.inherit mod
+        end 
+      end
+      
+      def helper_method *args
+        args = args.first if args.size == 1 and args.first.is_a?(Array)
+        # args.each{|m| m.to_s.must_be.in self.instance_methods}
+        args.each do |m|          
+          controller_context_class.delegate m, :to => :controller
+        end      
+      end
+    end    
+  end
+end

data/lib/crystal/controller/controller_context.rb

@@ -0,0 +1,7 @@
+module Crystal
+  class ControllerContext < TemplateContext
+    def controller
+      workspace.controller.must_be.defined
+    end    
+  end
+end

data/lib/crystal/controller/http_controller.rb

@@ -0,0 +1,43 @@
+module Crystal
+  module HttpController
+    inherit AbstractController
+    
+    protected
+      def render_with_parsed_arguments options
+        if options.content_type?
+          workspace.response.content_type = options.content_type
+          super
+        elsif options.location?
+          response = workspace.response
+          response.location, response.status = options.location, (options.status || 301)            
+          throw :special_result, %(<html><body>You are being <a href="#{options.location.html_escape}">redirected</a>.</body></html>)
+        elsif options.status?  
+          workspace.response.status = options.status          
+          super
+        else
+          super
+        end
+      end
+    
+    module ClassMethods      
+      inheritable_accessor :actions_allowed_for_get_request, []
+      
+      def allow_get_for *methods
+        enable_protection_from_get_requests!        
+        actions_allowed_for_get_request.push *methods.collect(&:to_s)
+      end
+      
+      private
+        def enable_protection_from_get_requests!
+          unless respond_to? :protect_from_get_request
+            define_method :protect_from_get_request do
+              if workspace.request.get? and !self.class.actions_allowed_for_get_request.include?(workspace.action)
+                raise "Get requests not allowed for :#{workspace.action} action!"
+              end            
+            end
+            before :protect_from_get_request
+          end
+        end
+    end
+  end
+end    

data/lib/crystal/controller/processors/controller_caller.rb

@@ -0,0 +1,40 @@
+module Crystal
+  module Processors    
+    class ControllerCaller < Processor
+      attr_accessor :result_variable
+      
+      def initialize next_processor, result_variable = 'content'
+        result_variable.must_be.present
+        
+        super(next_processor)                
+        @result_variable = result_variable
+      end
+      
+      def call                
+        # prepare
+        klass = workspace.class.must_be.present
+        raise "The controller class #{klass} must be a Crystal::AbstractController!" unless klass.is? Crystal::AbstractController
+        controller = workspace.controller = klass.new                  
+        action = workspace.action = workspace.method_name
+        format = workspace.params.format
+
+        # call
+        special_result = catch :special_result do
+          controller.run_callbacks :action, :method => action do          
+            # call controller
+            controller.send action
+            # render view
+            workspace[result_variable] = controller.render_action :action => action          
+          end
+        end
+        
+        if special_result
+          workspace[result_variable] = special_result
+        else
+          workspace[result_variable].must_be.defined
+        end        
+      end          
+    
+    end    
+  end
+end

data/lib/crystal/controller/processors/controller_error_handling.rb

@@ -0,0 +1,53 @@
+module Crystal
+  module Processors    
+    class ControllerErrorHandling < Processor
+      attr_accessor :result_variable
+      
+      def initialize next_processor, result_variable = 'content'
+        result_variable.must_be.present
+        super(next_processor)                
+        @result_variable = result_variable
+      end
+      
+      def call                
+        begin
+          next_processor.call          
+        rescue StandardError => e
+          if config.test?
+            raise e
+          elsif config.production?
+            error_shown_to_user = StandardError.new "Internal error!"
+            error_shown_to_user.set_backtrace []
+          else
+            error_shown_to_user = e
+          end
+            
+          format = workspace.params.format
+          handler = SPECIAL_ERROR_HANDLERS[format] || DEFAULT_ERROR_HANDLER
+          workspace[result_variable] = handler.call error_shown_to_user, format
+            
+          logger.error e
+          logger.info "\n"
+        end
+      end          
+    
+      SPECIAL_ERROR_HANDLERS = {
+        'json' => lambda{|e, format| 
+          {:error => e.message}.to_json
+        }
+      }
+      
+      DEFAULT_ERROR_HANDLER = lambda{|e, format|
+        tname = crystal.config.send "#{crystal.config.environment!}_error_template", nil
+        if tname and Template.exist?(tname, :format => format)            
+          data = Template.render(tname, 
+            :format => format,               
+            :locals => {:error => e}
+          )
+        else
+          e.message
+        end
+      }
+    end    
+  end
+end

data/lib/crystal/controller/processors/controller_logger.rb

@@ -0,0 +1,13 @@
+module Crystal
+  module Processors
+    class ControllerLogger < 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/controller.rb

@@ -0,0 +1,28 @@
+require 'crystal/conveyor'
+require 'crystal/template'
+
+%w(  
+  abstract_controller/render
+  abstract_controller/responder
+  abstract_controller/micelaneous
+  abstract_controller
+  controller_context
+  
+  processors/controller_logger
+  processors/controller_caller  
+  processors/controller_error_handling
+).each{|f| require "crystal/controller/#{f}"}
+
+module Crystal
+  autoload :HttpController, 'crystal/controller/http_controller'
+end
+
+# 
+# Initialization
+# 
+Crystal::Config::DEFAULTS.merge!({
+  :development_error_template => "/crystal_default_templates/development/error",
+  :production_error_template => nil,
+  :test_error_template => "/crystal_default_templates/development/error",
+}.stringify_keys)
+Crystal::Config::DEFAULTS['default_method'] ||= 'call'

data/lib/crystal/conveyor/conveyor.rb

@@ -0,0 +1,74 @@
+module Crystal
+  class Conveyor
+    inject :workspace => :workspace
+    
+    def definitions
+      @definitions ||= []
+    end
+        
+    def use processor_class, *initialization_arguments
+      definitions << [processor_class, initialization_arguments]
+    end
+    
+    def build!
+      @chain = lambda{}      
+      definitions.reverse.collect do |klass, args| 
+        klass.must_be.a Class
+        @chain = klass.new @chain, *args
+      end
+    end
+    
+    def call workspace_content = {}, &block
+      build! unless @chain
+      
+      crystal.activate :cycle, {} do        
+        self.workspace = Workspace.new
+        workspace.merge! workspace_content 
+        
+        if block
+          block.call{@chain.call}
+        else
+          @chain.call
+        end
+        
+        workspace
+      end
+    end
+    
+    def inspect
+      definitions.inspect
+    end
+    
+    # def trace name, &block
+    #   start_time = Time.now
+    #   block.call
+    #   (workspace.trace ||= []) << [name, Time.now - start_time]
+    # end       
+    
+    protected
+      # def build_chain
+      #   next_processor_call = nil
+      #   chain = reverse.collect do |processor|
+      #     next_processor_call = if next_processor_call
+      #       lambda{processor.call next_processor}
+      #     else
+      #       lambda{processor.call lambda{}}
+      #     end
+      #   end
+      #   next_processor_call
+      # end
+    
+    
+    # def add_before key, *processors
+    #   index = index{|processor| processor.name == key or processor.class == key}
+    #   raise "Can't find Processor '#{name}'!" unless index
+    #   insert index, *Array(processors)
+    # end
+    # 
+    # def add_after key, *processors
+    #   index = rindex{|processor| processor.name == key or processor.class == key}
+    #   raise "Can't find Processor '#{name}'!" unless index
+    #   insert index + 1, *Array(processors)
+    # end
+  end
+end

data/lib/crystal/conveyor/conveyors.rb

@@ -0,0 +1,20 @@
+module Crystal
+  class Conveyors
+    
+    def initialize
+      @hash = {}
+    end
+    
+    def [] conveyor_name
+      @hash[conveyor_name.to_s] ||= Crystal::Conveyor.new
+    end
+    
+    def method_missing m, &block
+      if block
+        block.call self[m]
+      else
+        self[m]
+      end
+    end
+  end
+end

data/lib/crystal/conveyor/params.rb

@@ -0,0 +1,22 @@
+module Crystal
+  class Params < OpenObject
+    # include OpenConstructor
+    
+    def initialize h = nil      
+      if h and (format = h.delete('format') || h.delete(:format))
+        h = h.clone
+        h[:format] = Format.new(format.to_s) 
+      end
+      update h if h
+    end
+    
+    def format= value
+      self[:format] = Format.new value
+    end
+    
+    def inspect      
+      h = to_h
+      h.inspect
+    end    
+  end
+end

data/lib/crystal/conveyor/processor.rb

@@ -0,0 +1,68 @@
+module Crystal  
+  class Processor
+    inject(
+      :config => :config,
+      :workspace => :workspace,
+      :logger => :logger
+    )
+    
+    attr_accessor :next_processor
+    
+    def initialize next_processor
+      @next_processor = next_processor
+    end      
+    
+    def self.inspect
+      self.name.split('::').last
+    end    
+  end
+end
+#       
+#     # def call            
+#     #   if workspace.error?
+#     #     respond_to :on_error
+#     #   else
+#     #     begin
+#     #       trace self.inspect do
+#     #         respond_to :process
+#     #       end
+#     #     rescue Exception => e
+#     #       workspace.error = e
+#     #       respond_to :on_error          
+#     #     end
+#     #   end
+#     # end
+#     
+#     
+#     
+#     # 
+#     # Unwrapping Call Stack
+#     # 
+#     def result_error= error
+#       @result_error = error
+#     end
+#     
+#     def result!
+#       @result_called.must_be.false
+#       @result_called = true
+#       raise @result_error if @result_error      
+#     end
+#     
+#     def result_called?      
+#       @result_called
+#     end
+#     attr_writer :result_called
+# 
+#     attr_accessor :after_block
+#     def after &block
+#       # @after_called.must_be.false
+#       @after_block = block.must_be.defined
+#       # @after_called = true
+#     end
+#     
+#     # def after_called?
+#     #   @after_called
+#     # end
+#     
+#   end
+# end

data/lib/crystal/conveyor/processors/conveyor_logger.rb

@@ -0,0 +1,24 @@
+module Crystal
+  module Processors
+    class ConveyorLogger < Processor            
+      def call
+        begin
+          next_processor.call
+          
+          # if workspace.trace?
+          #   total_time = workspace.trace.inject(0){|memo, pair| memo += pair.last}
+          #   max_pair = workspace.trace.max_by{|pair| pair.last}
+          #   logger.info "Completed in #{(total_time * 1000).round} ms (#{(max_pair.last * 1000).round} ms taken by #{max_pair.first})\n\n"
+          # else
+          logger.info "Completed in ? ms\n\n"
+          # end
+        rescue StandardError => e
+          raise e if config.test?
+            
+          logger.error e
+          logger.info "\n"
+        end
+      end
+    end
+  end
+end