mongoid_ext 0.6.1

data/lib/mongoid_ext/filter/result_set.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+module MongoidExt
+  module Filter
+    class ResultSet
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|respond_to\?|proxy_|^object_id$)/ }
+
+      attr_accessor :subject
+      attr_reader :total_entries, :per_page, :current_page
+      attr_reader :parsed_query
+      attr_reader :mongo_query
+      alias limit per_page
+
+      def initialize(total_entries, parsed_query, mongo_query, current_page, per_page=nil)
+        @total_entries    = total_entries.to_i
+        @mongo_query = mongo_query
+        @parsed_query = parsed_query
+        self.per_page     = per_page
+        self.current_page = current_page
+      end
+
+      def total_pages
+        (total_entries / per_page.to_f).ceil
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      def skip
+        (current_page - 1) * per_page
+      end
+      alias offset skip # for will paginate support
+
+      def send(method, *args, &block)
+        if respond_to?(method)
+          super
+        else
+          subject.send(method, *args, &block)
+        end
+      end
+
+      def ===(other)
+        other === subject
+      end
+
+      def method_missing(name, *args, &block)
+        @subject.send(name, *args, &block)
+      end
+
+      def respond_to?(name, *args, &block)
+        super || @subject.respond_to?(name, *args, &block)
+      end
+
+      private
+        def per_page=(value)
+          value = 25 if value.blank?
+          @per_page = value.to_i
+        end
+
+        def current_page=(value)
+          value = value.to_i
+          value = 1 if value < 1
+          @current_page = value
+        end
+    end
+  end
+end

data/lib/mongoid_ext/js/filter.js

@@ -0,0 +1,41 @@
+function filter(collection, q, config) {
+  var results = [];
+  var counter = 0;
+
+  var fields = {_keywords: 1};
+  for(var i in config.select) {
+    fields[config.select[i]] = 1;
+  }
+
+  var time = new Date().getTime();
+  db[collection].find(q, fields).limit(500).forEach(
+    function(doc) {
+      var score = 0.0;
+      for(var i in config.words) {
+        var word = config.words[i];
+        if(doc._keywords.indexOf(word) != -1 )
+          score += 15.0;
+      }
+
+      for(var i in config.stemmed) {
+        var word = config.stemmed[i];
+        if(doc._keywords.indexOf(word) != -1 )
+          score += (1.0 + word.length);
+      }
+
+      if(score >= config.min_score || 1.0 ) {
+        delete doc._keywords;
+        results.push({'score': score, 'doc': doc});
+        counter += 1;
+      }
+    }
+  );
+
+  var sorted = results.sort(function(a,b) {
+    return b.score - a.score;
+  });
+
+  time = (new Date().getTime() - time);
+
+  return {total_entries: counter, elapsed_time:  time, results: sorted.slice(0, config.limit||500)};
+}

data/lib/mongoid_ext/js/find_tags.js

@@ -0,0 +1,26 @@
+function find_tags(collection, regex, query, limit) {
+  var counter = function(collection, regex, query){
+      var counts = {};
+      db[collection].find(query, {"tags":1}).limit(500).forEach(
+        function(p){
+          if ( p.tags ){
+            for ( var i=0; i<p.tags.length; i++ ){
+              var name = p.tags[i];
+              if(name.match(regex) != null)
+                counts[name] = 1 + ( counts[name] || 0 );
+            }
+          }
+        }
+      );
+      return counts;
+  };
+
+  var counts = counter(collection, regex, query);
+
+  var tags = [];
+  for ( var tag in counts ){
+    tags.push( { name : tag , count : counts[tag] } )
+  }
+
+  return tags;
+}

data/lib/mongoid_ext/js/tag_cloud.js

@@ -0,0 +1,28 @@
+// TODO: port it to map reduce
+function tagCloud(collection, q, limit) {
+  var counter = function(collection, q){
+    var counts = {constructor: 0};
+    db[collection].find(q, {"tags":1}).limit(500).forEach(
+      function(p){
+        if ( p.tags ){
+          for ( var i=0; i<p.tags.length; i++ ){
+            var name = p.tags[i];
+            counts[name] = 1 + ( counts[name] || 0 );
+          }
+        }
+      }
+    );
+    if(counts["constructor"] == 0) { delete counts.constructor; }
+    return counts;
+  };
+
+  var counts = counter(collection, q);
+
+  // maybe sort to by nice
+  var sorted = [];
+  for ( var tag in counts ){
+    sorted.push( { name : tag , count : counts[tag] } )
+  }
+
+  return sorted.slice(0,limit||30);
+}

data/lib/mongoid_ext/modifiers.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+module MongoidExt
+  module Modifiers
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def increment(conditions, update)
+        _apply_modifier('$inc', conditions, update)
+      end
+
+      def decrement(conditions, update)
+        update.each do |k, v|
+          update[k] = -v.abs
+        end
+
+        _apply_modifier('$inc', conditions, update)
+      end
+
+      def override(conditions, update) # set() is already taken :(
+        _apply_modifier('$set', conditions, update)
+      end
+
+      def unset(conditions, update)
+        _apply_modifier('$unset', conditions, update)
+      end
+
+      def push(conditions, update)
+        _apply_modifier('$push', conditions, update)
+      end
+
+      def push_all(conditions, update)
+        _apply_modifier('$pushAll', conditions, update)
+      end
+
+      def push_uniq(conditions, update)
+        _apply_modifier('$addToSet', conditions, update)
+      end
+
+      def pull(conditions, update)
+        _apply_modifier('$pull', conditions, update)
+      end
+
+      def pull_all(conditions, update)
+        _apply_modifier('$pullAll', conditions, update)
+      end
+
+      def pop(conditions, update)
+        _apply_modifier('$pop', conditions, update)
+      end
+
+      private
+      def _apply_modifier(modifier, conditions, update)
+        collection.update(conditions, {modifier => update}, :multi => true)
+      end
+    end
+
+    module InstanceMethods
+      def unset(update)
+        self.class.unset({:_id => id}, update)
+      end
+
+      def increment(update)
+        self.class.increment({:_id => id}, update)
+      end
+
+      def decrement(update)
+        self.class.decrement({:_id => id}, update)
+      end
+
+      def override(update)
+        self.class.override({:_id => id}, update)
+      end
+
+      def push(update)
+        self.class.push({:_id => id}, update)
+      end
+
+      def pull(update)
+        self.class.pull({:_id => id}, update)
+      end
+
+      def push_uniq(update)
+        self.class.push_uniq({:_id => id}, update)
+      end
+
+      def pop(update)
+        self.class.pop({:_id => id}, update)
+      end
+    end
+  end
+end
+
+Mongoid::Document.send(:include, MongoidExt::Modifiers)

data/lib/mongoid_ext/mongo_mapper.rb

@@ -0,0 +1,63 @@
+module MongoidExt
+  module MongoMapper
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      def find_each(*args, &block)
+        all(*args).each do |doc|
+          block.call(doc)
+        end
+      end
+
+      def many(name, opts = {})
+        opts[:stored_as] = :array if opts.delete(:in)
+        if fkey = opts.delete(:foreign_key)
+          opts[:inverse_of] = fkey.sub(/_id$/, "")
+        end
+
+        references_many name, opts
+      end
+      alias :has_many :many
+
+      def one(name, opts = {})
+        if fkey = opts.delete(:foreign_key)
+          opts[:inverse_of] = fkey.sub(/_id$/, "")
+        end
+
+        references_one name, opts
+      end
+      alias :has_one :one
+
+      def belongs_to(name, opts = {})
+        if fkey = opts.delete(:foreign_key)
+          opts[:inverse_of] = fkey.sub(/_id$/, "")
+        end
+
+        if opts[:polymorphic]
+          raise ArgumentError, "polymorphic associations are not supported yet"
+        end
+
+        referenced_in name, opts
+      end
+
+      def timestamps!
+        include Mongoid::Timestamps
+      end
+
+      def key(name, *args)
+        opts = args.extract_options!
+
+        opts[:type] = args.first if !args.empty?
+
+        field name, opts
+      end
+
+      def ensure_index(*args)
+        index *args
+      end
+    end
+  end
+end

data/lib/mongoid_ext/paranoia.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+module MongoidExt #:nodoc:
+  # Include this module to get soft deletion of root level documents.
+  # This will add a deleted_at field to the +Document+, managed automatically.
+  # Potentially incompatible with unique indices. (if collisions with deleted items)
+  #
+  # To use:
+  #
+  #   class Person
+  #     include Mongoid::Document
+  #     include MongoidExt::Paranoia
+  #   end
+  module Paranoia
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    # Delete the paranoid +Document+ from the database completely. This will
+    # run the destroy callbacks.
+    #
+    # Example:
+    #
+    # <tt>document.destroy!</tt>
+    def destroy!
+      run_callbacks(:destroy) { delete! }
+    end
+
+    # Delete the paranoid +Document+ from the database completely.
+    #
+    # Example:
+    #
+    # <tt>document.delete!</tt>
+    def delete!
+      Mongoid::Persistence::Remove.new(self).persist
+    end
+
+    # Delete the +Document+, will set the deleted_at timestamp and not actually
+    # delete it.
+    #
+    # Example:
+    #
+    # <tt>document.remove</tt>
+    #
+    # Returns:
+    #
+    # true
+    def remove(options = {})
+      self.class.paranoia_klass.create(:document => self.raw_attributes)
+
+      super
+    end
+    alias :delete :remove
+
+    module ClassMethods #:nodoc:
+      # Find deleted documents
+      #
+      # Examples:
+      #
+      #   <tt>Person.deleted</tt>  # all deleted employees
+      #   <tt>Company.first.employees.deleted</tt>  # works with a join
+      #   <tt>Person.deleted.find("4c188dea7b17235a2a000001").first</tt>
+      #   <tt>Person.deleted.compact!(1.week.ago)</tt>
+      def deleted
+        self.paranoia_klass
+      end
+
+
+      def paranoia_klass
+        parent_klass = self
+        @paranoia_klass ||= Class.new do
+          include Mongoid::Document
+          include Mongoid::Timestamps
+
+          cattr_accessor :parent_class
+          self.parent_class = parent_klass
+
+          self.collection_name = "#{self.parent_class.collection_name}.trash"
+
+          field :document, :type => Hash
+
+          before_validation :set_id, :on => :create
+
+          def restore
+            self.class.parent_class.create(self.document)
+          end
+
+          def self.compact!(date = 1.month.ago)
+            self.delete_all(:created_at.lte => date)
+          end
+
+          private
+          def set_id
+            self["_id"] = self.document["_id"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid_ext/patches.rb

@@ -0,0 +1,17 @@
+module Mongo
+  class DB
+    def nolock_eval(code, *args)
+      if not code.is_a? BSON::Code
+        code = BSON::Code.new(code)
+      end
+
+      oh = BSON::OrderedHash.new
+      oh[:$eval] = code
+      oh[:args]  = args
+      oh[:nolock] = true
+
+      doc = command(oh)
+      doc['retval']
+    end
+  end
+end