mongoid_aggregates 0.1.0 → 0.1.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTE1ODI0NTJiYWU0MzExYjg0MWFmNDBjM2EzOTg5YzRjYjVkYzYyZQ==
+    MmQzMDM0OWZiOTYzNzQzNzM2YTg4MjEyOGI0NWIyOWQ4MTI3ZDk3Mg==
   data.tar.gz: !binary |-
-    ZWI2ODM4NWRlNjNiNTY5NGJkN2M2MDdjM2FlODIwNGJiMzFhMGJlNw==
+    OGRkNmVlYzhkNTQzY2Q3ZGUzYjYyMWQ1NjYzM2E4YmNjNGM4NDUzNQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OTJiNTEyNzE2MTk0ZjMzNDQ2ZDgyNDU4MjBkNzk3YjVjZDgwYmFiOWE1Mzg2
-    YmNiNzU3MjJkYjg1NTZkYWY0NTU1MzE2YjVkMzBjNzg0MWQ4M2ViMmM4OTA2
-    NWVjMzA5YTlmNzdhMTdmOGEzMGNiZjY0MjMxZmIxZGFkOTE2ZTE=
+    MDdmZmE0ODA4MjUyM2U4ZTcyYTk0ODlkMzkxYTFkY2U2ZjM2NzM4NjNmMGVi
+    YTc4NWZmMzM0YTk1M2RlMjE1NDMxNDIwYTUzYzllODg3ZTc1ZTEwZTVlNWUx
+    MDM0MTAwMjhjYzY0YjlhOGQ5NTMyYjcyOGEzODU0N2E3NTVmNDU=
   data.tar.gz: !binary |-
-    MTM5MmIzOGE3NTFlNTBjMTU4NjBkOWE5ZDVlYjU4MjBjNTQyMjA4Nzk1MWJh
-    MDdjYTg0NWM0MmRkNjgyZGUwMTc0NjQyMDFmZjNhZjJjMGRkZDJhMTZiZmYx
-    ZWMyMzM0ODlhYTI5MzcxZmViMmNmMmM4MTVhYzg4NmQ2MWMxZmI=
+    YjU4NzU5N2U1ZTNlNzQ2OTZiNmFlMmViNDU4MjI2NDQwMTZjNzk3NTE1YmRm
+    ZTU0YzM3NDZmOWE5MWM2ODZmMmU4NjMxZjExMTFiMjYyYjliYWY3YTEzZWZl
+    MmJjZmYyOTE1NGIxOTdkMjYyNDJjNzM5ODVjNWM0YjQ0YmE2MDk=

data/lib/mongoid/contextual/aggregable/aggregates.rb

@@ -0,0 +1,76 @@
+require_relative "commands/base"
+require_relative "commands/match"
+require_relative "commands/group"
+require_relative "commands/sort"
+
+module Mongoid
+  module Contextual
+    module Aggregable
+      # Contains behaviour for aggregating values in Mongo.
+      class Aggregates
+        def initialize(context)
+          @context = context
+          @commands = []
+        end
+
+        def all
+          @context.collection.aggregate(@commands)
+        end
+
+        def group(key, *args)
+          @commands.push(Commands::Group.new(key, *args))
+          self
+        end
+
+        def sort(*args)
+          @commands.push(Commands::Sort.new(*args))
+          self
+        end
+
+        def explain
+          @commands.to_json
+        end
+
+        def sum(field)
+          all.inject(0) {
+              |sum, item| sum + (item[field.to_s] || 0)
+          }
+        end
+
+        def compute(field)
+          res = all.inject(Hash.new 0) {
+              |compute, item| compute[:count] += 1; compute[:sum] += item["#{field}"] unless item["#{field}"].nil?; compute
+          }
+          res[:avg] = res[:sum] / (res[:count] != 0 ? res[:count] : 1 )
+          res
+        end
+
+        def count
+          all.count
+        end
+
+        protected
+
+        def method_missing(name, *args, &block)
+          if @context.scopes.has_key?(name)
+            criteria = @context.scopes[name][:scope].call(*args)
+            @commands.push(to_match(criteria))
+          elsif @context.respond_to?(name)
+            criteria = @context.send(name, *args)
+            @commands.push(to_match(criteria))
+          else
+            raise Errors::UnknownAttribute.new(@context, name)
+          end
+          self
+        end
+
+        def to_match(criteria)
+          hash = criteria.selector.inject({}) {|hash, (key, val)| hash[key] = val.is_a?(Array) ? val[0] : val; hash}
+          Commands::Match.new(hash)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/mongoid/contextual/aggregable/commands/base.rb

@@ -0,0 +1,27 @@
+module Mongoid
+  module Contextual
+    module Aggregable
+      # Contains behaviour for aggregating values in Mongo.
+      module Commands
+        class Base < Hash
+          def initialize(name, *args)
+            values = args.inject({}) { |res, hash| res.merge(hash) }
+            self[name] = values
+          end
+
+          protected
+          def normalize_id(key)
+            if (key.present? && (key.is_a?(String) || key.is_a?(Symbol)))
+              key.to_s =~ /^\$.+/ ? key : "$#{key}"
+            elsif key.is_a?(Hash)
+              key
+            else
+              'null'
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/contextual/aggregable/commands/group.rb

@@ -0,0 +1,14 @@
+module Mongoid
+  module Contextual
+    module Aggregable
+      module Commands
+        class Group < Base
+          def initialize(key, *args)
+            super('$group', *args.unshift({'_id' => normalize_id(key)}))
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/contextual/aggregable/commands/match.rb

@@ -0,0 +1,15 @@
+module Mongoid
+  module Contextual
+    module Aggregable
+      module Commands
+        class Match < Base
+          def initialize(*args)
+            super('$match', *args)
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/mongoid/contextual/aggregable/commands/sort.rb

@@ -0,0 +1,14 @@
+module Mongoid
+  module Contextual
+    module Aggregable
+      module Commands
+        class Sort < Base
+          def initialize(args)
+            super('$sort', args)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/contextual/aggregable/mongo_ex.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+require "mongoid/contextual/aggregable/aggregates"
+
+module Mongoid
+  module Contextual
+    module Aggregable
+      # Contains behaviour for aggregating values in Mongo.
+      module MongoEx
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Get all the aggregate values for the provided field.
+          #
+          # @example Get all the aggregate values.
+          #   aggregable.aggregates(:likes)
+          #
+          # @param [ String, Symbol ] field The field name.
+          #
+          # @return [ Hash ] The aggregate values in the form:
+          #   {
+          #     "count" => 2.0,
+          #     "max" => 1000.0,
+          #     "min" => 500.0,
+          #     "sum" => 1500.0,
+          #     "avg" => 750.0
+          #   }
+          #
+          # @since 3.0.0
+          def aggregates(field = nil)
+            if (field.present?)
+              if query.count > 0
+                result = collection.aggregate(pipeline(field)).to_a
+                if result.empty?
+                  {"count" => query.count, "avg" => 0, "sum" => 0}
+                else
+                  result.first
+                end
+              else
+                {"count" => 0}
+              end
+            else
+              Aggregates.new(self)
+            end
+          end
+
+          # Get the average value of the provided field.
+          #
+          # @example Get the average of a single field.
+          #   aggregable.avg(:likes)
+          #
+          # @param [ Symbol ] field The field to average.
+          #
+          # @return [ Float ] The average.
+          #
+          # @since 3.0.0
+          def avg(field)
+            aggregates(field)["avg"]
+          end
+
+          # Get the max value of the provided field. If provided a block, will
+          # return the Document with the greatest value for the field, in
+          # accordance with Ruby's enumerable API.
+          #
+          # @example Get the max of a single field.
+          #   aggregable.max(:likes)
+          #
+          # @example Get the document with the max value.
+          #   aggregable.max do |a, b|
+          #     a.likes <=> b.likes
+          #   end
+          #
+          # @param [ Symbol ] field The field to max.
+          #
+          # @return [ Float, Document ] The max value or document with the max
+          #   value.
+          #
+          # @since 3.0.0
+          def max(field = nil)
+            block_given? ? super() : aggregates(field)["max"]
+          end
+
+          # Get the min value of the provided field. If provided a block, will
+          # return the Document with the smallest value for the field, in
+          # accordance with Ruby's enumerable API.
+          #
+          # @example Get the min of a single field.
+          #   aggregable.min(:likes)
+          #
+          # @example Get the document with the min value.
+          #   aggregable.min do |a, b|
+          #     a.likes <=> b.likes
+          #   end
+          #
+          # @param [ Symbol ] field The field to min.
+          #
+          # @return [ Float, Document ] The min value or document with the min
+          #   value.
+          #
+          # @since 3.0.0
+          def min(field = nil)
+            block_given? ? super() : aggregates(field)["min"]
+          end
+
+          # Get the sum value of the provided field. If provided a block, will
+          # return the sum in accordance with Ruby's enumerable API.
+          #
+          # @example Get the sum of a single field.
+          #   aggregable.sum(:likes)
+          #
+          # @example Get the sum for the provided block.
+          #   aggregable.sum(&:likes)
+          #
+          # @param [ Symbol ] field The field to sum.
+          #
+          # @return [ Float ] The sum value.
+          #
+          # @since 3.0.0
+          def sum(field = nil)
+            block_given? ? super() : aggregates(field)["sum"] || 0
+          end
+
+          private
+
+          # Get the aggregation pipeline for provided field.
+          #
+          # @api private
+          #
+          # @example Get the pipeline.
+          #   aggregable.pipeline(:likes)
+          #
+          # @param [ String, Symbol ] field The name of the field.
+          #
+          # @return [ Array ] The array of pipeline operators.
+          #
+          # @since 3.1.0
+          def pipeline(field)
+            db_field = "$#{database_field_name(field)}"
+            pipeline = []
+            pipeline << {"$match" => criteria.nin(field => nil).selector}
+            pipeline << {"$limit" => criteria.options[:limit]} if criteria.options[:limit]
+            pipeline << {
+                "$group" => {
+                    "_id" => field.to_s,
+                    "count" => {"$sum" => 1},
+                    "max" => {"$max" => db_field},
+                    "min" => {"$min" => db_field},
+                    "sum" => {"$sum" => db_field},
+                    "avg" => {"$avg" => db_field}
+                }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid_aggregates.rb

@@ -1 +1 @@
-require 'mongoid/contextual/aggregable/mongo'
+require 'mongoid/contextual/aggregable/mongo_ex'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_aggregates
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Yair Levinson
@@ -10,12 +10,18 @@ bindir: bin
 cert_chain: []
 date: 2013-06-25 00:00:00.000000000 Z
 dependencies: []
-description: Aggregation extender for mongoid
+description: Aggregation extender for mongoid.
 email: yair@locbox.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/mongoid/contextual/aggregable/aggregates.rb
+- lib/mongoid/contextual/aggregable/commands/base.rb
+- lib/mongoid/contextual/aggregable/commands/group.rb
+- lib/mongoid/contextual/aggregable/commands/match.rb
+- lib/mongoid/contextual/aggregable/commands/sort.rb
+- lib/mongoid/contextual/aggregable/mongo_ex.rb
 - lib/mongoid_aggregates.rb
 homepage: http://rubygems.org/gems/mongoid_aggregates
 licenses: []
@@ -39,6 +45,6 @@ rubyforge_project:
 rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: Aggregation extender for mongoid
+summary: mongoid aggregation extender.
 test_files: []
 has_rdoc: