mongoid_misc 0.0.1

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake_ext'
+
+project(
+  name: "mongoid_misc",
+  gem: true,
+  summary: "Extensions for Mongoid",
+
+  author: "Alexey Petrushin",
+  homepage: "http://github.com/alexeypetrushin/mongoid_misc"
+)

data/lib/carrierwave_ext/fixes.rb

@@ -0,0 +1,12 @@
+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

data/lib/carrierwave_ext/micelaneous.rb

@@ -0,0 +1,26 @@
+# 
+# Changing filename format from <version>_<filename_with_extension> to <name>.<version>.<extension>
+# 
+CarrierWave::Uploader::Versions.class_eval do
+  def full_filename(for_file)
+    name = super
+    if version_name
+      ext = File.extname name
+      base = File.basename name, ext
+      "#{base}.#{version_name}#{ext}"
+    else
+      name
+    end    
+  end
+
+  def full_original_filename
+    name = super
+    if version_name
+      ext = File.extname name
+      base = File.basename name, ext
+      "#{base}.#{version_name}#{ext}"
+    else
+      name
+    end
+  end
+end

data/lib/carrierwave_ext/mongoid_embedded.rb

@@ -0,0 +1,37 @@
+# 
+# Because of Mongoid doesn't fires some events on embedded documents 
+# (it has 'smart' callback system and doesn't fires :save/:destroy if document don't really saved/destroyed)
+# we need to do it manually.
+# 
+
+Mongoid::Document.class_eval do
+  def each_embedded association_name, &b
+    Array(send(association_name)).each &b
+  end
+end
+
+module CarrierWave::MongoidEmbedded
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    def mount_embedded_uploader association_name, column
+      after_save do |doc|
+        doc.each_embedded(association_name) do |embedded|
+          embedded.send "store_#{column}!"
+        end
+      end
+    
+      before_save do |doc|
+        doc.each_embedded(association_name) do |embedded|
+          embedded.send "write_#{column}_identifier"
+        end
+      end
+    
+      after_destroy do |doc|
+        doc.each_embedded(association_name) do |embedded|
+          embedded.send "remove_#{column}!"
+        end
+      end
+    end
+  end
+end

data/lib/carrierwave_ext/spec.rb

@@ -0,0 +1,25 @@
+require 'mongoid_misc/spec'
+
+module CarrierWaveExtSpecHelper
+  TEST_PATH, TEST_CACHE_PATH = '/tmp/spec_fs', '/tmp/spec_fs_cache'
+  
+  def with_files
+    before do
+      CarrierWave.configure do |config|          
+        config.storage = :file
+        config.enable_processing = false
+        
+        config.cache_dir = TEST_CACHE_PATH
+        config.root = TEST_PATH
+      end
+    end
+    
+    before do 
+      [TEST_PATH, TEST_CACHE_PATH].each{|p| FileUtils.rm_r(p) if File.exist?(p)}
+    end
+    before do 
+      [TEST_PATH, TEST_CACHE_PATH].each{|p| FileUtils.rm_r(p) if File.exist?(p)}
+    end
+  end    
+end
+rspec.extend CarrierWaveExtSpecHelper

data/lib/carrierwave_ext.rb

@@ -0,0 +1,17 @@
+require 'carrierwave'
+require 'carrierwave/validations/active_model'
+require 'carrierwave/orm/mongoid'
+
+%w(
+  fixes
+  micelaneous
+  mongoid_embedded
+).each{|f| require "carrierwave_ext/#{f}"}
+
+CarrierWave::Uploader::Base.class_eval do
+  def name; model.send("#{mounted_as}_filename") end
+end
+
+Mongoid::Document.class_eval do
+  include CarrierWave::MongoidEmbedded  
+end

data/lib/mongo_ext/spec.rb

@@ -0,0 +1,11 @@
+rspec do
+  def clear_mongo_database name = 'test'
+    connection = Mongo::Connection.new
+    db = connection.db(name)
+    db.collection_names.each do |name|
+      next if name =~ /^system\./
+      db.collection(name).drop
+    end    
+    db
+  end
+end

data/lib/mongo_ext/upsert.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_ext.rb

@@ -0,0 +1,3 @@
+require 'mongo'
+
+require 'mongo_ext/upsert'

data/lib/mongo_migration/adapters/mongoid.rb

@@ -0,0 +1,9 @@
+class Mongo::Migration::Mongoid
+  def logger
+    Mongoid.logger
+  end    
+  
+  def database name
+    name == :default ? Mongoid.master : Mongoid.databases[name.to_s]
+  end
+end

data/lib/mongo_migration/definition.rb

@@ -0,0 +1,19 @@
+class Mongo::Migration::Definition
+  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

data/lib/mongo_migration/migration.rb

@@ -0,0 +1,71 @@
+class Mongo::Migration
+  attr_accessor :adapter
+  
+  def initialize adapter = nil
+    @adapter = adapter
+  end
+  
+  def define version, database_name = :default, &block    
+    raise "version should be an Integer! (but you provided '#{version}' instad)!" unless version.is_a? Integer
+    definition = Definition.new
+    block.call definition
+    definitions[database_name][version] = definition
+  end
+          
+  def update version, database_name = :default
+    db = adapter.database database_name
+    
+    if metadata(db)['version'] == version
+      adapter.logger.info "Database '#{database_name}' already is of #{version} version, no migration needed"
+      return false
+    else
+      adapter.logger.info "Migration for '#{database_name}', updating to #{version}"
+    end
+    
+    increase_db_version database_name, db while metadata(db)['version'] < version
+    decrease_db_version database_name, db while metadata(db)['version'] > version
+    true
+  end
+      
+  def metadata db
+    col = db.collection 'db_metadata'
+    col.find_one || {'version' => 0}
+  end
+  
+  def definitions
+    @definitions ||= Hash.new{|h, k| h[k] = []} 
+  end
+    
+  protected
+    def increase_db_version database_name, db    
+      m = metadata(db)
+      migration = definitions[database_name][m['version'] + 1]        
+      raise "No upgrade for version #{m['version'] + 1} of '#{database_name}' Database!" unless migration and migration.up
+      
+      migration.up.call db
+      
+      m['version'] += 1        
+      update_metadata db, m
+      
+      adapter.logger.info "Database '#{database_name}' upgraded to version #{m['version']}."
+    end
+    
+    def decrease_db_version database_name, db
+      m = metadata(db)
+      migration = definitions[database_name][m['version']]        
+      raise "No downgrade for version #{m['version']} of '#{database_name}' Database!" unless migration and migration.down
+      
+      migration.down.call db
+      
+      m['version'] -= 1
+      update_metadata db, m
+      
+      adapter.logger.info "Database '#{database_name}' downgraded to version #{m['version']}."
+    end
+
+    
+    def update_metadata db, metadata
+      col = db.collection 'db_metadata'
+      col.save metadata.to_hash
+    end
+end

data/lib/mongo_migration/tasks.rb

@@ -0,0 +1,19 @@
+namespace :db do
+  desc "Migrate Database"
+  task migrate: :migration_evnironment do
+    require 'mongo_migration'
+    
+    database_name = (ENV['d'] || ENV['database'] || :default).to_sym
+    version = ENV['v'] || ENV['version']
+    
+    if version.blank?
+      size = Mongo.migration.definitions[database_name].size
+      highest_defined_version = size == 0 ? 0 : size - 1  
+      version = highest_defined_version
+    else
+      version = version.to_i
+    end
+    
+    Mongo.migration.update version, database_name
+  end
+end

data/lib/mongo_migration.rb

@@ -0,0 +1,14 @@
+require 'mongo_ext'
+
+class Mongo::Migration; end
+
+%w(
+  definition
+  migration
+).each{|f| require "mongo_migration/#{f}"}
+
+Mongo.class_eval do
+  class << self
+    attr_accessor :migration
+  end
+end

data/lib/mongoid_misc/attribute_cache.rb

@@ -0,0 +1,16 @@
+module Mongoid::AttributeCache
+  extend ActiveSupport::Concern
+  
+  def cache
+    @cache ||= {}
+  end
+
+  def clear_cache
+    @cache = {}
+  end
+
+  def reload
+    @cache.clear if @cache
+    super
+  end
+end

data/lib/mongoid_misc/attribute_convertors.rb

@@ -0,0 +1,71 @@
+module Mongoid::AttributeConvertors
+  extend ActiveSupport::Concern
+  
+  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 {              
+        # Mongoid 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 {
+        # Mongoid uses it's internal Hash that doesn't support to_yaml
+        hash = {}; v.each{|k, v| hash[k] = v}               
+        hash.to_json.strip
+      }
+    }
+  }
+  
+  module ClassMethods
+    # supporf for :as_string option
+    def field name, options = {}                       
+      if converter_name = options[:as_string]
+        available_as_string name, converter_name
+        attr_protected "#{name}_as_string".to_sym if options[:protected]            
+      end
+      
+      super
+    end
+    
+    def available_as_string name, converter_name
+      converter = CONVERTORS[converter_name]
+      raise "unknown converter name :#{converter_name} for :#{name} field!" unless converter
+      
+      from_string, to_string = converter[:from_string], converter[:to_string]
+      name_as_string = "#{name}_as_string".to_sym
+      define_method name_as_string do
+        cache[name_as_string] ||= to_string.call(send(name))
+      end
+      
+      define_method "#{name_as_string}=" do |value|
+        cache.delete name_as_string                        
+        self.send "#{name}=", from_string.call(value)
+      end
+    end
+    
+    def available_as_yaml name
+      raise "delimiter not specified for :#{name} field!" unless delimiter
+      method = "#{name}_as_string"
+      define_method method do
+        self.send(name).join(delimiter)
+      end
+      define_method "#{method}=" do |value|            
+        value = (value || "").split(delimiter.strip).collect{|s| s.strip}
+        self.send "#{name}=", value
+      end
+    end
+  end
+  
+end

data/lib/mongoid_misc/belongs_to_with_counter_cache.rb

@@ -0,0 +1,43 @@
+module Mongoid::BelongsToWithCounterCache
+  extend ActiveSupport::Concern
+
+  module ClassMethods        
+    # 
+    # CounterCache
+    # belongs_to :item, counter_cashe: true
+    # 
+    def belongs_to name, options = {}, &block      
+      add_counter_cache name, options if options.delete(:counter_cache)
+      super
+    end
+    
+    protected
+      def add_counter_cache name, options
+        name = name.to_s
+        association_field = "#{name}_id"
+        cache_attribute_field = "#{self.alias.pluralize.underscore}_count"
+        cache_class = if class_name = options[:class_name]
+          class_name.constantize
+        else
+          name.classify.constantize
+        end
+        raise "field :#{cache_attribute_field} not defined on :#{cache_class}!" unless cache_class.fields.include? cache_attribute_field            
+        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_field)}, :$inc => {cache_attribute_field => 1})
+        end
+        protected increase_method_name            
+
+        define_method decrease_method_name do
+          cache_class.upsert!({id: self.send(association_field)}, :$inc => {cache_attribute_field => -1})
+        end
+        protected decrease_method_name
+
+        after_create increase_method_name
+        after_destroy decrease_method_name
+      end
+  end
+  
+end

data/lib/mongoid_misc/gems.rb

@@ -0,0 +1,16 @@
+# dependencies for core gems
+gem 'i18n', '0.5.0'
+gem 'activesupport', '3.0.7'
+gem 'activemodel', '3.0.7'
+gem 'bson', '1.3.1'
+gem 'bson_ext', '1.3.1'
+gem 'mongo', '1.3.0'
+gem 'will_paginate', '2.3.15'
+
+gem 'mini_magick',   '3.2.1'
+gem 'subexec',       '0.0.4'
+
+# core gems
+gem 'mongoid', '2.0.2'
+
+gem 'carrierwave',   '0.5.4'

data/lib/mongoid_misc/hacks.rb

@@ -0,0 +1,43 @@
+# 
+# Allow to specify different model name than class name
+# 
+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
+
+
+# 
+# Mongoid uses Proxy over Mongo::Collection, so we need to define all extra method on this proxy by hands
+# 
+%w(upsert!).each do |name|
+  Mongoid::Collection.send(:define_method, name){|*args| master.collection.send(name, *args)}
+end
+
+
+# 
+# Default value on the :foreign_key
+# 
+Mongoid::Relations::Metadata.class_eval do
+  def foreign_key_default_with_options
+    self[:default] || foreign_key_default_without_options
+  end
+  alias_method_chain :foreign_key_default, :options
+end
+
+
+# 
+# dynamic default scope
+# 

data/lib/mongoid_misc/micelaneous.rb

@@ -0,0 +1,91 @@
+module Mongoid::Micelaneous
+  extend ActiveSupport::Concern
+  
+  def upsert! *args
+    self.class.upsert!({id: id}, *args)
+  end
+  
+  def exist?
+    self.class.where(_id: id).count > 0
+  end
+  alias_method :exists?, :exist?
+  
+  def dom_id
+    new_record? ? "new_#{self.class.name.underscore}" : to_param
+  end
+  
+  def first! *a
+    super || raise(Mongoid::Errors::DocumentNotFound.new(self, a))
+  end
+  
+  def set_protected_attributes attribute_names, attributes
+    attribute_names.each do |name|
+      send "#{name}=", attributes[name] if attributes.include? name
+    end
+  end
+  
+  def t *a
+    I18n.t *a
+  end
+  
+  module ClassMethods       
+    # # 
+    # # Database aliases
+    # # 
+    # def set_database_alias als
+    #   name = Mongoid.database_aliases[als] || raise("unknown database alias '#{als}'!")
+    #   set_database name
+    # end
+    
+             
+    # 
+    # 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.each{|o| block.call o}
+        page += 1
+      end until results.blank? or results.size < per_page
+    end
+    
+    
+    # 
+    # shortcut for upsert
+    # 
+    def upsert! query, *args
+      query[:_id] = query.delete :id if query.include? :id
+      collection.upsert! query, *args          
+    end
+       
+         
+    def to_param
+      (id || '').to_s
+    end    
+  end
+  
+end
+
+
+# # 
+# # Database aliases
+# # 
+# module Mongoid
+#   def self.database_aliases; @database_aliases ||= {} end
+#   def self.set_database_aliases aliases
+#     database_aliases.merge! aliases
+#   end
+# end

data/lib/mongoid_misc/simple_finders.rb

@@ -0,0 +1,44 @@
+module Mongoid::SimpleFinders
+  extend ActiveSupport::Concern  
+  
+  module ClassMethods
+    def method_missing clause, *a, &b
+      if clause =~ /^([a-z]_by_[a-z_])|(by_[a-z_])/ 
+        clause = clause.to_s      
+      
+        bang = clause =~ /!$/
+        clause = clause[0..-2] if bang
+      
+        finder, field = if clause =~ /^by_/  
+          ['first', clause.sub(/by_/, '')]
+        else        
+          clause.split(/_by_/, 2)          
+        end                
+        finder = 'first' if finder == 'find'
+      
+        raise "You can't use bang version with :#{finder}!" if bang and finder != 'first'
+      
+        raise "invalid arguments for finder (#{a})!" unless a.size == 1
+        field_value = a.first
+
+        where(field => field_value).send(finder) || 
+          (bang && raise(Mongoid::Errors::DocumentNotFound.new(self, field_value)))
+      else
+        super
+      end
+    end
+    
+    # 
+    # find_by_id, special case
+    # 
+    def find_by_id id
+      where(_id: id).first
+    end
+    alias_method :by_id, :find_by_id
+
+    def find_by_id! id
+      find_by_id(id) || raise(Mongoid::Errors::DocumentNotFound.new(self, id))
+    end
+    alias_method :by_id!, :find_by_id!
+  end
+end

data/lib/mongoid_misc/spec.rb

@@ -0,0 +1,37 @@
+require 'mongo_ext/spec'
+
+# 
+# disabling :set_database, all tests will use the same :test database.
+# 
+Mongoid::MultiDatabase::ClassMethods.class_eval do
+  alias_method :_set_database, :set_database
+  def set_database database_name; end
+end
+
+
+# #        
+# # disabpling :set_database_alias
+# # 
+# Mongoid::Micelaneous::ClassMethods.class_eval do
+#   alias_method :_set_database_alias, :set_database_alias
+#   def set_database_alias alias_name; end
+# end
+
+
+# 
+# Configuring Mongoid to use :test database and clearing database before each test
+# 
+rspec do
+  def self.with_mongoid
+    before :all do
+      Mongoid.configure do |config|
+        connection = Mongo::Connection.new
+        config.master = connection.db('test')
+      end
+    end
+    
+    before do
+      clear_mongo_database
+    end
+  end
+end

data/lib/mongoid_misc/support.rb

@@ -0,0 +1,13 @@
+unless Class.method_defined? :alias
+  Class.class_eval do
+    def alias name = nil
+      if name
+        # name.must_be.a String
+        # name.must_not_be.blank
+        @alias = name.to_s
+      else
+        @alias ||= self.name.split('::').last
+      end
+    end
+  end
+end