ardm-aggregates 1.2.0

data/lib/dm-aggregates/model.rb

@@ -0,0 +1,13 @@
+module DataMapper
+  module Aggregates
+    module Model
+      include Functions
+
+      private
+
+      def property_by_name(property_name)
+        properties(repository.name)[property_name]
+      end
+    end
+  end
+end

data/lib/dm-aggregates/operators.rb

@@ -0,0 +1,25 @@
+module DataMapper
+  module Aggregates
+    module Operators
+      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 # module Operators
+  end # module Aggregates
+end # module DataMapper

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_method :assert_valid_fields_without_operator, :assert_valid_fields
+          alias_method :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 || @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

@@ -0,0 +1,13 @@
+module DataMapper
+  module Aggregates
+    module Repository
+      def aggregate(query)
+        unless query.valid?
+          []
+        else
+          adapter.aggregate(query)
+        end
+      end
+    end
+  end
+end

data/lib/dm-aggregates/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Aggregates
+    VERSION = '1.2.0'
+  end
+end

data/spec/isolated/require_after_setup_spec.rb

@@ -0,0 +1,21 @@
+require 'spec'
+require 'isolated/require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-aggregates upfront
+
+if %w[ postgres mysql sqlite oracle sqlserver ].include?(ENV['ADAPTER'])
+
+  describe "require 'dm-aggregates after calling DataMapper.setup" do
+
+    before(:all) do
+      @adapter = DataMapper::Spec.adapter
+      require 'dm-aggregates'
+    end
+
+    it_should_behave_like "require 'dm-aggregates'"
+
+  end
+
+end

data/spec/isolated/require_before_setup_spec.rb

@@ -0,0 +1,21 @@
+require 'spec'
+require 'isolated/require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-aggregates upfront
+
+if %w[ postgres mysql sqlite oracle sqlserver ].include?(ENV['ADAPTER'])
+
+  describe "require 'dm-aggregates' before calling DataMapper.setup" do
+
+    before(:all) do
+      require 'dm-aggregates'
+      @adapter = DataMapper::Spec.adapter
+    end
+
+    it_should_behave_like "require 'dm-aggregates'"
+
+  end
+
+end

data/spec/isolated/require_spec.rb

@@ -0,0 +1,13 @@
+shared_examples_for "require 'dm-aggregates'" do
+
+  %w[ Repository Model Collection Query ].each do |name|
+    it "should include the aggregate api in DataMapper::#{name}" do
+      (DataMapper.const_get(name) < DataMapper::Aggregates.const_get(name)).should be(true)
+    end
+  end
+
+  it "should include the aggregate api into the adapter" do
+    @adapter.respond_to?(:aggregate).should be(true)
+  end
+
+end

data/spec/public/collection_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe DataMapper::Collection do
+  supported_by :sqlite, :mysql, :postgres do
+    let(:dragons)   { Dragon.all  }
+    let(:countries) { Country.all }
+
+    it_should_behave_like 'It Has Setup Resources'
+    it_should_behave_like 'An Aggregatable Class'
+
+    describe 'ignore invalid query' do
+      let(:dragons) { Dragon.all.all(:id => []) }
+
+      [ :size, :count ].each do |method|
+        describe "##{method}" do
+          subject { dragons.send(method) }
+
+          it { should == 0 }
+        end
+      end
+
+      describe '#min' do
+        subject { dragons.min(:id) }
+
+        it { should be_nil }
+      end
+
+      describe '#max' do
+        subject { dragons.max(:id) }
+
+        it { should be_nil }
+      end
+
+      describe '#avg' do
+        subject { dragons.avg(:id) }
+
+        it { should be_nil }
+      end
+
+      describe '#sum' do
+        subject { dragons.sum(:id) }
+
+        it { should be_nil }
+      end
+
+      describe '#aggregate' do
+        subject { dragons.aggregate(:id) }
+
+        it { should == [] }
+      end
+    end
+
+    context 'with collections created with Set operations' do
+      let(:collection) { dragons.all(:name => 'George') | dragons.all(:name => 'Puff') }
+
+      describe '#size' do
+        subject { collection.size }
+
+        it { should == 2 }
+      end
+
+      describe '#count' do
+        subject { collection.count }
+
+        it { should == 2 }
+      end
+
+      describe '#min' do
+        subject { collection.min(:toes_on_claw) }
+
+        it { should == 3 }
+      end
+
+      describe '#max' do
+        subject { collection.max(:toes_on_claw) }
+
+        it { should == 4 }
+      end
+
+      describe '#avg' do
+        subject { collection.avg(:toes_on_claw) }
+
+        it { should == 3.5 }
+      end
+
+      describe '#sum' do
+        subject { collection.sum(:toes_on_claw) }
+
+        it { should == 7 }
+      end
+
+      describe '#aggregate' do
+        subject { collection.aggregate(:all.count, :name.count, :toes_on_claw.min, :toes_on_claw.max, :toes_on_claw.avg, :toes_on_claw.sum)}
+
+        it { should == [ 2, 2, 3, 4, 3.5, 7 ] }
+      end
+    end
+
+    context 'with a collection limited to 1 result' do
+      let(:dragons) { Dragon.all(:limit => 1) }
+
+      describe '#size' do
+        subject { dragons.size }
+
+        it { should == 1 }
+      end
+
+      describe '#count' do
+        subject { dragons.count }
+
+        it { pending('TODO: make count apply to the limited collection. Currently limit applies after the count') { should == 1 } }
+      end
+    end
+
+    context 'with the order reversed by the grouping field' do
+      subject { dragons.aggregate(:birth_at, :all.count) }
+
+      let(:dragons) { Dragon.all(:order => [ :birth_at.desc ]) }
+
+      it 'displays the results in reverse order' do
+        should == Dragon.aggregate(:birth_at, :all.count).reverse
+      end
+    end
+  end
+end

data/spec/public/model_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe DataMapper::Model do
+  supported_by :sqlite, :mysql, :postgres do
+    let(:dragons)   { Dragon  }
+    let(:countries) { Country }
+
+    it_should_behave_like 'It Has Setup Resources'
+    it_should_behave_like 'An Aggregatable Class'
+  end
+end

data/spec/public/shared/aggregate_shared_spec.rb

@@ -0,0 +1,322 @@
+shared_examples_for 'It Has Setup Resources' do
+  before :all do
+    @mysql    = defined?(DataMapper::Adapters::MysqlAdapter)    && @adapter.kind_of?(DataMapper::Adapters::MysqlAdapter)
+    @postgres = defined?(DataMapper::Adapters::PostgresAdapter) && @adapter.kind_of?(DataMapper::Adapters::PostgresAdapter)
+
+    @skip = (@mysql || @postgres) && ENV['TZ'].to_s.downcase != 'utc'
+  end
+
+  before :all do
+    DataMapper.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
+
+    Country.create(
+      :name                => 'China',
+      :population          => 1330044605,
+      :birth_rate          => 13.71,
+      :gold_reserve_tonnes => 600.0,
+      :gold_reserve_value  => 600.0 * @gold_tonne_price  # => 32150000
+    )
+
+    Country.create(
+      :name                => 'United States',
+      :population          => 303824646,
+      :birth_rate          => 14.18,
+      :gold_reserve_tonnes => 8133.5,
+      :gold_reserve_value  => 8133.5 * @gold_tonne_price
+    )
+
+    Country.create(
+      :name                => 'Brazil',
+      :population          => 191908598,
+      :birth_rate          => 16.04,
+      :gold_reserve_tonnes => nil  # example of no stats available
+    )
+
+    Country.create(
+      :name                => 'Russia',
+      :population          => 140702094,
+      :birth_rate          => 11.03,
+      :gold_reserve_tonnes => 438.2,
+      :gold_reserve_value  => 438.2 * @gold_tonne_price
+    )
+
+    Country.create(
+      :name                => 'Japan',
+      :population          => 127288419,
+      :birth_rate          => 7.87,
+      :gold_reserve_tonnes => 765.2,
+      :gold_reserve_value  => 765.2 * @gold_tonne_price
+    )
+
+    Country.create(
+      :name                => 'Mexico',
+      :population          => 109955400,
+      :birth_rate          => 20.04,
+      :gold_reserve_tonnes => nil  # example of no stats available
+    )
+
+    Country.create(
+      :name                => 'Germany',
+      :population          => 82369548,
+      :birth_rate          => 8.18,
+      :gold_reserve_tonnes => 3417.4,
+      :gold_reserve_value  => 3417.4 * @gold_tonne_price
+    )
+
+    @approx_by = 0.0001
+  end
+end
+
+shared_examples_for 'An Aggregatable Class' do
+  describe '#size' do
+    it_should_behave_like 'count with no arguments'
+  end
+
+  describe '#count' do
+    it_should_behave_like 'count with no arguments'
+
+    context 'with a property name' do
+      it 'counts the results' do
+        dragons.count(:name).should == 2
+      end
+
+      it 'counts the results with conditions having operators' do
+        dragons.count(:name, :toes_on_claw.gt => 3).should == 1
+      end
+
+      it 'counts the results with raw conditions' do
+        statement = 'is_fire_breathing = ?'
+        dragons.count(:name, :conditions => [ statement, false ]).should == 1
+        dragons.count(:name, :conditions => [ statement, true  ]).should == 1
+      end
+    end
+  end
+
+  describe '#min' do
+    context 'with no arguments' do
+      it 'raises an error' do
+        expect { dragons.min }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with a property name' do
+      it 'provides the lowest value of an Integer property' do
+        dragons.min(:toes_on_claw).should == 3
+        countries.min(:population).should == 82369548
+      end
+
+      it 'provides the lowest value of a Float property' do
+        countries.min(:birth_rate).should be_kind_of(Float)
+        countries.min(:birth_rate).should >= 7.87 - @approx_by  # approx match
+        countries.min(:birth_rate).should <= 7.87 + @approx_by  # approx match
+      end
+
+      it 'provides the lowest value of a BigDecimal property' do
+        countries.min(:gold_reserve_value).should be_kind_of(BigDecimal)
+        countries.min(:gold_reserve_value).should == BigDecimal('1217050983400.0')
+      end
+
+      it 'provides the lowest value of a DateTime property' do
+        pending_if 'TODO: returns incorrect value until DO handles TZs properly', @skip do
+          dragons.min(:birth_at).should be_kind_of(DateTime)
+          dragons.min(:birth_at).to_s.should == @birth_at.to_s
+        end
+      end
+
+      it 'provides the lowest value of a Date property' do
+        dragons.min(:birth_on).should be_kind_of(Date)
+        dragons.min(:birth_on).should == @birth_on
+      end
+
+      it 'provides the lowest value of a Time property' do
+        dragons.min(:birth_time).should be_kind_of(Time)
+        dragons.min(:birth_time).to_s.should == @birth_time.to_s
+      end
+
+      it 'provides the lowest value when conditions provided' do
+        dragons.min(:toes_on_claw, :is_fire_breathing => true).should  == 4
+        dragons.min(:toes_on_claw, :is_fire_breathing => false).should == 3
+      end
+    end
+  end
+
+  describe '#max' do
+    context 'with no arguments' do
+      it 'raises an error' do
+        expect { dragons.max }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with a property name' do
+      it 'provides the highest value of an Integer property' do
+        dragons.max(:toes_on_claw).should == 5
+        countries.max(:population).should == 1330044605
+      end
+
+      it 'provides the highest value of a Float property' do
+        countries.max(:birth_rate).should be_kind_of(Float)
+        countries.max(:birth_rate).should >= 20.04 - @approx_by  # approx match
+        countries.max(:birth_rate).should <= 20.04 + @approx_by  # approx match
+      end
+
+      it 'provides the highest value of a BigDecimal property' do
+        countries.max(:gold_reserve_value).should == BigDecimal('22589877164500.0')
+      end
+
+      it 'provides the highest value of a DateTime property' do
+        pending_if 'TODO: returns incorrect value until DO handles TZs properly', @skip do
+          dragons.min(:birth_at).should be_kind_of(DateTime)
+          dragons.min(:birth_at).to_s.should == @birth_at.to_s
+        end
+      end
+
+      it 'provides the highest value of a Date property' do
+        dragons.min(:birth_on).should be_kind_of(Date)
+        dragons.min(:birth_on).should == @birth_on
+      end
+
+      it 'provides the highest value of a Time property' do
+        dragons.min(:birth_time).should be_kind_of(Time)
+        dragons.min(:birth_time).to_s.should == @birth_time.to_s
+      end
+
+      it 'provides the highest value when conditions provided' do
+        dragons.max(:toes_on_claw, :is_fire_breathing => true).should  == 5
+        dragons.max(:toes_on_claw, :is_fire_breathing => false).should == 3
+      end
+    end
+  end
+
+  describe '#avg' do
+    context 'with no arguments' do
+      it 'raises an error' do
+        expect { dragons.avg }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with a property name' do
+      it 'provides the average value of an Integer property' do
+        dragons.avg(:toes_on_claw).should be_kind_of(Float)
+        dragons.avg(:toes_on_claw).should == 4.0
+      end
+
+      it 'provides the average value of a Float property' do
+        mean_birth_rate = (13.71 + 14.18 + 16.04 + 11.03 + 7.87 + 20.04 + 8.18) / 7
+        countries.avg(:birth_rate).should be_kind_of(Float)
+        countries.avg(:birth_rate).should >= mean_birth_rate - @approx_by  # approx match
+        countries.avg(:birth_rate).should <= mean_birth_rate + @approx_by  # approx match
+      end
+
+      it 'provides the average value of a BigDecimal property' do
+        mean_gold_reserve_value = ((600.0 + 8133.50 + 438.20 + 765.20 + 3417.40) * @gold_tonne_price) / 5
+        countries.avg(:gold_reserve_value).should be_kind_of(BigDecimal)
+        countries.avg(:gold_reserve_value).should == BigDecimal(mean_gold_reserve_value.to_s)
+      end
+
+      it 'provides the average value when conditions provided' do
+        dragons.avg(:toes_on_claw, :is_fire_breathing => true).should  == 4.5
+        dragons.avg(:toes_on_claw, :is_fire_breathing => false).should == 3
+      end
+    end
+  end
+
+  describe '#sum' do
+    context 'with no arguments' do
+      it 'raises an error' do
+        expect { dragons.sum }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with a property name' do
+      it 'provides the sum of values for an Integer property' do
+        dragons.sum(:toes_on_claw).should == 12
+
+        total_population = 1330044605 + 303824646 + 191908598 + 140702094 +
+                           127288419 + 109955400 + 82369548
+        countries.sum(:population).should == total_population
+      end
+
+      it 'provides the sum of values for a Float property' do
+        total_tonnes = 600.0 + 8133.5 + 438.2 + 765.2 + 3417.4
+        countries.sum(:gold_reserve_tonnes).should be_kind_of(Float)
+        countries.sum(:gold_reserve_tonnes).should >= total_tonnes - @approx_by  # approx match
+        countries.sum(:gold_reserve_tonnes).should <= total_tonnes + @approx_by  # approx match
+      end
+
+      it 'provides the sum of values for a BigDecimal property' do
+        countries.sum(:gold_reserve_value).should == BigDecimal('37090059214100.0')
+      end
+
+      it 'provides the average value when conditions provided' do
+        dragons.sum(:toes_on_claw, :is_fire_breathing => true).should  == 9
+        dragons.sum(:toes_on_claw, :is_fire_breathing => false).should == 3
+      end
+    end
+  end
+
+  describe '#aggregate' do
+    context 'with no arguments' do
+      it 'raises an error' do
+        expect { dragons.aggregate }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with only aggregate fields specified' do
+      it 'provides aggregate results' do
+        results = dragons.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
+
+    context 'with aggregate fields and a property to group by' do
+      it 'provides aggregate results' do
+        results = dragons.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 'does not break when a query path is specified' do
+      dragon = dragons.first(Dragon.knight.name => 'Chuck')
+      dragon.name.should == 'George'
+    end
+  end
+end
+
+shared_examples_for 'count with no arguments' do
+  it 'counts the results' do
+    dragons.count.should  == 3
+
+    countries.count.should == 7
+  end
+
+  it 'counts the results with conditions having operators' do
+    dragons.count(:toes_on_claw.gt => 3).should == 2
+
+    countries.count(:birth_rate.lt => 12).should == 3
+    countries.count(:population.gt => 1000000000).should == 1
+    countries.count(:population.gt => 2000000000).should == 0
+    countries.count(:population.lt => 10).should == 0
+  end
+
+  it 'counts the results with raw conditions' do
+    dragon_statement = 'is_fire_breathing = ?'
+    dragons.count(:conditions => [ dragon_statement, false ]).should == 1
+    dragons.count(:conditions => [ dragon_statement, true  ]).should == 2
+  end
+end