compendium 1.1.3.4 → 1.2.0

data/lib/compendium/report.rb

@@ -15,7 +15,7 @@ module Compendium
 
     class << self
       delegate :validate, to: :params_class
-      
+
       def inherited(report)
         Compendium.reports << report
 
@@ -45,7 +45,7 @@ module Compendium
         prefix = name.to_s.gsub(/[?!]\z/, '')
         report_class = "#{prefix}_report".classify.constantize rescue nil
 
-        return self == report_class if name.to_s.end_with?('?') and Compendium.reports.include?(report_class)
+        return self == report_class if name.to_s.end_with?('?') && Compendium.reports.include?(report_class)
 
         super
       end
@@ -54,7 +54,7 @@ module Compendium
         prefix = name.to_s.gsub(/[?!]\z/, '')
         report_class = "#{prefix}_report".classify.constantize rescue nil
 
-        return true if name.to_s.end_with?('?') and Compendium.reports.include?(report_class)
+        return true if name.to_s.end_with?('?') && Compendium.reports.include?(report_class)
         super
       end
 
@@ -82,10 +82,10 @@ module Compendium
       self.context = context
       self.results = {}
 
-      only = [options.delete(:only)].flatten.compact
-      except = [options.delete(:except)].flatten.compact
+      only = Array.wrap(options.delete(:only)).compact
+      except = Array.wrap(options.delete(:except)).compact
 
-      raise ArgumentError, 'cannot specify only and except options at the same time' if !only.empty? and !except.empty?
+      raise ArgumentError, 'cannot specify only and except options at the same time' if !only.empty? && !except.empty?
       (only + except).flatten.each { |q| raise ArgumentError, "invalid query #{q}" unless queries.include?(q) }
 
       queries_to_run = if !only.empty?
@@ -105,6 +105,10 @@ module Compendium
       Collection[Metric, queries.map{ |q| q.metrics.to_a }.flatten]
     end
 
+    def exports?(type)
+      return exporters[type.to_sym]
+    end
+
   private
 
     attr_accessor :context
@@ -113,17 +117,17 @@ module Compendium
       prefix = name.to_s.sub(/(?:_results|\?)\Z/, '').to_sym
 
       return queries[name] if queries.keys.include?(name)
-      return results[prefix] if name.to_s.end_with? '_results' and queries.keys.include?(prefix)
+      return results[prefix] if name.to_s.end_with?('_results') && queries.keys.include?(prefix)
       return params[name] if options.keys.include?(name)
-      return !!params[prefix] if name.to_s.end_with? '?' and options.keys.include?(prefix)
+      return !!params[prefix] if name.to_s.end_with?('?') && options.keys.include?(prefix)
       super
     end
 
     def respond_to_missing?(name, include_private = false)
       prefix = name.to_s.sub(/_results\Z/, '').to_sym
       return true if queries.keys.include?(name)
-      return true if name.to_s.end_with? '_results' and queries.keys.include?(prefix)
+      return true if name.to_s.end_with?('_results') && queries.keys.include?(prefix)
       super
     end
   end
-end
+end

data/lib/compendium/sum_query.rb

@@ -1,3 +1,4 @@
+require 'compendium/errors'
 require 'compendium/query'
 
 module Compendium
@@ -5,7 +6,6 @@ module Compendium
   # Often useful in conjunction with a grouped query and counter cache
   # (alternately, see CountQuery)
   class SumQuery < Query
-    InvalidCommand = Class.new(StandardError)
 
     attr_accessor :column
 
@@ -13,6 +13,8 @@ module Compendium
       @report = args.shift if arg_is_report?(args.first)
       @column = args.slice!(1)
       super(*args)
+
+      @options.reverse_merge!(order: "SUM(#{@column})", reverse: true)
     end
 
   private

data/lib/compendium/through_query.rb

@@ -17,7 +17,7 @@ module Compendium
 
       # If none of the through queries have any results, we shouldn't try to execute the query, because it
       # depends on the results of its parents.
-      return @results = ResultSet.new([]) if results.compact.empty?
+      return @results = ResultSet.new([]) if any_results?(results)
 
       # If the proc collects two arguments, pass results and params, otherwise just results
       args = !proc || proc.arity == 1 ? [results] : [results, params]
@@ -32,7 +32,7 @@ module Compendium
     def collect_through_query_results(params, context)
       results = {}
 
-      queries = [through].flatten.map(&method(:get_associated_query))
+      queries = Array.wrap(through).map(&method(:get_associated_query))
 
       queries.each do |q|
         q.run(params, context) unless q.ran?
@@ -42,5 +42,10 @@ module Compendium
       results = results[queries.first.name] if queries.size == 1
       results
     end
+
+    def any_results?(results)
+      results = results.values if results.is_a? Hash
+      results.all?(&:blank?)
+    end
   end
 end

data/lib/compendium/version.rb

@@ -1,3 +1,3 @@
 module Compendium
-  VERSION = "1.1.3.4"
+  VERSION = '1.2.0'
 end

data/spec/count_query_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'compendium'
 require 'compendium/count_query'
 
 class SingleCounter
@@ -8,14 +9,37 @@ class SingleCounter
 end
 
 class MultipleCounter
+  def order(*)
+    @order = true
+    self
+  end
+
+  def reverse_order
+    @reverse = true
+    self
+  end
+
   def count
-    { 1 => 123, 2 => 456, 3 => 789 }
+    results = { 1 => 340, 2 => 204, 3 => 983 }
+
+    if @order
+      results = results.sort_by{ |r| r[1] }
+      results.reverse! if @reverse
+      results = Hash[results]
+    end
+
+    results
   end
 end
 
 describe Compendium::CountQuery do
   subject { described_class.new(:counted_query, { count: true }, -> * { @counter }) }
 
+  it 'should have a default order' do
+    subject.options[:order].should == 'COUNT(*)'
+    subject.options[:reverse].should == true
+  end
+
   describe "#run" do
     it "should call count on the proc result" do
       @counter = SingleCounter.new
@@ -28,14 +52,26 @@ describe Compendium::CountQuery do
       subject.run(nil, self).should == [1792]
     end
 
-    it "should return a hash if given" do
-      @counter = MultipleCounter.new
-      subject.run(nil, self).should == { 1 => 123, 2 => 456, 3 => 789 }
+    context 'when given a hash' do
+      before { @counter = MultipleCounter.new }
+
+      it "should return a hash" do
+        subject.run(nil, self).should == { 3 => 983, 1 => 340, 2 => 204 }
+      end
+
+      it 'should be ordered in descending order' do
+        subject.run(nil, self).keys.should == [3, 1, 2]
+      end
+
+      it 'should use the given options' do
+        subject.options[:reverse] = false
+        subject.run(nil, self).keys.should == [2, 1, 3]
+      end
     end
 
     it "should raise an error if the proc does not respond to count" do
       @counter = Class.new
-      expect { subject.run(nil, self) }.to raise_error Compendium::CountQuery::InvalidCommand
+      expect { subject.run(nil, self) }.to raise_error Compendium::InvalidCommand
     end
   end
 end

data/spec/dsl_spec.rb

@@ -46,9 +46,14 @@ describe Compendium::DSL do
   end
 
   describe "#query" do
+    let(:proc1) { -> { :proc1 } }
+    let(:proc2) { -> { :proc2 } }
+
     let(:report_class) do
+      proc1 = proc1
+
       Class.new(Compendium::Report) do
-        query :test
+        query :test, &proc1
       end
     end
 
@@ -65,6 +70,36 @@ describe Compendium::DSL do
       subject.test.report.should == subject
     end
 
+    context 'when overriding an existing query' do
+      before do
+        subject.query :test, &proc2
+        subject.query :another_test, count: true
+      end
+
+      it 'should delete the existing query' do
+        subject.queries.count.should == 2
+      end
+
+      it 'should only have one query with each name' do
+        subject.queries.map(&:name).should =~ [:test, :another_test]
+      end
+
+      it 'should use the new proc' do
+        subject.test.proc.should == proc2
+      end
+
+      it 'should not allow replacing a query with a different type' do
+        expect { subject.query :test, count: true }.to raise_error { Compendium::CannotRedefineQueryType }
+        subject.test.should be_instance_of Compendium::Query
+      end
+
+      it 'should allow replacing a query with the same type' do
+        subject.query :another_test, count: true, &proc2
+        subject.another_test.proc.should == proc2
+        subject.another_test.should be_instance_of Compendium::CountQuery
+      end
+    end
+
     context "when given a through option" do
       before { report_class.query :through, through: :test }
       subject { report_class.queries[:through] }
@@ -221,6 +256,46 @@ describe Compendium::DSL do
     end
   end
 
+  describe '#table' do
+    let(:table_proc) { -> { display_nil_as 'na' } }
+
+    it 'should add table settings to the given query' do
+      subject.query :test
+      subject.table :test, &table_proc
+      subject.queries[:test].table_settings.should == table_proc
+    end
+
+    it 'should raise an error if there is no query of the given name' do
+      expect { subject.table :test, &table_proc }.to raise_error(ArgumentError, "query test is not defined")
+    end
+
+    it 'should allow table settings to be applied to multiple queries at once' do
+      subject.query :query1
+      subject.query :query2
+      subject.table :query1, :query2, &table_proc
+      subject.queries[:query1].table_settings.should == table_proc
+      subject.queries[:query2].table_settings.should == table_proc
+    end
+  end
+
+  describe '#exports' do
+    it 'should not have any exporters by default' do
+      subject.exporters.should be_empty
+    end
+
+    it 'should set the export to true if no options are given' do
+      subject.exports :csv
+      subject.exporters[:csv].should be_true
+    end
+
+    it 'should save any given options' do
+      subject.exports :csv, :main_query
+      subject.exports :pdf, :foo, :bar
+      subject.exporters[:csv].should == :main_query
+      subject.exporters[:pdf].should == [:foo, :bar]
+    end
+  end
+
   it "should allow previously defined queries to be redefined by name" do
     subject.query :test_query
     subject.test_query foo: :bar
@@ -231,4 +306,4 @@ describe Compendium::DSL do
     subject.query :test_query
     subject.test_query.should == subject.queries[:test_query]
   end
-end
+end

data/spec/presenters/csv_spec.rb

@@ -0,0 +1,30 @@
+require 'compendium/presenters/csv'
+
+describe Compendium::Presenters::CSV do
+  let(:results) { double('Results', records: [{ group: 'A', one: 1, two: 2 }, { group: 'B', one: 3, two: 4 }], keys: [:group, :one, :two]) }
+  let(:query) { double('Query', results: results, options: {}, table_settings: nil) }
+  let(:presenter) { described_class.new(query) }
+
+  before do
+    query.stub(:pos) { raise caller.join("\n") }
+  end
+
+  before { I18n.stub(:t) { |key| key } }
+
+  describe '#render' do
+    it 'should return a CSV of the results' do
+      presenter.render.should == "group,one,two\nA,1.00,2.00\nB,3.00,4.00\n"
+    end
+
+    it "should use the query's table settings" do
+      query.stub(:table_settings).and_return(-> * { number_format '%0.0f' })
+      presenter.render.should == "group,one,two\nA,1,2\nB,3,4\n"
+    end
+
+    it 'should output a total row if the query has totals' do
+      query.results.records << { group: '', one: 4, two: 6 }
+      query.options[:totals] = true
+      presenter.render.should == "group,one,two\nA,1.00,2.00\nB,3.00,4.00\ntotal,4.00,6.00\n"
+    end
+  end
+end

data/spec/presenters/settings/query_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'compendium/presenters/settings/query'
+
+describe Compendium::Presenters::Settings::Query do
+  subject { described_class.new }
+
+  describe '#update' do
+    before { subject.foo = :bar }
+
+    it 'should override previous settings' do
+      subject.update do |s|
+        s.foo :quux
+      end
+
+      subject.foo.should == :quux
+    end
+
+    it 'should allow the block parameter to be skipped' do
+      subject.update do
+        foo :quux
+      end
+
+      subject.foo.should == :quux
+    end
+  end
+end

data/spec/presenters/settings/table_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'compendium/presenters/table'
+
+describe Compendium::Presenters::Settings::Table do
+  let(:results) { double('Results', records: [{ one: 1, two: 2 }, { one: 3, two: 4 }], keys: [:one, :two]) }
+  let(:query) { double('Query', results: results, options: {}, table_settings: nil) }
+  let(:table) { Compendium::Presenters::Table.new(nil, query) }
+
+  subject { table.settings }
+
+  context 'default settings' do
+    its(:number_format) { should == '%0.2f' }
+    its(:table_class) { should == 'results' }
+    its(:header_class) { should == 'headings' }
+    its(:row_class) { should == 'data' }
+    its(:totals_class) { should == 'totals' }
+    its(:display_nil_as) { should be_nil }
+    its(:skipped_total_cols) { should be_empty }
+  end
+
+  context 'overriding default settings' do
+    let(:table) do
+      Compendium::Presenters::Table.new(nil, query) do |t|
+        t.number_format '%0.1f'
+        t.table_class 'report_table'
+        t.header_class 'report_heading'
+        t.display_nil_as 'N/A'
+      end
+    end
+
+    its(:number_format) { should == '%0.1f' }
+    its(:table_class) { should == 'report_table' }
+    its(:header_class) { should == 'report_heading' }
+    its(:display_nil_as) { should == 'N/A' }
+  end
+
+  describe '#update' do
+    it 'should override previous settings' do
+      subject.update do |s|
+        s.number_format '%0.3f'
+      end
+
+      subject.number_format.should == '%0.3f'
+    end
+  end
+
+  describe '#skip_total_for' do
+    it 'should add columns to the setting' do
+      subject.skip_total_for :foo, :bar
+      subject.skipped_total_cols.should == [:foo, :bar]
+    end
+
+    it 'should be callable multiple times' do
+      subject.skip_total_for :foo, :bar
+      subject.skip_total_for :quux
+      subject.skipped_total_cols.should == [:foo, :bar, :quux]
+    end
+
+    it 'should not care about type' do
+      subject.skip_total_for 'foo'
+      subject.skipped_total_cols.should == [:foo]
+    end
+  end
+end

data/spec/presenters/table_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'compendium/presenters/table'
+
+describe Compendium::Presenters::Table do
+  let(:template) { double('Template') }
+  let(:results) { double('Results', records: [{ one: 1, two: 2 }, { one: 3, two: 4 }], keys: [:one, :two]) }
+  let(:query) { double('Query', results: results, options: {}, table_settings: nil) }
+  let(:table) { described_class.new(template, query) }
+
+  context 'render' do
+    before do
+      template.stub(:content_tag) { |element, *, &block| block.nil? ? element : table.instance_exec(&block) }
+      I18n.stub(:t) { |key| key }
+    end
+
+    it 'should use the table class given in settings' do
+      table.settings.table_class 'report_table'
+
+      template.should_receive(:content_tag).with(:table, class: 'report_table')
+      table.render
+    end
+
+    it 'should use the default table class if not overridden' do
+      template.should_receive(:content_tag).with(:table, class: 'results')
+      table.render
+    end
+
+    it 'should build the heading row' do
+      template.should_receive(:content_tag).with(:tr, class: 'headings')
+      template.should_receive(:content_tag).with(:th, :one)
+      template.should_receive(:content_tag).with(:th, :two)
+      table.render
+    end
+
+    it 'should use the overridden heading class if given' do
+      table.settings.header_class 'report_header'
+
+      template.should_receive(:content_tag).with(:tr, class: 'report_header')
+      table.render
+    end
+
+    it 'should build data rows' do
+      template.should_receive(:content_tag).with(:tr, class: 'data').twice
+      table.render
+    end
+
+    it 'should use the overridden row class if given' do
+      table.settings.row_class 'report_row'
+
+      template.should_receive(:content_tag).with(:tr, class: 'report_row').twice
+      table.render
+    end
+
+    it 'should add a totals row if the query has totals: true set' do
+      query.options[:totals] = true
+
+      template.should_receive(:content_tag).with(:tr, class: 'totals')
+      table.render
+    end
+
+    it 'should not add a totals row if the query has totals: false set' do
+      query.options[:totals] = false
+
+      template.should_not_receive(:content_tag).with(:tr, class: 'totals')
+      table.render
+    end
+
+    it 'should not add a totals row if the query does not have :totals set' do
+      query.options.delete(:totals)
+
+      template.should_not_receive(:content_tag).with(:tr, class: 'totals')
+      table.render
+    end
+
+    it 'should use the totals class if that setting is overridden' do
+      query.options[:totals] = true
+      table.settings.totals_class 'report_totals'
+
+      template.should_receive(:content_tag).with(:tr, class: 'report_totals')
+      table.render
+    end
+  end
+end