compendium 1.0.4 → 1.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODBjOTg1ZGM3NjVhYTM3ZjcxZDM5YjMyYjI1M2I2MzJjYTkzZmFiNg==
+    OWQyNzhiZThjMTNmZGNiNTg1NzY1YzlhMGUwOGM1ZDllOGU1YzhkYQ==
   data.tar.gz: !binary |-
-    Yzg1ZDk0MmUxYTlkMDg2NTgzYTIxMzEyZjk3NjcxYjYwMzc2ZjhiZQ==
+    NWIyNjQ5YzBjMWI4YTZjMWNjOTEzMmExM2U3OTE5NTI5NTUyYzI0ZQ==
 SHA512:
   metadata.gz: !binary |-
-    ZTA4YTdjYjUwOWE5ZTU3ODVhZmRhMzU2NjViZjZiMGFjZjk3ZDhkYjY0MjIz
-    NjY3ZmVjODkzNGYyNWNiNDY2ODlmZWNiNTI4NGI2MGFhNGIzNThjMzgwZjZl
-    ZTM5MzIzNjVlNDdmY2FiN2U2MTAxZTQwN2Q0NWUxZmFmN2Q2MjM=
+    OWMxY2NjZDlhYmNjMzliNTJjMjE3N2Y3N2EyMmNmNjQ5Nzc3ZWYwZWIwYjli
+    NjBlYTNlMTRlNzRmZDg3NjdjNTUxNmM5NTZhODhhNGFmZjk0ZTg4MTkwMzBi
+    NjMyZDgyZWM5NjUxOWRmYTg4N2UzMjFlNWM0ZGExOTRiZTRiZjE=
   data.tar.gz: !binary |-
-    N2QyNWI2OGU4ZGQ0OWJiODMxZDNhOTA4NDU1NTliOTViNzAxMzQ3MGRlZTAz
-    Y2UxODhjMjUyZTEzNjFhYmI5MzkwZGI3ZTYzNzEwMWM4NWVmNGVlZjJmYjdh
-    NTZkYWJkODVmYzk4OTUzZTVhNjkxNDVjODhjN2QyNmY2N2Q4ZTM=
+    ZWI0OGNlYTkzNmQ2MDQ5ZGE4ZmM0NWY5NmRlZDU0NjNhNzgwNzFkMDI3MjA4
+    OTFkOGZhYzY0ZWZiYWNkMjY0ZDVjMjlmMzJkM2EwYTEzN2NkYTAxNzM5NzA0
+    MDA1Njk3ZDQ5NjAxNWRmNTdkZWE2NWM4NDVhMGE2YzE3ZmNhZDc=

data/app/assets/stylesheets/compendium/_metrics.css.scss

@@ -14,6 +14,7 @@ div.metrics
     text-align: center;
     color: #575757;
     @include border-radius(10px);
+    vertical-align: middle;
 
     .metric-label
     {
@@ -31,6 +32,7 @@ div.metrics
       font-size: 600%;
       font-weight: bold;
       color: black;
+      line-height: 57px;
 
       .metric-data-inner
       {
@@ -86,6 +88,7 @@ div.metrics
       .metric-data
       {
         top: -10px;
+        line-height: 140px;
       }
     }
   }

data/lib/compendium/dsl.rb

@@ -34,11 +34,18 @@ module Compendium
     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|
-        raise ArgumentError, "query #{query} is not defined" unless queries.key?(query)
-        queries[query].add_metric(name, proc, opts)
+      if opts.key?(:through)
+        [opts.delete(:through)].flatten.each do |query|
+          raise ArgumentError, "query #{query} is not defined" unless queries.key?(query)
+          queries[query].add_metric(name, proc, opts)
+        end
+      else
+        # Allow metrics to define queries implicitly
+        # ie. if you need a metric that counts a column, there's no need to explicitly create a query
+        # and just pass it into a metric
+        query = define_query("__metric_#{name}", {}, &block)
+        query.add_metric(name, -> result { result.first }, opts)
       end
     end
 
@@ -91,6 +98,7 @@ module Compendium
 
       metrics[name] = opts[:metric] if opts.key?(:metric)
       queries << query
+      query
     end
 
     def add_params_validations(name, validations)

data/lib/compendium/report.rb

@@ -58,16 +58,16 @@ module Compendium
       self.context = context
       self.results = {}
 
-      only = options.delete(:only)
-      except = options.delete(:except)
+      only = [options.delete(:only)].flatten.compact
+      except = [options.delete(:except)].flatten.compact
 
-      raise ArgumentError, 'cannot specify only and except options at the same time' if only && except
-      ([only] + [except]).flatten.compact.each { |q| raise ArgumentError, 'invalid query #{q}' unless queries.include?(q) }
+      raise ArgumentError, 'cannot specify only and except options at the same time' if !only.empty? and !except.empty?
+      (only + except).flatten.each { |q| raise ArgumentError, "invalid query #{q}" unless queries.include?(q) }
 
-      queries_to_run = if only
-        queries.slice(only)
-      elsif except
-        queries.except(except)
+      queries_to_run = if !only.empty?
+        queries.slice(*only)
+      elsif !except.empty?
+        queries.except(*except)
       else
         queries
       end

data/lib/compendium/result_set.rb

@@ -9,8 +9,12 @@ module Compendium
     alias :all :records
 
     def initialize(records)
-      @records = records.map do |r|
-        r.respond_to?(:with_indifferent_access) ? r.with_indifferent_access : r
+      @records = if records.respond_to?(:map)
+        records.map do |r|
+          r.respond_to?(:with_indifferent_access) ? r.with_indifferent_access : r
+        end
+      else
+        [records]
       end
 
       @records = Hash[@records] if records.is_a?(Hash)

data/lib/compendium/through_query.rb

@@ -13,13 +13,16 @@ module Compendium
   private
 
     def collect_results(context, params)
-      args = collect_through_query_results(params, context)
+      results = 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?
+      return @results = ResultSet.new([]) if results.compact.empty?
 
-      super(context, args)
+      # If the proc collects two arguments, pass results and params, otherwise just results
+      args = !proc || proc.arity == 1 ? [results] : [results, params]
+
+      super(context, *args)
     end
 
     def fetch_results(command)
@@ -33,7 +36,7 @@ module Compendium
 
       queries.each do |q|
         q.run(params, context) unless q.ran?
-        results[q.name] = q.results.records
+        results[q.name] = q.results.records.dup
       end
 
       results = results[queries.first.name] if queries.size == 1

data/lib/compendium/version.rb

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

data/spec/dsl_spec.rb

@@ -129,25 +129,33 @@ describe Compendium::DSL 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
+    context "when through is specified" 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 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
 
-    it "should allow metrics to be defined with a block" do
-      subject.metric :block_metric, through: :test do
-        123
+        subject.queries[:test].metrics[:block_metric].run(self, nil).should == 123
       end
 
-      subject.queries[:test].metrics[:block_metric].run(self, nil).should == 123
+      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 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
+    context "when through is not specified" do
+      before { subject.metric(:no_through_metric) { |data| data } }
+
+      its(:queries) { should include :__metric_no_through_metric }
+
+      it "should return the result of the query as the result of the metric" do
+        subject.queries[:__metric_no_through_metric].metrics[:no_through_metric].run(self, [123]).should == 123
+      end
     end
   end
 

data/spec/report_spec.rb

@@ -39,7 +39,9 @@ describe Compendium::Report do
             [params[:first].__getobj__, params[:second].__getobj__]
           end
 
-          metric :test_metric, -> results { results.to_a.max }, through: :test
+          metric :lambda_metric, -> results { results.to_a.max }, through: :test
+          metric(:block_metric, through: :test) { |results| results.to_a.max }
+          metric(:implicit_metric) { [1, 2, 3].count }
         end
       end
 
@@ -53,14 +55,25 @@ describe Compendium::Report do
 
       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)
+      it "should allow metric results to be accessed through a query" do
+        subject.test.metrics[:lambda_metric].result.should == Date.new(2011, 11, 11)
+      end
+
+      it "should run its metrics defined as a lambda" do
+        subject.metrics[:lambda_metric].result.should == Date.new(2011, 11, 11)
+      end
+
+      it "should run its metrics defined as a block" do
+        subject.metrics[:block_metric].result.should == Date.new(2011, 11, 11)
+      end
+
+      it "should run its implicit metrics" do
+        subject.metrics[:implicit_metric].result.should == 3
       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
+        report2.metrics[:lambda_metric].result.should be_nil
       end
 
       it "should not affect the class collections" do
@@ -122,11 +135,46 @@ describe Compendium::Report do
         subject.second.should_not have_run
       end
 
+      it "should allow multiple queries to be specified by :only" do
+        report_class.query(:third) {}
+        subject.run(nil, only: [:first, :third])
+        subject.first.should have_run
+        subject.second.should_not have_run
+        subject.third.should have_run
+      end
+
+      it "should not run through queries related to a query specified by only if not also specified" do
+        report_class.query(:through, through: :first) {}
+        subject.run(nil, only: :first)
+        subject.through.should_not have_run
+      end
+
+      it "should run through queries related to a query specified by only if also specified" do
+        report_class.query(:through, through: :first) {}
+        subject.run(nil, only: [:first, :through])
+        subject.through.should have_run
+      end
+
       it "should not run queries specified by :except" do
         subject.run(nil, except: :first)
         subject.first.should_not have_run
         subject.second.should have_run
       end
+
+      it "should allow multiple queries to be specified by :except" do
+        report_class.query(:third) {}
+        subject.run(nil, except: [:first, :third])
+        subject.first.should_not have_run
+        subject.second.should have_run
+        subject.third.should_not have_run
+      end
+
+      it "should not run through queries excepted related to a query even if the main query is not excepted" do
+        report_class.query(:through, through: :first) {}
+        subject.run(nil, except: :through)
+        subject.through.should_not have_run
+        subject.first.should have_run
+      end
     end
   end
 

data/spec/result_set_spec.rb

@@ -19,5 +19,10 @@ describe Compendium::ResultSet do
       let(:results) { { one: 1, two: 2 } }
       it { should == { one: 1, two: 2 } }
     end
+
+    context "when given a scalar" do
+      let(:results) { 3 }
+      it { should == [3] }
+    end
   end
 end

data/spec/through_query_spec.rb

@@ -35,6 +35,30 @@ describe Compendium::ThroughQuery do
 
     before { parent3.stub(:execute_query) { |cmd| cmd } }
 
+    it "should pass along the params if the proc collects it" do
+      params = { one: 1, two: 2 }
+      q = described_class.new(:through, parent3, {}, -> r, params { params })
+      q.run(params).should == params
+    end
+
+    it "should pass along the params if the proc has a splat argument" do
+      params = { one: 1, two: 2 }
+      q = described_class.new(:through, parent3, {}, -> *args { args })
+      q.run(params).should == [[[1, 2, 3]], params.with_indifferent_access]
+    end
+
+    it "should not pass along the params if the proc doesn't collects it" do
+      params = { one: 1, two: 2 }
+      q = described_class.new(:through, parent3, {}, -> r { r })
+      q.run(params).should == [[1, 2, 3]]
+    end
+
+    it "should not affect its parent query" do
+      q = described_class.new(:through, parent3, {}, -> r { r.map!{ |i| i * 2 } })
+      q.run(nil).should == [[1, 2, 3, 1, 2, 3]]
+      parent3.results.should == [[1, 2, 3]]
+    end
+
     context "with a single parent" do
       subject { described_class.new(:sub, parent1, {}, -> r { r.first }) }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compendium
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Daniel Vandersluis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-18 00:00:00.000000000 Z
+date: 2013-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :runtime