active_reporter 0.6.1 → 0.6.5

data/spec/active_reporter/dimension/base_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Base do
   def new_dimension(dimension_params = {}, report_params = {}, opts = {})
@@ -10,18 +10,18 @@ describe ActiveReporter::Dimension::Base do
     )
   end
 
-  describe '#filter_values' do
-    it 'accepts one' do
-      dimension = new_dimension(only: 'bar')
+  describe "#filter_values" do
+    it "accepts one" do
+      dimension = new_dimension(only: "bar")
       expect(dimension.filter_values).to eq %w(bar)
     end
 
-    it 'accepts many' do
+    it "accepts many" do
       dimension = new_dimension(only: %w(bar baz))
       expect(dimension.filter_values).to eq %w(bar baz)
     end
 
-    it 'determines #filtering?' do
+    it "determines #filtering?" do
       dimension = new_dimension(only: %w(bar baz))
       expect(dimension).to be_filtering
 
@@ -30,42 +30,42 @@ describe ActiveReporter::Dimension::Base do
     end
   end
 
-  describe '#sort_order' do
-    it 'can be desc/asc, falls back to root, defaults to asc' do
+  describe "#sort_order" do
+    it "can be desc/asc, falls back to root, defaults to asc" do
       dimension = new_dimension
-      expect(dimension.sort_order).to eq 'ASC'
+      expect(dimension.sort_order).to eq "ASC"
 
       dimension = new_dimension(sort_desc: true)
-      expect(dimension.sort_order).to eq 'DESC'
+      expect(dimension.sort_order).to eq "DESC"
 
       dimension = new_dimension(sort_desc: false)
-      expect(dimension.sort_order).to eq 'ASC'
+      expect(dimension.sort_order).to eq "ASC"
 
       dimension = new_dimension({}, sort_desc: true)
-      expect(dimension.sort_order).to eq 'DESC'
+      expect(dimension.sort_order).to eq "DESC"
 
       dimension = new_dimension({}, sort_desc: false)
-      expect(dimension.sort_order).to eq 'ASC'
+      expect(dimension.sort_order).to eq "ASC"
     end
   end
 
-  describe '#null_order' do
-    it 'can be first/last, falls back to root, defaults to first (only if postgres)' do
+  describe "#null_order" do
+    it "can be first/last, falls back to root, defaults to first (only if postgres)" do
       if ActiveReporter.database_type == :postgres
         dimension = new_dimension
-        expect(dimension.null_order).to eq 'NULLS FIRST'
+        expect(dimension.null_order).to eq "NULLS FIRST"
 
         dimension = new_dimension(nulls_last: true)
-        expect(dimension.null_order).to eq 'NULLS LAST'
+        expect(dimension.null_order).to eq "NULLS LAST"
 
         dimension = new_dimension(nulls_last: false)
-        expect(dimension.null_order).to eq 'NULLS FIRST'
+        expect(dimension.null_order).to eq "NULLS FIRST"
 
         dimension = new_dimension({}, nulls_last: true)
-        expect(dimension.null_order).to eq 'NULLS LAST'
+        expect(dimension.null_order).to eq "NULLS LAST"
 
         dimension = new_dimension({}, nulls_last: false)
-        expect(dimension.null_order).to eq 'NULLS FIRST'
+        expect(dimension.null_order).to eq "NULLS FIRST"
       else
         dimension = new_dimension
         expect(dimension.null_order).to be_blank
@@ -73,30 +73,30 @@ describe ActiveReporter::Dimension::Base do
     end
   end
 
-  describe '#relate' do
-    it 'defaults to the identity function' do
+  describe "#relate" do
+    it "defaults to the identity function" do
       dimension = new_dimension
       expect(dimension.relate(5)).to eq 5
     end
 
-    it 'can be overridden, e.g. for joins' do
+    it "can be overridden, e.g. for joins" do
       dimension = new_dimension({}, {}, relation: ->(r) { r + 5 })
       expect(dimension.relate(5)).to eq 10
     end
   end
 
-  describe '#expression' do
-    it 'defaults to treating name as a column of the report klass table' do
+  describe "#expression" do
+    it "defaults to treating name as a column of the report klass table" do
       dimension = ActiveReporter::Dimension::Base.new(
         :bar,
-        OpenStruct.new(table_name: 'foo')
+        OpenStruct.new(table_name: "foo")
       )
-      expect(dimension.expression).to eq('foo.bar')
+      expect(dimension.expression).to eq("foo.bar")
     end
 
-    it 'can be overridden' do
+    it "can be overridden" do
       dimension = new_dimension({}, {}, table_name: :baz, attribute: :bat)
-      expect(dimension.expression).to eq 'baz.bat'
+      expect(dimension.expression).to eq "baz.bat"
     end
   end
 end

data/spec/active_reporter/dimension/bin/set_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Bin::Set do
-  describe '.from_hash' do
-    it 'builds a bin from a hash or nil' do
+  describe ".from_hash" do
+    it "builds a bin from a hash or nil" do
       bin = described_class.from_hash(min: 1, max: 2)
       expect(bin.min).to eq 1
       expect(bin.max).to eq 2
@@ -13,19 +13,19 @@ describe ActiveReporter::Dimension::Bin::Set do
     end
   end
 
-  describe '.from_sql' do
-    it 'builds a bin from a bin text string' do
+  describe ".from_sql" do
+    it "builds a bin from a bin text string" do
       bin = described_class.from_sql("1,2")
-      expect(bin.min).to eq '1'
-      expect(bin.max).to eq '2'
+      expect(bin.min).to eq "1"
+      expect(bin.max).to eq "2"
 
       bin = described_class.from_sql("1,")
-      expect(bin.min).to eq '1'
+      expect(bin.min).to eq "1"
       expect(bin.max).to eq nil
 
       bin = described_class.from_sql(",2")
       expect(bin.min).to eq nil
-      expect(bin.max).to eq '2'
+      expect(bin.max).to eq "2"
 
       bin = described_class.from_sql(",")
       expect(bin.min).to eq nil
@@ -33,51 +33,51 @@ describe ActiveReporter::Dimension::Bin::Set do
     end
   end
 
-  describe '#contains_sql' do
-    it 'returns SQL checking if expr is in the bin' do
+  describe "#contains_sql" do
+    it "returns SQL checking if expr is in the bin" do
       bin = described_class.new(1, 2)
-      expect(bin.contains_sql('foo')).to eq "(foo >= 1 AND foo < 2)"
+      expect(bin.contains_sql("foo")).to eq "(foo >= 1 AND foo < 2)"
 
       bin = described_class.new(1, nil)
-      expect(bin.contains_sql('foo')).to eq "foo >= 1"
+      expect(bin.contains_sql("foo")).to eq "foo >= 1"
 
       bin = described_class.new(nil, 2)
-      expect(bin.contains_sql('foo')).to eq "foo < 2"
+      expect(bin.contains_sql("foo")).to eq "foo < 2"
 
       bin = described_class.new(nil, nil)
-      expect(bin.contains_sql('foo')).to eq "foo IS NULL"
+      expect(bin.contains_sql("foo")).to eq "foo IS NULL"
     end
   end
 
-  describe '#to_json' do
-    it 'reexpresses the bin as a hash' do
+  describe "#to_json" do
+    it "reexpresses the bin as a hash" do
       bin = described_class.new(1, 2)
       json = { a: bin }.to_json
-      expect(JSON.parse(json)).to eq('a' => { 'min' => 1, 'max' => 2 })
+      expect(JSON.parse(json)).to eq("a" => { "min" => 1, "max" => 2 })
     end
   end
 
-  describe 'hashing' do
-    it 'works with hashes' do
+  describe "hashing" do
+    it "works with hashes" do
       bin1 = described_class.new(1, 2)
       bin2 = described_class.new(1, 2)
       bin3 = { min: 1, max: 2 }
 
-      h = { bin3 => 'foo' }
-      expect(h[bin1]).to eq 'foo'
-      expect(h[bin2]).to eq 'foo'
-      expect(h[bin3]).to eq 'foo'
+      h = { bin3 => "foo" }
+      expect(h[bin1]).to eq "foo"
+      expect(h[bin2]).to eq "foo"
+      expect(h[bin3]).to eq "foo"
     end
 
-    it 'works with nil' do
+    it "works with nil" do
       bin1 = described_class.new(nil, nil)
       bin2 = described_class.new(nil, nil)
       bin3 = nil
 
-      h = { bin3 => 'foo' }
-      expect(h[bin1]).to eq 'foo'
-      expect(h[bin2]).to eq 'foo'
-      expect(h[bin3]).to eq 'foo'
+      h = { bin3 => "foo" }
+      expect(h[bin1]).to eq "foo"
+      expect(h[bin2]).to eq "foo"
+      expect(h[bin3]).to eq "foo"
     end
   end
 end

data/spec/active_reporter/dimension/bin/table_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Bin::Table do
   let(:bin_set) { ActiveReporter::Dimension::Bin::Set }
 
-  describe '#filter' do
-    it 'ORs together predicates across bins' do
+  describe "#filter" do
+    it "ORs together predicates across bins" do
       table = described_class.new([
         bin_set.new(nil, nil),
         bin_set.new(0, nil),
@@ -12,14 +12,14 @@ describe ActiveReporter::Dimension::Bin::Table do
         bin_set.new(3, 5)
       ])
 
-      sql = table.filter(Post, 'x').to_sql
+      sql = table.filter(Post, "x").to_sql
 
       expect(sql).to include "WHERE (x IS NULL OR x >= 0 OR x < 10 OR (x >= 3 AND x < 5))"
     end
   end
 
-  describe '#group' do
-    it 'joins to a union of bin rows, then groups by the range' do
+  describe "#group" do
+    it "joins to a union of bin rows, then groups by the range" do
       table = described_class.new([
         bin_set.new(nil, nil),
         bin_set.new(0, nil),
@@ -27,7 +27,7 @@ describe ActiveReporter::Dimension::Bin::Table do
         bin_set.new(3, 5)
       ])
 
-      sql = table.group(Post, 'likes', 'likes').to_sql
+      sql = table.group(Post, "likes", "likes").to_sql
 
       expect(sql).to start_with "SELECT likes_bin_table.bin_text AS likes"
 

data/spec/active_reporter/dimension/bin_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Bin do
   def new_dimension(dimension_params = {}, report_params = {}, opts = {})
@@ -13,23 +13,23 @@ describe ActiveReporter::Dimension::Bin do
     expect { yield }.to raise_error(ActiveReporter::InvalidParamsError)
   end
 
-  describe 'param validation' do
-    it 'yells unless :bin_count is numeric' do
-      expect_error { new_dimension(bin_count: 'hey') }
+  describe "param validation" do
+    it "yells unless :bin_count is numeric" do
+      expect_error { new_dimension(bin_count: "hey") }
       expect_error { new_dimension(bin_count: nil) }
       new_dimension(bin_count: 5)
       new_dimension(bin_count: 1.24)
     end
   end
 
-  describe '#min/max' do
-    it 'finds the extremes in filter_values' do
+  describe "#min/max" do
+    it "finds the extremes in filter_values" do
       dimension = new_dimension(only: [{ min: 1, max: 3 }, { min: -3 }, { min: 17, max: 40 }])
       expect(dimension.min).to eq -3
       expect(dimension.max).to eq 40
     end
 
-    it 'falls back to the smallest value in the data' do
+    it "falls back to the smallest value in the data" do
       dimension = ActiveReporter::Dimension::Bin.new(:likes,
         OpenStruct.new(records: Post, params: {}),
         model: :post, attribute: :likes
@@ -44,8 +44,8 @@ describe ActiveReporter::Dimension::Bin do
     end
   end
 
-  describe '#group_values' do
-    it 'defaults to dividing the domain into bins of bin_width' do
+  describe "#group_values" do
+    it "defaults to dividing the domain into bins of bin_width" do
       dimension = new_dimension(only: { min: 0, max: 3 })
       allow(dimension).to receive(:bin_width).and_return(1)
       allow(dimension).to receive(:data_contains_nil?).and_return(false)
@@ -56,10 +56,10 @@ describe ActiveReporter::Dimension::Bin do
       ]
     end
 
-    it 'is inclusive of max if data-driven' do
+    it "is inclusive of max if data-driven" do
       dimension = new_dimension(only: { min: 0 })
       allow(dimension.report).to receive(:records).and_return(Post)
-      allow(dimension).to receive(:expression).and_return('posts.likes')
+      allow(dimension).to receive(:expression).and_return("posts.likes")
       allow(dimension).to receive(:bin_width).and_return(1)
       create(:post, likes: 2)
       expect(dimension.group_values).to eq [
@@ -69,7 +69,7 @@ describe ActiveReporter::Dimension::Bin do
       ]
     end
 
-    it 'can be customized' do
+    it "can be customized" do
       dimension = new_dimension(bins: { min: 0, max: 1 })
       expect(dimension.group_values).to eq [{ min: 0, max: 1 }]
     end

data/spec/active_reporter/dimension/category_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Category do
   def author_dimension(report)
@@ -6,53 +6,53 @@ describe ActiveReporter::Dimension::Category do
       "LEFT OUTER JOIN authors ON authors.id = posts.author_id") })
   end
 
-  describe '#filter' do
-    it 'filters to rows matching at least one value' do
-      p1 = create(:post, author: 'Alice')
-      p2 = create(:post, author: 'Bob')
+  describe "#filter" do
+    it "filters to rows matching at least one value" do
+      p1 = create(:post, author: "Alice")
+      p2 = create(:post, author: "Bob")
       p3 = create(:post, author: nil)
 
       def filter_by(author_values)
         report = OpenStruct.new(
-          table_name: 'posts',
+          table_name: "posts",
           params: { dimensions: { author: { only: author_values } } }
         )
         dimension = author_dimension(report)
         dimension.filter(dimension.relate(Post))
       end
 
-      expect(filter_by(['Alice'])).to eq [p1]
+      expect(filter_by(["Alice"])).to eq [p1]
       expect(filter_by([nil])).to eq [p3]
-      expect(filter_by(['Alice', nil])).to eq [p1, p3]
-      expect(filter_by(['Alice', 'Bob'])).to eq [p1, p2]
+      expect(filter_by(["Alice", nil])).to eq [p1, p3]
+      expect(filter_by(["Alice", "Bob"])).to eq [p1, p2]
       expect(filter_by([])).to eq []
     end
   end
 
-  describe '#group' do
-    it 'groups the relation by the exact value of the SQL expression' do
-      p1 = create(:post, author: 'Alice')
-      p2 = create(:post, author: 'Alice')
+  describe "#group" do
+    it "groups the relation by the exact value of the SQL expression" do
+      p1 = create(:post, author: "Alice")
+      p2 = create(:post, author: "Alice")
       p3 = create(:post, author: nil)
-      p4 = create(:post, author: 'Bob')
-      p5 = create(:post, author: 'Bob')
-      p6 = create(:post, author: 'Bob')
+      p4 = create(:post, author: "Bob")
+      p5 = create(:post, author: "Bob")
+      p6 = create(:post, author: "Bob")
 
-      report = OpenStruct.new(table_name: 'posts', params: {})
+      report = OpenStruct.new(table_name: "posts", params: {})
       dimension = author_dimension(report)
 
       results = dimension.group(dimension.relate(Post)).select("COUNT(*) AS count").map do |r|
-        r.attributes.values_at(dimension.send(:sql_value_name), 'count')
+        r.attributes.values_at(dimension.send(:sql_value_name), "count")
       end
 
-      expect(results).to eq [[nil, 1], ['Alice', 2], ['Bob', 3]]
+      expect(results).to eq [[nil, 1], ["Alice", 2], ["Bob", 3]]
     end
   end
 
-  describe '#group_values' do
-    it 'echoes filter_values if filtering' do
+  describe "#group_values" do
+    it "echoes filter_values if filtering" do
       dimension = author_dimension(OpenStruct.new(params: {
-        dimensions: { author: { only: ['foo', 'bar'] } }
+        dimensions: { author: { only: ["foo", "bar"] } }
       }))
       expect(dimension.group_values).to eq %w(foo bar)
     end

data/spec/active_reporter/dimension/enum_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Enum do
   let(:report_model) { :post }
@@ -7,12 +7,12 @@ describe ActiveReporter::Dimension::Enum do
   let(:report) { OpenStruct.new(params: { dimensions: { status: status_dimension_options } }, groupers: [:status, :category], raw_data: raw_data) }
 
   let(:raw_data) { {
-    ['published', 'post_count'] => 5, ['published', 'post_total'] => 500.00, ['published', 'post_average'] => 100.00,
-    ['archived', 'post_count'] => 7, ['archived', 'post_total'] => 530.25, ['archived', 'post_average'] => 75.75,
+    ["published", "post_count"] => 5, ["published", "post_total"] => 500.00, ["published", "post_average"] => 100.00,
+    ["archived", "post_count"] => 7, ["archived", "post_total"] => 530.25, ["archived", "post_average"] => 75.75,
   } }
 
-  let(:enum_values) { { 'draft' => 0, 'unpublished' => 1, 'published' => 2, 'archived' => 3 } }
-  let(:group_values) { ['published', 'archived'] }
+  let(:enum_values) { { "draft" => 0, "unpublished" => 1, "published" => 2, "archived" => 3 } }
+  let(:group_values) { ["published", "archived"] }
   let(:all_values) { enum_values.keys.unshift(nil) }
   
   let(:status_dimension) do
@@ -23,24 +23,24 @@ describe ActiveReporter::Dimension::Enum do
     dimension
   end
 
-  describe '#group_values' do
-    context 'when filtering' do
-      let(:filter_values) { ['unpublished', 'published', 'archived'] }
+  describe "#group_values" do
+    context "when filtering" do
+      let(:filter_values) { ["unpublished", "published", "archived"] }
 
-      it 'returns filter_values' do
+      it "returns filter_values" do
         expect(status_dimension).to be_filtering
         expect(status_dimension.group_values).to eq filter_values
       end
     end
 
-    it 'returns group enum values' do
+    it "returns group enum values" do
       expect(status_dimension).not_to be_filtering
       expect(status_dimension.group_values).to match group_values
     end
   end
 
-  describe '#all_values' do
-    it 'returns model enum values' do
+  describe "#all_values" do
+    it "returns model enum values" do
       expect(status_dimension.all_values).to match all_values
     end
   end

data/spec/active_reporter/dimension/number_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Number do
   def new_dimension(dimension_params = {}, report_params = {}, opts = {})
@@ -14,23 +14,23 @@ describe ActiveReporter::Dimension::Number do
     expect { yield }.to raise_error(ActiveReporter::InvalidParamsError)
   end
 
-  describe 'param validation' do
-    it 'yells unless :bin_width is numeric' do
-      expect_error { new_dimension(bin_width: '') }
-      expect_error { new_dimension(bin_width: '49er') }
+  describe "param validation" do
+    it "yells unless :bin_width is numeric" do
+      expect_error { new_dimension(bin_width: "") }
+      expect_error { new_dimension(bin_width: "49er") }
       expect_error { new_dimension(bin_width: { seconds: 1 }) }
       expect(new_dimension(bin_width: 10.5).bin_width).to eq 10.5
-      expect(new_dimension(bin_width: '10').bin_width).to eq 10.0
+      expect(new_dimension(bin_width: "10").bin_width).to eq 10.0
     end
   end
 
-  describe '#bin_width' do
-    it 'reads from params' do
+  describe "#bin_width" do
+    it "reads from params" do
       dimension = new_dimension(bin_width: 7)
       expect(dimension.bin_width).to eq 7
     end
 
-    it 'can divide the domain into :bin_count bins' do
+    it "can divide the domain into :bin_count bins" do
       dimension = new_dimension(bin_count: 5, only: { min: 0, max: 5 })
       expect(dimension.bin_width).to eq 1
       allow(dimension).to receive(:data_contains_nil?).and_return(false)
@@ -43,7 +43,7 @@ describe ActiveReporter::Dimension::Number do
       ]
     end
 
-    it 'can include nils if they are present in the data' do
+    it "can include nils if they are present in the data" do
       dimension = new_dimension(bin_count: 3, only: { min: 0, max: 3 })
       allow(dimension).to receive(:data_contains_nil?).and_return(true)
       expect(dimension.group_values).to eq [
@@ -63,7 +63,7 @@ describe ActiveReporter::Dimension::Number do
       ]
     end
 
-    it 'defaults to 10 equal bins' do
+    it "defaults to 10 equal bins" do
       dimension = new_dimension(only: { min: 0, max: 5 })
       expect(dimension.bin_width).to eq 0.5
     end

data/spec/active_reporter/dimension/time_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActiveReporter::Dimension::Time do
   def new_dimension(dimension_params = {}, report_params = {}, opts = {})
@@ -14,47 +14,47 @@ describe ActiveReporter::Dimension::Time do
     expect { yield }.to raise_error(ActiveReporter::InvalidParamsError)
   end
 
-  describe 'param validation' do
-    it 'yells unless :bin_width is a duration hash' do
-      expect_error { new_dimension(bin_width: '') }
+  describe "param validation" do
+    it "yells unless :bin_width is a duration hash" do
+      expect_error { new_dimension(bin_width: "") }
       expect_error { new_dimension(bin_width: 5) }
-      expect_error { new_dimension(bin_width: { seconds: 'hey' }) }
+      expect_error { new_dimension(bin_width: { seconds: "hey" }) }
       expect_error { new_dimension(bin_width: { seconds: 1, chickens: 0 }) }
       new_dimension(bin_width: { seconds: 1, minutes: 2 })
       new_dimension(bin_width: { weeks: 12, years: 7 })
     end
 
-    it 'yells unless :bins and :only values are times' do
-      expect_error { new_dimension(bins: { min: 'hey' }) }
-      expect_error { new_dimension(only: { min: 'hey' }) }
-      expect_error { new_dimension(only: [{ min: '2015-01-01', max: '2015-01-10' }, { min: 'chicken' }]) }
-      new_dimension(bins: { min: '2015-01-01', max: '2015-01-10' })
-      new_dimension(only: { min: '2015-01-01', max: '2015-01-10' })
-      new_dimension(only: [nil, { min: '2015-01-01', max: '2015-01-10' }, { max: '2015-02-10' }])
+    it "yells unless :bins and :only values are times" do
+      expect_error { new_dimension(bins: { min: "hey" }) }
+      expect_error { new_dimension(only: { min: "hey" }) }
+      expect_error { new_dimension(only: [{ min: "2015-01-01", max: "2015-01-10" }, { min: "chicken" }]) }
+      new_dimension(bins: { min: "2015-01-01", max: "2015-01-10" })
+      new_dimension(only: { min: "2015-01-01", max: "2015-01-10" })
+      new_dimension(only: [nil, { min: "2015-01-01", max: "2015-01-10" }, { max: "2015-02-10" }])
     end
   end
 
-  describe '#bin_width' do
-    it 'can translate a duration hash into an ActiveSupport::Duration' do
+  describe "#bin_width" do
+    it "can translate a duration hash into an ActiveSupport::Duration" do
       dimension = new_dimension(bin_width: { seconds: 10, minutes: 1 })
       expect(dimension.bin_width).to eq 70.seconds
       dimension = new_dimension(bin_width: { days: 8, weeks: 1 })
       expect(dimension.bin_width).to eq 15.days
     end
 
-    it 'can divide the domain into :bin_count bins' do
-      dimension = new_dimension(bin_count: 10, only: [{ min: '2015-01-01' }, { max: '2015-01-11' }])
+    it "can divide the domain into :bin_count bins" do
+      dimension = new_dimension(bin_count: 10, only: [{ min: "2015-01-01" }, { max: "2015-01-11" }])
       allow(dimension).to receive(:data_contains_nil?).and_return(false)
       expect(dimension.bin_width).to eq 1.day
       expect(dimension.group_values.map(&:min).map(&:day)).to eq (1..10).to_a
     end
 
-    it 'defaults to a sensical, standard duration' do
-      dimension = new_dimension(only: [{ min: '2015-01-01' }, { max: '2015-01-02' }])
+    it "defaults to a sensical, standard duration" do
+      dimension = new_dimension(only: [{ min: "2015-01-01" }, { max: "2015-01-02" }])
       expect(dimension.bin_width).to eq 1.hour
-      dimension = new_dimension(only: [{ min: '2015-01-01' }, { max: '2015-01-11' }])
+      dimension = new_dimension(only: [{ min: "2015-01-01" }, { max: "2015-01-11" }])
       expect(dimension.bin_width).to eq 1.day
-      dimension = new_dimension(only: [{ min: '2015-01-01' }, { max: '2015-02-11' }])
+      dimension = new_dimension(only: [{ min: "2015-01-01" }, { max: "2015-02-11" }])
       expect(dimension.bin_width).to eq 1.week
     end
   end