dm-aggregates 0.9.2 → 0.9.3

data/History.txt

@@ -0,0 +1 @@
+

data/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+LICENSE
+Manifest.txt
+README.txt
+Rakefile
+TODO
+lib/dm-aggregates.rb
+lib/dm-aggregates/adapters/data_objects_adapter.rb
+lib/dm-aggregates/aggregate_functions.rb
+lib/dm-aggregates/collection.rb
+lib/dm-aggregates/model.rb
+lib/dm-aggregates/repository.rb
+lib/dm-aggregates/support/symbol.rb
+lib/dm-aggregates/version.rb
+spec/integration/aggregates_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/Rakefile

@@ -1,51 +1,44 @@
 require 'rubygems'
 require 'spec'
-require 'rake/clean'
-require 'rake/gempackagetask'
 require 'spec/rake/spectask'
 require 'pathname'
 
-CLEAN.include '{log,pkg}/'
+ROOT = Pathname(__FILE__).dirname.expand_path
+require ROOT + 'lib/dm-aggregates/version'
 
-spec = Gem::Specification.new do |s|
-  s.name             = 'dm-aggregates'
-  s.version          = '0.9.2'
-  s.platform         = Gem::Platform::RUBY
-  s.has_rdoc         = true
-  s.extra_rdoc_files = %w[ README LICENSE TODO ]
-  s.summary          = 'DataMapper plugin providing support for aggregates, functions on collections and datasets'
-  s.description      = s.summary
-  s.author           = 'Foy Savas'
-  s.email            = 'foysavas@gmail.com'
-  s.homepage         = 'http://github.com/sam/dm-more/tree/master/dm-aggregates'
-  s.require_path     = 'lib'
-  s.files            = FileList[ '{lib,spec}/**/*.rb', 'spec/spec.opts', 'Rakefile', *s.extra_rdoc_files ]
-  s.add_dependency('dm-core', "=#{s.version}")
-end
+AUTHOR = "Foy Savas"
+EMAIL  = "foysavas@gmail.com"
+GEM_NAME = "dm-aggregates"
+GEM_VERSION = DataMapper::More::Aggregates::VERSION
+GEM_DEPENDENCIES = [["dm-core", GEM_VERSION]]
+GEM_CLEAN = ["log", "pkg"]
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO ] }
+
+PROJECT_NAME = "datamapper"
+PROJECT_URL  = "http://github.com/sam/dm-more/tree/master/dm-aggregates"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY = "DataMapper plugin providing support for aggregates, functions on collections and datasets"
+
+require ROOT.parent + 'tasks/hoe'
 
 task :default => [ :spec ]
 
 WIN32 = (RUBY_PLATFORM =~ /win32|mingw|cygwin/) rescue nil
 SUDO  = WIN32 ? '' : ('sudo' unless ENV['SUDOLESS'])
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
-
-desc "Install #{spec.name} #{spec.version} (default ruby)"
+desc "Install #{GEM_NAME} #{GEM_VERSION} (default ruby)"
 task :install => [ :package ] do
-  sh "#{SUDO} gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources", :verbose => false
+  sh "#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources", :verbose => false
 end
 
-desc "Uninstall #{spec.name} #{spec.version} (default ruby)"
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION} (default ruby)"
 task :uninstall => [ :clobber ] do
-  sh "#{SUDO} gem uninstall #{spec.name} -v#{spec.version} -I -x", :verbose => false
+  sh "#{SUDO} gem uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x", :verbose => false
 end
 
 namespace :jruby do
-  desc "Install #{spec.name} #{spec.version} with JRuby"
+  desc "Install #{GEM_NAME} #{GEM_VERSION} with JRuby"
   task :install => [ :package ] do
-    sh %{#{SUDO} jruby -S gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources}, :verbose => false
+    sh %{#{SUDO} jruby -S gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}, :verbose => false
   end
 end
 

data/lib/dm-aggregates.rb

@@ -1,12 +1,15 @@
 require 'rubygems'
 
-gem 'dm-core', '=0.9.2'
+dir = Pathname(__FILE__).dirname.expand_path + 'dm-aggregates'
+
+require dir + 'version'
+gem 'dm-core', DataMapper::More::Aggregates::VERSION
 require 'dm-core'
 
-dir = Pathname(__FILE__).dirname.expand_path / 'dm-aggregates'
 
-require dir / 'functions'
-require dir / 'model'
-require dir / 'repository'
-require dir / 'collection'
-require dir / 'adapters' / 'data_objects_adapter'
+require dir + 'aggregate_functions'
+require dir + 'model'
+require dir + 'repository'
+require dir + 'collection'
+require dir + 'adapters' + 'data_objects_adapter'
+require dir + 'support' + 'symbol'

data/lib/dm-aggregates/adapters/data_objects_adapter.rb

@@ -1,53 +1,68 @@
 module DataMapper
   module Adapters
     class DataObjectsAdapter
-      def count(property, query)
-        query(aggregate_read_statement(:count, property, query), *query.bind_values).first
+      def aggregate(query)
+        with_reader(read_statement(query), query.bind_values) do |reader|
+          results = []
+
+          while(reader.next!) do
+            row = query.fields.zip(reader.values).map do |field,value|
+              if field.respond_to?(:operator)
+                send(field.operator, field.target, value)
+              else
+                field.typecast(value)
+              end
+            end
+
+            results << (query.fields.size > 1 ? row : row[0])
+          end
+
+          results
+        end
       end
 
-      def min(property, query)
-        min = query(aggregate_read_statement(:min, property, query), *query.bind_values).first
-        property.typecast(min)
+      private
+
+      def count(property, value)
+        value.to_i
+      end
+
+      def min(property, value)
+        property.typecast(value)
       end
 
-      def max(property, query)
-        max = query(aggregate_read_statement(:max, property, query), *query.bind_values).first
-        property.typecast(max)
+      def max(property, value)
+        property.typecast(value)
       end
 
-      def avg(property, query)
-        avg = query(aggregate_read_statement(:avg, property, query), *query.bind_values).first
-        property.type == Integer ? avg.to_f : property.typecast(avg)
+      def avg(property, value)
+        property.type == Integer ? value.to_f : property.typecast(value)
       end
 
-      def sum(property, query)
-        sum = query(aggregate_read_statement(:sum, property, query), *query.bind_values).first
-        property.typecast(sum)
+      def sum(property, value)
+        property.typecast(value)
       end
 
       module SQL
         private
 
-        def aggregate_read_statement(aggregate_function, property, query)
-          statement = "SELECT #{aggregate_field_statement(query.repository, aggregate_function, property, query.links.any?)}"
-          statement << " FROM #{quote_table_name(query.model.storage_name(query.repository.name))}"
-          statement << links_statement(query)                        if query.links.any?
-          statement << " WHERE #{conditions_statement(query)}"       if query.conditions.any?
-
-          # TODO: when GROUP BY support added, uncomment this, and (by default) have
-          # it sort on the non-aggregate fields being SELECTed
-          #statement << " ORDER BY #{order_statement(query)}"         if query.order.any?
-
-          statement << " LIMIT #{quote_column_value(query.limit)}"   if query.limit
-          statement << " OFFSET #{quote_column_value(query.offset)}" if query.offset && query.offset > 0
-          statement
-        rescue => e
-          DataMapper.logger.error("QUERY INVALID: #{query.inspect} (#{e})")
-          raise e
+        alias original_property_to_column_name property_to_column_name
+
+        def property_to_column_name(repository, property, qualify)
+          case property
+            when Query::Operator
+              aggregate_field_statement(repository, property.operator, property.target, qualify)
+            when Property
+              original_property_to_column_name(repository, property, qualify)
+						when Query::Path
+							 original_property_to_column_name(repository, property, qualify)
+            else
+              raise ArgumentError, "+property+ must be a DataMapper::Query::Operator or a DataMapper::Property, but was a #{property.class} (#{property.inspect})"
+          end
         end
 
         def aggregate_field_statement(repository, aggregate_function, property, qualify)
-          column_name  = if aggregate_function == :count && property.nil?
+          column_name = if aggregate_function == :count && property == :all
             '*'
           else
             property_to_column_name(repository, property, qualify)

data/lib/dm-aggregates/aggregate_functions.rb

@@ -0,0 +1,200 @@
+module DataMapper
+  module AggregateFunctions
+    # Count results (given the conditions)
+    #
+    # @example the count of all friends
+    #   Friend.count
+    #
+    # @example the count of all friends older then 18
+    #   Friend.count(:age.gt => 18)
+    #
+    # @example the count of all your female friends
+    #   Friend.count(:conditions => [ 'gender = ?', 'female' ])
+    #
+    # @example the count of all friends with an address (NULL values are not included)
+    #   Friend.count(:address)
+    #
+    # @example the count of all friends with an address that are older then 18
+    #   Friend.count(:address, :age.gt => 18)
+    #
+    # @example the count of all your female friends with an address
+    #   Friend.count(:address, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] of the property you with to count (optional)
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the count given the conditions
+    #
+    # @api public
+    def count(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      if property_name
+        assert_kind_of 'property', property_by_name(property_name), Property
+      end
+
+      aggregate(query.merge(:fields => [ property_name ? property_name.count : :all.count ]))
+    end
+
+    # Get the lowest value of a property
+    #
+    # @example the age of the youngest friend
+    #   Friend.min(:age)
+    #
+    # @example  the age of the youngest female friend
+    #   Friend.min(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the lowest value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the lowest value of a property given the conditions
+    #
+    # @api public
+    def min(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal, DateTime, Date, Time
+
+      aggregate(query.merge(:fields => [ property_name.min ]))
+    end
+
+    # Get the highest value of a property
+    #
+    # @example the age of the oldest friend
+    #   Friend.max(:age)
+    #
+    # @example the age of the oldest female friend
+    #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the highest value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the highest value of a property given the conditions
+    #
+    # @api public
+    def max(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal, DateTime, Date, Time
+
+      aggregate(query.merge(:fields => [ property_name.max ]))
+    end
+
+    # Get the average value of a property
+    #
+    # @example the average age of all friends
+    #   Friend.avg(:age)
+    #
+    # @example the average age of all female friends
+    #   Friend.avg(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the average value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the average value of a property given the conditions
+    #
+    # @api public
+    def avg(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal
+
+      aggregate(query.merge(:fields => [ property_name.avg ]))
+    end
+
+    # Get the total value of a property
+    #
+    # @example the total age of all friends
+    #   Friend.sum(:age)
+    #
+    # @example the total age of all female friends
+    #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ])
+    #
+    # @param property [Symbol] the property you wish to get the total value of
+    # @param  opts [Hash, Symbol] the conditions
+    #
+    # @return [Integer] return the total value of a property given the conditions
+    #
+    # @api public
+    def sum(*args)
+      query         = args.last.kind_of?(Hash) ? args.pop : {}
+      property_name = args.first
+
+      assert_property_type property_name, Integer, Float, BigDecimal
+
+      aggregate(query.merge(:fields => [ property_name.sum ]))
+    end
+
+    # Perform aggregate queries
+    #
+    # @example the count of friends
+    #   Friend.aggregate(:all.count)
+    #
+    # @example the minimum age, the maximum age and the total age of friends
+    #   Friend.aggregate(:age.min, :age.max, :age.sum)
+    #
+    # @example the average age, grouped by gender
+    #   Friend.aggregate(:age.avg, :fields => [ :gender ])
+    #
+    # @param aggregates [Symbol, ...] operators to aggregate with
+    # @params query [Hash] the conditions
+    #
+    # @return [Array,Numeric,DateTime,Date,Time] the results of the
+    #   aggregate query
+    #
+    # @api public
+    def aggregate(*args)
+      query = args.last.kind_of?(Hash) ? args.pop : {}
+
+      query[:fields] ||= []
+      query[:fields]  |= args
+      query[:fields].map! { |f| normalize_field(f) }
+      query[:order]  ||= query[:fields].select { |p| p.kind_of?(Property) }
+
+      raise ArgumentError, 'query[:fields] must not be empty' if query[:fields].empty?
+
+      query = scoped_query(query)
+
+      if query.fields.any? { |p| p.kind_of?(Property) }
+        query.repository.aggregate(query.update(:unique => true))
+      else
+        query.repository.aggregate(query).first  # only return one row
+      end
+    end
+
+    private
+
+    def assert_property_type(name, *types)
+      if name.nil?
+        raise ArgumentError, 'property name must not be nil'
+      end
+
+      type = property_by_name(name).type
+
+      unless types.include?(type)
+        raise ArgumentError, "#{name} must be #{types * ' or '}, but was #{type}"
+      end
+    end
+
+    def normalize_field(field)
+      assert_kind_of 'field', field, Query::Operator, Symbol, Property
+
+      case field
+        when Query::Operator
+          if field.target == :all
+            field
+          else
+            field.class.new(property_by_name(field.target), field.operator)
+          end
+        when Symbol
+          property_by_name(field)
+        when Property
+          field
+      end
+    end
+  end
+end

data/lib/dm-aggregates/collection.rb

@@ -1,18 +1,11 @@
 module DataMapper
   class Collection
-    include Aggregates
+    include AggregateFunctions
 
     private
 
-    def with_repository_and_property(*args, &block)
-      query         = args.last.respond_to?(:merge) ? args.pop : {}
-      property_name = args.first
-
-      query      = scoped_query(query)
-      repository = query.repository
-      property   = properties[property_name] if property_name
-
-      yield repository, property, query
+    def property_by_name(property_name)
+      properties[property_name]
     end
   end
 end

data/lib/dm-aggregates/model.rb

@@ -1,18 +1,11 @@
 module DataMapper
   module Model
-    include Aggregates
+    include AggregateFunctions
 
     private
 
-    def with_repository_and_property(*args, &block)
-      query         = args.last.respond_to?(:merge) ? args.pop : {}
-      property_name = args.first
-
-      query      = scoped_query(query)
-      repository = query.repository
-      property   = properties(repository.name)[property_name] if property_name
-
-      yield repository, property, query
+    def property_by_name(property_name)
+      properties(repository.name)[property_name]
     end
   end
 end

data/lib/dm-aggregates/repository.rb

@@ -1,23 +1,7 @@
 module DataMapper
   class Repository
-    def count(property, query)
-      adapter.count(property, query)
-    end
-
-    def min(property, query)
-      adapter.min(property, query)
-    end
-
-    def max(property, query)
-      adapter.max(property, query)
-    end
-
-    def avg(property, query)
-      adapter.avg(property, query)
-    end
-
-    def sum(property, query)
-      adapter.sum(property, query)
+    def aggregate(query)
+      adapter.aggregate(query)
     end
   end
 end

data/lib/dm-aggregates/support/symbol.rb

@@ -0,0 +1,21 @@
+class Symbol
+  def count
+    DataMapper::Query::Operator.new(self, :count)
+  end
+
+  def min
+    DataMapper::Query::Operator.new(self, :min)
+  end
+
+  def max
+    DataMapper::Query::Operator.new(self, :max)
+  end
+
+  def avg
+    DataMapper::Query::Operator.new(self, :avg)
+  end
+
+  def sum
+    DataMapper::Query::Operator.new(self, :sum)
+  end
+end # class Symbol

data/lib/dm-aggregates/version.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module More
+    module Aggregates
+      VERSION = "0.9.3"
+    end
+  end
+end

data/spec/integration/aggregates_spec.rb

@@ -5,35 +5,55 @@ if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
   describe 'DataMapper::Resource' do
     before :all do
       # A simplistic example, using with an Integer property
+			class Knight
+				include DataMapper::Resource
+
+				property :id,								Serial
+				property :name,							String
+			end
+
       class Dragon
         include DataMapper::Resource
-        property :id, Serial
-        property :name, String
+
+        property :id,                Serial
+        property :name,              String
         property :is_fire_breathing, TrueClass
-        property :toes_on_claw, Integer
+        property :toes_on_claw,      Integer
+        property :birth_at,          DateTime
+        property :birth_on,          Date
+        property :birth_time,        Time
 
-        auto_migrate!(:default)
+				belongs_to :knight
       end
 
-      Dragon.create(:name => 'George', :is_fire_breathing => false, :toes_on_claw => 3)
-      Dragon.create(:name => 'Puff',   :is_fire_breathing => true,  :toes_on_claw => 4)
-      Dragon.create(:name => nil,      :is_fire_breathing => true,  :toes_on_claw => 5)
+
       # A more complex example, with BigDecimal and Float properties
       # Statistics taken from CIA World Factbook:
       # https://www.cia.gov/library/publications/the-world-factbook/
       class Country
         include DataMapper::Resource
 
-        property :id,                  Integer, :serial => true
-        property :name,                String,  :nullable => false
+        property :id,                  Serial
+        property :name,                String,     :nullable => false
         property :population,          Integer
         property :birth_rate,          Float,      :precision => 4,  :scale => 2
         property :gold_reserve_tonnes, Float,      :precision => 6,  :scale => 2
         property :gold_reserve_value,  BigDecimal, :precision => 15, :scale => 1  # approx. value in USD
-
-        auto_migrate!(:default)
       end
 
+      [ Dragon, Country, Knight ].each { |m| m.auto_migrate! }
+
+      @birth_at   = DateTime.now
+      @birth_on   = Date.parse(@birth_at.to_s)
+      @birth_time = Time.parse(@birth_at.to_s)
+
+			@chuck = Knight.create( :name => 'Chuck' )
+			@larry = Knight.create( :name => 'Larry')
+
+      Dragon.create(:name => 'George', :is_fire_breathing => false, :toes_on_claw => 3, :birth_at => @birth_at, :birth_on => @birth_on, :birth_time => @birth_time, :knight => @chuck )
+      Dragon.create(:name => 'Puff',   :is_fire_breathing => true,  :toes_on_claw => 4, :birth_at => @birth_at, :birth_on => @birth_on, :birth_time => @birth_time, :knight => @larry )
+      Dragon.create(:name => nil,      :is_fire_breathing => true,  :toes_on_claw => 5, :birth_at => nil,       :birth_on => nil,       :birth_time => nil)
+
       gold_kilo_price  = 277738.70
       @gold_tonne_price = gold_kilo_price * 10000
 
@@ -144,6 +164,21 @@ if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
             target(Country, target_type).min(:gold_reserve_value).should == BigDecimal('1217050983400.0')
           end
 
+          it 'should provide the lowest value of a DateTime property' do
+            target(Dragon, target_type).min(:birth_at).should be_kind_of(DateTime)
+            target(Dragon, target_type).min(:birth_at).to_s.should == @birth_at.to_s
+          end
+
+          it 'should provide the lowest value of a Date property' do
+            target(Dragon, target_type).min(:birth_on).should be_kind_of(Date)
+            target(Dragon, target_type).min(:birth_on).to_s.should == @birth_on.to_s
+          end
+
+          it 'should provide the lowest value of a Time property' do
+            target(Dragon, target_type).min(:birth_time).should be_kind_of(Time)
+            target(Dragon, target_type).min(:birth_time).to_s.should == @birth_time.to_s
+          end
+
           it 'should provide the lowest value when conditions provided' do
             target(Dragon, target_type).min(:toes_on_claw, :is_fire_breathing => true).should  == 4
             target(Dragon, target_type).min(:toes_on_claw, :is_fire_breathing => false).should == 3
@@ -174,6 +209,21 @@ if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
             target(Country, target_type).max(:gold_reserve_value).should == BigDecimal('22589877164500.0')
           end
 
+          it 'should provide the highest value of a DateTime property' do
+            target(Dragon, target_type).min(:birth_at).should be_kind_of(DateTime)
+            target(Dragon, target_type).min(:birth_at).to_s.should == @birth_at.to_s
+          end
+
+          it 'should provide the highest value of a Date property' do
+            target(Dragon, target_type).min(:birth_on).should be_kind_of(Date)
+            target(Dragon, target_type).min(:birth_on).to_s.should == @birth_on.to_s
+          end
+
+          it 'should provide the highest value of a Time property' do
+            target(Dragon, target_type).min(:birth_time).should be_kind_of(Time)
+            target(Dragon, target_type).min(:birth_time).to_s.should == @birth_time.to_s
+          end
+
           it 'should provide the highest value when conditions provided' do
             target(Dragon, target_type).max(:toes_on_claw, :is_fire_breathing => true).should  == 5
             target(Dragon, target_type).max(:toes_on_claw, :is_fire_breathing => false).should == 3
@@ -247,6 +297,35 @@ if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
           end
         end
       end
-    end
+
+      describe ".aggregate on a #{target_type}" do
+        describe 'with no arguments' do
+          it 'should raise an error' do
+            lambda { target(Dragon, target_type).aggregate }.should raise_error(ArgumentError)
+          end
+        end
+
+        describe 'with only aggregate fields specified' do
+          it 'should provide aggregate results' do
+            results = target(Dragon, target_type).aggregate(:all.count, :name.count, :toes_on_claw.min, :toes_on_claw.max, :toes_on_claw.avg, :toes_on_claw.sum)
+            results.should == [ 3, 2, 3, 5, 4.0, 12 ]
+          end
+        end
+
+        describe 'with aggregate fields and a property to group by' do
+          it 'should provide aggregate results' do
+            results = target(Dragon, target_type).aggregate(:all.count, :name.count, :toes_on_claw.min, :toes_on_claw.max, :toes_on_claw.avg, :toes_on_claw.sum, :is_fire_breathing)
+            results.should == [ [ 1, 1, 3, 3, 3.0, 3, false ], [ 2, 1, 4, 5, 4.5, 9, true ] ]
+          end
+        end
+      end
+    
+			describe "query path issue" do
+			  it "should not break when a query path is specified" do
+			    dragon = Dragon.first(Dragon.knight.name => 'Chuck')
+					dragon.name.should == 'George'
+			  end
+			end
+		end
   end
 end

data/spec/spec_helper.rb

@@ -8,7 +8,7 @@ def load_driver(name, default_uri)
   lib = "do_#{name}"
 
   begin
-    gem lib, '=0.9.2'
+    gem lib, '=0.9.3'
     require lib
     DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
     DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-aggregates
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors: 
 - Foy Savas
@@ -9,47 +9,64 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-25 00:00:00 -05:00
+date: 2008-07-24 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: dm-core
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.2
+        version: 0.9.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
     version: 
 description: DataMapper plugin providing support for aggregates, functions on collections and datasets
-email: foysavas@gmail.com
+email: 
+- foysavas@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.txt
 - LICENSE
 - TODO
 files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO
+- lib/dm-aggregates.rb
 - lib/dm-aggregates/adapters/data_objects_adapter.rb
+- lib/dm-aggregates/aggregate_functions.rb
 - lib/dm-aggregates/collection.rb
-- lib/dm-aggregates/functions.rb
 - lib/dm-aggregates/model.rb
 - lib/dm-aggregates/repository.rb
-- lib/dm-aggregates.rb
+- lib/dm-aggregates/support/symbol.rb
+- lib/dm-aggregates/version.rb
 - spec/integration/aggregates_spec.rb
-- spec/spec_helper.rb
 - spec/spec.opts
-- Rakefile
-- README
-- LICENSE
-- TODO
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/sam/dm-more/tree/master/dm-aggregates
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --main
+- README.txt
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -66,8 +83,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.0.1
+rubyforge_project: datamapper
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: DataMapper plugin providing support for aggregates, functions on collections and datasets

data/lib/dm-aggregates/functions.rb

@@ -1,118 +0,0 @@
-module DataMapper
-  module Aggregates
-
-    # Count results (given the conditions)
-    #
-    # ==== Example
-    #   Friend.count # returns count of all friends
-    #   Friend.count(:age.gt => 18) # returns count of all friends older then 18
-    #   Friend.count(:conditions => [ 'gender = ?', 'female' ]) # returns count of all your female friends
-    #   Friend.count(:address) # returns count of all friends with an address (NULL values are not included)
-    #   Friend.count(:address, :age.gt => 18) # returns count of all friends with an address that are older then 18
-    #   Friend.count(:address, :conditions => [ 'gender = ?', 'female' ]) # returns count of all your female friends with an address
-    #
-    # ==== Parameters
-    # property<Symbol>:: of the property you with to count (optional)
-    # opts<Hash, Symbol>:: of the conditions
-    #
-    # ==== Returns
-    # <Integer>:: with the count of the results
-    #---
-    # @public
-    def count(*args)
-      with_repository_and_property(*args) do |repository,property,query|
-        repository.count(property, query.merge(:limit => 1))
-      end
-    end
-
-    # Get the lowest value of a property
-    #
-    # ==== Example
-    #   Friend.min(:age) # returns the age of the youngest friend
-    #   Friend.min(:age, :conditions => [ 'gender = ?', 'female' ]) # returns the age of the youngest female friends
-    #
-    # ==== Parameters
-    # property<Symbol>:: the property you wish to get the lowest value of
-    # opts<Hash, Symbol>:: the conditions
-    #
-    # ==== Returns
-    # <Integer>:: return the lowest value of a property given the conditions
-    #---
-    # @public
-    def min(*args)
-      with_repository_and_property(*args) do |repository,property,query|
-        check_property_is_number(property)
-        repository.min(property, query.merge(:limit => 1))
-      end
-    end
-
-    # Get the highest value of a property
-    #
-    # ==== Example
-    #   Friend.max(:age) # returns the age of the oldest friend
-    #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ]) # returns the age of the oldest female friends
-    #
-    # ==== Parameters
-    # property<Symbol>:: the property you wish to get the highest value of
-    # opts<Hash, Symbol>:: the conditions
-    #
-    # ==== Returns
-    # <Integer>:: return the highest value of a property given the conditions
-    #---
-    # @public
-    def max(*args)
-      with_repository_and_property(*args) do |repository,property,query|
-        check_property_is_number(property)
-        repository.max(property, query.merge(:limit => 1))
-      end
-    end
-
-    # Get the average value of a property
-    #
-    # ==== Example
-    #   Friend.avg(:age) # returns the average age of friends
-    #   Friend.avg(:age, :conditions => [ 'gender = ?', 'female' ]) # returns the average age of the female friends
-    #
-    # ==== Parameters
-    # property<Symbol>:: the property you wish to get the average value of
-    # opts<Hash, Symbol>:: the conditions
-    #
-    # ==== Returns
-    # <Integer>:: return the average value of a property given the conditions
-    #---
-    # @public
-    def avg(*args)
-      with_repository_and_property(*args) do |repository,property,query|
-        check_property_is_number(property)
-        repository.avg(property, query.merge(:limit => 1))
-      end
-    end
-
-    # Get the total value of a property
-    #
-    # ==== Example
-    #   Friend.sum(:age) # returns total age of all friends
-    #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ]) # returns the total age of all female friends
-    #
-    # ==== Parameters
-    # property<Symbol>:: the property you wish to get the total value of
-    # opts<Hash, Symbol>:: the conditions
-    #
-    # ==== Returns
-    # <Integer>:: return the total value of a property given the conditions
-    #---
-    # @public
-    def sum(*args)
-      with_repository_and_property(*args) do |repository,property,query|
-        check_property_is_number(property)
-        repository.sum(property, query.merge(:limit => 1))
-      end
-    end
-
-    private
-
-    def check_property_is_number(property)
-      raise ArgumentError, "+property+ should be an Integer, Float or BigDecimal, but was #{property.nil? ? 'nil' : property.type.class}" unless property && [ Integer, Float, BigDecimal ].include?(property.type)
-    end
-  end
-end