mongo_mapper_ext 0.2.2 → 0.2.3

data/Rakefile

@@ -1,10 +1,10 @@
 require 'rake_ext'
 
 project(
-  :name => "mongo_mapper_ext",
-  :version => "0.2.2",
-  :summary => "Extensions for MongoMapper",
+  name: "mongo_mapper_ext",
+  version: "0.2.3",
+  summary: "Extensions for MongoMapper",
 
-  :author => "Alexey Petrushin",
-  :homepage => "http://github.com/alexeypetrushin/mongo_mapper"
+  author: "Alexey Petrushin",
+  homepage: "http://github.com/alexeypetrushin/mongo_mapper"
 )

data/lib/mongo_db_ext/micelaneous.rb

@@ -0,0 +1,12 @@
+#
+# upsert
+# 
+Mongo::Collection.class_eval do
+  def upsert! query, opt
+    opt.size.must == 1
+    opt.must_be.a Hash
+    opt.values.first.must_be.a Hash
+    
+    update(query, opt, {upsert: true, safe: true})
+  end
+end

data/lib/mongo_mapper_ext/gems.rb

@@ -1,2 +1,17 @@
-gem 'mongo_mapper', '0.8.6'
-gem 'bson_ext', '1.1.1'
+# core gems
+gem 'mongo_mapper', '0.9.0'
+
+gem 'carrierwave',   '0.5.3'
+
+# dependencies for core gems
+gem 'i18n', '0.5.0'
+gem 'activesupport', '3.0.7'
+gem 'activemodel', '3.0.7'
+gem 'bson', '1.3.0'
+gem 'bson_ext', '1.3.0'
+gem 'mongo', '1.3.0'
+gem 'plucky', '0.3.6'
+gem 'jnunemaker-validatable', '1.8.4'
+
+gem 'mini_magick',   '3.2.1'
+gem 'subexec',       '0.0.4'

data/lib/mongo_mapper_ext/hacks/active_model.rb

@@ -0,0 +1,16 @@
+ActiveModel::Name.class_eval do
+  def initialize klass, name = nil
+    name ||= klass.name
+    
+    super name
+    
+    @klass = klass
+    @singular = ActiveSupport::Inflector.underscore(self).tr('/', '_').freeze
+    @plural = ActiveSupport::Inflector.pluralize(@singular).freeze
+    @element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).freeze
+    @human = ActiveSupport::Inflector.humanize(@element).freeze
+    @collection = ActiveSupport::Inflector.tableize(self).freeze
+    @partial_path = "#{@collection}/#{@element}".freeze
+    @i18n_key = ActiveSupport::Inflector.underscore(self).tr('/', '.').to_sym
+  end
+end

data/lib/mongo_mapper_ext/hacks/fixes.rb

@@ -18,3 +18,40 @@ MongoMapper::Plugins::Associations::InArrayProxy.class_eval do
     reset
   end
 end
+
+#
+# Problem after destroying model the :to_param method returns :nill, 
+# and we can't use :to_param in view (for example in ajax to remove element with id from the screen).
+#
+module MongoMapper
+  module Plugins
+    module Rails
+      module InstanceMethods
+        # def to_param
+        #   id.to_s if persisted? # old realization
+        # end
+        def to_param
+          id.to_s
+        end
+      end
+    end
+  end
+end
+
+
+# 
+# Use class alias instead of class name, because it causes foreign keys like 'models_account_id' instead of 'account_id' if
+# for models like Models::Account
+# 
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyDocumentsProxy
+          def foreign_key
+            # options[:foreign_key] || proxy_owner.class.name.to_s.underscore.gsub("/", "_") + "_id"
+            options[:foreign_key] || proxy_owner.class.alias.to_s.underscore.gsub("/", "_") + "_id"
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper_ext/{micelaneous.rb → logging.rb}

@@ -1,13 +1,28 @@
-#
-# upsert
 # 
-Mongo::Collection.class_eval do
-  def upsert id, opt
-    opt.size.must == 1
-    opt.must_be.a Hash
-    opt.values.first.must_be.a Hash
+# Custom Logger
+# 
+MongoMapper.class_eval do
+  class << self
+    
+    def logger
+      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
     
-    update({:_id => id}, opt, {:upsert => true, :safe => true})
   end
 end
 
@@ -36,6 +51,13 @@ MongoMapper.class_eval do
       end
     end
   end
+  
+  def self.use_database database_alias
+    database_alias = database_alias.to_s
+    MongoMapper.db_config.must.include database_alias 
+    MongoMapper.connection = MongoMapper.connections['default']
+    MongoMapper.database = MongoMapper.db_config['default']['name']
+  end
 end
 
 

data/lib/mongo_mapper_ext/migration.rb

@@ -65,7 +65,7 @@ module MongoMapper::Migration
         
     def metadata db
       col = db.collection 'db_metadata'
-      metadata = (col.find_one || {:version => 0}).to_openobject
+      metadata = (col.find_one || {version: 0}).to_openobject
     end
     
     def definitions

data/lib/mongo_mapper_ext/mongo_mapper.rb

@@ -1,25 +0,0 @@
-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 → attribute_cache.rb}

@@ -1,6 +1,7 @@
 module MongoMapper
   module Plugins
-    module AttributesCache
+    module AttributeCache
+      extend ActiveSupport::Concern
       
       module InstanceMethods
         def cache

data/lib/mongo_mapper_ext/plugins/attribute_convertors.rb

@@ -0,0 +1,79 @@
+module MongoMapper
+  module Plugins
+    module AttributeConvertors
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        ATTRIBUTE_CONVERTORS = {
+          line: {
+            from_string: -> s {(s || "").split(',').collect{|s| s.strip}},
+            to_string:   -> v {v.join(', ')}
+          },
+          column: {
+            from_string: -> s {(s || "").split("\n").collect{|s| s.strip}},
+            to_string:   -> v {v.join("\n")}
+          },
+          yaml: {
+            from_string: -> s {YAML.load s rescue {}},
+            to_string:   -> v {              
+              # MongoMapper uses it's internal Hash that doesn't support to_yaml
+              hash = {}; v.each{|k, v| hash[k] = v}               
+              hash.to_yaml.strip
+            }
+          },
+          json: {
+            from_string: -> s {JSON.parse s rescue {}},
+            to_string:   -> v {
+              # MongoMapper uses it's internal Hash that doesn't support to_yaml
+              hash = {}; v.each{|k, v| hash[k] = v}               
+              hash.to_json.strip
+            }
+          }
+        }
+        
+        
+        # 
+        # supporf for :as_string option
+        # 
+        def key(*args)
+          key = super                    
+          if converter_name = key.options[:as_string]
+            key_name = key.name.to_sym            
+            available_as_string key_name, converter_name
+            attr_protected "#{key_name}_as_string".to_sym if key.options[:protected]            
+          end
+          key
+        end
+        
+        def available_as_string key_name, converter_name
+          converter = ATTRIBUTE_CONVERTORS[converter_name]
+          raise "unknown converter name :#{converter_name} for :#{key_name} key!" unless converter
+          
+          from_string, to_string = converter[:from_string], converter[:to_string]
+          key_name_as_string = "#{key_name}_as_string".to_sym
+          define_method key_name_as_string do
+            cache[key_name_as_string] ||= to_string.call(self.send(key_name))
+          end
+          define_method "#{key_name_as_string}=" do |value|
+            cache.delete key_name_as_string                        
+            self.send "#{key_name}=", from_string.call(value)
+          end
+        end
+        
+        def available_as_yaml key_name
+          raise "delimiter not specified for :#{key_name} key!" unless delimiter
+          method = "#{key_name}_as_string"
+          define_method method do
+            self.send(key_name).join(delimiter)
+          end
+          define_method "#{method}=" do |value|            
+            value = (value || "").split(delimiter.strip).collect{|s| s.strip}
+            self.send "#{key_name}=", value
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/mongo_mapper_ext/plugins/belongs_to_with_counter_cache.rb

@@ -0,0 +1,45 @@
+module MongoMapper
+  module Plugins
+    module BelongsToWithCounterCache
+      extend ActiveSupport::Concern
+
+      module ClassMethods                
+        # 
+        # CounterCache
+        # belongs_to :item, counter_cashe: true
+        # 
+        def belongs_to association_id, options={}, &extension          
+          options.must_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 = "#{self.alias.pluralize.underscore}_count"
+            cache_class = if class_name = options[:class_name]
+              class_name.constantize
+            else
+              association_id.classify.constantize
+            end
+            cache_class.keys.must.include cache_attribute            
+            increase_method_name = "increase_#{cache_class.alias.underscore}_#{self.alias.pluralize.underscore}_counter"
+            decrease_method_name = "decrease_#{cache_class.alias.underscore}_#{self.alias.pluralize.underscore}_counter"
+
+            define_method increase_method_name do
+              cache_class.upsert!({id: self.send(association_key)}, :$inc => {cache_attribute => 1})
+            end
+            protected increase_method_name            
+
+            define_method decrease_method_name do
+              cache_class.upsert!({id: 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/plugins/carrierwave.rb

@@ -0,0 +1,60 @@
+require 'carrierwave/validations/active_model'
+
+# 
+# Hacks
+# 
+CarrierWave::SanitizedFile.class_eval do
+  def sanitize_regexp
+    /[^[:word:]\.\-\+\s_]/i
+  end
+end
+
+CarrierWave::Uploader::Cache.class_eval do
+  def original_filename=(filename)
+    raise CarrierWave::InvalidParameter, "invalid filename" unless filename =~ /\A[[:word:]\.\-\+\s_]+\z/i
+    @original_filename = filename
+  end
+end
+
+
+# 
+# mount_uploader
+# 
+module MongoMapper
+  module Plugins
+    module CarrierWave
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        include ::CarrierWave::Mount
+        ##
+        # See +CarrierWave::Mount#mount_uploader+ for documentation
+        #
+        def mount_uploader(column, uploader, options={}, &block)
+          define_key column, uploader, options
+
+          super
+
+          alias_method :read_uploader, :read_attribute
+          alias_method :write_uploader, :write_attribute
+
+          include ::CarrierWave::Validations::ActiveModel
+
+          validates_integrity_of  column if uploader_option(column.to_sym, :validate_integrity)
+          validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
+
+          after_save "store_#{column}!".to_sym
+          before_save "write_#{column}_identifier".to_sym
+          after_destroy "remove_#{column}!".to_sym
+        end
+        
+        protected
+          def define_key column, uploader, options
+            options[:mount_on] ||= "#{column}_filename"
+            name = options[:mount_on]
+            key name
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper_ext/plugins/{default_scope.rb → custom_scope.rb}

@@ -1,6 +1,7 @@
 module MongoMapper
   module Plugins
-    module DefaultScope
+    module CustomScope
+      extend ActiveSupport::Concern
       
       module ClassMethods
         def query options = {}
@@ -46,7 +47,7 @@ module MongoMapper
         
         protected
           def default_scope options = nil, &block          
-            options.must_be.a [NilClass, Hash]
+            options.must_be.a NilClass, Hash
             self.write_inheritable_attribute(:default_scope, (options || block))
           end
                   

data/lib/mongo_mapper_ext/plugins/db_config.rb

@@ -1,47 +1,85 @@
-# # 
-# # Connect to database_alias specified in config
-# #
-# module MongoMapper
-#   module Plugins
-#     module DbConfig
-#       
-#       module ClassMethods        
-#         inheritable_accessor :database_alias, nil
-#         def use_database database_alias
-#           self.database_alias = database_alias.to_s
-#         end
-#         
-#         def connection(mongo_connection=nil)
-#           assert_supported
-#           if mongo_connection.nil?
-#             @connection || connection_from_alias || MongoMapper.connection
-#           else
-#             @connection = mongo_connection
-#           end
-#         end
+module MongoMapper  
+  # 
+  # Connection Pool
+  # 
+  class ConnectionsPool < Hash    
+    def [](database_alias)
+      database_alias = database_alias.to_s
+      unless connection = super(database_alias)            
+        MongoMapper.db_config.must.include database_alias
+        db_options = MongoMapper.db_config[database_alias]        
+        connection = Mongo::Connection.new(db_options['host'], db_options['port'], logger: MongoMapper.logger)
+  
+        if defined?(PhusionPassenger)
+          PhusionPassenger.on_event(:starting_worker_process) do |forked|
+            connection.connect_to_master if forked
+          end
+        end
+    
+        self[database_alias] = connection
+      end            
+      return connection
+    end
+  end
+  
+  
+  # 
+  # Databases Pool
+  # 
+  class DatabasesPool < Hash
+    def [](database_alias)
+      database_alias = database_alias.to_s
+      unless db = super(database_alias)
+        MongoMapper.db_config.must.include database_alias
+        db_options = MongoMapper.db_config[database_alias]
+        db = MongoMapper.connections[database_alias].db db_options['name'].must_be.a(String)
+        self[database_alias] = db
+      end
+      return db
+    end
+  end
+  
+  class << self
+    attr_accessor :db_config
+
+    def db_config      
+      @db_config ||= {}
+    end
+
+    def connections
+      @connections ||= ConnectionsPool.new
+    end
+
+    def databases
+      @databases ||= DatabasesPool.new
+    end
+  end                              
+end
+
+
 # 
-#         def database_name
-#           assert_supported
-#           @database_name || database_name_from_alias
-#         end
-#         
-#         private
-#           def database_name_from_alias
-#             return unless database_alias
-#             
-#             MongoMapper.db_config.must.include database_alias
-#             MongoMapper.db_config[database_alias]['name']
-#           end
-#           
-#           def connection_from_alias
-#             return unless database_alias
-#             
-#             MongoMapper.db_config.must.include database_alias
-#             MongoMapper.connections[database_alias]
-#           end
-#         
-#       end
-#       
-#     end
-#   end
-# end
+# Plugin
+# 
+module MongoMapper
+  module Plugins
+    module DbConfig
+      extend ActiveSupport::Concern
+      
+      module ClassMethods                
+        # 
+        # Connect to database_alias specified in config
+        # 
+        def use_database database_alias
+          # defer do
+          database_alias = database_alias.to_s
+          MongoMapper.db_config.must.include database_alias
+      
+          self.connection MongoMapper.connections[database_alias]
+          set_database_name MongoMapper.db_config[database_alias]['name']
+          # end
+        end                
+      end
+      
+    end
+  end
+end

data/lib/mongo_mapper_ext/plugins/micelaneous.rb

@@ -1,95 +1,51 @@
 module MongoMapper
-  # def self.deferred; @deferred ||= [] end
-  # def self.call_deferred
-  #   deferred.every.call
-  #   deferred.clear
-  # end
-  
   module Plugins
     module Micelaneous
+      extend ActiveSupport::Concern
       
       module InstanceMethods
-        def upsert *args
-          self.class.upsert id, *args
+        def upsert! *args
+          self.class.upsert!({id: id}, *args)
+        end
+        
+        def exist?
+          self.class.find(id) != nil
         end
       end
       
-      module ClassMethods
+      module ClassMethods                
+        # 
+        # model_name
+        # 
+        def model_name *args
+          if args.empty?
+            @model_name ||= ::ActiveModel::Name.new self, self.alias
+          else
+            @model_name = ::ActiveModel::Name.new self, args.first
+          end          
+        end
+        
+        
         # 
         # 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 = 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
         
         
-        # 
-        # Deferred execution
-        # 
-        # def defer &block
-        #   MongoMapper.deferred << block
-        # end
-        
-        
-        # 
-        # Connect to database_alias specified in config
-        # 
-        def use_database database_alias
-          # defer do
-          database_alias = database_alias.to_s
-          MongoMapper.db_config.must.include database_alias
-      
-          self.connection MongoMapper.connections[database_alias]
-          set_database_name MongoMapper.db_config[database_alias]['name']
-          # end
-        end                
-        
-        
         # 
         # shortcut for upsert
         # 
-        def upsert *args
-          collection.upsert *args          
+        def upsert! query, *args
+          query[:_id] = query.delete :id if query.include? :id
+          collection.upsert! query, *args          
         end
-        
-        
-        # 
-        # CounterCache
-        # belongs_to :item, :counter_cashe => true
-        # 
-        def belongs_to association_id, options={}, &extension          
-          options.must_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.must.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