mongoid_taggable_with_context 1.1.3 → 1.1.4

data/lib/mongoid/taggable_with_context/aggregation_strategy/map_reduce.rb

@@ -1,71 +1,71 @@
-module Mongoid::TaggableWithContext::AggregationStrategy
-  module MapReduce
-    extend ActiveSupport::Concern
-    included do
-      set_callback :save,     :after, :map_reduce_all_contexts!, if: :tags_changed?
-      set_callback :destroy,  :after, :map_reduce_all_contexts!
-      delegate :aggregation_collection_for, to: "self.class"
-    end
-    
-    module ClassMethods
-      # Collection name for storing results of tag count aggregation
-      
-      def aggregation_database_collection_for(context)
-        (@aggregation_database_collection ||= {})[context] ||= Moped::Collection.new(self.collection.database, aggregation_collection_for(context))
-      end
-
-      def aggregation_collection_for(context)
-        "#{collection_name}_#{context}_aggregation"
-      end
-
-      def tags_for(context, conditions={})
-        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(_id: 1).to_a.map{ |t| t["_id"] }
-      end
-
-      # retrieve the list of tag with weight(count), this is useful for
-      # creating tag clouds
-      def tags_with_weight_for(context, conditions={})
-        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(_id: 1).to_a.map{ |t| [t["_id"], t["value"].to_i] }
-      end
-      
-    end
-    
-    protected
-
-    def changed_tag_arrays
-      self.class.tag_database_fields & changes.keys.map(&:to_sym)
-    end
-    
-    def tags_changed?
-      !changed_tag_arrays.empty?
-    end
-    
-    def map_reduce_all_contexts!
-      self.class.tag_contexts.each do |context|
-        map_reduce_context!(context)
-      end
-    end
-    
-    def map_reduce_context!(context)
-      db_field = self.class.tag_options_for(context)[:db_field]
-
-      map = <<-END
-        function() {
-          if (!this.#{db_field})return;
-          for (index in this.#{db_field})
-            emit(this.#{db_field}[index], 1);
-        }
-      END
-
-      reduce = <<-END
-        function(key, values) {
-          var count = 0;
-          for (index in values) count += values[index];
-          return count;
-        }
-      END
-
-      self.class.map_reduce(map, reduce).out(replace: aggregation_collection_for(context)).time
-    end
-  end
-end
+module Mongoid::TaggableWithContext::AggregationStrategy
+  module MapReduce
+    extend ActiveSupport::Concern
+    included do
+      set_callback :save,     :after, :map_reduce_all_contexts!, if: :tags_changed?
+      set_callback :destroy,  :after, :map_reduce_all_contexts!
+      delegate :aggregation_collection_for, to: "self.class"
+    end
+    
+    module ClassMethods
+      # Collection name for storing results of tag count aggregation
+      
+      def aggregation_database_collection_for(context)
+        (@aggregation_database_collection ||= {})[context] ||= Moped::Collection.new(self.collection.database, aggregation_collection_for(context))
+      end
+
+      def aggregation_collection_for(context)
+        "#{collection_name}_#{context}_aggregation"
+      end
+
+      def tags_for(context, conditions={})
+        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(_id: 1).to_a.map{ |t| t["_id"] }
+      end
+
+      # retrieve the list of tag with weight(count), this is useful for
+      # creating tag clouds
+      def tags_with_weight_for(context, conditions={})
+        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(_id: 1).to_a.map{ |t| [t["_id"], t["value"].to_i] }
+      end
+      
+    end
+    
+    protected
+
+    def changed_tag_arrays
+      self.class.tag_database_fields & changes.keys.map(&:to_sym)
+    end
+    
+    def tags_changed?
+      !changed_tag_arrays.empty?
+    end
+    
+    def map_reduce_all_contexts!
+      self.class.tag_contexts.each do |context|
+        map_reduce_context!(context)
+      end
+    end
+    
+    def map_reduce_context!(context)
+      db_field = self.class.tag_options_for(context)[:db_field]
+
+      map = <<-END
+        function() {
+          if (!this.#{db_field})return;
+          for (index in this.#{db_field})
+            emit(this.#{db_field}[index], 1);
+        }
+      END
+
+      reduce = <<-END
+        function(key, values) {
+          var count = 0;
+          for (index in values) count += values[index];
+          return count;
+        }
+      END
+
+      self.class.map_reduce(map, reduce).out(replace: aggregation_collection_for(context)).time
+    end
+  end
+end

data/lib/mongoid/taggable_with_context/aggregation_strategy/real_time.rb

@@ -1,116 +1,116 @@
-module Mongoid::TaggableWithContext::AggregationStrategy
-  module RealTime
-    extend ActiveSupport::Concern
-
-    included do
-      set_callback :save,     :after, :update_tags_aggregations_on_save
-      set_callback :destroy,  :after, :update_tags_aggregations_on_destroy
-    end
-    
-    module ClassMethods
-      def tag_name_attribute
-        "_id"
-      end
-
-      # Collection name for storing results of tag count aggregation
-
-      def aggregation_database_collection_for(context)
-        (@aggregation_database_collection ||= {})[context] ||= Moped::Collection.new(self.collection.database, aggregation_collection_for(context))
-      end
-
-      def aggregation_collection_for(context)
-        "#{collection_name}_#{context}_aggregation"
-      end
-
-      def tags_for(context, conditions={})
-        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(tag_name_attribute.to_sym => 1).to_a.map{ |t| t[tag_name_attribute] }
-      end
-
-      # retrieve the list of tag with weight(count), this is useful for
-      # creating tag clouds
-      def tags_with_weight_for(context, conditions={})
-        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(tag_name_attribute.to_sym => 1).to_a.map{ |t| [t[tag_name_attribute], t["value"].to_i] }
-      end
-
-      def recalculate_all_context_tag_weights!
-        tag_contexts.each do |context|
-          recalculate_tag_weights!(context)
-        end
-      end
-
-      def recalculate_tag_weights!(context)
-        db_field = self.class.tag_options_for(context)[:db_field]
-
-        map = <<-END
-        function() {
-          if (!this.#{db_field})return;
-          for (index in this.#{db_field})
-            emit(this.#{db_field}[index], 1);
-        }
-        END
-
-        reduce = <<-END
-        function(key, values) {
-          var count = 0;
-          for (index in values) count += values[index];
-          return count;
-        }
-        END
-
-        self.class.map_reduce(map, reduce).out(replace: aggregation_collection_for(context)).time
-      end
-
-      # adapted from https://github.com/jesuisbonbon/mongoid_taggable/commit/42feddd24dedd66b2b6776f9694d1b5b8bf6903d
-      def tags_autocomplete(context, criteria, options={})
-        result = aggregation_database_collection_for(context).find({tag_name_attribute.to_sym => /^#{criteria}/})
-        result = result.sort(value: -1) if options[:sort_by_count] == true
-        result = result.limit(options[:max]) if options[:max] > 0
-        result.to_a.map{ |r| [r[tag_name_attribute], r["value"]] }
-      end
-    end
-
-    protected
-
-    def get_conditions(context, tag)
-      {self.class.tag_name_attribute.to_sym => tag}
-    end
-    
-    def update_tags_aggregation(context, old_tags=[], new_tags=[])
-      coll = self.class.aggregation_database_collection_for(context)
-
-      old_tags ||= []
-      new_tags ||= []
-      unchanged_tags  = old_tags & new_tags
-      tags_removed    = old_tags - unchanged_tags
-      tags_added      = new_tags - unchanged_tags
-
-      
-      tags_removed.each do |tag|
-        coll.find(get_conditions(context, tag)).upsert({'$inc' => {value: -1}})
-      end
-      tags_added.each do |tag|
-        coll.find(get_conditions(context, tag)).upsert({'$inc' => {value: 1}})
-      end
-      #coll.find({_id: {"$in" => tags_removed}}).update({'$inc' => {:value => -1}}, [:upsert])
-      #coll.find({_id: {"$in" => tags_added}}).update({'$inc' => {:value => 1}}, [:upsert])
-    end
-    
-    def update_tags_aggregations_on_save
-      indifferent_changes = HashWithIndifferentAccess.new changes
-      self.class.tag_database_fields.each do |field|
-        next if indifferent_changes[field].nil?
-
-        old_tags, new_tags = indifferent_changes[field]
-        update_tags_aggregation(field, old_tags, new_tags)
-      end
-    end
-    
-    def update_tags_aggregations_on_destroy
-      self.class.tag_database_fields.each do |field|
-        old_tags = send field
-        new_tags = []
-        update_tags_aggregation(field, old_tags, new_tags)
-      end      
-    end
-  end
-end
+module Mongoid::TaggableWithContext::AggregationStrategy
+  module RealTime
+    extend ActiveSupport::Concern
+
+    included do
+      set_callback :save,     :after, :update_tags_aggregations_on_save
+      set_callback :destroy,  :after, :update_tags_aggregations_on_destroy
+    end
+    
+    module ClassMethods
+      def tag_name_attribute
+        "_id"
+      end
+
+      # Collection name for storing results of tag count aggregation
+
+      def aggregation_database_collection_for(context)
+        (@aggregation_database_collection ||= {})[context] ||= Moped::Collection.new(self.collection.database, aggregation_collection_for(context))
+      end
+
+      def aggregation_collection_for(context)
+        "#{collection_name}_#{context}_aggregation"
+      end
+
+      def tags_for(context, conditions={})
+        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(tag_name_attribute.to_sym => 1).to_a.map{ |t| t[tag_name_attribute] }
+      end
+
+      # retrieve the list of tag with weight(count), this is useful for
+      # creating tag clouds
+      def tags_with_weight_for(context, conditions={})
+        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }}).sort(tag_name_attribute.to_sym => 1).to_a.map{ |t| [t[tag_name_attribute], t["value"].to_i] }
+      end
+
+      def recalculate_all_context_tag_weights!
+        tag_contexts.each do |context|
+          recalculate_tag_weights!(context)
+        end
+      end
+
+      def recalculate_tag_weights!(context)
+        db_field = self.class.tag_options_for(context)[:db_field]
+
+        map = <<-END
+        function() {
+          if (!this.#{db_field})return;
+          for (index in this.#{db_field})
+            emit(this.#{db_field}[index], 1);
+        }
+        END
+
+        reduce = <<-END
+        function(key, values) {
+          var count = 0;
+          for (index in values) count += values[index];
+          return count;
+        }
+        END
+
+        self.class.map_reduce(map, reduce).out(replace: aggregation_collection_for(context)).time
+      end
+
+      # adapted from https://github.com/jesuisbonbon/mongoid_taggable/commit/42feddd24dedd66b2b6776f9694d1b5b8bf6903d
+      def tags_autocomplete(context, criteria, options={})
+        result = aggregation_database_collection_for(context).find({tag_name_attribute.to_sym => /^#{criteria}/})
+        result = result.sort(value: -1) if options[:sort_by_count] == true
+        result = result.limit(options[:max]) if options[:max] > 0
+        result.to_a.map{ |r| [r[tag_name_attribute], r["value"]] }
+      end
+    end
+
+    protected
+
+    def get_conditions(context, tag)
+      {self.class.tag_name_attribute.to_sym => tag}
+    end
+    
+    def update_tags_aggregation(context, old_tags=[], new_tags=[])
+      coll = self.class.aggregation_database_collection_for(context)
+
+      old_tags ||= []
+      new_tags ||= []
+      unchanged_tags  = old_tags & new_tags
+      tags_removed    = old_tags - unchanged_tags
+      tags_added      = new_tags - unchanged_tags
+
+      
+      tags_removed.each do |tag|
+        coll.find(get_conditions(context, tag)).upsert({'$inc' => {value: -1}})
+      end
+      tags_added.each do |tag|
+        coll.find(get_conditions(context, tag)).upsert({'$inc' => {value: 1}})
+      end
+      #coll.find({_id: {"$in" => tags_removed}}).update({'$inc' => {:value => -1}}, [:upsert])
+      #coll.find({_id: {"$in" => tags_added}}).update({'$inc' => {:value => 1}}, [:upsert])
+    end
+    
+    def update_tags_aggregations_on_save
+      indifferent_changes = HashWithIndifferentAccess.new changes
+      self.class.tag_database_fields.each do |field|
+        next if indifferent_changes[field].nil?
+
+        old_tags, new_tags = indifferent_changes[field]
+        update_tags_aggregation(field, old_tags, new_tags)
+      end
+    end
+    
+    def update_tags_aggregations_on_destroy
+      self.class.tag_database_fields.each do |field|
+        old_tags = send field
+        new_tags = []
+        update_tags_aggregation(field, old_tags, new_tags)
+      end      
+    end
+  end
+end

data/lib/mongoid/taggable_with_context/aggregation_strategy/real_time_group_by.rb

@@ -1,52 +1,52 @@
-module Mongoid::TaggableWithContext::AggregationStrategy
-  module RealTimeGroupBy
-    extend ActiveSupport::Concern
-    include Mongoid::TaggableWithContext::AggregationStrategy::RealTime
-
-    module ClassMethods
-      def tag_name_attribute
-        "_name"
-      end
-
-      def tags_for(context, group_by, conditions={})
-        results = if group_by
-          query(context, group_by).to_a.map{ |t| t[tag_name_attribute] }
-        else
-          super(context, conditions)
-        end
-        results.uniq
-      end
-
-      def tags_with_weight_for(context, group_by, conditions={})
-        results = if group_by
-          query(context, group_by).to_a.map{ |t| [t[tag_name_attribute], t["value"].to_i] }
-        else
-          super(context, conditions)
-        end
-
-        tag_hash = {}
-        results.each do |tag, weight|
-          tag_hash[tag] ||= 0
-          tag_hash[tag] += weight
-        end
-        tag_hash.to_a
-      end
-
-      protected
-      def query(context, group_by)
-        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }, group_by: group_by}).sort(tag_name_attribute.to_sym => 1)
-      end
-    end
-
-    protected
-
-    def get_conditions(context, tag)
-      conditions = {self.class.tag_name_attribute.to_sym => tag}
-      group_by = self.class.get_tag_group_by_field_for(context)
-      if group_by
-        conditions.merge!({group_by: self.send(group_by)})
-      end
-      conditions
-    end
-  end
+module Mongoid::TaggableWithContext::AggregationStrategy
+  module RealTimeGroupBy
+    extend ActiveSupport::Concern
+    include Mongoid::TaggableWithContext::AggregationStrategy::RealTime
+
+    module ClassMethods
+      def tag_name_attribute
+        "_name"
+      end
+
+      def tags_for(context, group_by, conditions={})
+        results = if group_by
+          query(context, group_by).to_a.map{ |t| t[tag_name_attribute] }
+        else
+          super(context, conditions)
+        end
+        results.uniq
+      end
+
+      def tags_with_weight_for(context, group_by, conditions={})
+        results = if group_by
+          query(context, group_by).to_a.map{ |t| [t[tag_name_attribute], t["value"].to_i] }
+        else
+          super(context, conditions)
+        end
+
+        tag_hash = {}
+        results.each do |tag, weight|
+          tag_hash[tag] ||= 0
+          tag_hash[tag] += weight
+        end
+        tag_hash.to_a
+      end
+
+      protected
+      def query(context, group_by)
+        aggregation_database_collection_for(context).find({value: {"$gt" => 0 }, group_by: group_by}).sort(tag_name_attribute.to_sym => 1)
+      end
+    end
+
+    protected
+
+    def get_conditions(context, tag)
+      conditions = {self.class.tag_name_attribute.to_sym => tag}
+      group_by = self.class.get_tag_group_by_field_for(context)
+      if group_by
+        conditions.merge!({group_by: self.send(group_by)})
+      end
+      conditions
+    end
+  end
 end