mongoid-mapreduce 0.1.2 → 0.1.3

data/README.md

@@ -59,9 +59,7 @@ 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 = Employee.map_reduce(:rooms, :formula => :array_values)
 rooms.length          # => 6
 rooms.find(1)._count  # => 3
 rooms.counts["5"]     # => 2

data/lib/mongoid/mapreduce.rb

@@ -3,4 +3,5 @@ require 'mongoid/mapreduce/base'
 require 'mongoid/mapreduce/document'
 require 'mongoid/mapreduce/reducer'
 require 'mongoid/mapreduce/results'
+require 'mongoid/mapreduce/serialization'
 require 'mongoid/mapreduce/version'

data/lib/mongoid/mapreduce/base.rb

@@ -11,18 +11,8 @@ module Mongoid
       #
       # Returns a Hash of results
       def map_reduce(map_key=:_id, options={}, &block)
-        reducer = Reducer.new(self, criteria.selector, map_key)
-
-        if options.key?(:count_field)
-          reducer.count_field = options[:count_field].to_sym
-        end
-
-        if options.key?(:fields)
-          options[:fields].each do |f|
-            reducer.field f.to_sym
-          end
-        end
-
+        options[:map_key] = map_key
+        reducer = Reducer.new(self, criteria.selector, options)
         reducer.instance_eval(&block) if block.present?
         reducer.run
       end

data/lib/mongoid/mapreduce/formula/aggregate_fields.rb

@@ -0,0 +1,66 @@
+require 'mongoid/mapreduce/serialization'
+
+module Mongoid
+  module MapReduce
+    module Formula
+
+      class AggregateFields
+        include Mongoid::MapReduce::Serialization
+
+        def initialize(fields, options={})
+          options[:map_key] ||= :_id
+          options[:count_field] ||= :_count
+
+          @map_key = options[:map_key]
+          @count_field = options[:count_field]
+          @fields = fields
+        end
+
+        # Generate a map function
+        # Emits the map key with an array of field values
+        #
+        # Returns String
+        def map
+          fn =  "function() { "
+          fn <<   "emit (this.#{@map_key}, [#{[1, @fields.collect{|k,v| "this.#{k}"}].flatten.join(", ")}]); "
+          fn << "}"
+        end
+
+        # Generates a reduce function
+        # Adds each value in the given array
+        #
+        # Returns String
+        def reduce
+          fn =  "function(k, v) { "
+          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] += (typeof val[i] == Boolean) ? (val[i] ? 1 : 0) : val[i] "
+          fn <<     "} "
+          fn <<   "}); "
+          fn <<   "return results.toString(); "
+          fn << "}"
+        end
+
+        # Process the results of a given collection
+        #
+        # collection - the MongoDB collection returned from the map/reduce op
+        #
+        # Returns Results
+        def process(collection)
+          return collection.inject(Results.new) do |h, k|
+            key = k.values[0]
+            vals = (k.values[1].is_a?(String) ? k.values[1].split(',') : k.values[1])
+            doc = Document.new :_key_name => @map_key.to_s, :_key_value => key, @map_key => key, @count_field => vals[0].to_i
+            @fields.each_with_index do |f, i|
+              doc[f[0].to_sym] = serialize(vals[i + 1], f[1][:type])
+            end
+            h << doc
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mongoid/mapreduce/formula/array_values.rb

@@ -0,0 +1,65 @@
+require 'mongoid/mapreduce/serialization'
+
+module Mongoid
+  module MapReduce
+    module Formula
+
+      class ArrayValues
+        include Mongoid::MapReduce::Serialization
+
+        def initialize(fields, options={})
+          options[:map_key] ||= :_id
+          options[:count_type] ||= Integer
+          options[:count_field] ||= :_count
+
+          if fields.length > 1
+            raise "Error: The Array Values formula can only take 1 field"
+          end
+
+          @field_name = options[:map_key]
+          @field_type = options[:count_type]
+          @count_field = options[:count_field]
+        end
+
+        # Generate a map function
+        # Emits the value 1 for each value of the given array field
+        #
+        # Returns String
+        def map
+          fn =  "function() { "
+          fn <<   "this.#{@field_name.to_s}.forEach(function(value) { "
+          fn <<     "emit(value, 1); "
+          fn <<   "}); "
+          fn << "}"
+        end
+
+        # Generates a reduce function
+        # Adds the given values
+        #
+        # Returns String
+        def reduce
+          fn =  "function(k, v) { "
+          fn <<   "var result = 0; "
+          fn <<   "v.forEach(function(val) { result += val; }); "
+          fn <<   "return result; "
+          fn << "}"
+        end
+
+        # Process the results of a given collection
+        #
+        # collection - the MongoDB collection returned from the map/reduce op
+        #
+        # Returns Results
+        def process(collection)
+          return collection.inject(Results.new) do |h, k|
+            key = k.values[0].to_s =~ /(^[-+]?[0-9]+$)|(\.0+)$/ ? Integer(k.values[0]) : Float(k.values[0])
+            val = serialize(k.values[1].is_a?(String) ? k.values[1].split(',') : k.values[1], @field_type)
+            h << Document.new(:_key_name => @field_name, :_key_value => key, key.to_s => val, @count_field => val)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mongoid/mapreduce/reducer.rb

@@ -1,3 +1,6 @@
+require 'mongoid/mapreduce/formula/aggregate_fields.rb'
+require 'mongoid/mapreduce/formula/array_values.rb'
+
 module Mongoid
   module MapReduce
 
@@ -9,100 +12,41 @@ module Mongoid
       #
       # klass - Mongoid model Class
       # selector - Selector to use for search (often from criteria)
-      # map_key - Key to use in map function
+      # options - Hash of options:
+      #             count_field - Name of field used to store count in results
+      #             formula - Name of formula to be used (underscore)
+      #             map_key - Name of field used as key in map function
       #
       # Returns nothing
-      def initialize(klass, selector, map_key)
+      def initialize(klass, selector, options)
+        options[:klass] = klass
+        options[:selector] = selector
+        options[:formula] ||= :aggregate_fields
+
         @klass = klass
         @selector = selector
-        @map_key = map_key
-        @count_field = :_count
+        @formula_name = options[:formula]
+        @options = options
         @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
-        fn =  "function() { "
-        if map_from_array?
-          fn << map_array_values(map_array_field)
-        else
-          fn << map_aggregates
+        if options.key?(:fields)
+          options[:fields].each do |f|
+            field f.to_sym
+          end
         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
-      #
+      # Expose the currently selected formula, from instance variable if possible.
       #
-      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
-        fn = "function(k, v) { "
-        if map_from_array?
-          fn << reduce_array_values
-        else
-          fn << reduce_aggregates
+      # Returns Formula object.
+      def formula
+        # Find and initialize our formula
+        klass = "Mongoid::MapReduce::Formula::#{@formula_name.to_s.camelize}"
+        begin
+          @formula ||= klass.constantize.new(@fields, @options)
+        rescue NameError
+          raise "Could not load formula for #{klass}"
         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] += (typeof val[i] == Boolean) ? (val[i] ? 1 : 0) : 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
@@ -112,49 +56,21 @@ module Mongoid
       # Returns nothing.
       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.is_a?(Boolean) ? (obj ? 1 : 0) : obj
-        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
       #
       # Returns Mongoid::MapReduce::Results object (array)
       # containing Mongoid::MapReduce::Document objects (hashes)
       def run
         begin
-          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])
-
-            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
+          coll = @klass.collection.map_reduce(formula.map, formula.reduce, { query: @selector, out: "#map_reduce" } ).find.to_a
+        rescue
+          raise "Error: could not execute map reduce function"
         end
 
+        formula.process(coll)
       end
 
     end

data/lib/mongoid/mapreduce/serialization.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module MapReduce
+    module Serialization
+
+      # 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.is_a?(Boolean) ? (obj ? 1 : 0) : obj
+        obj = obj.to_s =~ /(^[-+]?[0-9]+$)|(\.0+)$/ ? Integer(obj) : Float(obj)
+        Mongoid::Fields::Mappings.for(klass).allocate.serialize(obj)
+      end
+
+    end
+  end
+end

data/lib/mongoid/mapreduce/version.rb

@@ -1,7 +1,7 @@
 module Mongoid
   module MapReduce
 
-    VERSION = '0.1.2'
+    VERSION = '0.1.3'
 
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-mapreduce
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-23 00:00:00.000000000Z
+date: 2011-09-24 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &70107200564540 !ruby/object:Gem::Requirement
+  requirement: &70361782922640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70107200564540
+  version_requirements: *70361782922640
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &70107200564040 !ruby/object:Gem::Requirement
+  requirement: &70361782922040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.3'
   type: :runtime
   prerelease: false
-  version_requirements: *70107200564040
+  version_requirements: *70361782922040
 - !ruby/object:Gem::Dependency
   name: growl
-  requirement: &70107200563660 !ruby/object:Gem::Requirement
+  requirement: &70361782921580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70107200563660
+  version_requirements: *70361782921580
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70107200563100 !ruby/object:Gem::Requirement
+  requirement: &70361782920960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70107200563100
+  version_requirements: *70361782920960
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70107200562580 !ruby/object:Gem::Requirement
+  requirement: &70361782920360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70107200562580
+  version_requirements: *70361782920360
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70107200562120 !ruby/object:Gem::Requirement
+  requirement: &70361782919780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +76,7 @@ dependencies:
         version: 0.4.3
   type: :development
   prerelease: false
-  version_requirements: *70107200562120
+  version_requirements: *70361782919780
 description: Mongoid MapReduce provides simple aggregation features for your Mongoid
   models
 email:
@@ -87,8 +87,11 @@ extra_rdoc_files: []
 files:
 - lib/mongoid/mapreduce/base.rb
 - lib/mongoid/mapreduce/document.rb
+- lib/mongoid/mapreduce/formula/aggregate_fields.rb
+- lib/mongoid/mapreduce/formula/array_values.rb
 - lib/mongoid/mapreduce/reducer.rb
 - lib/mongoid/mapreduce/results.rb
+- lib/mongoid/mapreduce/serialization.rb
 - lib/mongoid/mapreduce/version.rb
 - lib/mongoid/mapreduce.rb
 - lib/mongoid-mapreduce.rb