dm-aggregates 0.9.11 → 0.10.0

data/{History.txt → History.rdoc}

@@ -1,3 +1,7 @@
+=== 0.10.0 / 2009-10-15
+
+* Updated to work with dm-core 0.10.0
+
 === 0.9.11 / 2009-03-29
 
 * No changes this version

data/Manifest.txt

@@ -1,16 +1,17 @@
-History.txt
+History.rdoc
 LICENSE
 Manifest.txt
-README.txt
+README.rdoc
 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/core_ext/symbol.rb
 lib/dm-aggregates/model.rb
+lib/dm-aggregates/query.rb
 lib/dm-aggregates/repository.rb
-lib/dm-aggregates/support/symbol.rb
 lib/dm-aggregates/version.rb
 spec/public/collection_spec.rb
 spec/public/model_spec.rb

data/Rakefile

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'rubygems'
 
 ROOT    = Pathname(__FILE__).dirname.expand_path
 JRUBY   = RUBY_PLATFORM =~ /java/
@@ -14,10 +13,10 @@ GEM_NAME = 'dm-aggregates'
 GEM_VERSION = DataMapper::Aggregates::VERSION
 GEM_DEPENDENCIES = [['dm-core', GEM_VERSION]]
 GEM_CLEAN = %w[ log pkg coverage ]
-GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO History.txt ] }
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.rdoc LICENSE TODO History.rdoc ] }
 
 PROJECT_NAME = 'datamapper'
-PROJECT_URL  = "http://github.com/sam/dm-more/tree/master/#{GEM_NAME}"
+PROJECT_URL  = "http://github.com/datamapper/dm-more/tree/master/#{GEM_NAME}"
 PROJECT_DESCRIPTION = PROJECT_SUMMARY = 'DataMapper plugin providing support for aggregates, functions on collections and datasets'
 
 [ ROOT, ROOT.parent ].each do |dir|

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

@@ -1,24 +1,44 @@
 module DataMapper
-  module Adapters
-    class DataObjectsAdapter
+  module Aggregates
+    module DataObjectsAdapter
+      def self.included(base)
+        base.send(:include, SQL)
+      end
+
       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)
+        fields = query.fields
+        types  = fields.map { |p| p.respond_to?(:operator) ? String : p.primitive }
+
+        field_size = fields.size
+
+        records = []
+
+        with_connection do |connection|
+          statement, bind_values = select_statement(query)
+
+          command = connection.create_command(statement)
+          command.set_types(types)
+
+          reader = command.execute_reader(*bind_values)
+
+          begin
+            while(reader.next!)
+              row = 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
-            end
 
-            results << (query.fields.size > 1 ? row : row[0])
+              records << (field_size > 1 ? row : row[0])
+            end
+          ensure
+            reader.close
           end
-
-          results
         end
+
+        records
       end
 
       private
@@ -44,26 +64,32 @@ module DataMapper
       end
 
       module SQL
-        private
-
-        alias original_property_to_column_name property_to_column_name
+        def self.included(base)
+          base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # FIXME: figure out a cleaner approach than AMC
+            alias property_to_column_name_without_operator property_to_column_name
+            alias property_to_column_name property_to_column_name_with_operator
+          RUBY
+        end
 
-        def property_to_column_name(repository, property, qualify)
+        def property_to_column_name_with_operator(property, qualify)
           case property
-            when Query::Operator
-              aggregate_field_statement(repository, property.operator, property.target, qualify)
-            when Property, Query::Path
-              original_property_to_column_name(repository, property, qualify)
+            when DataMapper::Query::Operator
+              aggregate_field_statement(property.operator, property.target, qualify)
+
+            when Property, DataMapper::Query::Path
+              property_to_column_name_without_operator(property, qualify)
+
             else
               raise ArgumentError, "+property+ must be a DataMapper::Query::Operator, a DataMapper::Property or a Query::Path, but was a #{property.class} (#{property.inspect})"
           end
         end
 
-        def aggregate_field_statement(repository, aggregate_function, property, qualify)
+        def aggregate_field_statement(aggregate_function, property, qualify)
           column_name = if aggregate_function == :count && property == :all
             '*'
           else
-            property_to_column_name(repository, property, qualify)
+            property_to_column_name(property, qualify)
           end
 
           function_name = case aggregate_function
@@ -78,8 +104,22 @@ module DataMapper
           "#{function_name}(#{column_name})"
         end
       end # module SQL
-
-      include SQL
     end # class DataObjectsAdapter
+  end # module Aggregates
+
+  module Adapters
+    extendable do
+
+      # TODO: document
+      # @api private
+      def const_added(const_name)
+        if DataMapper::Aggregates.const_defined?(const_name)
+          adapter = const_get(const_name)
+          adapter.send(:include, DataMapper::Aggregates.const_get(const_name))
+        end
+
+        super
+      end
+    end
   end # module Adapters
 end # module DataMapper

data/lib/dm-aggregates/aggregate_functions.rb

@@ -1,200 +1,203 @@
 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
+  module Aggregates
+    module Functions
+      # 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
 
-      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 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 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 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
+      # 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) }
-        # explicitly specify the fields to circumvent a bug in Query#update
-        query.repository.aggregate(query.update(:fields => query.fields, :unique => true))
-      else
-        query.repository.aggregate(query).first  # only return one row
+      # 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
-    end
 
-    private
+      private
 
-    def assert_property_type(name, *types)
-      if name.nil?
-        raise ArgumentError, 'property name must not be nil'
-      end
+      def assert_property_type(name, *types)
+        if name.nil?
+          raise ArgumentError, 'property name must not be nil'
+        end
 
-      type = property_by_name(name).type
+        type = property_by_name(name).type
 
-      unless types.include?(type)
-        raise ArgumentError, "#{name} must be #{types * ' or '}, but was #{type}"
+        unless types.include?(type)
+          raise ArgumentError, "#{name} must be #{types * ' or '}, but was #{type}"
+        end
       end
-    end
 
-    def normalize_field(field)
-      assert_kind_of 'field', field, Query::Operator, Symbol, Property
+      def normalize_field(field)
+        assert_kind_of 'field', field, DataMapper::Query::Operator, Symbol, Property
+
+        case field
+          when DataMapper::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)
 
-      case field
-        when Query::Operator
-          if field.target == :all
+          when Property
             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,15 +1,17 @@
 module DataMapper
-  class Collection
-    include AggregateFunctions
+  module Aggregates
+    module Collection
+      include Functions
 
-#    def size
-#      loaded? ? super : count
-#    end
+#      def size
+#        loaded? ? super : count
+#      end
 
-    private
+      private
 
-    def property_by_name(property_name)
-      properties[property_name]
+      def property_by_name(property_name)
+        properties[property_name]
+      end
     end
   end
 end

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

@@ -0,0 +1,9 @@
+class Symbol
+  [ :count, :min, :max, :avg, :sum ].each do |sym|
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{sym}
+        DataMapper::Query::Operator.new(self, #{sym.inspect})
+      end
+    RUBY
+  end
+end # class Symbol

data/lib/dm-aggregates/model.rb

@@ -1,15 +1,17 @@
 module DataMapper
-  module Model
-    include AggregateFunctions
+  module Aggregates
+    module Model
+      include Functions
 
-#    def size
-#      count
-#    end
+#      def size
+#        count
+#      end
 
-    private
+      private
 
-    def property_by_name(property_name)
-      properties(repository.name)[property_name]
+      def property_by_name(property_name)
+        properties(repository.name)[property_name]
+      end
     end
   end
 end

data/lib/dm-aggregates/query.rb

@@ -0,0 +1,27 @@
+module DataMapper
+  module Aggregates
+    module Query
+      def self.included(base)
+        base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # FIXME: figure out a cleaner approach than AMC
+          alias assert_valid_fields_without_operator assert_valid_fields
+          alias assert_valid_fields assert_valid_fields_with_operator
+        RUBY
+      end
+
+      def assert_valid_fields_with_operator(fields, unique)
+        operators, fields = fields.partition { |f| f.kind_of?(DataMapper::Query::Operator) }
+
+        operators.each do |operator|
+          target = operator.target
+
+          unless target == :all || target.kind_of?(Property) && target.model == model && @properties.include?(target)
+            raise ArgumentError, "+options[:fields]+ entry #{target.inspect} does not map to a property in #{model}"
+          end
+        end
+
+        assert_valid_fields_without_operator(fields, unique)
+      end
+    end
+  end
+end

data/lib/dm-aggregates/repository.rb

@@ -1,7 +1,9 @@
 module DataMapper
-  class Repository
-    def aggregate(query)
-      adapter.aggregate(query)
+  module Aggregates
+    module Repository
+      def aggregate(query)
+        adapter.aggregate(query)
+      end
     end
   end
 end

data/lib/dm-aggregates/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module Aggregates
-    VERSION = '0.9.11'
+    VERSION = '0.10.0'.freeze
   end
 end

data/lib/dm-aggregates.rb

@@ -1,15 +1,26 @@
-require 'rubygems'
+require 'dm-aggregates/adapters/data_objects_adapter'
+require 'dm-aggregates/aggregate_functions'
+require 'dm-aggregates/collection'
+require 'dm-aggregates/core_ext/symbol'
+require 'dm-aggregates/model'
+require 'dm-aggregates/query'
+require 'dm-aggregates/repository'
+require 'dm-aggregates/version'
 
-dir = Pathname(__FILE__).dirname.expand_path + 'dm-aggregates'
+module DataMapper
+  class Repository
+    include Aggregates::Repository
+  end
 
-require dir + 'version'
-gem 'dm-core', '0.9.11'
-require 'dm-core'
+  module Model
+    include Aggregates::Model
+  end
 
+  class Collection
+    include Aggregates::Collection
+  end
 
-require dir + 'aggregate_functions'
-require dir + 'model'
-require dir + 'repository'
-require dir + 'collection'
-require dir + 'adapters' + 'data_objects_adapter'
-require dir + 'support' + 'symbol'
+  class Query
+    include Aggregates::Query
+  end
+end

data/spec/public/collection_spec.rb

@@ -1,5 +1,4 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+require 'spec_helper'
 
 if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
   describe DataMapper::Collection do

data/spec/public/model_spec.rb

@@ -1,5 +1,4 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+require 'spec_helper'
 
 if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
   describe DataMapper::Model do

data/spec/public/shared/aggregate_shared_spec.rb

@@ -19,7 +19,7 @@ shared_examples_for 'It Has Setup Resources' do
       property :birth_on,          Date
       property :birth_time,        Time
 
-      belongs_to :knight
+      belongs_to :knight, :nullable => true
     end
 
     # A more complex example, with BigDecimal and Float properties

data/spec/spec.opts

@@ -1 +1,2 @@
 --colour
+--loadby random

data/spec/spec_helper.rb

@@ -1,9 +1,16 @@
-require 'pathname'
 require 'rubygems'
 
-SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
-require SPEC_ROOT.parent + 'lib/dm-aggregates'
-Pathname.glob((SPEC_ROOT + '{lib,*/shared}/**/*.rb').to_s).each { |f| require f }
+# use local dm-core if running from a typical dev checkout.
+lib = File.join('..', '..', 'dm-core', 'lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib)
+require 'dm-core'
+
+# Support running specs with 'rake spec' and 'spec'
+$LOAD_PATH.unshift('lib') unless $LOAD_PATH.include?('lib')
+
+require 'dm-aggregates'
+
+require 'public/shared/aggregate_shared_spec'
 
 def load_driver(name, default_uri)
   return false if ENV['ADAPTER'] != name.to_s

data/tasks/install.rb

@@ -4,7 +4,7 @@ end
 
 desc "Install #{GEM_NAME} #{GEM_VERSION}"
 task :install => [ :package ] do
-  sudo_gem "install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
+  sudo_gem "install pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
 end
 
 desc "Uninstall #{GEM_NAME} #{GEM_VERSION}"

data/tasks/spec.rb

@@ -1,6 +1,4 @@
 begin
-  gem 'rspec', '~>1.2'
-  require 'spec'
   require 'spec/rake/spectask'
 
   task :default => [ :spec ]
@@ -8,16 +6,18 @@ begin
   desc 'Run specifications'
   Spec::Rake::SpecTask.new(:spec) do |t|
     t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
-    t.spec_files = Pathname.glob((ROOT + 'spec/**/*_spec.rb').to_s).map { |f| f.to_s }
+    t.libs      << 'lib' << 'spec' # needed for CI rake spec task, duplicated in spec_helper
 
     begin
-      gem 'rcov', '~>0.8'
+      require 'rcov'
       t.rcov = JRUBY ? false : (ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true)
       t.rcov_opts << '--exclude' << 'spec'
       t.rcov_opts << '--text-summary'
       t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
     rescue LoadError
       # rcov not installed
+    rescue SyntaxError
+      # rcov syntax invalid
     end
   end
 rescue LoadError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-aggregates
 version: !ruby/object:Gem::Version 
-  version: 0.9.11
+  version: 0.10.0
 platform: ruby
 authors: 
 - Foy Savas
@@ -9,19 +9,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-29 00:00:00 -07:00
+date: 2009-09-16 00:00:00 -07: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.11
-    version: 
+dependencies: []
+
 description: DataMapper plugin providing support for aggregates, functions on collections and datasets
 email: 
 - foysavas [a] gmail [d] com
@@ -30,24 +21,25 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.txt
+- README.rdoc
 - LICENSE
 - TODO
-- History.txt
+- History.rdoc
 files: 
-- History.txt
+- History.rdoc
 - LICENSE
 - Manifest.txt
-- README.txt
+- README.rdoc
 - 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/core_ext/symbol.rb
 - lib/dm-aggregates/model.rb
+- lib/dm-aggregates/query.rb
 - lib/dm-aggregates/repository.rb
-- lib/dm-aggregates/support/symbol.rb
 - lib/dm-aggregates/version.rb
 - spec/public/collection_spec.rb
 - spec/public/model_spec.rb
@@ -57,11 +49,13 @@ files:
 - tasks/install.rb
 - tasks/spec.rb
 has_rdoc: true
-homepage: http://github.com/sam/dm-more/tree/master/dm-aggregates
+homepage: http://github.com/datamapper/dm-more/tree/master/dm-aggregates
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -79,9 +73,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: datamapper
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: DataMapper plugin providing support for aggregates, functions on collections and datasets
 test_files: []
 

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

@@ -1,21 +0,0 @@
-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