crystal_ext 0.0.4

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'fileutils'
+current_dir = File.expand_path(File.dirname(__FILE__))
+Dir.chdir current_dir
+
+
+# 
+# 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.4",
+  :summary => "Extensions for the Crystal Framework",  
+  :dependencies => %w(crystal)
+}
+
+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
+
+task :release => [:gem, :push, :clean]

data/lib/crystal_ext/defer_js.rb

@@ -0,0 +1,73 @@
+module Crystal
+  JavascriptHelper.class_eval do
+    
+    def javascript_tag_with_defer value = nil, &block
+      if @defer_js and !@deferred_js_called
+        @deffered_js_initialized.must_be.true
+        
+        value = capture &block if block
+        
+        value = <<END
+deferred_static_scripts.push(function(){
+#{value}
+});
+END
+        
+        value = javascript_tag_without_defer value
+        if block
+          concat value
+        else
+          value
+        end
+      else
+        javascript_tag_without_defer value, &block
+      end
+    end
+    alias_method_chain :javascript_tag, :defer
+    
+    def initialize_deferred_js
+      return "" unless @defer_js
+      
+      @deffered_js_initialized.must_be.false
+      @deffered_js_initialized = true
+      dont_defer_js do
+        javascript_tag "var deferred_static_scripts = [];"
+      end
+    end
+    
+    def call_deferred_js
+      return "" unless @defer_js
+      
+      @deffered_js_initialized.must_be.true
+      @deferred_js_called.must_be.false
+      @deferred_js_called = true
+      content = <<END
+var i;
+for(i in deferred_static_scripts){deferred_static_scripts[i]()}
+deferred_static_scripts = [];
+END
+      dont_defer_js do
+        javascript_tag content
+      end
+    end
+    
+    def dont_defer_js &block
+      before = @defer_js
+      begin
+        @defer_js = false
+        block.call
+      ensure
+        @defer_js = before
+      end
+    end
+    
+    def defer_js!
+      @defer_js.must_be.false      
+      workspace.params.format.must == 'html'
+      
+      @defer_js = true
+      @deferred_js_called = false      
+      # @defer_static_scripts = workspace.params.format.js? ? false : true
+    end
+  end
+end

data/lib/crystal_ext/ensure_no_www.rb

@@ -0,0 +1,37 @@
+# enshure domain has no www. except if there's custom subdomain
+module Crystal
+  # class UrlWithWww < StandardError
+  # end
+  
+  module Processors        
+    class EnsureNoWww < Processor
+      def call
+        workspace.params.must_be.defined
+        if workspace.params.html? and url_with_www?
+          redirect_without_www
+        else
+          next_processor.call
+        end
+      end            
+      
+      protected
+        def uri
+          @uri ||= Uri.parse workspace.request.url
+        end
+      
+        def url_with_www?
+          uri.host =~ /^www\./
+        end
+        
+        def redirect_without_www
+          uri.host = uri.host.sub(/^www\./, '')
+          url = uri.to_s
+          
+          response = workspace.response
+          response.status = 301
+          response.headers['Location'] = url
+          response.body = %(<html><body>You are being <a href="#{url.html_escape}">redirected</a>.</body></html>)
+        end
+    end
+  end
+end

data/lib/crystal_ext/i18n.rb

@@ -0,0 +1,23 @@
+# Hack, ActiveSupport currently uses differrent version
+# gem 'i18n', '>= 0.4.1'
+# require 'i18n'
+
+require "i18n/backend/pluralization" 
+I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
+
+dir = File.expand_path(File.dirname(__FILE__))
+I18n.load_path += Dir["#{dir}/i18n/locales/*/*.{rb,yml}"]
+
+
+# 
+# Helpers for Crystal
+# 
+[
+  :AbstractController,
+  :ControllerContext,  
+].each do |klass_name|
+  if defined?(Crystal) and Crystal.const_defined?(klass_name)
+    klass = Crystal.const_get(klass_name)
+    klass.delegate :t, :to => I18n
+  end
+end

data/lib/crystal_ext/i18n/locales/ru/pluralization.rb

@@ -0,0 +1,62 @@
+# {
+#   :'ru' => {
+#     :pluralize => lambda { |n| 
+#       # Правило плюрализации для русского языка, взято из CLDR, http://unicode.org/cldr/
+#       #
+#       #
+#       # Russian language pluralization rules, taken from CLDR project, http://unicode.org/cldr/
+#       #
+#       #   one -> n mod 10 is 1 and n mod 100 is not 11;
+#       #   few -> n mod 10 in 2..4 and n mod 100 not in 12..14;
+#       #   many -> n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14;
+#       #   other -> everything else
+#       #
+#       # Пример
+#       #
+#       #   :one  = 1, 21, 31, 41, 51, 61...
+#       #   :few  = 2-4, 22-24, 32-34...
+#       #   :many = 0, 5-20, 25-30, 35-40...
+#       #   :other = 1.31, 2.31, 5.31...
+#       modulo10 = n.modulo(10)
+#       modulo100 = n.modulo(100)
+#       
+#       if modulo10 == 1 && modulo100 != 11
+#         :one
+#       elsif (modulo10 == 2 || modulo10 == 3 || modulo10 == 4) && !(modulo100 == 12 || modulo100 == 13 || modulo100 == 14)
+#         :few
+#       elsif modulo10 == 0 || (modulo10 == 5 || modulo10 == 6 || modulo10 == 7 || modulo10 == 8 || modulo10 == 9) || (modulo100 == 11 || modulo100 == 12 || modulo100 == 13 || modulo100 == 14)
+#         :many
+#       else
+#         :other
+#       end
+#     }
+#   }
+# }
+
+{
+  :ru => {
+    :i18n => {
+      :plural => {
+        :rule => lambda{|n|
+          # Правило плюрализации для русского языка, взято из CLDR, http://unicode.org/cldr/
+          #
+          #
+          # Russian language pluralization rules, taken from CLDR project, http://unicode.org/cldr/
+          #
+          #   one -> n mod 10 is 1 and n mod 100 is not 11;
+          #   few -> n mod 10 in 2..4 and n mod 100 not in 12..14;
+          #   many -> n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14;
+          #   other -> everything else
+          #
+          # Пример
+          #
+          #   :one  = 1, 21, 31, 41, 51, 61...
+          #   :few  = 2-4, 22-24, 32-34...
+          #   :many = 0, 5-20, 25-30, 35-40...
+          #   :other = 1.31, 2.31, 5.31...
+          n % 10 == 1 && n % 100 != 11 ? :one : [2, 3, 4].include?(n % 10) && ![12, 13, 14].include?(n % 100) ? :few : n % 10 == 0 || [5, 6, 7, 8, 9].include?(n % 10) || [11, 12, 13, 14].include?(n % 100) ? :many : :other 
+        }
+      }
+    }
+  }
+}

data/lib/crystal_ext/plugin.rb

@@ -0,0 +1,21 @@
+module Crystal
+  @plugin_initializers = {}
+  class << self
+    attr_accessor :plugin_initializers
+  
+    def initialize_plugin type, dir, *args, &block
+      type = type.to_s      
+      plugin_initializers.must.include(type)
+      
+      pi_class = plugin_initializers[type]
+      pi = pi_class.new dir, *args
+      block.call pi if block
+    end
+  end
+end
+
+require 'crystal_ext/plugin/web'
+crystal.plugin_initializers['web'] = Crystal::Plugin::Web
+
+require 'crystal_ext/plugin/app'
+crystal.plugin_initializers['app'] = Crystal::Plugin::App

data/lib/crystal_ext/plugin/app.rb

@@ -0,0 +1,19 @@
+module Crystal
+  module Plugin
+    class App
+      attr_reader :dir
+      
+      def initialize dir
+        @dir = dir
+      end
+      
+      def plugins list
+        plugins = Array.wrap(list)
+        # add to $LOAD_PATH
+        # plugins.each{|plugin| $LOAD_PATH << "#{dir}/#{plugin}" unless $LOAD_PATH.include?("#{dir}/#{plugin}")}
+        # call plugin's init
+        plugins.each{|plugin| require "#{plugin}/config/init" if File.exist? "#{dir}/#{plugin}/config/init.rb"}
+      end
+    end
+  end
+end

data/lib/crystal_ext/plugin/web.rb

@@ -0,0 +1,44 @@
+module Crystal
+  module Plugin
+    class Web
+      attr_reader :dir
+      
+      def initialize dir
+        @dir = dir
+      end
+      
+      def asset name
+        require 'asset_packager'
+        AssetPackager.add "#{dir}/config/asset_packages.yml", "#{dir}/public"
+        
+        crystal.after :environment do
+          crystal.ensure_public_symlink name, "#{dir}/public"
+        end
+      end
+      
+      def routes
+        crystal.after :environment do
+          routes_file = "#{dir}/config/routes.rb"
+          load routes_file if File.exist? routes_file
+        end
+      end
+      
+      def locales
+        I18n.load_path += Dir["#{dir}/config/locales/**/*.{rb,yml}"]
+      end
+      
+      def require_paths *relative_paths
+        relative_paths = relative_paths.first if relative_paths.first.is_a? Array
+        relative_paths.each do |relative_path|
+          path = "#{dir}/#{relative_path}"
+          $LOAD_PATH << path unless $LOAD_PATH.include? path
+        end
+      end
+      
+      def autoload *list
+        list = list.first if list.first.is_a? Array
+        list.each{|d| autoload_dir "#{dir}/#{d}"}
+      end
+    end
+  end
+end

data/lib/crystal_ext/prepare_model.rb

@@ -0,0 +1,18 @@
+Crystal::AbstractController::ClassMethods.class_eval do
+  def prepare_model aclass, opt = {}
+    id = opt.delete(:id) || :id
+    
+    # variable = opt.delete(:variable) || aclass.model_name.underscore
+    opt.must.include :variable
+    variable = opt.delete(:variable)    
+    
+    finder = opt.delete(:finder) || :find!
+    
+    method = "prepare_#{variable}"
+    define_method method do
+      model = aclass.send finder, params[id]
+      instance_variable_set "@#{variable}", model
+    end
+    before method, opt
+  end
+end

data/lib/crystal_ext/profiles/web_ext.rb

@@ -0,0 +1,75 @@
+require 'crystal_ext/profiles/web_ext_require'
+
+# 
+# Routes
+# 
+Crystal::HttpController.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
+      
+      # forgery protection
+      web.use PrepareAutenticityToken
+      
+      # ensure no www
+      web.use EnsureNoWww
+    
+      # 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
+
+
+# 
+# RackAdapter
+# 
+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_ext/profiles/web_ext_require.rb

@@ -0,0 +1,13 @@
+# crystal
+require 'crystal/profiles/web_require'
+
+# crystal_ext
+%w(
+  defer_js
+  i18n
+  prepare_model
+  user_error
+  ensure_no_www
+  protect_from_forgery
+  plugin
+).each{|f| require "crystal_ext/#{f}"}

data/lib/crystal_ext/protect_from_forgery.rb

@@ -0,0 +1,64 @@
+# 
+# Processor
+# 
+module Crystal
+  module Processors
+    class PrepareAutenticityToken < Processor      
+      def call        
+        if config.session?
+          request = workspace.request.must_be.defined
+          params = workspace.params.must_be.defined
+              
+          token = request.session['authenticity_token'] || params['session_authenticity_token']
+
+          if token.blank? and request.get? and
+            token = generate_authenticity_token
+            request.session['authenticity_token'] = token
+          end
+                
+          workspace.session_authenticity_token = token
+        end
+        
+        next_processor.call
+      end
+
+        
+      protected
+        def generate_authenticity_token
+          ActiveSupport::SecureRandom.base64(32)
+        end
+    end
+  end
+end
+
+
+# 
+# Remote
+# 
+Crystal::HttpController.class_eval do
+  BROWSER_GENERATED_TYPES = %w(html url_encoded_form multipart_form text).to_set
+  
+  protected
+    def protect_from_forgery &block
+      request = workspace.request
+      allow = (
+        request.get? or
+        # TODO2 check content_type is lovercased
+        !BROWSER_GENERATED_TYPES.include?(request.content_type) or
+        (workspace.session_authenticity_token.present? and 
+        workspace.session_authenticity_token == params.authenticity_token)
+      )
+
+      if allow
+        block.call
+      else
+        raise "Invalid authenticity token!"
+      end
+    end
+end
+
+Crystal::HttpController::ClassMethods.class_eval do  
+  def protect_from_forgery options = {}
+    around :protect_from_forgery, options
+  end
+end

data/lib/crystal_ext/user_error.rb

@@ -0,0 +1,12 @@
+class UserError < StandardError
+end
+
+Object.class_eval do
+  def raise_user_error msg
+    raise UserError, msg
+  end
+
+  def self.raise_user_error msg
+    raise UserError, msg
+  end
+end

data/readme.md

@@ -0,0 +1,14 @@
+# Extensions for the Crystal framework.
+
+- abstract_interface - tools for rapid interface creation.
+- common_interface - concrete interface built with abstract_interface tools.
+- asset_packager - packages CSS and JS asset for your application.
+- crystal_ext - additions and extensions of the Crystal.
+- crystal_jquery - jQuery plugin for the Crystal.
+- mongo_mapper_ext - additions and extensions of the MongoMapper.
+- rad - Rapid Application Development tool built upon of the Crystal.
+
+Please go to specs for docs.
+
+P.S.
+All these components will be in standalone gems, but right now it's simpler for me to hold all of them in one place.

data/spec/controller_helper.rb

@@ -0,0 +1,19 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+require 'crystal/profiles/web_require'
+
+require 'crystal/spec'
+
+Spec::Example::ExampleGroup.class_eval do
+  def self.with_controller_ext_spec
+    before :all do
+      crystal.after :environment do
+        crystal.register(:router, :depends_on => :environment){Crystal::Router.new(:class, [Crystal::DefaultRoute.new])}
+
+        crystal.conveyors.web do |web|
+          web.use Crystal::Processors::ControllerCaller, :content
+        end
+      end
+    end
+  end
+end

data/spec/defer_js_spec.rb

@@ -0,0 +1,32 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/controller_helper"
+require 'crystal/html'
+require 'crystal_ext/defer_js'
+
+describe "Defer JS" do
+  before :each do
+    class ContextStub
+      include Crystal::BasicHtmlHelper, Crystal::JavascriptHelper
+      
+      def workspace
+        @workspace ||= {
+          :params => {
+            :format => 'html'
+          }.to_openobject
+        }.to_openobject
+      end    
+    end
+    
+    @t = ContextStub.new
+  end
+  
+  it "should work as usual if deffered mode not enabled" do
+    @t.javascript_tag("script").should == %(<script type="text/javascript">script</script>)
+  end
+  
+  it "deffered mode" do
+    @t.defer_js!
+    @t.initialize_deferred_js.should =~ /var deferred_static_scripts/
+    @t.javascript_tag('script').should =~ /deferred_static_scripts/
+    @t.call_deferred_js.should =~ /deferred_static_scripts/
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,5 @@
+dir = File.expand_path(File.dirname(__FILE__))
+lib_dir = File.expand_path("#{dir}/../../../lib")
+$LOAD_PATH << lib_dir unless $LOAD_PATH.include? lib_dir
+
+require 'spec_ext'

data/spec/i18n_spec.rb

@@ -0,0 +1,30 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+require 'crystal/support' # to check that i18n will correctly works with ActiveSupport
+require 'crystal_ext/i18n'
+
+describe 'I18n' do
+  before :all do
+    dir = File.expand_path(File.dirname(__FILE__))
+    I18n.load_path += Dir["#{dir}/i18n_spec/locales/*/*.{rb,yml}"]
+  end
+  
+  def t *args
+    I18n.t *args
+  end
+  
+  it "basic" do
+    I18n.locale = 'en'
+    t(:name).should == "Name"
+    t(:name).is_a?(String).should be_true
+    
+    I18n.locale = 'ru'
+    t(:name).should == "Имя"
+  end
+  
+  it "pluggable pluralization" do
+    I18n.locale = 'ru'
+    t(:comments_count, :count => 1).should == "1 комментарий"
+    t(:comments_count, :count => 2).should == "2 комментария"
+    t(:comments_count, :count => 5).should == "5 комментариев"
+  end
+end

data/spec/i18n_spec/locales/en/general.yml

@@ -0,0 +1,5 @@
+en:
+  name: "Name"
+  comments:
+    one: "%{count} comment"
+    many: "%{count} comments"

data/spec/i18n_spec/locales/ru/general.yml

@@ -0,0 +1,7 @@
+ru:
+  name: "Имя"
+  comments_count:
+    one: "%{count} комментарий"
+    few: "%{count} комментария"
+    many: "%{count} комментариев"
+    other: "%{count} комментариев"

data/spec/prepare_model_spec.rb

@@ -0,0 +1,42 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/controller_helper"
+require 'crystal_ext/prepare_model'
+
+describe "User Error" do
+  with_environment :test
+  with_controller_ext_spec
+  
+  before :all do
+    class ::SomeModel
+      def self.find! id
+        id.should == 'some id'
+        SomeModel.new
+      end
+    end
+    
+    # crystal[:config].environment = :test
+    # crystal[:environment] = Crystal::Environment.new
+    # crystal[:environment].load :controller_ext_spec
+  end
+  
+  after :all do    
+    remove_constants %w(SomeModel ControllerSpec)
+    
+    # Micon.clear
+  end
+  
+  it "user error" do
+    class ::ControllerSpec
+      inherit Crystal::HttpController
+      
+      prepare_model SomeModel, :id => :some_model, :variable => 'some_model'
+      
+      def action
+        @some_model.should_not == nil
+        render :inline => 'ok'
+      end
+    end
+    
+    ccall(ControllerSpec, :action, :some_model => 'some id').content.should == 'ok'
+    # workspace.response.should == [200, {"Content-Type"=>"application/json"}, %({"result":true})]
+  end
+end

data/spec/protect_from_forgery_spec.rb

@@ -0,0 +1,169 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+require 'crystal/profiles/web_require'
+require 'crystal_ext/protect_from_forgery'
+
+require 'crystal/spec/environment'
+
+describe "Forgery protection" do  
+  with_environment :test
+  
+  before :all do    
+    class ForgerySpecHelper < Crystal::Processor
+      def call
+        block = workspace.check_forgery.before_request
+        block.call workspace if block
+        workspace.before_request_done = true
+
+        next_processor.call
+
+        block = workspace.check_forgery.after_request
+        block.call workspace if block
+        workspace.after_request_done = true    
+      end
+    end
+    
+    class ::AnRemote
+      inherit Crystal::HttpController
+      
+      protect_from_forgery :only => :protected_method
+      
+      def protected_method
+        render :inline => 'protected result'
+      end
+      
+      def method_without_protection
+        render :inline => 'result'
+      end
+      
+      def dumb_method; end
+    end
+    
+    crystal.after :environment do      
+      crystal.conveyors.web do |web|
+        web.use Crystal::Processors::PrepareParams
+        web.use Crystal::Processors::EvaluateFormat
+        web.use ForgerySpecHelper
+        web.use Crystal::Processors::PrepareAutenticityToken
+        web.use Crystal::Processors::ControllerCaller, :content
+      end
+      
+      crystal.config.session = {'key' => 'session_id'}
+    end
+  end
+  
+  after :all do
+    remove_constants %w(AnRemote ForgerySpecHelper)
+  end
+  
+  def check_forgery opt    
+    workspace = nil 
+    result = Crystal::HTTPAdapter.mock_call({}, :check_forgery => opt.to_openobject) do |&block|
+      block.call
+      workspace = crystal[:workspace]
+    end
+    
+    workspace.before_request_done.should be_true
+    workspace.after_request_done.should be_true
+    workspace
+  end
+  
+  it "should set :authenticity_token only for :get and :html request" do
+    check_forgery(
+      :before_request => lambda{|workspace|        
+        workspace.env['REQUEST_METHOD'] = 'GET'        
+        workspace.env['CONTENT_TYPE'] = 'html'
+        workspace.class = AnRemote
+        workspace.method_name = 'dumb_method'
+      },
+      :after_request => lambda{|workspace|
+        workspace.request.session['authenticity_token'].should_not be_blank
+      }
+    )
+    
+    # post
+    check_forgery(
+      :before_request => lambda{|workspace|        
+        workspace.env['REQUEST_METHOD'] = 'POST'        
+        workspace.env['CONTENT_TYPE'] = 'html'
+        workspace.class = AnRemote
+        workspace.method_name = 'dumb_method'
+      },
+      :after_request => lambda{|workspace|
+        workspace.request.session['authenticity_token'].should be_blank
+      }
+    )
+  end
+  
+  it "should check any non :get request with browser's formats for :authenticity_token" do
+    lambda{
+      check_forgery(
+        :before_request => lambda{|workspace|        
+          workspace.env['REQUEST_METHOD'] = 'POST'        
+          workspace.env['CONTENT_TYPE'] = 'html'
+          workspace.class = AnRemote
+          workspace.method_name = 'protected_method'
+        }
+      )
+    }.should raise_error(/Invalid authenticity token/)
+    
+    # with correct :authenticity_token
+    check_forgery(
+      :before_request => lambda{|workspace|
+        workspace.env['REQUEST_METHOD'] = 'POST'        
+        workspace.env['CONTENT_TYPE'] = 'html'
+        workspace.request.session['authenticity_token'] = 'secure token'
+        workspace.params['authenticity_token'] = 'secure token'
+        workspace.class = AnRemote
+        workspace.method_name = 'protected_method'
+      },
+      :after_request => lambda{|workspace|
+        workspace.content.should == "protected result"
+      }
+    )
+    
+    # non-browser format
+    check_forgery(
+      :before_request => lambda{|workspace|
+        workspace.env['REQUEST_METHOD'] = 'POST'        
+        workspace.env['CONTENT_TYPE'] = 'non-browser-format'
+        workspace.class = AnRemote
+        workspace.method_name = 'protected_method'
+      },
+      :after_request => lambda{|workspace|
+        workspace.content.should == "protected result"
+      }
+    )
+  end
+  
+  it "should not protect non protected methods" do
+    check_forgery(
+      :before_request => lambda{|workspace|        
+        workspace.env['REQUEST_METHOD'] = 'POST'        
+        workspace.env['CONTENT_TYPE'] = 'html'
+        workspace.class = AnRemote
+        workspace.method_name = 'method_without_protection'
+      },
+      :after_request => lambda{|workspace|
+        workspace.content.should == "result"
+      }
+    )    
+  end
+  
+  it "should use :session_authenticity_token from params (for flash support)" do
+    check_forgery(
+      :before_request => lambda{|workspace|
+        workspace.env['REQUEST_METHOD'] = 'POST'        
+        workspace.params.format = 'html'
+        workspace.params['session_authenticity_token'] = 'secure token'
+        workspace.params['authenticity_token'] = 'secure token'
+        workspace.class = AnRemote
+        workspace.method_name = 'protected_method'
+      },
+      :after_request => lambda{|workspace|
+        workspace.content.should == "protected result"
+      }
+    )
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/user_error_spec.rb

@@ -0,0 +1,41 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/controller_helper"
+require 'crystal_ext/user_error'
+require 'crystal_ext/controller_helper'
+
+describe "User Error" do
+  with_environment :test
+  with_controller_ext_spec
+  
+  # before :all do
+  #   crystal[:config].environment = :test
+  #   crystal[:environment] = Crystal::Environment.new
+  #   crystal[:environment].load :controller_ext_spec
+  # end
+  
+  after :all do
+    # Micon.clear
+    remove_constants %w(UserErrorSpec)
+  end
+  
+  it "user error" do
+    class ::UserErrorSpec
+      inherit Crystal::HttpController
+      
+      def call
+        raise_user_error "some error"
+      end      
+      
+      protected
+        def catch_user_error
+          begin
+            yield
+          rescue UserError => ue
+            render :inline => "Catched #{ue.message}"
+          end
+        end
+        around :catch_user_error
+    end
+    
+    ccall(UserErrorSpec, :call).content.should == "Catched some error"
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: crystal_ext
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Alexey Petrushin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-11 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: crystal
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- readme.md
+- lib/crystal_ext/defer_js.rb
+- lib/crystal_ext/ensure_no_www.rb
+- lib/crystal_ext/i18n/locales/ru/pluralization.rb
+- lib/crystal_ext/i18n.rb
+- lib/crystal_ext/plugin/app.rb
+- lib/crystal_ext/plugin/web.rb
+- lib/crystal_ext/plugin.rb
+- lib/crystal_ext/prepare_model.rb
+- lib/crystal_ext/profiles/web_ext.rb
+- lib/crystal_ext/profiles/web_ext_require.rb
+- lib/crystal_ext/protect_from_forgery.rb
+- lib/crystal_ext/user_error.rb
+- spec/controller_helper.rb
+- spec/defer_js_spec.rb
+- spec/helper.rb
+- spec/i18n_spec/locales/en/general.yml
+- spec/i18n_spec/locales/ru/general.yml
+- spec/i18n_spec.rb
+- spec/prepare_model_spec.rb
+- spec/protect_from_forgery_spec.rb
+- spec/spec.opts
+- spec/user_error_spec.rb
+has_rdoc: true
+homepage: http://github.com/alexeypetrushin/crystal_ext
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Extensions for the Crystal Framework
+test_files: []
+