compendium 0.0.1 → 1.0.0

data/lib/compendium/version.rb

@@ -1,3 +1,3 @@
 module Compendium
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/lib/compendium.rb

@@ -1,5 +1,50 @@
-require "compendium/version"
+require 'compendium/engine'
+require 'compendium/version'
+require 'active_support/configurable'
 
 module Compendium
+  autoload :AbstractChartProvider,  'compendium/abstract_chart_provider'
+  autoload :ChartProvider,          'compendium/abstract_chart_provider'
+  autoload :ContextWrapper,         'compendium/context_wrapper'
+  autoload :DSL,                    'compendium/dsl'
+  autoload :Metric,                 'compendium/metric'
+  autoload :Option,                 'compendium/option'
+  autoload :Params,                 'compendium/params'
+  autoload :Query,                  'compendium/query'
+  autoload :ResultSet,              'compendium/result_set'
+  autoload :Report,                 'compendium/report'
 
+  autoload :Param,                  'compendium/param_types'
+  autoload :BooleanParam,           'compendium/param_types'
+  autoload :DateParam,              'compendium/param_types'
+  autoload :DropdownParam,          'compendium/param_types'
+  autoload :ParamWithChoices,       'compendium/param_types'
+  autoload :RadioParam,             'compendium/param_types'
+
+  def self.reports
+    @reports ||= []
+  end
+
+  # Configures global settings for Compendium
+  #   Compendium.configure do |config|
+  #     config.chart_provider = :AmCharts
+  #   end
+  def self.configure(&block)
+    yield @config ||= Compendium::Configuration.new
+  end
+
+  def self.config
+    @config
+  end
+
+  # need a Class for 3.0
+  class Configuration #:nodoc:
+    include ActiveSupport::Configurable
+
+    config_accessor :chart_provider
+  end
+
+  configure do |config|
+    config.chart_provider = Compendium::AbstractChartProvider.find_chart_provider
+  end
 end

data/spec/context_wrapper_spec.rb

@@ -0,0 +1,71 @@
+require 'compendium/context_wrapper'
+
+class Wrapper1
+  def test_val
+    123
+  end
+end
+
+class Wrapper2
+  def wrapped
+    true
+  end
+end
+
+class Wrapper3
+  def wrapper_num
+    3
+  end
+end
+
+class Wrapper4
+  def wrapper_num
+    4
+  end
+end
+
+describe Compendium::ContextWrapper do
+  describe ".wrap" do
+    let(:w1) { Wrapper1.new }
+    let(:w2) { Wrapper2.new }
+    let(:w3) { Wrapper3.new }
+    let(:w4) { Wrapper4.new }
+
+    subject { described_class.wrap(w2, w1) }
+
+    it { should respond_to :test_val }
+    it { should respond_to :wrapped }
+
+    its(:test_val) { should == 123 }
+    its(:wrapped) { should == true }
+
+    it "should not affect the original objects" do
+      subject
+      w1.should_not respond_to :wrapped
+      w2.should_not respond_to :test_val
+    end
+
+    it "should yield a block if given" do
+      described_class.wrap(w2, w1) { test_val }.should == 123
+    end
+
+    context "overriding methods" do
+      subject { described_class.wrap(w4, w3) }
+      its(:wrapper_num) { should == 4 }
+    end
+
+    context "nested wrapping" do
+      let(:inner) { described_class.wrap(w2, w1) }
+      subject { described_class.wrap(inner, w3) }
+
+      it { should respond_to :test_val }
+      it { should respond_to :wrapped }
+      it { should respond_to :wrapper_num }
+
+      it "should not extend the inner wrap" do
+        subject
+        inner.should_not respond_to :wrapper_num
+      end
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,90 @@
+require 'compendium'
+require 'compendium/dsl'
+
+describe Compendium::DSL do
+  subject do
+    Class.new do
+      extend Compendium::DSL
+    end
+  end
+
+  describe "#option" do
+    before { subject.option :starting_on, :date }
+
+    its(:options) { should include :starting_on }
+    specify { subject.options[:starting_on].should be_date }
+
+    it "should allow previously defined options to be redefined" do
+      subject.option :starting_on, :boolean
+      subject.options[:starting_on].should be_boolean
+      subject.options[:starting_on].should_not be_date
+    end
+  end
+
+  describe "#query" do
+    subject do
+      Class.new(Compendium::Report) do
+        query :test
+      end
+    end
+
+    its(:queries) { should include :test }
+
+    it "should relate the new query back to the report instance" do
+      r = subject.new
+      r.test.report.should == r
+    end
+
+    it "should not relate a query to the report class" do
+      subject.test.report.should be_nil
+    end
+  end
+
+  describe "#chart" do
+    before { subject.chart(:chart) }
+
+    its(:queries) { should include :chart }
+  end
+
+  describe "#data" do
+    before { subject.data(:data) }
+
+    its(:queries) { should include :data }
+  end
+
+  describe "#metric" do
+    let(:metric_proc) { ->{ :metric } }
+
+    before do
+      subject.query :test
+      subject.metric :test_metric, metric_proc, through: :test
+    end
+
+    it "should add a metric to the given query" do
+      subject.queries[:test].metrics.first.name.should == :test_metric
+    end
+
+    it "should set the metric command" do
+      subject.queries[:test].metrics.first.command.should == metric_proc
+    end
+
+    it "should raise an error if through is not specified" do
+      expect{ subject.metric :test_metric, metric_proc }.to raise_error ArgumentError, 'through option must be specified for metric'
+    end
+
+    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
+  end
+
+  it "should allow previously defined queries to be redefined by name" do
+    subject.query :test_query
+    subject.test_query foo: :bar
+    subject.queries[:test_query].options.should == { foo: :bar }
+  end
+
+  it "should allow previously defined queries to be accessed by name" do
+    subject.query :test_query
+    subject.test_query.should == subject.queries[:test_query]
+  end
+end

data/spec/metric_spec.rb

@@ -0,0 +1,84 @@
+require 'compendium/metric'
+
+class MetricContext
+  def calculate(data)
+    data.first.first
+  end
+end
+
+describe Compendium::Metric do
+  let(:ctx) { MetricContext.new }
+  let(:data) { [[1, 2, 3], [4, 5, 6]] }
+
+  subject { described_class.new(:test_metric, :query, nil) }
+
+  describe "#run" do
+    it "should delegate the command to the context when the command is a symbol" do
+      subject.command = :calculate
+      subject.run(ctx, data).should == 1
+    end
+
+    it "should call the command when it is a proc" do
+      subject.command = -> d { d.flatten.inject(:+) }
+      subject.run(ctx, data).should == 21
+    end
+
+    it "should allow procs that refer back to the context" do
+      subject.command = -> d { calculate(d) * 2 }
+      subject.run(ctx, data).should == 2
+    end
+
+    context "when an if proc is given" do
+      before { subject.command = -> * { 100 } }
+
+      it "should calculate the metric if the proc evaluates to true" do
+        subject.options[:if] = ->{ true }
+        subject.run(ctx, data).should == 100
+      end
+
+      it "should not calculate the metric if the proc evaluates to false" do
+        subject.options[:if] = ->{ false }
+        subject.run(ctx, data).should be_nil
+      end
+
+      it "should clear the result if the proc evaluates to false" do
+        subject.options[:if] = ->{ false }
+        subject.result = 123
+        subject.run(ctx, data)
+        subject.result.should be_nil
+      end
+    end
+
+    context "when an unless proc is given" do
+      before { subject.command = -> * { 100 } }
+
+      it "should calculate the metric if the proc evaluates to false" do
+        subject.options[:unless] = ->{ false }
+        subject.run(ctx, data).should == 100
+      end
+
+      it "should not calculate the metric if the proc evaluates to true" do
+        subject.options[:unless] = ->{ true }
+        subject.run(ctx, data).should be_nil
+      end
+
+      it "should clear the result if the proc evaluates to false" do
+        subject.options[:unless] = ->{ true }
+        subject.result = 123
+        subject.run(ctx, data)
+        subject.result.should be_nil
+      end
+    end
+  end
+
+  describe "#ran?" do
+    it "should return true if there are any results" do
+      subject.stub(result: 123)
+      subject.should have_ran
+    end
+
+    it "should return false if there are no results" do
+      subject.should_not have_ran
+    end
+  end
+end

data/spec/option_spec.rb

@@ -0,0 +1,12 @@
+require 'compendium/option'
+
+describe Compendium::Option do
+  it "should raise an ArgumentError if no name is given" do
+    expect { described_class.new }.to raise_error ArgumentError, "name must be provided"
+  end
+
+  it "should set up type predicates from the type option" do
+    o = described_class.new(name: :option, type: :date)
+    o.should be_date
+  end
+end

data/spec/param_types_spec.rb

@@ -0,0 +1,147 @@
+require 'compendium/param_types'
+
+describe Compendium::Param do
+  subject{ described_class.new(:test) }
+
+  it { should_not be_boolean }
+  it { should_not be_date }
+  it { should_not be_dropdown }
+  it { should_not be_radio }
+
+  describe "#==" do
+    it "should compare to the param's value" do
+      subject.stub(value: :test_value)
+      subject.should == :test_value
+    end
+  end
+end
+
+describe Compendium::ParamWithChoices do
+  subject{ described_class.new(0, %w(a b c)) }
+
+  it { should_not be_boolean }
+  it { should_not be_date }
+  it { should_not be_dropdown }
+  it { should_not be_radio }
+
+  it "should return the index when given an index" do
+    p = described_class.new(1, [:foo, :bar, :baz])
+    p.should == 1
+  end
+
+  it "should return the index when given a value" do
+    p = described_class.new(:foo, [:foo, :bar, :baz])
+    p.should == 0
+  end
+
+  it "should return the index when given a string value" do
+    p = described_class.new("2", [:foo, :bar, :baz])
+    p.should == 2
+  end
+
+  it "should raise an error if given an invalid index" do
+    expect { described_class.new(3, [:foo, :bar, :baz]) }.to raise_error IndexError
+  end
+
+  it "should raise an error if given a value that is not included in the choices" do
+    expect { described_class.new(:quux, [:foo, :bar, :baz]) }.to raise_error IndexError
+  end
+
+  describe "#value" do
+    it "should return the value of the given choice" do
+      p = described_class.new(2, [:foo, :bar, :baz])
+      p.value.should == :baz
+    end
+  end
+end
+
+describe Compendium::BooleanParam do
+  subject{ described_class.new(true) }
+
+  it { should be_boolean }
+  it { should_not be_date }
+  it { should_not be_dropdown }
+  it { should_not be_radio }
+
+  it "should pass along 0 and 1" do
+    described_class.new(0).should == 0
+    described_class.new(1).should == 1
+  end
+
+  it "should convert a numeric string to a number" do
+    described_class.new('0').should == 0
+    described_class.new('1').should == 1
+  end
+
+  it "should return 0 for a truthy value" do
+    described_class.new(true).should == 0
+    described_class.new(:abc).should == 0
+  end
+
+  it "should return 1 for a falsey value" do
+    described_class.new(false).should == 1
+    described_class.new(nil).should == 1
+  end
+
+  describe "#value" do
+    it "should return true for a truthy value" do
+      described_class.new(true).value.should == true
+      described_class.new(:abc).value.should == true
+      described_class.new(0).value.should == true
+    end
+
+    it "should return false for a falsey value" do
+      described_class.new(false).value.should == false
+      described_class.new(nil).value.should == false
+      described_class.new(1).value.should == false
+    end
+  end
+
+  describe "#!" do
+    it "should return false if the boolean is true" do
+      !described_class.new(true).should == false
+    end
+
+    it "should return true if the boolean is false" do
+
+    end
+  end
+end
+
+describe Compendium::DateParam do
+  subject{ described_class.new(Date.today) }
+
+  it { should_not be_boolean }
+  it { should be_date }
+  it { should_not be_dropdown }
+  it { should_not be_radio }
+
+  it "should convert date strings to date objects" do
+    p = described_class.new("2010-05-20")
+    p.should == Date.new(2010, 5, 20)
+  end
+
+  it "should convert other date/time formats to date objects" do
+    described_class.new(DateTime.new(2010, 5, 20, 10, 30, 59)) == Date.new(2010, 5, 20)
+    described_class.new(Time.new(2010, 5, 20, 10, 30, 59)) == Date.new(2010, 5, 20)
+    described_class.new(Date.new(2010, 5, 20)) == Date.new(2010, 5, 20)
+  end
+end
+
+describe Compendium::DropdownParam do
+  subject{ described_class.new(0, %w(a b c)) }
+
+  it { should_not be_boolean }
+  it { should_not be_date }
+  it { should be_dropdown }
+  it { should_not be_radio }
+end
+
+describe Compendium::RadioParam do
+  subject{ described_class.new(0, %w(a b c)) }
+
+  it { should_not be_boolean }
+  it { should_not be_date }
+  it { should_not be_dropdown }
+  it { should be_radio }
+end

data/spec/params_spec.rb

@@ -0,0 +1,28 @@
+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)
+  } }
+
+  subject{ described_class.new(@params, options) }
+
+  it "should only allow keys that are given as options" do
+    @params = { starting_on: '2013-10-15', foo: :bar }
+    subject.keys.should_not include :foo
+  end
+
+  it "should set missing options to their default value" do
+    @params = {}
+    subject.starting_on.should == Date.today
+  end
+
+  it "should set missing options to nil if there is no default value" do
+    @params = {}
+    subject.ending_on.should be_nil
+  end
+end

data/spec/presenters/base_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'compendium/presenters/base'
+
+TestPresenter = Class.new(Compendium::Presenters::Base) do
+  presents :test_obj
+end
+
+describe Compendium::Presenters::Base do
+  let(:template) { double("Template", delegated?: true) }
+  subject { TestPresenter.new(template, :test) }
+
+  it "should allow the object name to be overridden" do
+    subject.test_obj.should == :test
+  end
+
+  it "should delegate missing methods to the template object" do
+    template.should_receive(:delegated?)
+    subject.should be_delegated
+  end
+end

data/spec/presenters/option_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'compendium/presenters/option'
+require 'compendium/option'
+
+describe Compendium::Presenters::Option do
+  let(:template) do
+    t = double('Template')
+    t.stub(:t) { |key| key } # Stub I18n.t to just return the given value
+    t
+  end
+
+  let(:option) { Compendium::Option.new(name: :test_option) }
+
+  subject { described_class.new(template, option) }
+
+  describe "#name" do
+    it "should pass the name through I18n" do
+      template.should_receive(:t).with(:test_option)
+      subject.name
+    end
+  end
+
+  describe "#note" do
+    before { template.stub(:content_tag) }
+
+    it "should return nil if no note is specified" do
+      subject.note.should be_nil
+    end
+
+    it "should pass to I18n if the note option is set to true" do
+      option.merge!(note: true)
+      template.should_receive(:t).with(:test_option_note)
+      subject.note
+    end
+
+    it "should pass to I18n if the note option is set" do
+      option.merge!(note: :the_note)
+      template.should_receive(:t).with(:the_note)
+      subject.note
+    end
+
+    it "should create the note within a div with class option-note" do
+      option.merge!(note: true)
+      template.should_receive(:content_tag).with(:div, anything, class: 'option-note')
+      subject.note
+    end
+  end
+end
+

data/spec/query_spec.rb

@@ -0,0 +1,33 @@
+require 'compendium/query'
+
+describe Compendium::Query do
+  describe "#run" do
+    let(:query) { described_class.new(:test, {}, -> * { [1, 2, 3] }) }
+    before { query.stub(:fetch_results) { |c| c } }
+
+    it "should return the result of the query" do
+      query.run(nil).should == [1, 2, 3]
+    end
+
+    it "should mark the query as having ran" do
+      query.run(nil)
+      query.should have_run
+    end
+
+    it "should not affect any cloned queries" do
+      q2 = query.clone
+      query.run(nil)
+      q2.should_not have_run
+    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
+    end
+
+    it "should return false if the query's proc is not nil" do
+      Compendium::Query.new(:test, {}, ->{}).should_not be_nil
+    end
+  end
+end

data/spec/report_spec.rb

@@ -0,0 +1,93 @@
+require 'compendium/report'
+
+describe Compendium::Report do
+  subject { described_class }
+
+  its(:queries) { should be_empty }
+  its(:options) { should be_empty }
+
+  it "should not do anything when run" do
+    report = subject.new
+    report.run
+    report.results.should be_empty
+  end
+
+  context "with multiple instances" do
+    let(:report_class) do
+      Class.new(Compendium::Report) do
+        query :test
+        metric :test_metric, ->{}, through: :test
+      end
+    end
+
+    subject { report_class.new }
+    let(:report2) { report_class.new }
+
+    its(:queries) { should_not equal report2.queries }
+    its(:queries) { should_not equal report_class.queries }
+    its(:metrics) { should_not equal report2.metrics }
+  end
+
+  describe "#run" do
+    let(:report_class) do
+      Class.new(Compendium::Report) do
+        option :first, :date
+        option :second, :date
+
+        query :test do |params|
+          [params[:first].__getobj__, params[:second].__getobj__]
+        end
+
+        metric :test_metric, -> results { results.to_a.max }, through: :test
+      end
+    end
+
+    subject { report_class.new(first: '2010-10-10', second: '2011-11-11') }
+    let!(:report2) { report_class.new }
+
+    before do
+      Compendium::Query.any_instance.stub(:fetch_results) { |c| c }
+      subject.run
+    end
+
+    its('test_results.records') { should == [Date.new(2010, 10, 10), Date.new(2011, 11, 11)] }
+
+    it "should run its metrics" do
+      subject.test.metrics[:test_metric].result.should == Date.new(2011, 11, 11)
+      subject.metrics[:test_metric].result.should == Date.new(2011, 11, 11)
+    end
+
+    it "should not affect other instances of the report class" do
+      report2.test.results.should be_nil
+      report2.metrics[:test_metric].result.should be_nil
+    end
+
+    it "should not affect the class collections" do
+      report_class.test.results.should be_nil
+    end
+
+    context "with through queries" do
+      let(:report_class) do
+        Class.new(Compendium::Report) do
+          option :first, :boolean, default: false
+          query(:test) { |params| !!params[:first] ? [100, 200, 400, 800] : [1600, 3200, 6400]}
+          query(:through, through: :test) { |results| [results.first] }
+        end
+      end
+
+      subject { report_class.new(first: true) }
+
+      its('through.results') { should == [100] }
+
+      it "should not mark other instances' queries as ran" do
+        report2.test.should_not have_run
+      end
+
+      it "should not affect other instances" do
+        report2.queries.each { |q| q.stub(:fetch_results) { |c| c } }
+        report2.run
+        report2.through.results.should == [1600]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$:.unshift File.expand_path("../../app/classes", __FILE__)