masamune 0.17.12 → 0.17.13

data/spec/masamune/data_plan/builder_spec.rb

@@ -27,27 +27,28 @@ describe Masamune::DataPlan::Builder do
     end
 
     context 'with multiple namespaces' do
-      let(:namespaces) { ['a', 'b'] }
-      let(:commands) { ['load', 'store'] }
+      let(:namespaces) { %w(a b) }
+      let(:commands) { %w(load store) }
       let(:sources) { [{ path: 'log/%Y%m%d.*.log' }, { path: 'table/y=%Y/m=%m/d=%d' }] }
       let(:targets) { [{ path: 'table/y=%Y/m=%m/d=%d' }, { path: 'daily/%Y-%m-%d' }] }
 
       before do
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('a:load', { path: 'table/y=%Y/m=%m/d=%d'})
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('a:load', { path: 'log/%Y%m%d.*.log' })
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('a:load', path: 'table/y=%Y/m=%m/d=%d')
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('a:load', path: 'log/%Y%m%d.*.log')
         expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_command_rule).with('a:load', an_instance_of(Proc))
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('b:store', { path: 'daily/%Y-%m-%d' })
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('b:store', { path: 'table/y=%Y/m=%m/d=%d' })
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('b:store', path: 'daily/%Y-%m-%d')
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('b:store', path: 'table/y=%Y/m=%m/d=%d')
         expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_command_rule).with('b:store', an_instance_of(Proc))
         subject
       end
 
-      it 'should build a Masamune::DataPlan::Engine instance' do; end
+      it 'should build a Masamune::DataPlan::Engine instance' do
+      end
     end
 
     context 'with :for option' do
-      let(:namespaces) { ['a', 'a', 'a'] }
-      let(:commands) { ['missing_before', 'override', 'missing_after'] }
+      let(:namespaces) { %w(a a a) }
+      let(:commands) { %w(missing_before override missing_after) }
       let(:sources) { [{ path: 'log/%Y%m%d.*.log', for: 'override' }] }
       let(:targets) { [{ path: 'table/y=%Y/m=%m/d=%d', for: 'override' }] }
 
@@ -55,8 +56,8 @@ describe Masamune::DataPlan::Builder do
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_target_rule).with('a:missing_before', anything)
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_source_rule).with('a:missing_before', anything)
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_command_rule).with('a:missing_before', an_instance_of(Proc))
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('a:override', { path: 'table/y=%Y/m=%m/d=%d' })
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('a:override', { path: 'log/%Y%m%d.*.log' })
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('a:override', path: 'table/y=%Y/m=%m/d=%d')
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('a:override', path: 'log/%Y%m%d.*.log')
         expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_command_rule).with('a:override', an_instance_of(Proc))
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_target_rule).with('a:missing_after', anything)
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_source_rule).with('a:missing_after', anything)
@@ -64,26 +65,28 @@ describe Masamune::DataPlan::Builder do
         subject
       end
 
-      it 'should build a Masamune::DataPlan::Engine instance' do; end
+      it 'should build a Masamune::DataPlan::Engine instance' do
+      end
     end
 
     context 'with :skip option' do
-      let(:namespaces) { ['a', 'a', 'a'] }
-      let(:commands) { ['missing_before', 'override'] }
-      let(:sources) { [{ skip: true}, { path: 'log/%Y%m%d.*.log' }] }
-      let(:targets) { [{ skip: true}, { path: 'table/y=%Y/m=%m/d=%d' }] }
+      let(:namespaces) { %w(a a a) }
+      let(:commands) { %w(missing_before override) }
+      let(:sources) { [{ skip: true }, { path: 'log/%Y%m%d.*.log' }] }
+      let(:targets) { [{ skip: true }, { path: 'table/y=%Y/m=%m/d=%d' }] }
 
       before do
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_target_rule).with('a:missing_before', anything)
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_source_rule).with('a:missing_before', anything)
         expect_any_instance_of(Masamune::DataPlan::Engine).not_to receive(:add_command_rule).with('a:missing_before', an_instance_of(Proc))
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('a:override', { path: 'table/y=%Y/m=%m/d=%d' })
-        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('a:override', { path: 'log/%Y%m%d.*.log' })
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_target_rule).with('a:override', path: 'table/y=%Y/m=%m/d=%d')
+        expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_source_rule).with('a:override', path: 'log/%Y%m%d.*.log')
         expect_any_instance_of(Masamune::DataPlan::Engine).to receive(:add_command_rule).with('a:override', an_instance_of(Proc))
         subject
       end
 
-      it 'should build a Masamune::DataPlan::Engine instance' do; end
+      it 'should build a Masamune::DataPlan::Engine instance' do
+      end
     end
   end
 end

data/spec/masamune/data_plan/elem_spec.rb

@@ -32,14 +32,14 @@ describe Masamune::DataPlan::Elem do
 
   let(:name) { 'primary' }
   let(:type) { :target }
-  let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {path: '/report/%Y-%m-%d/%H'}) }
-  let(:other_rule) { Masamune::DataPlan::Rule.new(engine, name, type, {path: '/log/%Y%m%d.*.log'}) }
+  let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, path: '/report/%Y-%m-%d/%H') }
+  let(:other_rule) { Masamune::DataPlan::Rule.new(engine, name, type, path: '/log/%Y%m%d.*.log') }
 
-  let(:start_time) { DateTime.civil(2013,07,19,11,07) }
-  let(:other_start_time) { DateTime.civil(2013,07,20,0,0) }
+  let(:start_time) { DateTime.civil(2013, 07, 19, 11, 07) }
+  let(:other_start_time) { DateTime.civil(2013, 07, 20, 0, 0) }
 
-  let(:options) { {tz: 'EST'} }
-  let(:other_options) { {tz: 'PST'} }
+  let(:options) { { tz: 'EST' } }
+  let(:other_options) { { tz: 'PST' } }
 
   let(:instance) { described_class.new(rule, start_time, options) }
 
@@ -80,8 +80,8 @@ describe Masamune::DataPlan::Elem do
   end
 
   describe '#last_modified_at' do
-    let(:early) { Time.parse("2014-05-01 00:00:00 +0000") }
-    let(:later) { Time.parse("2014-06-01 00:00:00 +0000") }
+    let(:early) { Time.parse('2014-05-01 00:00:00 +0000') }
+    let(:later) { Time.parse('2014-06-01 00:00:00 +0000') }
 
     subject do
       instance.last_modified_at.utc
@@ -89,8 +89,8 @@ describe Masamune::DataPlan::Elem do
 
     context 'with missing mtime' do
       before do
-        expect(rule.engine.filesystem).to receive(:stat).with(instance.path).
-          and_return(nil)
+        expect(rule.engine.filesystem).to receive(:stat).with(instance.path)
+          .and_return(nil)
       end
 
       it { is_expected.to eq(Masamune::DataPlan::Elem::MISSING_MODIFIED_AT) }
@@ -98,8 +98,8 @@ describe Masamune::DataPlan::Elem do
 
     context 'with single mtime' do
       before do
-        expect(rule.engine.filesystem).to receive(:stat).with(instance.path).
-          and_return(OpenStruct.new(mtime: early))
+        expect(rule.engine.filesystem).to receive(:stat).with(instance.path)
+          .and_return(OpenStruct.new(mtime: early))
       end
 
       it { is_expected.to eq(early) }
@@ -110,7 +110,7 @@ describe Masamune::DataPlan::Elem do
     subject { instance.explode.map(&:path) }
 
     context 'with free path and existing files' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {path: '/report/%Y-%m-%d/%H'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, path: '/report/%Y-%m-%d/%H') }
       before do
         engine.filesystem.touch!('/report/2013-07-19/11/part-0000')
       end
@@ -118,12 +118,12 @@ describe Masamune::DataPlan::Elem do
     end
 
     context 'with free path and missing files' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {path: '/report/%Y-%m-%d/%H'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, path: '/report/%Y-%m-%d/%H') }
       it { is_expected.to be_empty }
     end
 
     context 'with bound path and existing files' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {path: '/report/file'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, path: '/report/file') }
       before do
         engine.filesystem.touch!('/report/file')
       end
@@ -131,12 +131,12 @@ describe Masamune::DataPlan::Elem do
     end
 
     context 'with bound path and missing files' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {path: '/report/file'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, path: '/report/file') }
       it { is_expected.to be_empty }
     end
 
     context 'with free table and existing table' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {table: 'visits_fact', partition: 'y%Y%m'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, table: 'visits_fact', partition: 'y%Y%m') }
       before do
         expect(instance.rule.engine.postgres_helper).to receive(:table_exists?).and_return(true)
       end
@@ -144,7 +144,7 @@ describe Masamune::DataPlan::Elem do
     end
 
     context 'with free table and missing table' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {table: 'visits_fact', partition: 'y%Y%m'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, table: 'visits_fact', partition: 'y%Y%m') }
       before do
         expect(instance.rule.engine.postgres_helper).to receive(:table_exists?).and_return(false)
       end
@@ -152,7 +152,7 @@ describe Masamune::DataPlan::Elem do
     end
 
     context 'with bound table and existing table' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {table: 'visits_fact'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, table: 'visits_fact') }
       before do
         expect(instance.rule.engine.postgres_helper).to receive(:table_exists?).and_return(true)
       end
@@ -160,7 +160,7 @@ describe Masamune::DataPlan::Elem do
     end
 
     context 'with bound table and missing table' do
-      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, {table: 'visits_fact'}) }
+      let(:rule) { Masamune::DataPlan::Rule.new(engine, name, type, table: 'visits_fact') }
       before do
         expect(instance.rule.engine.postgres_helper).to receive(:table_exists?).and_return(false)
       end

data/spec/masamune/data_plan/engine_spec.rb

@@ -31,7 +31,7 @@ describe Masamune::DataPlan::Engine do
   end
 
   let(:command) do
-    Proc.new do |engine, rule|
+    proc do |engine, rule|
       missing_targets = []
       engine.targets(rule).missing.each do |target|
         missing_targets << target.path if target.sources.existing.any?
@@ -43,7 +43,7 @@ describe Masamune::DataPlan::Engine do
   before do
     engine.add_target_rule('non_primary', path: '/table/y=%Y/m=%m/d=%d', primary: false)
     engine.add_source_rule('non_primary', path: '/log/%Y%m%d.*.log', primary: false)
-    engine.add_command_rule('non_primary', ->(*_) { fail } )
+    engine.add_command_rule('non_primary', ->(*_) { raise })
     engine.add_target_rule('primary', path: '/table/y=%Y/m=%m/d=%d')
     engine.add_source_rule('primary', path: '/log/%Y%m%d.*.log')
     engine.add_command_rule('primary', command)
@@ -61,8 +61,8 @@ describe Masamune::DataPlan::Engine do
   end
 
   describe '#targets_for_date_range' do
-    let(:start) { Date.civil(2013,01,01) }
-    let(:stop) { Date.civil(2013,01,03) }
+    let(:start) { Date.civil(2013, 01, 01) }
+    let(:stop) { Date.civil(2013, 01, 03) }
 
     subject { engine.targets_for_date_range(rule, start, stop).map(&:path) }
 
@@ -104,26 +104,26 @@ describe Masamune::DataPlan::Engine do
       let(:rule) { 'primary' }
       let(:source) { '/log/20130101.random.log' }
 
-      it { expect(targets.first.start_time).to eq(Date.civil(2013,01,01)) }
-      it { expect(targets.first.stop_time).to eq(Date.civil(2013,01,02)) }
+      it { expect(targets.first.start_time).to eq(Date.civil(2013, 01, 01)) }
+      it { expect(targets.first.stop_time).to eq(Date.civil(2013, 01, 02)) }
       it { expect(targets.first.path).to eq('/table/y=2013/m=01/d=01') }
     end
 
     context 'derived_daily' do
       let(:rule) { 'derived_daily' }
-      let(:source)  { '/table/y=2013/m=01/d=01' }
+      let(:source) { '/table/y=2013/m=01/d=01' }
 
-      it { expect(targets.first.start_time).to eq(Date.civil(2013,01,01)) }
-      it { expect(targets.first.stop_time).to eq(Date.civil(2013,01,02)) }
+      it { expect(targets.first.start_time).to eq(Date.civil(2013, 01, 01)) }
+      it { expect(targets.first.stop_time).to eq(Date.civil(2013, 01, 02)) }
       it { expect(targets.first.path).to eq('/daily/2013-01-01') }
     end
 
     context 'derived_monthly' do
       let(:rule) { 'derived_monthly' }
-      let(:source)  { '/table/y=2013/m=01/d=01' }
+      let(:source) { '/table/y=2013/m=01/d=01' }
 
-      it { expect(targets.first.start_time).to eq(Date.civil(2013,01,01)) }
-      it { expect(targets.first.stop_time).to eq(Date.civil(2013,02,01)) }
+      it { expect(targets.first.start_time).to eq(Date.civil(2013, 01, 01)) }
+      it { expect(targets.first.stop_time).to eq(Date.civil(2013, 02, 01)) }
       it { expect(targets.first.path).to eq('/monthly/2013-01') }
     end
   end
@@ -167,15 +167,15 @@ describe Masamune::DataPlan::Engine do
       let(:target) { '/monthly/2013-01' }
 
       (1..31).each do |day|
-        it { expect(sources).to include '/table/y=2013/m=01/d=%02d' % day }
+        it { expect(sources).to include format('/table/y=2013/m=01/d=%02d', day) }
       end
       it { expect(sources.size).to eq(31) }
     end
 
     context 'invalid target' do
       let(:rule) { 'derived_daily' }
-      let(:target) {  '/table/y=2013/m=01/d=01' }
-      it { expect { subject }.to raise_error /Cannot bind_input/ }
+      let(:target) { '/table/y=2013/m=01/d=01' }
+      it { expect { subject }.to raise_error(/Cannot bind_input/) }
     end
   end
 
@@ -204,7 +204,7 @@ describe Masamune::DataPlan::Engine do
 
     context 'invalid target' do
       let(:target) { '/daily' }
-      it { expect { subject }.to raise_error /No rule matches/ }
+      it { expect { subject }.to raise_error(/No rule matches/) }
     end
   end
 
@@ -224,7 +224,7 @@ describe Masamune::DataPlan::Engine do
     context 'with :targets' do
       let(:rule) { 'primary' }
 
-      let(:options) { {targets: ['/table/y=2013/m=01/d=01', '/table/y=2013/m=01/d=02', '/table/y=2013/m=01/d=02']} }
+      let(:options) { { targets: ['/table/y=2013/m=01/d=01', '/table/y=2013/m=01/d=02', '/table/y=2013/m=01/d=02'] } }
 
       it { expect(targets).to include '/table/y=2013/m=01/d=01' }
       it { expect(targets).to include '/table/y=2013/m=01/d=02' }
@@ -235,10 +235,10 @@ describe Masamune::DataPlan::Engine do
     context 'with :sources' do
       let(:rule) { 'derived_daily' }
 
-      let(:options) { {sources: ['/table/y=2013/m=01/d=01', '/table/y=2013/m=01/d=02', '/table/y=2013/m=01/d=02']} }
+      let(:options) { { sources: ['/table/y=2013/m=01/d=01', '/table/y=2013/m=01/d=02', '/table/y=2013/m=01/d=02'] } }
 
-      it { expect(targets).to include "/daily/2013-01-01" }
-      it { expect(targets).to include "/daily/2013-01-02" }
+      it { expect(targets).to include '/daily/2013-01-01' }
+      it { expect(targets).to include '/daily/2013-01-02' }
       it { expect(sources).to include '/table/y=2013/m=01/d=01' }
       it { expect(sources).to include '/table/y=2013/m=01/d=02' }
     end
@@ -257,10 +257,13 @@ describe Masamune::DataPlan::Engine do
 
     context 'primary rule' do
       let(:rule) { 'primary' }
-      let(:targets) {  [
-        '/table/y=2013/m=01/d=01',
-        '/table/y=2013/m=01/d=02',
-        '/table/y=2013/m=01/d=03' ] }
+      let(:targets) do
+        [
+          '/table/y=2013/m=01/d=01',
+          '/table/y=2013/m=01/d=02',
+          '/table/y=2013/m=01/d=03'
+        ]
+      end
 
       context 'when target data exists' do
         before do
@@ -269,7 +272,8 @@ describe Masamune::DataPlan::Engine do
           execute
         end
 
-        it 'should not call touch!' do; end
+        it 'should not call touch!' do
+        end
       end
 
       context 'when partial target data exists' do
@@ -280,7 +284,8 @@ describe Masamune::DataPlan::Engine do
           execute
         end
 
-        it 'should call touch!' do; end
+        it 'should call touch!' do
+        end
       end
 
       context 'when source data does not exist' do
@@ -289,13 +294,14 @@ describe Masamune::DataPlan::Engine do
           execute
         end
 
-        it 'should not call touch!' do; end
+        it 'should not call touch!' do
+        end
       end
     end
 
     shared_examples_for 'derived daily data' do
       context 'when primary target data exists' do
-        let(:derived_targets) {  ['/table/y=2013/m=01/d=01/DATA', '/table/y=2013/m=01/d=02/DATA', '/table/y=2013/m=01/d=03/DATA'] }
+        let(:derived_targets) { ['/table/y=2013/m=01/d=01/DATA', '/table/y=2013/m=01/d=02/DATA', '/table/y=2013/m=01/d=03/DATA'] }
 
         before do
           engine.filesystem.touch!('/log/20130101.app1.log', '/log/20130102.app1.log', '/log/20130103.app1.log')
@@ -304,11 +310,12 @@ describe Masamune::DataPlan::Engine do
           execute
         end
 
-        it 'should call touch!' do; end
+        it 'should call touch!' do
+        end
       end
 
       context 'when primary target data exists and :resolve is false' do
-        let(:options) { {resolve: false} }
+        let(:options) { { resolve: false } }
 
         before do
           engine.filesystem.touch!('/log/20130101.app1.log', '/log/20130102.app1.log', '/log/20130103.app1.log')
@@ -316,7 +323,8 @@ describe Masamune::DataPlan::Engine do
           execute
         end
 
-        it 'should not call touch!' do; end
+        it 'should not call touch!' do
+        end
       end
     end
 
@@ -331,7 +339,7 @@ describe Masamune::DataPlan::Engine do
 
     context 'derived_monthly rule' do
       let(:rule) { 'derived_monthly' }
-      let(:targets) {  ['/monthly/2013-01/DATA'] }
+      let(:targets) { ['/monthly/2013-01/DATA'] }
 
       it_behaves_like 'derived daily data' do
         let(:derived_command) { derived_monthly_command }
@@ -348,7 +356,7 @@ describe Masamune::DataPlan::Engine do
     end
 
     it 'should raise exception' do
-      expect { engine.prepare('derived', targets: ['/log/20140228.wtf.log']) }.to raise_error /Max depth .* exceeded for rule 'derived'/
+      expect { engine.prepare('derived', targets: ['/log/20140228.wtf.log']) }.to raise_error(/Max depth .* exceeded for rule 'derived'/)
     end
   end
 end

data/spec/masamune/data_plan/rule_spec.rb

@@ -25,7 +25,7 @@ describe Masamune::DataPlan::Rule do
   let(:name) { 'primary' }
   let(:type) { :target }
   let(:pattern) { 'report/%Y-%m-%d/%H' }
-  let(:options) { {path: pattern} }
+  let(:options) { { path: pattern } }
 
   let(:instance) { described_class.new(engine, name, type, options) }
 
@@ -40,7 +40,7 @@ describe Masamune::DataPlan::Rule do
     end
 
     context 'with lambda' do
-      let(:pattern) { lambda { |_| 'report/%Y-%m-%d/%H' } }
+      let(:pattern) { ->(_) { 'report/%Y-%m-%d/%H' } }
       it { is_expected.to eq('report/%Y-%m-%d/%H') }
     end
   end
@@ -59,7 +59,7 @@ describe Masamune::DataPlan::Rule do
     end
 
     context 'with DateTime input' do
-      let(:input) { DateTime.civil(2013,04,05,23,13) }
+      let(:input) { DateTime.civil(2013, 04, 05, 23, 13) }
 
       describe '#path' do
         subject { elem.path }
@@ -69,7 +69,7 @@ describe Masamune::DataPlan::Rule do
 
     context 'with DateTime input and unix timestamp pattern' do
       let(:pattern) { 'logs/%H-s.log' }
-      let(:input) { DateTime.civil(2013,04,05,23,13) }
+      let(:input) { DateTime.civil(2013, 04, 05, 23, 13) }
 
       describe '#path' do
         subject { elem.path }
@@ -78,7 +78,7 @@ describe Masamune::DataPlan::Rule do
     end
 
     context 'with Date input' do
-      let(:input) { Date.civil(2013,04,05) }
+      let(:input) { Date.civil(2013, 04, 05) }
 
       describe '#path' do
         subject { elem.path }
@@ -92,7 +92,7 @@ describe Masamune::DataPlan::Rule do
 
     context 'with default' do
       let(:input) { 'report/2013-04-05/23' }
-      let(:output_date) { DateTime.civil(2013,04,05,23) }
+      let(:output_date) { DateTime.civil(2013, 04, 05, 23) }
 
       describe '#path' do
         subject { elem.path }
@@ -113,7 +113,7 @@ describe Masamune::DataPlan::Rule do
     context 'with unix timestamp pattern' do
       let(:pattern) { 'logs/%H-s.log' }
       let(:input) { 'logs/1365202800.log' }
-      let(:output_date) { DateTime.civil(2013,04,05,23) }
+      let(:output_date) { DateTime.civil(2013, 04, 05, 23) }
 
       describe '#path' do
         subject { elem.path }
@@ -140,7 +140,7 @@ describe Masamune::DataPlan::Rule do
     context 'with wildcard pattern' do
       let(:pattern) { 'requests/y=%Y/m=%-m/d=%-d/h=%-k/*' }
       let(:input) { 'requests/y=2013/m=4/d=30/h=20/part-00000' }
-      let(:output_date) { DateTime.civil(2013,04,30,20) }
+      let(:output_date) { DateTime.civil(2013, 04, 30, 20) }
 
       describe '#path' do
         subject { elem.path }
@@ -160,8 +160,8 @@ describe Masamune::DataPlan::Rule do
   end
 
   describe '#unify' do
-    let(:primary) { described_class.new(engine, name, type, {path: 'report/%Y-%m-%d/%H'}) }
-    let(:induced) { described_class.new(engine, name, type, {path: 'table/y=%Y/m=%m/d=%d/h=%H'}) }
+    let(:primary) { described_class.new(engine, name, type, path: 'report/%Y-%m-%d/%H') }
+    let(:induced) { described_class.new(engine, name, type, path: 'table/y=%Y/m=%m/d=%d/h=%H') }
     let(:elem) { primary.bind_input(input) }
 
     subject(:new_elem) { instance.unify(elem, induced) }
@@ -176,7 +176,7 @@ describe Masamune::DataPlan::Rule do
     end
 
     context 'when input partially matches basis pattern' do
-      let(:induced) { described_class.new(engine, name, type, {path: 'table/%Y-%m'}) }
+      let(:induced) { described_class.new(engine, name, type, path: 'table/%Y-%m') }
 
       let(:input) { 'report/2013-01-02/00' }
 
@@ -240,14 +240,14 @@ describe Masamune::DataPlan::Rule do
 
   describe '#generate' do
     context 'with a block' do
-      let(:start_date) { DateTime.civil(2013,04,05,20) }
-      let(:stop_date) { DateTime.civil(2013,04,05,20) }
+      let(:start_date) { DateTime.civil(2013, 04, 05, 20) }
+      let(:stop_date) { DateTime.civil(2013, 04, 05, 20) }
       specify { expect { |b| instance.generate(start_date, stop_date, &b) }.to yield_control }
     end
 
     context 'without a block' do
-      let(:start_date) { DateTime.civil(2013,04,05,20) }
-      let(:stop_date) { DateTime.civil(2013,04,05,22) }
+      let(:start_date) { DateTime.civil(2013, 04, 05, 20) }
+      let(:stop_date) { DateTime.civil(2013, 04, 05, 22) }
 
       subject(:elems) do
         instance.generate(start_date, stop_date)
@@ -307,7 +307,7 @@ describe Masamune::DataPlan::Rule do
   end
 
   describe '#time_round' do
-    let(:input_time) { DateTime.civil(2013,9,13,23,13) }
+    let(:input_time) { DateTime.civil(2013, 9, 13, 23, 13) }
     subject { instance.time_round(input_time) }
 
     before do
@@ -316,15 +316,15 @@ describe Masamune::DataPlan::Rule do
 
     context 'hourly' do
       let(:time_step) { :hours }
-      it { is_expected.to eq(DateTime.civil(2013,9,13,23)) }
+      it { is_expected.to eq(DateTime.civil(2013, 9, 13, 23)) }
     end
     context 'daily' do
       let(:time_step) { :days }
-      it { is_expected.to eq(DateTime.civil(2013,9,13)) }
+      it { is_expected.to eq(DateTime.civil(2013, 9, 13)) }
     end
     context 'monthly' do
       let(:time_step) { :months }
-      it { is_expected.to eq(DateTime.civil(2013,9)) }
+      it { is_expected.to eq(DateTime.civil(2013, 9)) }
     end
     context 'yearly' do
       let(:time_step) { :years }