mongoid-mapreduce 0.1.0 → 0.1.1

data/README.md

@@ -6,7 +6,13 @@ Mongoid MapReduce provides simple aggregation functions to your models using Mon
 
 ## How simple is simple?
 
-Very. You provide a Mongoid model, criteria, map key and a list of fields to be aggregated. It returns a list of results (one per unique map key value).
+Short answer: very!
+
+There are two map/reduce formulae:
+
+**Aggregates:** Provide a map key and a list of fields to be aggregated via addition.
+
+**Array List:** Provide an array field, the values will be individually aggregated via addition.
 
 ## Getting Started
 
@@ -28,6 +34,7 @@ class Employee
   field :awards, :type => Integer
   field :age, :type => Integer
   field :male, :type => Integer
+  field :rooms, :type => Array
 end
 ```
 
@@ -35,12 +42,12 @@ You can now use the *map_reduce* method on your model to aggregate data:
 
 ```ruby
 # Create a few example employees
-Employee.create :name => 'Alan', :division => 'Software', :age => 20, :awards => 5, :male => 1
-Employee.create :name => 'Bob', :division => 'Software', :age => 25, :awards => 4, :male => 1
-Employee.create :name => 'Chris', :division => 'Hardware', :age => 30, :awards => 3, :male => 1
-Employee.create :name => 'Darcy', :division => 'Sales', :age => 35, :awards => 3, :male => 0
+Employee.create :name => 'Alan', :division => 'Software', :age => 20, :awards => 5, :male => 1, :rooms => [1,2,3]
+Employee.create :name => 'Bob', :division => 'Software', :age => 25, :awards => 4, :male => 1, :rooms => [1,2,3]
+Employee.create :name => 'Chris', :division => 'Hardware', :age => 30, :awards => 3, :male => 1, :rooms => [4,5,6]
+Employee.create :name => 'Darcy', :division => 'Sales', :age => 35, :awards => 3, :male => 0, :rooms => [1,2,3,4,5,6]
 
-# Produces 3 records, one for each division.
+# Aggregate formula: produces 3 records, one for each division.
 divs = Employee.map_reduce(:division, :fields => [:age, :awards])
 divs.length               # => 3
 divs.find('Software').age # => 45
@@ -50,6 +57,15 @@ divs.last.age             # => 35
 divs.keys                 # => ['Hardware', 'Software', 'Sales']
 divs.has_key?('Sales')    # => true
 divs.to_hash              # => { "Software" => ..., "Hardware" => ..., "Sales" => ... }
+
+# Array Value formula: produces 6 records, one for each room.
+rooms = Employee.map_reduce do
+  field :rooms, :formula => :array_values
+end
+rooms.length          # => 6
+rooms.find(1)._count  # => 3
+rooms.counts["5"]     # => 2
+rooms.counts          # => { "1" => 3, "2" => 3, "3" => 3, "4" => 2, "5" => 2, "6" => 2 }
 ```
 
 You can also add Mongoid criteria before the operation:
@@ -61,6 +77,29 @@ divs.length               # => 2
 divs.has_key?('Sales')    # => false
 ```
 
+You choose to supply fields as arguments or in a block:
+
+```ruby
+# These are the same:
+Employee.where(:age.gt => 20).map_reduce(:division, :fields => [:age, :awards])
+Employee.where(:age.gt => 20).map_reduce(:division) do
+  field :age
+  field :awards
+end
+```
+
+Fields can be of any type supported by Mongoid serialization, and field type is specified in block configuration:
+
+```ruby
+divs = Employee.map_reduce(:division) do
+  field :age, :type => Integer
+  field :awards, :type => Float
+end
+
+divs.find('Software').age     # => 60
+divs.find('Software').awards  # => 9.0
+```
+
 Additional meta fields are included in the results:
 
 NOTE: _key_name and _key_value are discarded when converting to Hash.
@@ -77,15 +116,6 @@ divs.find('Software')._count      # => 2
 Employee.map_reduce(:division, :count_field => :num).find('Software').num  #=> 2
 ```
 
-You can also choose to supply fields in a block:
-
-```ruby
-Employee.where(:age.gt => 20).map_reduce(:division) do
-  field :age
-  field :awards
-end
-```
-
 ## Enhancements and Pull Requests
 
 If you find the project useful but it doesn't meet all of your needs, feel free to fork it and send a pull request.

data/lib/mongoid/mapreduce/base.rb

@@ -18,7 +18,9 @@ module Mongoid
         end
 
         if options.key?(:fields)
-          reducer.fields = options[:fields].collect {|f| f.to_sym }
+          options[:fields].each do |f|
+            reducer.field f.to_sym
+          end
         end
 
         reducer.instance_eval(&block) if block.present?

data/lib/mongoid/mapreduce/document.rb

@@ -10,7 +10,7 @@ module Mongoid
       # Returns value of super
       def initialize(attrs)
         attrs.each do |k, v|
-          self[k.to_sym] = v
+          self[k] = v
         end
         super
       end
@@ -23,7 +23,9 @@ module Mongoid
       #
       # Returns value of supplied symbol/string if exists
       def method_missing(sym, *args, &block)
-        if self.has_key?(sym.to_sym)
+        if self.has_key?(sym)
+          return self[sym]
+        elsif self.has_key?(sym.to_sym)
           return self[sym.to_sym]
         elsif self.has_key?(sym.to_s)
           return self[sym.to_s]

data/lib/mongoid/mapreduce/reducer.rb

@@ -3,7 +3,7 @@ module Mongoid
 
     class Reducer
 
-      attr_accessor :fields, :count_field
+      attr_accessor :count_field
 
       # Initialize the reducer with given values
       #
@@ -17,21 +17,92 @@ module Mongoid
         @selector = selector
         @map_key = map_key
         @count_field = :_count
-        @fields = []
+        @fields = {}
+      end
+
+      # Obtain the field we are using for the map, if using an array values map.
+      #
+      # Returns true or false
+      def map_array_field
+        @fields.select { |k, v| v[:formula] == :array_values }.first
+      end
+
+      # Determines whether or not we are mapping from an array value
+      #
+      # Returns true or false
+      def map_from_array?
+        @fields.select { |k, v| v[:formula] == :array_values }.any?
       end
 
       # Generates the JavaScript map function
       #
+      # If we have any fields defined with a map function of :array_values, use that to map
+      # otherwise, use our aggregate map function.
+      #
       # Returns String
       def map
-        "function() { emit(this.#{@map_key}, [1, #{@fields.collect{|k| "this.#{k}"}.join(", ")}]); }"
+        fn =  "function() { "
+        if map_from_array?
+          fn << map_array_values(map_array_field)
+        else
+          fn << map_aggregates
+        end
+        fn << "}"
+        fn
+      end
+
+      # Generate a map function from one unique map key and a number of aggregate sources
+      #
+      #
+      def map_aggregates
+        fields = @fields.select { |k, v| v[:formula] == :aggregate }
+        "emit (this.#{@map_key}, [#{[1, fields.collect{|k,v| "this.#{k}"}].flatten.join(", ")}]); "
+      end
+
+      # Generate a map function from one unique map key and a number of aggregate sources
+      #
+      #
+      def map_array_values(field)
+        "this.#{field[0].to_s}.forEach(function(value) { emit(value, 1); }); "
       end
 
       # Generates the JavaScript reduce function
       #
       # Returns String
       def reduce
-        "function(k, v) { var results = [0#{",0" * @fields.length}]; v.forEach(function(v){ [0,#{@fields.collect.with_index{|k,i| i+1}.join(",")}].forEach(function(k){ results[k] += v[k] }) }); return results.toString(); }"
+        fn = "function(k, v) { "
+        if map_from_array?
+          fn << reduce_array_values
+        else
+          fn << reduce_aggregates
+        end
+        fn << "}"
+        fn
+      end
+
+      # Generates a reduce function for aggregate map
+      #
+      # Returns String
+      def reduce_aggregates
+        fields = @fields.select { |k, v| v[:formula] == :aggregate }
+        fn = ""
+        fn << "var results = [#{(["0"] * (fields.length + 1)).flatten.join(", ")}]; "
+        fn << "v.forEach(function(val) { "
+        fn <<   "for(var i=0; i<= #{fields.length}; i++) { "
+        fn <<     "results[i] += val[i] "
+        fn <<   "} "
+        fn << "}); "
+        fn << "return results.toString(); "
+      end
+
+      # Generates a reduce function for array values
+      #
+      # Returns String
+      def reduce_array_values
+        fn = ""
+        fn << "var result = 0; "
+        fn << "v.forEach(function(val) { result += val; }); "
+        fn << "return result; "
       end
 
       # Adds a field to the map/reduce operation
@@ -39,8 +110,22 @@ module Mongoid
       # sym - String or Symbol, name of field to add
       #
       # Returns nothing.
-      def field(sym)
-        @fields << sym.to_sym
+      def field(sym, options={})
+        options[:type] ||= Integer
+        options[:formula] ||= :aggregate
+        @fields[sym.to_sym] = options
+      end
+
+      # Serialize an object to the specified class
+      #
+      # obj - Object to serialize
+      # klass - Class to prefer
+      #
+      # Returns serialized object or nil
+      def serialize(obj, klass)
+        return nil if obj.blank?
+        obj = obj.to_s =~ /(^[-+]?[0-9]+$)|(\.0+)$/ ? Integer(obj) : Float(obj)
+        Mongoid::Fields::Mappings.for(klass).allocate.serialize(obj)
       end
 
       # Runs the map/reduce operation and returns the result
@@ -52,10 +137,18 @@ module Mongoid
           res = @klass.collection.map_reduce(map, reduce, { query: @selector, out: "#map_reduce" } ).find.to_a
           return res.inject(Results.new) do |h, k|
             idx = k.values[0]
-            d = (k.values[1].is_a?(String) ? k.values[1].split(',') : k.values[1]).collect {|i| i.is_a?(Boolean) ? (i ? 1 : 0) : i.to_i }
-            doc = Document.new :_key_name => @map_key.to_sym, :_key_value => idx, @map_key.to_sym => idx, @count_field.to_sym => d[0]
-            @fields.flatten.each_with_index do |k, i|
-              doc[k.to_sym] = d[i + 1]
+            d = (k.values[1].is_a?(String) ? k.values[1].split(',') : k.values[1])
+
+            if d.is_a?(Array)
+              doc = Document.new :_key_name => @map_key.to_s, :_key_value => idx, @map_key => idx, @count_field => d[0].to_i
+              @fields.each_with_index do |h, i|
+                doc[h[0].to_sym] = serialize(d[i + 1], h[1][:type])
+              end
+            else
+              f = map_array_field[0]
+              k = serialize(idx, map_array_field[1][:type])
+              v = d.to_i
+              doc = Document.new :_key_name => f, :_key_value => k, k.to_s => v, @count_field => v
             end
             h << doc
           end

data/lib/mongoid/mapreduce/results.rb

@@ -45,7 +45,14 @@ module Mongoid
       #
       # Returns Hash
       def to_hash
-        self.each.inject({}){|h, doc| h[doc._key_value] = doc.to_hash; h }
+        self.each.inject({}){|h, doc| h[doc._key_value.to_s] = doc.to_hash; h }
+      end
+
+      # Simplifies the Results to a Hash containing only a key and a single value (the count)
+      #
+      # Returns Hash
+      def counts
+        self.each.inject({}) {|h, doc| h[doc._key_value.to_s] = doc._count; h }
       end
 
     end

data/lib/mongoid/mapreduce/version.rb

@@ -1,7 +1,7 @@
 module Mongoid
   module MapReduce
 
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
 
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-mapreduce
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-22 00:00:00.000000000Z
+date: 2011-09-23 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &70365613354940 !ruby/object:Gem::Requirement
+  requirement: &70109620996440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70365613354940
+  version_requirements: *70109620996440
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &70365613354440 !ruby/object:Gem::Requirement
+  requirement: &70109620995920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.3'
   type: :runtime
   prerelease: false
-  version_requirements: *70365613354440
+  version_requirements: *70109620995920
 - !ruby/object:Gem::Dependency
   name: growl
-  requirement: &70365613354060 !ruby/object:Gem::Requirement
+  requirement: &70109620995540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70365613354060
+  version_requirements: *70109620995540
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70365613353520 !ruby/object:Gem::Requirement
+  requirement: &70109620994980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70365613353520
+  version_requirements: *70109620994980
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70365613353020 !ruby/object:Gem::Requirement
+  requirement: &70109620994340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70365613353020
+  version_requirements: *70109620994340
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70365613352560 !ruby/object:Gem::Requirement
+  requirement: &70109620993880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +76,7 @@ dependencies:
         version: 0.4.3
   type: :development
   prerelease: false
-  version_requirements: *70365613352560
+  version_requirements: *70109620993880
 description: Mongoid MapReduce provides simple aggregation features for your Mongoid
   models
 email: