compendium 1.0.2 → 1.0.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Y2M5ZWFmZjNlN2Q0YWQ0MGQ4ZTQ0Njg3ZDIzN2VjMTI4NzZlOTJlYw==
+    ODBjOTg1ZGM3NjVhYTM3ZjcxZDM5YjMyYjI1M2I2MzJjYTkzZmFiNg==
   data.tar.gz: !binary |-
-    ZjFkNjcwNmU2YTRlOTNhZTdiZjYyYmU0MzA1MDEzZGJhMjdmOGQ3MQ==
+    Yzg1ZDk0MmUxYTlkMDg2NTgzYTIxMzEyZjk3NjcxYjYwMzc2ZjhiZQ==
 SHA512:
   metadata.gz: !binary |-
-    NjlmNzliZjA5MjU3N2E4Mzk2NzZkOWM0M2JmM2YzYzk1YWNjNDQ1MjgyZTc3
-    MGFkNzM5ODc4YzI1NGUyMzM1ZDliMWE1ZDY5NmQ2YTQzMjFkNjgzOGNiMzQy
-    ZGM3NWI5OTA5YjlhMGY0YzMwMjYwNzYzNjJiYjQ5ODE1MDY0NTM=
+    ZTA4YTdjYjUwOWE5ZTU3ODVhZmRhMzU2NjViZjZiMGFjZjk3ZDhkYjY0MjIz
+    NjY3ZmVjODkzNGYyNWNiNDY2ODlmZWNiNTI4NGI2MGFhNGIzNThjMzgwZjZl
+    ZTM5MzIzNjVlNDdmY2FiN2U2MTAxZTQwN2Q0NWUxZmFmN2Q2MjM=
   data.tar.gz: !binary |-
-    ODAwYmEwOTJhMmViNTczMTQ4ZGNmYTY0ZGZmZjNjZTZkYjJjMTAwNzNiYjgx
-    ZmEyOTA0MDRjNmFkMWNiMWM5NzQ3ZTYyYzkzMDlmYzY4ZTk0YTczOTgyZTgy
-    MTc3ODZmYjU4NGY1MDA4NGJmMjVmNDgyNjIzOTE5YzcyY2Y4NzA=
+    N2QyNWI2OGU4ZGQ0OWJiODMxZDNhOTA4NDU1NTliOTViNzAxMzQ3MGRlZTAz
+    Y2UxODhjMjUyZTEzNjFhYmI5MzkwZGI3ZTYzNzEwMWM4NWVmNGVlZjJmYjdh
+    NTZkYWJkODVmYzk4OTUzZTVhNjkxNDVjODhjN2QyNmY2N2Q4ZTM=

data/app/classes/compendium/presenters/chart.rb

@@ -1,11 +1,18 @@
+require 'compendium/presenters/query'
+require 'active_support/core_ext/array/extract_options'
+
 module Compendium::Presenters
   class Chart < Query
-    attr_reader :data, :chart_provider
+    attr_reader :data, :container, :chart_provider
+
+    def initialize(template, object, *args, &setup)
+      options = args.extract_options!
+      type, container = args
 
-    def initialize(template, object, type, container = nil, &setup)
       super(template, object)
 
-      @data = results.records
+      @data = options[:index] ? results.records[options[:index]] : results
+      @data = @data.records if @data.is_a?(Compendium::ResultSet)
       @data = @data[0...-1] if query.options[:totals]
 
       @container = container || query.name

data/app/classes/compendium/presenters/option.rb

@@ -5,7 +5,7 @@ module Compendium::Presenters
     presents :option
 
     def name
-      t(option.name)
+      t("options.#{option.name}", cascade: { offset: 2 })
     end
 
     def label(form)
@@ -21,10 +21,12 @@ module Compendium::Presenters
       out << content_tag(:span, label, class: 'option-label')
 
       if option.note?
-        note = t(option.note == true ? :"#{option.name}_note" : option.note)
+        key = option.note == true ? :"#{option.name}_note" : option.note
+        note = t("options.#{key}", cascade: { offset: 2 })
+        title = t("options.#{option.name}_note_title", default: '', cascade: { offset: 2 })
 
         if defined?(AccessibleTooltip)
-          return accessible_tooltip(:help, label: out, title: t("#{option.name}_note_title", default: '')) { note }
+          return accessible_tooltip(:help, label: out, title: title) { note }
         else
           out << content_tag(:div, note, class: 'option-note')
         end

data/app/classes/compendium/presenters/query.rb

@@ -1,3 +1,5 @@
+require 'compendium/presenters/base'
+
 module Compendium::Presenters
   class Query < Base
     presents :query

data/app/controllers/compendium/reports_controller.rb

@@ -4,6 +4,7 @@ module Compendium
     include Compendium::ReportsHelper
 
     before_filter :find_report
+    before_filter :validate_options, only: :run
     before_filter :run_report, only: :run
 
     def setup
@@ -24,6 +25,7 @@ module Compendium
       begin
         require(@report_name) unless Rails.env.development? or Module.const_defined?(@report_name.classify)
         @report_class = @report_name.camelize.constantize
+        @report = setup_report
       rescue LoadError
         flash[:error] = t(:invalid_report)
         redirect_to action: :index
@@ -31,16 +33,20 @@ module Compendium
     end
 
     def render_setup(opts = {})
-      locals = { report: setup_report, prefix: @prefix }
-      render_if_exists(opts.merge(locals: locals)) || render(locals: locals)
+      locals = { report: @report, prefix: @prefix }
+      opts.empty? ? render(action: :setup, locals: locals) : render_if_exists(opts.merge(locals: locals)) || render(action: :setup, locals: locals)
     end
 
     def setup_report
       @report_class.new(params[:report] || {})
     end
 
+    def validate_options
+      render_setup and return unless @report.valid?
+    end
+
     def run_report
-      @report = @report_class.new(params[:report]).run(self)
+      @report.run(self)
     end
 
     def get_template_prefixes

data/app/views/compendium/reports/setup.haml

@@ -5,7 +5,7 @@
 
 .options
   = form_for report, as: :report, url: compendium_reports_run_path do |f|
-    - report.options.values.each do |option|
+    - report.options.each do |option|
       - expose option, Compendium::Presenters::Option do |opt|
         .option
           = opt.label(f)

data/compendium.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'rails', '>= 3.0.0'
   gem.add_dependency 'sass-rails', '>= 3.0.0'
   gem.add_dependency 'compass-rails', '>= 1.0.0'
-  gem.add_dependency 'collection_of', '1.0.4'
+  gem.add_dependency 'collection_of', '1.0.5'
   gem.add_dependency 'inheritable_attr', '>= 1.0.0'
   gem.add_development_dependency 'rspec', '~> 2.0'
 end

data/lib/compendium/collection_query.rb

@@ -0,0 +1,44 @@
+require 'compendium/query'
+
+module Compendium
+  # A CollectionQuery is a Query which runs once for each in a given set of criteria
+  class CollectionQuery < Query
+    attr_accessor :collection
+
+    def initialize(*)
+      super
+      self.collection = prepare_collection(@options[:collection])
+    end
+
+    def run(params, context = self)
+      collection_values = get_collection_values(context, params)
+
+      results = collection_values.inject({}) do |r, (key, value)|
+        res = collect_results(context, params, key, value)
+        r[key] = res unless res.empty?
+        r
+      end
+
+      # A CollectionQuery's results will be a ResultSet of ResultSets
+      @results = ResultSet.new(results)
+    end
+
+  private
+
+    def get_collection_values(context, params)
+      self.collection = get_associated_query(collection) if collection.is_a?(Symbol)
+
+      if collection.is_a?(Query)
+        collection.run(params, context) unless collection.ran?
+        collection.results
+      else
+        collection
+      end
+    end
+
+    def prepare_collection(collection)
+      return collection if collection.is_a?(Query) or collection.is_a?(Symbol)
+      collection.is_a?(Hash) ? collection : Hash[collection.zip(collection)]
+    end
+  end
+end

data/lib/compendium/dsl.rb

@@ -7,7 +7,7 @@ module Compendium
   module DSL
     def self.extended(klass)
       klass.inheritable_attr :queries, default: ::Collection[Query]
-      klass.inheritable_attr :options, default: {}
+      klass.inheritable_attr :options, default: ::Collection[Option]
     end
 
     def query(name, opts = {}, &block)
@@ -20,16 +20,20 @@ module Compendium
       opts = args.extract_options!
       type = args.shift
 
+      add_params_validations(name, opts.delete(:validates))
+
       if options[name]
         options[name].type = type if type
         options[name].default = opts.delete(:default) if opts.key?(:default)
         options[name].merge!(opts)
       else
-        options[name] = Compendium::Option.new(opts.merge(name: name, type: type))
+        options << Compendium::Option.new(opts.merge(name: name, type: type))
       end
     end
 
-    def metric(name, proc, opts = {})
+    def metric(name, *args, &block)
+      proc = args.first.is_a?(Proc) ? args.first : block
+      opts = args.extract_options!
       raise ArgumentError, 'through option must be specified for metric' unless opts.key?(:through)
 
       [opts.delete(:through)].flatten.each do |query|
@@ -38,6 +42,15 @@ module Compendium
       end
     end
 
+    # Each Report will have its own descendant of Params in order to safely add validations
+    def params_class
+      @params_class ||= Class.new(Params)
+    end
+
+    def params_class=(klass)
+      @params_class = klass
+    end
+
     # Allow defined queries to be redefined by name, eg:
     # query :main_query
     # main_query { collect_records_here }
@@ -59,22 +72,30 @@ module Compendium
 
   private
 
-    def define_query(name, opts, type = Query, &block)
-      name = name.to_sym
-      query = type.new(name, opts, block)
+    def define_query(name, opts, &block)
+      params = [name.to_sym, opts, block]
+      query_type = Query
 
-      if opts.key?(:through)
+      if opts.key?(:collection)
+        query_type = CollectionQuery
+      elsif opts.key?(:through)
+        # Ensure each through query is defined
         through = [opts[:through]].flatten
+        through.each { |q| raise ArgumentError, "query #{q} is not defined" unless self.queries.include?(q.to_sym) }
 
-        through.each do |q|
-          raise ArgumentError, "query #{q} is not defined" unless self.queries.include?(q.to_sym)
-        end
-
-        query.through = through
+        query_type = ThroughQuery
+        params.insert(1, through)
       end
 
+      query = query_type.new(*params)
+
       metrics[name] = opts[:metric] if opts.key?(:metric)
       queries << query
     end
+
+    def add_params_validations(name, validations)
+      return if validations.blank?
+      self.params_class.validates name, validations
+    end
   end
 end

data/lib/compendium/param_types.rb

@@ -32,7 +32,7 @@ module Compendium
         raise IndexError if (!obj.nil? and index.nil?) or index.to_i.abs > @choices.length - 1
       end
 
-      super(index || 0)
+      super(index)
     end
 
     def value

data/lib/compendium/params.rb

@@ -2,9 +2,12 @@ require 'compendium/open_hash'
 require 'compendium/param_types'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/object/blank'
+require 'active_model'
 
 module Compendium
   class Params < OpenHash
+    include ActiveModel::Validations
+
     attr_reader :options
 
     def initialize(hash = {}, options = {})
@@ -12,15 +15,19 @@ module Compendium
       super(prepare_hash_from_options(hash))
     end
 
+    def self.model_name
+      ActiveModel::Name.new(Compendium::Params, Compendium, 'compendium.params')
+    end
+
   protected
 
     def prepare_hash_from_options(params)
       params = params.slice(*options.keys)
 
-      options.each do |option_name, metadata|
+      options.each do |option|
         begin
-          klass = "Compendium::#{"#{metadata.type}Param".classify}".constantize
-          params[option_name] = klass.new(get_default_value(params[option_name], metadata.default), metadata.choices)
+          klass = "Compendium::#{"#{option.type}Param".classify}".constantize
+          params[option.name] = klass.new(get_default_value(params[option.name], option.default), option.choices)
         rescue IndexError
           raise IndexError, "invalid index for #{option_name}"
         end

data/lib/compendium/query.rb

@@ -1,12 +1,14 @@
 require 'compendium/result_set'
 require 'compendium/params'
+require 'compendium/presenters/chart'
+require 'compendium/presenters/table'
 require 'collection_of'
 require_relative '../../config/initializers/ruby/hash'
 
 module Compendium
   class Query
     attr_reader :name, :results, :metrics
-    attr_accessor :options, :proc, :through, :report
+    attr_accessor :options, :proc, :report
 
     def initialize(*args)
       @report = args.shift if arg_is_report?(args.first)
@@ -23,7 +25,7 @@ module Compendium
     end
 
     def run(params, context = self)
-      collect_results(params, context)
+      collect_results(context, params)
       collect_metrics(context)
 
       @results
@@ -34,11 +36,11 @@ module Compendium
     end
 
     def render_table(template, *options, &block)
-      Compendium::Presenters::Table.new(template, self, *options, &block).render
+      Compendium::Presenters::Table.new(template, self, *options, &block).render unless empty?
     end
 
     def render_chart(template, *options, &block)
-      Compendium::Presenters::Chart.new(template, self, *options, &block).render
+      Compendium::Presenters::Chart.new(template, self, *options, &block).render unless empty?
     end
 
     def ran?
@@ -46,24 +48,20 @@ module Compendium
     end
     alias_method :has_run?, :ran?
 
+    # A query is nil if it has no proc
     def nil?
       proc.nil?
     end
 
-  private
-
-    def collect_results(params, context)
-      if through.nil?
-        args = params
-      else
-        args = collect_through_query_results(through, params, context)
+    # A query is empty if it has no results
+    def empty?
+      results.empty?
+    end
 
-        # 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 args.compact.empty?
-      end
+  private
 
-      command = context.instance_exec(args, &proc) if proc
+    def collect_results(context, *params)
+      command = context.instance_exec(*params, &proc) if proc
       command = fetch_results(command)
       @results = ResultSet.new(command) if command
     end
@@ -73,11 +71,7 @@ module Compendium
     end
 
     def fetch_results(command)
-      if options.key?(:through) or options.fetch(:collect, nil) == :active_record
-        command
-      else
-        execute_command(command)
-      end
+      (options.fetch(:collect, nil) == :active_record) ? command : execute_command(command)
     end
 
     def execute_command(command)
@@ -90,26 +84,12 @@ module Compendium
       ::ActiveRecord::Base.connection.select_all(command)
     end
 
-    def collect_through_query_results(through, params, context)
-      results = {}
-
-      through = [through].flatten.map(&method(:get_through_query))
-
-      through.each do |q|
-        q.run(params, context) unless q.ran?
-        results[q.name] = q.results.records
-      end
-
-      results = results[through.first.name] if through.size == 1
-      results
-    end
-
-    def get_through_query(name)
-      report.queries[name]
-    end
-
     def arg_is_report?(arg)
       arg.is_a?(Report) or (arg.is_a?(Class) and arg < Report)
     end
+
+    def get_associated_query(query)
+      query.is_a?(Query) ? query : report.queries[query]
+    end
   end
 end

data/lib/compendium/report.rb

@@ -1,5 +1,7 @@
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/string/inflections'
 require 'compendium/dsl'
 
 module Compendium
@@ -8,12 +10,45 @@ module Compendium
 
     extend Compendium::DSL
 
-    def self.inherited(report)
-      Compendium.reports << report
+    delegate :valid?, :errors, to: :params
+
+    class << self
+      def inherited(report)
+        Compendium.reports << report
+
+        # Each Report object has its own Params class so that validations can be added without affecting other
+        # reports. However, validations also need to be inherited, so when inheriting a report, subclass its
+        # params_class
+        report.params_class = Class.new(self.params_class)
+        report.params_class.class_eval %Q{
+          def self.model_name
+            ActiveModel::Name.new(Compendium::Params, Compendium, "compendium.params.#{report.name.underscore rescue 'report'}")
+          end
+        }
+      end
+
+      # Define predicate methods for getting the report type
+      # ie. r.spending? checks that r == SpendingReport
+      def method_missing(name, *args, &block)
+        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)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        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)
+        super
+      end
     end
 
     def initialize(params = {})
-      @params = Params.new(params, options)
+      @params = self.class.params_class.new(params, options)
 
       # When creating a new report, map each query back to the report
       queries.each { |q| q.report = self }

data/lib/compendium/result_set.rb

@@ -1,8 +1,9 @@
 require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module Compendium
   class ResultSet
-    delegate :first, :last, :to_a, :empty?, :each, :map, :[], :count, :length, :size, :==, to: :records
+    delegate :first, :last, :to_a, :empty?, :each, :map, :inject, :select, :detect, :[], :count, :length, :size, :==, to: :records
 
     attr_reader :records
     alias :all :records
@@ -11,6 +12,8 @@ module Compendium
       @records = records.map do |r|
         r.respond_to?(:with_indifferent_access) ? r.with_indifferent_access : r
       end
+
+      @records = Hash[@records] if records.is_a?(Hash)
     end
 
     def keys

data/lib/compendium/through_query.rb

@@ -0,0 +1,43 @@
+require 'compendium/query'
+
+module Compendium
+  class ThroughQuery < Query
+    attr_accessor :through
+
+    def initialize(*args)
+      @report = args.shift if arg_is_report?(args.first)
+      @through = args.slice!(1)
+      super(*args)
+    end
+
+  private
+
+    def collect_results(context, params)
+      args = collect_through_query_results(params, context)
+
+      # 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 args.compact.empty?
+
+      super(context, args)
+    end
+
+    def fetch_results(command)
+      command
+    end
+
+    def collect_through_query_results(params, context)
+      results = {}
+
+      queries = [through].flatten.map(&method(:get_associated_query))
+
+      queries.each do |q|
+        q.run(params, context) unless q.ran?
+        results[q.name] = q.results.records
+      end
+
+      results = results[queries.first.name] if queries.size == 1
+      results
+    end
+  end
+end

data/lib/compendium/version.rb

@@ -1,3 +1,3 @@
 module Compendium
-  VERSION = "1.0.2"
+  VERSION = "1.0.4"
 end

data/lib/compendium.rb

@@ -5,6 +5,7 @@ require 'active_support/configurable'
 module Compendium
   autoload :AbstractChartProvider,  'compendium/abstract_chart_provider'
   autoload :ChartProvider,          'compendium/abstract_chart_provider'
+  autoload :CollectionQuery,        'compendium/collection_query'
   autoload :ContextWrapper,         'compendium/context_wrapper'
   autoload :DSL,                    'compendium/dsl'
   autoload :Metric,                 'compendium/metric'
@@ -13,6 +14,7 @@ module Compendium
   autoload :Query,                  'compendium/query'
   autoload :ResultSet,              'compendium/result_set'
   autoload :Report,                 'compendium/report'
+  autoload :ThroughQuery,           'compendium/through_query'
 
   autoload :Param,                  'compendium/param_types'
   autoload :BooleanParam,           'compendium/param_types'

data/spec/collection_query_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'compendium/collection_query'
+
+describe Compendium::CollectionQuery do
+  let(:collection) { { one: 1, two: 2, three: 3 } }
+  subject { described_class.new(:collection_query, { collection: collection }, -> _, key, item { [item * 2] }) }
+
+  before { Compendium::Query.any_instance.stub(:execute_query) { |cmd| cmd } }
+
+  describe "#run" do
+    context do
+      before { subject.run(nil) }
+
+      its(:results) { should be_a Compendium::ResultSet }
+      its(:results) { should == { one: [2], two: [4], three: [6] } }
+
+      context "when given an array instead of a hash" do
+        let(:collection) { [1, 2, 3] }
+
+        its(:results) { should be_a Compendium::ResultSet }
+        its(:results) { should == { 1 => [2], 2 => [4], 3 => [6] } }
+      end
+    end
+
+    it "should not collect empty results" do
+      subject.proc = -> _, key, item { [item] if item > 2 }
+      subject.run(nil)
+      subject.results.should == { three: [3] }
+    end
+
+    context "when given another query" do
+      let(:q) { Compendium::Query.new(:q, {}, -> * { { one: 1, two: 2, three: 3 } }) }
+      subject { described_class.new(:collection, { collection: q }, -> _, key, item { [ item * 2 ] }) }
+
+      before { subject.run(nil) if example.metadata.fetch(:run_query, true) }
+
+      its(:results) { should == { one: [2], two: [4], three: [6] } }
+
+      it "should not re-run the query if it has already ran", run_query: false do
+        q.run(nil)
+        q.should_not_receive(:run)
+        subject.run(nil)
+      end
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -25,15 +25,34 @@ describe Compendium::DSL do
       subject.option :starting_on, :date, default: proc
       subject.options[:starting_on].default.should == proc
     end
+
+    it "should add validations" do
+      subject.option :foo, validates: { presence: true }
+      subject.params_class.validators_on(:foo).should_not be_empty
+    end
+
+    it "should not add validations if no validates option is given" do
+      subject.params_class.should_not_receive :validates
+      subject.option :foo
+    end
+
+    it "should not bleed overridden options into the superclass" do
+      r = Class.new(subject)
+      r.option :starting_on, :boolean
+      r.option :new, :date
+      subject.options[:starting_on].should be_date
+    end
   end
 
   describe "#query" do
-    subject do
+    let(:report_class) do
       Class.new(Compendium::Report) do
         query :test
       end
     end
 
+    subject { report_class }
+
     its(:queries) { should include :test }
 
     it "should relate the new query back to the report instance" do
@@ -44,6 +63,42 @@ describe Compendium::DSL do
     it "should not relate a query to the report class" do
       subject.test.report.should be_nil
     end
+
+    context "when given a through option" do
+      before { report_class.query :through, through: :test }
+      subject { report_class.queries[:through] }
+
+      it { should be_a Compendium::ThroughQuery }
+      its(:through) { should == [:test] }
+    end
+
+    context "when given a collection option" do
+      subject { report_class.queries[:collection] }
+
+      context "that is an enumerable" do
+        before { report_class.query :collection, collection: [] }
+
+        it { should be_a Compendium::CollectionQuery }
+      end
+
+      context "that is a symbol" do
+        let(:query) { double("Query") }
+
+        before do
+          Compendium::Query.any_instance.stub(:get_associated_query).with(:query).and_return(query)
+          report_class.query :collection, collection: :query
+        end
+
+        its(:collection) { should == :query }
+      end
+
+      context "that is a query" do
+        let(:query) { Compendium::Query.new(:query, {}, ->{}) }
+        before { report_class.query :collection, collection: query }
+
+        its(:collection) { should == query }
+      end
+    end
   end
 
   describe "#chart" do
@@ -81,6 +136,19 @@ describe Compendium::DSL do
     it "should raise an error if specified for an invalid query" do
       expect{ subject.metric :test_metric, metric_proc, through: :fake }.to raise_error ArgumentError, 'query fake is not defined'
     end
+
+    it "should allow metrics to be defined with a block" do
+      subject.metric :block_metric, through: :test do
+        123
+      end
+
+      subject.queries[:test].metrics[:block_metric].run(self, nil).should == 123
+    end
+
+    it "should allow metrics to be defined with a lambda" do
+      subject.metric :block_metric, -> * { 123 }, through: :test
+      subject.queries[:test].metrics[:block_metric].run(self, nil).should == 123
+    end
   end
 
   it "should allow previously defined queries to be redefined by name" do

data/spec/params_spec.rb

@@ -1,13 +1,15 @@
 require 'compendium/params'
 
 describe Compendium::Params do
-  let(:options) { {
-    starting_on: Compendium::Option.new(name: :starting_on, type: :date, default: ->{ Date.today }),
-    ending_on: Compendium::Option.new(name: :ending_on, type: :date),
-    report_type: Compendium::Option.new(name: :report_type, type: :radio, choices: [:big, :small]),
-    boolean: Compendium::Option.new(name: :boolean, type: :boolean),
-    another_boolean: Compendium::Option.new(name: :another_boolean, type: :boolean)
-  } }
+  let(:options) {
+    opts = Collection[Compendium::Option]
+    opts << Compendium::Option.new(name: :starting_on, type: :date, default: ->{ Date.today })
+    opts << Compendium::Option.new(name: :ending_on, type: :date)
+    opts << Compendium::Option.new(name: :report_type, type: :radio, choices: [:big, :small])
+    opts << Compendium::Option.new(name: :boolean, type: :boolean)
+    opts << Compendium::Option.new(name: :another_boolean, type: :boolean)
+    opts
+  }
 
   subject{ described_class.new(@params, options) }
 
@@ -25,4 +27,17 @@ describe Compendium::Params do
     @params = {}
     subject.ending_on.should be_nil
   end
+
+  describe "#validations" do
+    let(:report_class) { Class.new(described_class) }
+    subject { report_class.new({}, options) }
+
+    before do
+      report_class.validates :ending_on, presence: true
+      subject.valid?
+    end
+
+    it { should_not be_valid }
+    its('errors.keys') { should include :ending_on }
+  end
 end

data/spec/presenters/chart_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'compendium/presenters/chart'
+
+describe Compendium::Presenters::Chart do
+  before do
+    described_class.any_instance.stub(:provider) { double('ChartProvider') }
+    described_class.any_instance.stub(:initialize_chart_provider)
+  end
+
+  describe '#initialize' do
+    let(:template) { double('Template') }
+    let(:query) { double('Query', name: 'test_query', results: results, options: {}) }
+    let(:results) { Compendium::ResultSet.new([]) }
+
+    context 'when all params are given' do
+      subject{ described_class.new(template, query, :pie, :container) }
+
+      its(:data) { should == results.records }
+      its(:container) { should == :container }
+    end
+
+    context 'when container is not given' do
+      subject{ described_class.new(template, query, :pie) }
+
+      its(:data) { should == results.records }
+      its(:container) { should == 'test_query' }
+    end
+
+    context "when options are given" do
+      before { results.stub(:records) { { one: [] } } }
+      subject{ described_class.new(template, query, :pie, index: :one) }
+
+      its(:data) { should == results.records[:one] }
+      its(:container) { should == 'test_query' }
+    end
+  end
+end

data/spec/presenters/option_spec.rb

@@ -15,7 +15,7 @@ describe Compendium::Presenters::Option do
 
   describe "#name" do
     it "should pass the name through I18n" do
-      template.should_receive(:t).with(:test_option)
+      template.should_receive(:t).with('options.test_option', anything)
       subject.name
     end
   end

data/spec/query_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'compendium/query'
 
 describe Compendium::Query do
@@ -48,50 +49,47 @@ describe Compendium::Query do
       query = described_class.new(:blank, {}, nil)
       query.run(nil).should be_empty
     end
+  end
 
-    context 'through queries' do
-      let(:parent_query1) { described_class.new(:parent1, {}, -> * { }) }
-      let(:parent_query2) { described_class.new(:parent2, {}, -> * { }) }
-      let(:parent_query3) { described_class.new(:parent3, {}, -> * { [[1, 2, 3]] }) }
-
-      subject { described_class.new(:sub, {}, -> records { records.first }) }
-
-      before do
-        subject.stub(:get_through_query).with(:parent1).and_return(parent_query1)
-        subject.stub(:get_through_query).with(:parent2).and_return(parent_query2)
-        subject.stub(:get_through_query).with(:parent3).and_return(parent_query3)
-        described_class.any_instance.stub(:execute_query) { |cmd| cmd }
-      end
-
-      it "should not try to run a through query if the parent query has no results" do
-        subject.through = :parent1
+  describe "#nil?" do
+    it "should return true if the query's proc is nil" do
+      Compendium::Query.new(:test, {}, nil).should be_nil
+    end
 
-        expect { subject.run(nil) }.to_not raise_error
-        subject.results.should be_empty
-      end
+    it "should return false if the query's proc is not nil" do
+      Compendium::Query.new(:test, {}, ->{}).should_not be_nil
+    end
+  end
 
-      it "should not try to run a through query with multiple parents all of which have no results" do
-        subject.through = [:parent1, :parent2]
+  describe "#render_chart" do
+    let(:template) { double("Template") }
+    subject { described_class.new(:test, {}, -> * {}) }
 
-        expect { subject.run(nil) }.to_not raise_error
-        subject.results.should be_empty
-      end
+    it "should return nil if the query has no results" do
+      subject.stub(empty?: true)
+      subject.render_chart(template).should be_nil
+    end
 
-      it "should allow non blank queries" do
-        subject.through = :parent3
-        subject.run(nil)
-        subject.results.should == [1, 2, 3]
-      end
+    it "should initialize a new Chart presenter if the query has results" do
+      subject.stub(empty?: false)
+      Compendium::Presenters::Chart.should_receive(:new).with(template, subject).and_return(double("Presenter").as_null_object)
+      subject.render_chart(template)
     end
   end
 
-  describe "#nil?" do
-    it "should return true if the query's proc is nil" do
-      Compendium::Query.new(:test, {}, nil).should be_nil
+  describe "#render_table" do
+    let(:template) { double("Template") }
+    subject { described_class.new(:test, {}, -> * {}) }
+
+    it "should return nil if the query has no results" do
+      subject.stub(empty?: true)
+      subject.render_table(template).should be_nil
     end
 
-    it "should return false if the query's proc is not nil" do
-      Compendium::Query.new(:test, {}, ->{}).should_not be_nil
+    it "should initialize a new Table presenter if the query has results" do
+      subject.stub(empty?: false)
+      Compendium::Presenters::Table.should_receive(:new).with(template, subject).and_return(double("Presenter").as_null_object)
+      subject.render_table(template)
     end
   end
 end

data/spec/report_spec.rb

@@ -129,4 +129,60 @@ describe Compendium::Report do
       end
     end
   end
+
+  describe "predicate methods" do
+    before do
+      OneReport = Class.new(Compendium::Report)
+      TwoReport = Class.new(Compendium::Report)
+      ThreeReport = Class.new
+    end
+
+    after do
+      Object.send(:remove_const, :OneReport)
+      Object.send(:remove_const, :TwoReport)
+      Object.send(:remove_const, :ThreeReport)
+    end
+
+    it { should respond_to(:one?) }
+    it { should respond_to(:two?) }
+    it { should_not respond_to(:three?) }
+
+    it { should_not be_one }
+    it { should_not be_two }
+
+    specify { OneReport.should be_one }
+    specify { TwoReport.should be_two }
+  end
+
+  describe "parameters" do
+    let(:report_class) { Class.new(subject) }
+    let(:report_class2) { Class.new(report_class) }
+
+    it "should include ancestors params" do
+      report_class.params_class.ancestors.should include subject.params_class
+    end
+
+    it "should inherit validations" do
+      report_class.params_class.validates :foo, presence: true
+      report_class2.params_class.validators_on(:foo).should_not be_nil
+    end
+  end
+
+  describe "#valid?" do
+    let(:report_class) do
+      Class.new(described_class) do
+        option :id, :dropdown, choices: (0..10).to_a, validates: { presence: true }
+      end
+    end
+
+    it "should return true if there are no validation failures" do
+      r = report_class.new(id: 5)
+      r.should be_valid
+    end
+
+    it "should return false if there are validation failures" do
+      r = report_class.new(id: nil)
+      r.should_not be_valid
+    end
+  end
 end

data/spec/result_set_spec.rb

@@ -0,0 +1,23 @@
+require 'compendium/result_set'
+
+describe Compendium::ResultSet do
+  describe "#initialize" do
+    subject{ described_class.new(results).records }
+
+    context "when given an array" do
+      let(:results) { [1, 2, 3] }
+      it { should == [1, 2, 3] }
+    end
+
+    context "when given an array of hashes" do
+      let(:results) { [{one: 1}, {two: 2}] }
+      it { should == [{"one" => 1}, {"two" => 2}] }
+      its(:first) { should be_a ActiveSupport::HashWithIndifferentAccess }
+    end
+
+    context "when given a hash" do
+      let(:results) { { one: 1, two: 2 } }
+      it { should == { one: 1, two: 2 } }
+    end
+  end
+end

data/spec/through_query_spec.rb

@@ -0,0 +1,71 @@
+require 'compendium/through_query'
+
+describe Compendium::ThroughQuery do
+  describe "#initialize" do
+    let(:options) { double("Options") }
+    let(:proc) { double("Proc") }
+    let(:through) { double("Query") }
+
+    context "when supplying a report" do
+      let(:r) { Compendium::Report.new }
+      subject { described_class.new(r, :test, through, options, proc)}
+
+      its(:report) { should == r }
+      its(:name) { should == :test }
+      its(:through) { should == through }
+      its(:options) { should == options }
+      its(:proc) { should == proc }
+    end
+
+    context "when not supplying a report" do
+      subject { described_class.new(:test, through, options, proc)}
+
+      its(:report) { should be_nil }
+      its(:name) { should == :test }
+      its(:through) { should == through }
+      its(:options) { should == options }
+      its(:proc) { should == proc }
+    end
+  end
+
+  describe "#run" do
+    let(:parent1) { Compendium::Query.new(:parent1, {}, -> * { }) }
+    let(:parent2) { Compendium::Query.new(:parent2, {}, -> * { }) }
+    let(:parent3) { Compendium::Query.new(:parent3, {}, -> * { [[1, 2, 3]] }) }
+
+    before { parent3.stub(:execute_query) { |cmd| cmd } }
+
+    context "with a single parent" do
+      subject { described_class.new(:sub, parent1, {}, -> r { r.first }) }
+
+      it "should not try to run a through query if the parent query has no results" do
+        expect { subject.run(nil) }.to_not raise_error
+        subject.results.should be_empty
+      end
+    end
+
+    context "with multiple parents" do
+      subject { described_class.new(:sub, [parent1, parent2], {}, -> r { r.first }) }
+
+      it "should not try to run a through query with multiple parents all of which have no results" do
+        expect { subject.run(nil) }.to_not raise_error
+        subject.results.should be_empty
+      end
+
+      it "should allow non blank queries" do
+        subject.through = parent3
+        subject.run(nil)
+        subject.results.should == [1, 2, 3]
+      end
+    end
+
+    context "when the through option is an actual query" do
+      subject { described_class.new(:sub, parent3, {}, -> r { r.first }) }
+
+      before { subject.run(nil) }
+
+      its(:through) { should == parent3 }
+      its(:results) { should == [1, 2, 3] }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compendium
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Daniel Vandersluis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-11 00:00:00.000000000 Z
+date: 2013-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :runtime
@@ -60,12 +60,12 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: 1.0.5
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: 1.0.5
 - !ruby/object:Gem::Dependency
   type: :runtime
   prerelease: false
@@ -129,6 +129,7 @@ files:
 - lib/compendium.rb
 - lib/compendium/abstract_chart_provider.rb
 - lib/compendium/chart_provider/amcharts.rb
+- lib/compendium/collection_query.rb
 - lib/compendium/context_wrapper.rb
 - lib/compendium/dsl.rb
 - lib/compendium/engine.rb
@@ -141,7 +142,9 @@ files:
 - lib/compendium/query.rb
 - lib/compendium/report.rb
 - lib/compendium/result_set.rb
+- lib/compendium/through_query.rb
 - lib/compendium/version.rb
+- spec/collection_query_spec.rb
 - spec/context_wrapper_spec.rb
 - spec/dsl_spec.rb
 - spec/metric_spec.rb
@@ -149,10 +152,13 @@ files:
 - spec/param_types_spec.rb
 - spec/params_spec.rb
 - spec/presenters/base_spec.rb
+- spec/presenters/chart_spec.rb
 - spec/presenters/option_spec.rb
 - spec/query_spec.rb
 - spec/report_spec.rb
+- spec/result_set_spec.rb
 - spec/spec_helper.rb
+- spec/through_query_spec.rb
 homepage: https://github.com/dvandersluis/compendium
 licenses:
 - MIT
@@ -178,6 +184,7 @@ signing_key:
 specification_version: 4
 summary: Ruby on Rails reporting framework
 test_files:
+- spec/collection_query_spec.rb
 - spec/context_wrapper_spec.rb
 - spec/dsl_spec.rb
 - spec/metric_spec.rb
@@ -185,8 +192,11 @@ test_files:
 - spec/param_types_spec.rb
 - spec/params_spec.rb
 - spec/presenters/base_spec.rb
+- spec/presenters/chart_spec.rb
 - spec/presenters/option_spec.rb
 - spec/query_spec.rb
 - spec/report_spec.rb
+- spec/result_set_spec.rb
 - spec/spec_helper.rb
+- spec/through_query_spec.rb
 has_rdoc: