crystal-ext 0.0.1

data/lib/mongo_mapper_ext/migration.rb

@@ -0,0 +1,108 @@
+module MongoMapper::Migration
+  class MigrationDefinition
+    def upgrade &block
+      if block
+        @upgrade = block
+      else
+        @upgrade
+      end
+    end
+    alias_method :up, :upgrade
+    
+    def downgrade &block
+      if block
+        @downgrade = block
+      else
+        @downgrade
+      end
+    end
+    alias_method :down, :downgrade
+  end
+  
+  class Logger
+    attr_accessor :enabled
+    
+    def initialize enabled = true
+      self.enabled = enabled
+    end
+    
+    def info message
+      puts message if enabled
+    end
+  end
+  
+  class << self
+    def logger= logger
+      @logger = logger ? logger : Logger.new(false)
+    end
+    
+    def logger; @logger ||= Logger.new end
+    
+    def define database_alias, version, &block
+      database_alias = database_alias.to_s
+      
+      version.should! :be_a, Integer
+      definition = MigrationDefinition.new
+      block.call definition
+      definitions[database_alias][version] = definition
+    end
+            
+    def update database_alias, version  
+      database_alias = database_alias.to_s
+      db = MongoMapper.databases[database_alias]
+      
+      if metadata(db).version == version
+        logger.info "Database '#{database_alias}' already is of #{version} version, no migration needed."
+        return false
+      else
+        logger.info "Migration for '#{database_alias}' Database:"
+      end
+      
+      increase_db_version database_alias, db while metadata(db).version < version
+      decrease_db_version database_alias, db while metadata(db).version > version
+      true
+    end
+        
+    def metadata db
+      col = db.collection 'db_metadata'
+      metadata = (col.find_one || {:version => 0}).to_openobject
+    end
+    
+    def definitions
+      @definitions ||= Hash.new{|h, k| h[k] = []} 
+    end
+    
+    protected
+      def increase_db_version database_alias, db    
+        m = metadata(db)
+        migration = definitions[database_alias][m.version + 1]        
+        raise "No upgrade for version #{m.version + 1} of '#{database_alias}' Database!" unless migration and migration.up
+        
+        migration.up.call db
+        
+        m.version += 1        
+        update_metadata db, m
+        
+        logger.info "Database '#{database_alias}' upgraded to version #{m.version}."
+      end
+      
+      def decrease_db_version database_alias, db
+        m = metadata(db)
+        migration = definitions[database_alias][m.version]        
+        raise "No downgrade for version #{m.version} of '#{database_alias}' Database!" unless migration and migration.down
+        
+        migration.down.call db
+        
+        m.version -= 1
+        update_metadata db, m
+        
+        logger.info "Database '#{database_alias}' downgraded to version #{m.version}."
+      end
+
+      
+      def update_metadata db, metadata
+        col = db.collection 'db_metadata'
+        col.save metadata.to_hash
+      end
+  end
+end

data/lib/mongo_mapper_ext/mongo_mapper.rb

@@ -0,0 +1,25 @@
+MongoMapper.class_eval do
+  class << self
+    
+    def logger
+      # return @logger ||= Logger.new(nil) if defined?(Spec)
+      unless @logger
+        @logger = if "irb" == $0
+          Logger.new(STDOUT)
+        else
+          if defined?(Rails)
+            Rails.test? ? Logger.new(nil) : Rails.logger
+          else
+            Logger.new(STDOUT)
+          end
+        end
+      end
+      @logger
+    end
+    
+    def logger= logger
+      @logger = logger
+    end
+    
+  end
+end

data/lib/mongo_mapper_ext/plugins/attributes_cache.rb

@@ -0,0 +1,22 @@
+module MongoMapper
+  module Plugins
+    module AttributesCache
+      
+      module InstanceMethods
+        def cache
+          @cache ||= {}
+        end
+
+        def clear_cache
+          @cache = {}
+        end
+
+        def reload
+          @cache.clear if @cache
+          super
+        end
+      end
+      
+    end
+  end
+end

data/lib/mongo_mapper_ext/plugins/default_scope.rb

@@ -0,0 +1,76 @@
+module MongoMapper
+  module Plugins
+    module DefaultScope
+      
+      module ClassMethods
+        def find_one options = {}
+          super default_scope_options.merge(options)
+        end
+
+        def find_many options = {}
+          super default_scope_options.merge(options)
+        end
+        
+        def count options={}
+          super default_scope_options.merge(options)
+        end
+        
+        def with_exclusive_scope options = {}, &block
+          Thread.current['mm_with_exclusive_scope'].should! :be_nil
+          
+          before = Thread.current['mm_with_exclusive_scope']
+          begin
+            Thread.current['mm_with_exclusive_scope'] = options
+            block.call if block
+          ensure
+            Thread.current['mm_with_exclusive_scope'] = before
+          end
+        end
+        
+        def with_scope options = {}, &block
+          Thread.current['mm_with_exclusive_scope'].should! :be_nil
+          
+          before = Thread.current['mm_with_scope']
+          begin
+            options = before.merge options if before
+            Thread.current['mm_with_scope'] = options
+            block.call if block
+          ensure
+            Thread.current['mm_with_scope'] = before
+          end
+        end
+        
+        protected
+          def default_scope options = nil, &block          
+            options.should! :be_a, [NilClass, Hash]
+            self.write_inheritable_attribute(:default_scope, (options || block))
+          end
+                  
+        private
+          def default_scope_options
+            default_scope = self.read_inheritable_attribute(:default_scope)
+            
+            exclusive_options = Thread.current['mm_with_exclusive_scope']
+            return exclusive_options if exclusive_options
+            
+            options = if default_scope
+              if default_scope.respond_to? :call
+                default_scope.call self
+              else
+                default_scope
+              end
+            else
+              {}
+            end
+            
+            if scope_options = Thread.current['mm_with_scope']
+              options = options.merge scope_options
+            end
+            
+            options
+          end
+      end
+      
+    end
+  end
+end

data/lib/mongo_mapper_ext/plugins/micelaneous.rb

@@ -0,0 +1,81 @@
+module MongoMapper
+  module Plugins
+    module Micelaneous
+      
+      module InstanceMethods
+        def upsert *args
+          self.class.upsert id, *args
+        end
+      end
+      
+      module ClassMethods
+        # 
+        # Sequentiall :all for big collection
+        # 
+        def all_sequentially &block
+          page, per_page = 1, 5
+          begin
+            results = paginate(:page => page, :per_page => per_page, :order => '_id asc')
+            results.each{|o| block.call o}
+            page += 1
+          end until results.blank? or results.size < per_page
+        end
+        
+        
+        # 
+        # Connect to database_alias specified in config
+        # 
+        def use_database database_alias          
+          database_alias = database_alias.to_s
+          MongoMapper.db_config.should! :include, database_alias
+
+          self.connection MongoMapper.connections[database_alias]
+          set_database_name MongoMapper.db_config[database_alias]['name']
+        end        
+        
+        
+        # 
+        # shortcut for upsert
+        # 
+        def upsert *args
+          collection.upsert *args          
+        end
+        
+        
+        # 
+        # CounterCache
+        # belongs_to :item, :counter_cashe => true
+        # 
+        def belongs_to association_id, options={}, &extension          
+          options.should_not! :include, :counter_cashe
+          if options.delete(:counter_cache) || options.delete('counter_cache')
+            association_id = association_id.to_s
+            association_key = "#{association_id}_id"
+            cache_attribute = "#{name.pluralize.underscore}_count"
+            cache_class = association_id.classify.constantize
+            cache_class.keys.should! :include, cache_attribute            
+            increase_method_name = "increase_#{cache_class.name.underscore}_#{name.pluralize.underscore}_counter"
+            decrease_method_name = "decrease_#{cache_class.name.underscore}_#{name.pluralize.underscore}_counter"
+            
+            define_method increase_method_name do
+              cache_class.upsert self.send(association_key), :$inc => {cache_attribute => 1}
+            end
+            protected increase_method_name            
+            
+            define_method decrease_method_name do
+              cache_class.upsert self.send(association_key), :$inc => {cache_attribute => -1}
+            end
+            protected decrease_method_name
+            
+            after_create increase_method_name
+            after_destroy decrease_method_name
+          end
+          
+          super association_id, options, &extension
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/mongo_mapper_ext/spec_helper.rb

@@ -0,0 +1,10 @@
+Spec::Runner.configure do |config|
+  config.before(:each) do    
+    MongoMapper.db_config.each do |db_alias, opt|
+      db = MongoMapper.databases[db_alias]
+      db.collection_names.each do |name|
+        db.collection(name).drop
+      end
+    end
+  end
+end

data/lib/mongo_mapper_ext/view_helpers.rb

@@ -0,0 +1,10 @@
+# 
+# HTML helpers
+# 
+[MongoMapper::EmbeddedDocument::InstanceMethods, MongoMapper::Document::InstanceMethods].each do |aclass|
+  aclass.class_eval do
+    def dom_id
+      new_record? ? "new_#{self.class.name.underscore}" : to_param
+    end
+  end
+end

data/lib/mongo_mapper_ext.rb

@@ -0,0 +1,29 @@
+require 'mongo_mapper'
+
+
+[
+  'hacks/fixes',
+  'hacks/time_measuring',
+  'migration',
+  'mongo_mapper',
+  'view_helpers',
+  'db_config',
+  'micelaneous',
+  
+  'plugins/default_scope',
+  'plugins/attributes_cache',
+  'plugins/micelaneous',  
+].each do |file|
+  require "#{File.dirname __FILE__}/mongo_mapper_ext/#{file}"
+end
+
+module CommonPluginsAddition
+  def self.included(model)
+    model.plugin MongoMapper::Plugins::DefaultScope
+    model.plugin MongoMapper::Plugins::AttributesCache
+    model.plugin MongoMapper::Plugins::Micelaneous
+    
+    model.attr_protected :id, :_id, :_type, :created_at, :updated_at
+  end
+end
+MongoMapper::Document.append_inclusions(CommonPluginsAddition)

data/lib/rails_ext/README.markdown

@@ -0,0 +1,13 @@
+# Ruby on Rails extensions.
+
+* Abstract Interface: Tool for rapid web interface creation, see [Common Interface][common_interface] - concrete realisation of Abstract Interface
+* MongoMapperExt: MongoMapper extensions, Migration, Query Profiling in Log, Attributes Cache, Default Scope, BelongsTo Counter Cache
+* Sunspot: Sunspot support for MongoMapper
+* rails_ext - a lots of Rails hacks, mainly to add inheritance support (because there's no OOD and inheritance in Rails by default).
+
+All these extensions should be different gems itself but right for me it's easier to deal with all of them in one place, later I'll split them.
+
+
+Copyright (c) 2009 Alexey Petrushin ([http://bos-tec.com](http://bos-tec.com)), released under the MIT license.
+
+[common_interface]: http://github.com/alexeypetrushin/common_interface

data/lib/rails_ext/action_controller/global_path_prefix.rb

@@ -0,0 +1,56 @@
+# 
+# Global path prefix (hack with relative_url_root)
+# 
+GLOBAL_PATH_PREFIX_DELIMITER = '-'
+ActionController::Base.send :class_eval do 
+  def self.global_path_prefix
+    @global_path_prefix ||= []
+  end
+  
+  def self.global_path_prefix= list
+    @global_path_prefix = list.collect{|v| v.to_s}
+  end
+  
+  cattr_accessor :_relative_url_root  
+end
+ActionController::Base._relative_url_root = ActionController::Base.relative_url_root || ""
+
+# 
+# Generation
+# 
+
+# routes
+ActionController::Base.send :class_eval do
+  around_filter :hack_relative_url_root
+  protected 
+  
+  # preparing relative_url_root from params
+  def hack_relative_url_root
+    begin
+      update_relative_url_root!
+      yield
+    ensure
+      ActionController::Base.relative_url_root = ActionController::Base._relative_url_root
+    end
+  end
+  
+  def update_relative_url_root!
+    prefix_params = []
+    ActionController::Base.global_path_prefix.each do |name|
+      unless (param = params[name]).blank?
+        prefix_params << [name, CGI.escape(param)]
+      end
+    end
+    prefix = prefix_params.collect{|name, param|  "#{param}#{GLOBAL_PATH_PREFIX_DELIMITER}#{name}"}.join('/')
+    ActionController::Base.relative_url_root = ActionController::Base._relative_url_root + (prefix.blank? ? "" : "/" + prefix)
+  end
+end
+
+# 
+# Usability
+# allows to install a global_path_prefix to the route set by calling: map.global_path_prefix 'locale'
+ActionController::Routing::RouteSet::Mapper.class_eval do
+  def global_path_prefix *args
+    ActionController::Base.global_path_prefix = args
+  end
+end

data/lib/rails_ext/action_controller/micelaneous.rb

@@ -0,0 +1,118 @@
+# Shortcut for :unprocessable_entity, head(:failed) instead of head(:unprocessable_entity)
+ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[:failed] = 422
+
+# 
+# url_for, used to generate url_for for string path with options and with default_url_options
+# 
+ActionController::Base.class_eval do
+  protected  
+    # 
+    # link_to
+    # 
+    def link_to text, uri
+      %{<a href="#{uri}">#{text}</a>}
+    end  
+  
+    # 
+    # Bunch of small actions
+    # 
+    def render_action action_or_template    
+      args = action_or_template.to_s.split('/')      
+      args.size.should! :be_in, 1..2
+      if args.size == 1
+        action = args.first
+        @the_action = action.to_sym
+        render :action => 'actions'
+      else
+        path, action = args
+        @the_action = action.to_sym
+        render :template => "#{path}/actions"
+      end       
+    end
+    
+    def the_action; @the_action end
+    helper_method :the_action    
+  
+  
+    # 
+    # Url from String Path
+    # 
+    def url_for_path path, options = {}
+      unless options.delete :no_prefix
+        url = ActionController::Base.relative_url_root + path
+      else
+        url = path.dup
+      end
+      
+      options = default_url_options.merge options
+      
+      # Delete 'nil' parameters
+      to_delete = []
+      options.each{|k, v| to_delete << k if v.nil?}
+      to_delete.each{|k| options.delete k}
+      
+      host = options.delete(:host) || options.delete('host')
+      port = options.delete(:port) || options.delete('port')
+      
+      delimiter = path.include?('?') ? '&' : '?'
+      
+      url << "#{delimiter}#{options.to_query}" unless options.empty?
+      url._url_format = options[:format] if options[:format] # hack for links with ajax support
+      url
+      
+      if host.blank?
+        url
+      else
+        %{http://#{host}#{":#{port}" unless port.blank?}#{url}}
+      end
+    end
+    helper_method :url_for_path
+  
+   
+    # 
+    # User Error
+    # 
+    def catch_user_error
+      begin
+        yield
+      rescue UserError => e
+        flash[:error] = e.message
+        flash[:sticky_error] = e.message
+        do_not_persist_params do
+          if request.xhr? or request.format == 'js'
+            render :inline => "", :layout => 'application'
+          else
+            redirect_to default_path
+          end          
+        end
+      end
+    end
+    around_filter :catch_user_error
+        
+    # 
+    # enshure domain has www. except if there's custom subdomain
+    # 
+    def ensure_no_www
+      uri = Addressable::URI.parse request.url
+      if uri.host =~ /^www\./
+        uri.host = uri.host.sub(/^www\./, '')
+        redirect_to uri.to_s
+      end
+    end        
+  
+  class << self
+    
+    def prepare_model aclass, opt = {}
+      id = opt.delete(:id) || :id
+      variable = opt.delete(:variable) || aclass.model_name.underscore
+      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_filter method, opt
+    end
+  end
+end

data/lib/rails_ext/action_controller/persistent_params.rb

@@ -0,0 +1,96 @@
+ActionController::Base.send :class_eval do
+  protected
+  
+  DO_NOT_PERSIST = ['_', '_method']
+
+  def default_url_options options = {}
+    persistent_params = {}
+    
+    if options
+      options = options.stringify_keys if options
+      global_persistent_params = ActionController::Base.global_persistent_params
+    
+      if Thread.current[:persist_params] or options.delete(:persist)
+        params.each do |key, value|
+          persist = (
+            (key =~ /^_/) and
+            !(options.include?(key) or DO_NOT_PERSIST.include?(key))
+          ) or global_persistent_params.include?(key)
+
+          persistent_params[key] = value if persist
+        end
+      end
+        
+      # global_persistent_params.each do |key, value|
+      #   persistent_params[key] = value unless options.include?(key)
+      # end
+    end
+    
+    return persistent_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 
+  helper_method :persist_params
+  
+  def do_not_persist_params &block
+    before = Thread.current[:persist_params]
+    begin
+      Thread.current[:persist_params] = false
+      block.call
+    ensure
+      Thread.current[:persist_params] = before
+    end
+  end 
+  helper_method :do_not_persist_params
+  
+  # def prepare_global_persistent_params
+  #   persistent_params = ActionController::Base.global_persistent_params
+  #   prefix_params = ActionController::Base.global_path_prefix
+  #   params = self.params.stringify_keys
+  #   params.each do |key, value|
+  #     if persistent_params.include?(key) and !prefix_params.include?(key)
+  #       global_persistent_params[key] = value
+  #     end
+  #   end
+  # end
+  # def global_persistent_params
+  #   @global_persistent_params ||= {}
+  # end
+  # before_filter :prepare_global_persistent_params
+  
+  class << self
+    def global_persistent_params= params
+      @global_persistent_params = params.collect &:to_s
+    end
+    
+    def global_persistent_params
+      @global_persistent_params ||= []
+    end
+    
+    def persist_params *args
+      if args.empty?
+        around_filter :persist_params
+      elsif args.first.is_a? Hash
+        # args.first.should! :be_a, Hash
+        around_filter :persist_params, args.first
+      else
+        around_filter :persist_params, :only => args.first
+      end
+    end
+  end
+end
+
+# allows to install a global_persistent_params to the route set by calling: map.global_persistent_params 'locale'
+ActionController::Routing::RouteSet::Mapper.class_eval do
+  def global_persistent_params *args
+    ActionController::Base.global_persistent_params = args
+  end
+end

data/lib/rails_ext/action_controller/redirect_helper.rb

@@ -0,0 +1,14 @@
+ActionController::Base.send :class_eval do
+  protected
+  def default_path options = {}
+    url_for_path SETTING.default_path!, options.merge(:no_prefix => true)
+  end
+
+  def return_to_path options = {}
+    do_not_persist_params do 
+      url_for_path params[:_return_to] || session[:return_to] || SETTING.default_path!, options.merge(:no_prefix => true)
+    end
+  end
+    
+  helper_method :default_path, :return_to_path
+end

data/lib/rails_ext/action_controller/reload_page.rb

@@ -0,0 +1,7 @@
+ActionController::Base.send :class_eval do
+  protected
+  def reload_page
+    preserve_flash_for_ajax_page_update
+    render :inline => "window.location.reload();", :layout => 'application'
+  end
+end

data/lib/rails_ext/action_controller.rb

@@ -0,0 +1,19 @@
+require 'rails_ext/basic'
+
+require 'rails_ext/action_controller/micelaneous'
+
+require 'rails_ext/action_controller/global_path_prefix'
+require 'rails_ext/hacks/global_path_prefix'
+
+require 'rails_ext/hacks/link_to'
+
+require 'rails_ext/hacks/ajax_flash'
+
+require 'rails_ext/hacks/ajax_redirect_to'
+
+require 'rails_ext/action_controller/persistent_params'
+require 'rails_ext/hacks/persistent_params'
+
+require 'rails_ext/action_controller/redirect_helper'
+
+require 'rails_ext/action_controller/reload_page'