crystal_ext 0.0.7 → 0.0.11

data/Rakefile

@@ -1,10 +1,73 @@
-require 'rake_ext'
+require 'rake'
+require 'fileutils'
+current_dir = File.expand_path(File.dirname(__FILE__))
+Dir.chdir current_dir
 
-project(
+
+# 
+# Specs
+# 
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_files = FileList["spec/**/*_spec.rb"].select{|f| f !~ /\/_/}
+  t.libs = ["#{current_dir}/lib"]
+end
+
+
+# 
+# Gem
+# 
+require 'rake/clean'
+require 'rake/gempackagetask'
+
+gem_options = {
   :name => "crystal_ext",
-  :version => "0.0.7",
-  :summary => "Extensions for Crystal Framework",
+  :version => "0.0.11",
+  :summary => "Ruby Web Framework",  
+  :dependencies => %w(
+    activesupport
+    ruby_ext
+    rack
+    nokogiri
+    mail
+    addressable
+  )
+}
+
+gem_name = gem_options[:name]
+spec = Gem::Specification.new do |s|
+  gem_options.delete(:dependencies).each{|d| s.add_dependency d}
+  gem_options.each{|k, v| s.send "#{k}=", v}
+  
+  s.name = gem_name
+  s.author = "Alexey Petrushin"
+  s.homepage = "http://github.com/alexeypetrushin/#{gem_options[:name]}"
+  s.require_path = "lib"
+  s.files = (%w{Rakefile readme.md} + Dir.glob("{lib,spec}/**/*"))
+  
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true  
+end
+
+package_dir = "#{current_dir}/build"
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+  p.need_zip = true
+  p.package_dir = package_dir
+end
+
+task :push do
+  # dir = Dir.chdir package_dir do
+  gem_file = Dir.glob("#{package_dir}/#{gem_name}*.gem").first
+  system "gem push #{gem_file}"
+  # end
+end
+
+task :clean do
+  system "rm -r #{package_dir}"
+end
 
-  :author => "Alexey Petrushin",
-  :homepage => "http://github.com/alexeypetrushin/crystal_ext"
-)
+task :release => [:gem, :push, :clean]

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