masamune 0.17.12 → 0.17.13

data/lib/masamune/transform/postgres/stage_dimension.rb

@@ -35,16 +35,14 @@ module Masamune::Transform::Postgres
       TargetPresenter.new(@target)
     end
 
-    private
-
     class TargetPresenter < SimpleDelegator
       include Masamune::LastElement
 
       def insert_columns(source)
         shared_columns(source).values.map do |columns|
           column = columns.first
-          if reference = column.reference
-            reference.foreign_key_name
+          if column.reference
+            column.reference.foreign_key_name
           else
             column.name
           end
@@ -54,8 +52,8 @@ module Masamune::Transform::Postgres
       def insert_values(source)
         shared_columns(source).values.map do |columns|
           column = columns.first
-          if reference = column.reference
-            reference.surrogate_key.qualified_name(reference.label)
+          if column.reference
+            column.reference.surrogate_key.qualified_name(column.reference.label)
           elsif column.type == :json || column.type == :yaml || column.type == :key_value
             "json_to_hstore(#{column.qualified_name})"
           else
@@ -67,10 +65,10 @@ module Masamune::Transform::Postgres
 
       def join_conditions(source)
         join_columns = shared_columns(source).values.flatten
-        join_columns = join_columns.select { |column| column.reference }
-        join_columns = join_columns.group_by { |column| column.reference }
+        join_columns = join_columns.select(&:reference)
+        join_columns = join_columns.group_by(&:reference)
 
-        conditions = Hash.new { |h,k| h[k] = Set.new }
+        conditions = Hash.new { |h, k| h[k] = Set.new }
         join_columns.each do |reference, columns|
           left_uniq = Set.new
           (columns + lateral_references(source, reference)).each do |column|
@@ -83,7 +81,7 @@ module Masamune::Transform::Postgres
       end
 
       def lateral_references(source, reference)
-        source.shared_columns(reference).keys.reject { |column| column.auto_reference }
+        source.shared_columns(reference).keys.reject(&:auto_reference)
       end
     end
   end

data/lib/masamune/transform/postgres/stage_fact.rb

@@ -36,16 +36,14 @@ module Masamune::Transform::Postgres
       TargetPresenter.new(@target)
     end
 
-    private
-
     class TargetPresenter < SimpleDelegator
       include Masamune::LastElement
 
       def insert_columns(source)
         shared_columns(source).values.map do |columns|
           column = columns.first
-          if reference = column.reference
-            reference.foreign_key_name
+          if column.reference
+            column.reference.foreign_key_name
           else
             column.name
           end
@@ -55,8 +53,8 @@ module Masamune::Transform::Postgres
       def insert_values(source)
         shared_columns(source).values.map do |columns|
           column = columns.first
-          if !column.degenerate? && reference = column.reference
-            value = reference.surrogate_key.qualified_name(column.reference.label)
+          if !column.degenerate? && column.reference
+            value = column.reference.surrogate_key.qualified_name(column.reference.label)
             column.reference.unknown ? "COALESCE(#{value}, #{column.reference.unknown})" : value
           else
             column.qualified_name
@@ -71,11 +69,11 @@ module Masamune::Transform::Postgres
 
       def join_conditions(source)
         join_columns = shared_columns(source).values.flatten
-        join_columns = join_columns.select { |column| column.reference }
-        join_columns = join_columns.group_by { |column| column.reference }
+        join_columns = join_columns.select(&:reference)
+        join_columns = join_columns.group_by(&:reference)
 
         dependencies = Masamune::TopologicalHash.new
-        conditions = Hash.new { |h,k| h[k] = OpenStruct.new(type: 'INNER', conditions: []) }
+        conditions = Hash.new { |h, k| h[k] = OpenStruct.new(type: 'INNER', conditions: []) }
         join_columns.each do |reference, columns|
           reference_name = join_alias(reference)
           columns.each do |column|
@@ -86,8 +84,8 @@ module Masamune::Transform::Postgres
             coalesce_values = []
 
             if cross_references.any?
-              dependencies[reference_name] += cross_references.map { |reference, _| join_alias(reference) }
-              coalesce_values << cross_references.map { |reference, column| column.qualified_name(reference.label) }
+              dependencies[reference_name] += cross_references.map { |cross_reference, _| join_alias(cross_reference) }
+              coalesce_values << cross_references.map { |cross_reference, cross_column| cross_column.qualified_name(cross_reference.label) }
             end
 
             column.reference.auto_surrogate_keys.each do |auto_surrogate_key|
@@ -101,9 +99,12 @@ module Masamune::Transform::Postgres
               coalesce_values << column.adjacent.sql_value(column.adjacent.default)
             end
 
-            conditions[reference_name].conditions << (coalesce_values.any? ?
-              "#{column.foreign_key_name} = COALESCE(#{column.qualified_name}, #{coalesce_values.join(', ')})" :
-              "#{column.foreign_key_name} = #{column.qualified_name}")
+            conditions[reference_name].conditions <<
+            if coalesce_values.any?
+              "#{column.foreign_key_name} = COALESCE(#{column.qualified_name}, #{coalesce_values.join(', ')})"
+            else
+              "#{column.foreign_key_name} = #{column.qualified_name}"
+            end
           end
 
           if reference.type == :two || reference.type == :four

data/lib/masamune/version.rb

@@ -21,5 +21,5 @@
 #  THE SOFTWARE.
 
 module Masamune
-  VERSION = '0.17.12'
+  VERSION = '0.17.13'.freeze
 end

data/spec/masamune/actions/aws_emr_spec.rb

@@ -56,7 +56,7 @@ describe Masamune::Actions::AwsEmr do
   end
 
   describe '.after_initialize' do
-    let(:options) { {initialize: true} }
+    let(:options) { { initialize: true } }
 
     subject(:after_initialize_invoke) do
       instance.after_initialize_invoke(options)
@@ -67,13 +67,13 @@ describe Masamune::Actions::AwsEmr do
     end
 
     context 'when cluster_id is missing' do
-      let(:configuration) { {enabled: true} }
+      let(:configuration) { { enabled: true } }
       it { expect { subject }.to raise_error Thor::RequiredArgumentMissingError, /No value provided for required options '--cluster-id'/ }
     end
 
     context 'when cluster_id is present without initialize' do
-      let(:configuration) { {enabled: true} }
-      let(:options) { {cluster_id: 'j-XYZ'} }
+      let(:configuration) { { enabled: true } }
+      let(:options) { { cluster_id: 'j-XYZ' } }
       before do
         expect(instance).to_not receive(:aws_emr)
       end
@@ -84,8 +84,8 @@ describe Masamune::Actions::AwsEmr do
     end
 
     context 'when cluster_id does not exist' do
-      let(:configuration) { {enabled: true} }
-      let(:options) { {initialize: true, cluster_id: 'j-XYZ'} }
+      let(:configuration) { { enabled: true } }
+      let(:options) { { initialize: true, cluster_id: 'j-XYZ' } }
       before do
         mock_command(/\Aaws emr/, mock_failure)
       end
@@ -93,8 +93,8 @@ describe Masamune::Actions::AwsEmr do
     end
 
     context 'when cluster_id exists' do
-      let(:configuration) { {enabled: true} }
-      let(:options) { {initialize: true, cluster_id: 'j-XYZ'} }
+      let(:configuration) { { enabled: true } }
+      let(:options) { { initialize: true, cluster_id: 'j-XYZ' } }
       before do
         mock_command(/\Aaws emr/, mock_success)
       end

data/spec/masamune/actions/execute_spec.rb

@@ -27,11 +27,11 @@ describe Masamune::Actions::Execute do
       include Masamune::Actions::Execute
 
       def before_execute
-        fail
+        raise
       end
 
       def after_execute
-        fail
+        raise
       end
     end
   end
@@ -45,21 +45,21 @@ describe Masamune::Actions::Execute do
 
     context 'with a simple command' do
       let(:command) { %w(echo ping) }
-      let(:options) { {fail_fast: true} }
+      let(:options) { { fail_fast: true } }
 
       it { expect { |b| instance.execute(*command, options, &b) }.to yield_with_args('ping', 0) }
     end
 
     context 'with a simple command with input' do
       let(:command) { %w(cat) }
-      let(:options) { {input: 'pong', fail_fast: true} }
+      let(:options) { { input: 'pong', fail_fast: true } }
 
       it { expect { |b| instance.execute(*command, options, &b) }.to yield_with_args('pong', 0) }
     end
 
     context 'with a simple command with env' do
-      let(:command) { %Q(bash -c "echo $MESSAGE") }
-      let(:options) { {env: { 'MESSAGE' => 'pong' }, fail_fast: true} }
+      let(:command) { %(bash -c "echo $MESSAGE") }
+      let(:options) { { env: { 'MESSAGE' => 'pong' }, fail_fast: true } }
 
       it { expect { |b| instance.execute(*command, options, &b) }.to yield_with_args('pong', 0) }
     end

data/spec/masamune/actions/hive_spec.rb

@@ -31,7 +31,7 @@ describe Masamune::Actions::Hive do
 
   let(:filesystem) { Masamune::MockFilesystem.new }
   let(:instance) { klass.new }
-  let(:configuration) { {database: 'test'} }
+  let(:configuration) { { database: 'test' } }
 
   before do
     filesystem.add_path(:tmp_dir, File.join(Dir.tmpdir, SecureRandom.hex))
@@ -53,7 +53,7 @@ describe Masamune::Actions::Hive do
 
     context 'with cluster_id' do
       before do
-        allow(instance).to receive_message_chain(:configuration, :aws_emr).and_return({cluster_id: 'j-XYZ'})
+        allow(instance).to receive_message_chain(:configuration, :aws_emr).and_return(cluster_id: 'j-XYZ')
         mock_command(/\Ahive/, mock_failure)
         mock_command(/\Aaws emr/, mock_success, StringIO.new('ssh fakehost exit'))
         mock_command(/\Assh fakehost hive/, mock_success)
@@ -75,8 +75,8 @@ describe Masamune::Actions::Hive do
   end
 
   describe '.after_initialize' do
-    let(:options) { {initialize: true} }
-    let(:configuration) { {database: 'test'} }
+    let(:options) { { initialize: true } }
+    let(:configuration) { { database: 'test' } }
 
     subject(:after_initialize_invoke) do
       instance.after_initialize_invoke(options)
@@ -88,46 +88,51 @@ describe Masamune::Actions::Hive do
         expect(instance).to_not receive(:hive)
         after_initialize_invoke
       end
-      it 'should not call hive' do; end
+      it 'should not call hive' do
+      end
     end
 
     context 'with default database' do
-      let(:configuration) { {database: 'default'} }
+      let(:configuration) { { database: 'default' } }
       before do
         expect(instance).to receive(:hive).with(exec: an_instance_of(String)).never
         after_initialize_invoke
       end
-      it 'should not call hive with create database' do; end
+      it 'should not call hive with create database' do
+      end
     end
 
     context 'with database' do
       before do
-        expect(instance).to receive(:hive).with(exec: 'CREATE DATABASE IF NOT EXISTS test;', :database => nil).once.and_return(mock_success)
+        expect(instance).to receive(:hive).with(exec: 'CREATE DATABASE IF NOT EXISTS test;', database: nil).once.and_return(mock_success)
         expect(instance).to receive(:hive).with(file: an_instance_of(String)).once.and_return(mock_success)
         after_initialize_invoke
       end
-      it 'should call hive with create database' do; end
+      it 'should call hive with create database' do
+      end
     end
 
     context 'with location' do
-      let(:configuration) { {database: 'test', location: '/tmp'} }
+      let(:configuration) { { database: 'test', location: '/tmp' } }
       before do
-        expect(instance).to receive(:hive).with(exec: 'CREATE DATABASE IF NOT EXISTS test LOCATION "/tmp";', :database => nil).once.and_return(mock_success)
+        expect(instance).to receive(:hive).with(exec: 'CREATE DATABASE IF NOT EXISTS test LOCATION "/tmp";', database: nil).once.and_return(mock_success)
         expect(instance).to receive(:hive).with(file: an_instance_of(String)).once.and_return(mock_success)
         after_initialize_invoke
       end
-      it 'should call hive with create database' do; end
+      it 'should call hive with create database' do
+      end
     end
 
     context 'with dry_run' do
-      let(:options) { {initialize: true, dry_run: true} }
+      let(:options) { { initialize: true, dry_run: true } }
       before do
-        expect(instance).to receive(:hive).with(exec: 'CREATE DATABASE IF NOT EXISTS test;', :database => nil).once.and_return(mock_success)
+        expect(instance).to receive(:hive).with(exec: 'CREATE DATABASE IF NOT EXISTS test;', database: nil).once.and_return(mock_success)
         expect(instance).to receive(:hive).with(file: an_instance_of(String)).once.and_return(mock_success)
         expect(instance).to receive(:hive).with(exec: 'SHOW TABLES;', safe: true, fail_fast: false).once.and_return(mock_success)
         after_initialize_invoke
       end
-      it 'should call hive with show tables' do; end
+      it 'should call hive with show tables' do
+      end
     end
   end
 end

data/spec/masamune/actions/postgres_spec.rb

@@ -32,7 +32,7 @@ describe Masamune::Actions::Postgres do
   end
 
   let(:instance) { klass.new }
-  let(:configuration) { {database: 'test'} }
+  let(:configuration) { { database: 'test' } }
   let(:postgres_helper) { double }
   let(:catalog) { double }
 
@@ -65,10 +65,10 @@ describe Masamune::Actions::Postgres do
   end
 
   describe '.after_initialize' do
-    let(:options) { {initialize: true} }
+    let(:options) { { initialize: true } }
     let(:setup_files) { [] }
     let(:schema_files) { [] }
-    let(:configuration) { {database: 'test', setup_files: setup_files, schema_files: schema_files} }
+    let(:configuration) { { database: 'test', setup_files: setup_files, schema_files: schema_files } }
 
     subject(:after_initialize_invoke) do
       instance.after_initialize_invoke(options)
@@ -81,7 +81,8 @@ describe Masamune::Actions::Postgres do
         expect(instance).to_not receive(:postgres)
         after_initialize_invoke
       end
-      it 'should not call postgres_admin or postgres' do; end
+      it 'should not call postgres_admin or postgres' do
+      end
     end
 
     context 'when database does not exist' do
@@ -91,7 +92,8 @@ describe Masamune::Actions::Postgres do
         expect(instance).to receive(:postgres).with(file: 'catalog.psql', retries: 0).once
         after_initialize_invoke
       end
-      it 'should call posgres_admin once' do; end
+      it 'should call posgres_admin once' do
+      end
     end
 
     context 'when database exists' do
@@ -101,7 +103,8 @@ describe Masamune::Actions::Postgres do
         expect(instance).to receive(:postgres).with(file: 'catalog.psql', retries: 0).once
         after_initialize_invoke
       end
-      it 'should not call postgres_admin' do; end
+      it 'should not call postgres_admin' do
+      end
     end
 
     context 'when setup_files are configured' do
@@ -112,7 +115,8 @@ describe Masamune::Actions::Postgres do
         expect(instance).to receive(:postgres).with(file: 'catalog.psql', retries: 0).once
         after_initialize_invoke
       end
-      it 'should call postgres with setup_files' do; end
+      it 'should call postgres with setup_files' do
+      end
     end
 
     context 'when schema_files are configured' do
@@ -123,7 +127,8 @@ describe Masamune::Actions::Postgres do
         expect(instance).to receive(:postgres).once
         after_initialize_invoke
       end
-      it 'should call postgres with schema_files' do; end
+      it 'should call postgres with schema_files' do
+      end
     end
 
     context 'when schema_files that are globs are configured' do
@@ -134,7 +139,8 @@ describe Masamune::Actions::Postgres do
         expect(instance).to receive(:postgres).with(file: 'catalog.psql', retries: 0).once
         after_initialize_invoke
       end
-      it 'should call postgres with schema_files' do; end
+      it 'should call postgres with schema_files' do
+      end
     end
 
     context 'when ruby schema_files configured' do
@@ -145,7 +151,8 @@ describe Masamune::Actions::Postgres do
         expect(instance).to receive(:postgres).with(file: 'catalog.psql', retries: 0).once
         after_initialize_invoke
       end
-      it 'should call postgres with schema_files' do; end
+      it 'should call postgres with schema_files' do
+      end
     end
   end
 end

data/spec/masamune/after_initialization_callbacks_spec.rb

@@ -26,18 +26,23 @@ describe Masamune::AfterInitializeCallbacks do
       include Masamune::AfterInitializeCallbacks
 
       def first_callback; end
+
       def early_callback; end
+
       def default_callback; end
+
       def unknown_callback; end
+
       def later_callback; end
+
       def final_callback; end
 
-      after_initialize(:first) { |o| o.first_callback }
-      after_initialize(:early) { |o| o.early_callback }
-      after_initialize(:default) { |o| o.default_callback }
-      after_initialize(:unknown) { |o| o.unknown_callback }
-      after_initialize(:later) { |o| o.later_callback }
-      after_initialize(:final) { |o| o.final_callback}
+      after_initialize(:first, &:first_callback)
+      after_initialize(:early, &:early_callback)
+      after_initialize(:default, &:default_callback)
+      after_initialize(:unknown, &:unknown_callback)
+      after_initialize(:later, &:later_callback)
+      after_initialize(:final, &:final_callback)
     end
   end
 
@@ -54,6 +59,7 @@ describe Masamune::AfterInitializeCallbacks do
       instance.after_initialize_invoke
     end
 
-    it 'should call callbacks in priority order' do; end
+    it 'should call callbacks in priority order' do
+    end
   end
 end

data/spec/masamune/commands/aws_emr_spec.rb

@@ -37,43 +37,43 @@ describe Masamune::Commands::AwsEmr do
     it { is_expected.to be_empty }
 
     context 'with config file' do
-      let(:configuration) { {config_file: '/etc/aws/config'} }
-      it { is_expected.to eq({'AWS_CONFIG_FILE' => '/etc/aws/config'}) }
+      let(:configuration) { { config_file: '/etc/aws/config' } }
+      it { is_expected.to eq('AWS_CONFIG_FILE' => '/etc/aws/config') }
     end
   end
 
   describe '#command_args' do
     subject { instance.command_args }
 
-    it { is_expected.to eq(['aws', 'emr', 'ssh']) }
+    it { is_expected.to eq(%w(aws emr ssh)) }
 
     context 'with --cluster-id j-XYZ' do
       let(:delegate) { double(command_args: ['hive', '-e', "'show tables;'"]) }
       let(:attrs) { { config_file: '/etc/aws_config', cluster_id: 'j-XYZ' } }
 
       before do
-        expect(instance).to receive(:execute).with('aws', 'emr', 'ssh', '--cluster-id', 'j-XYZ', '--command', 'exit', {env: {"AWS_CONFIG_FILE"=>"/etc/aws_config"}, fail_fast: true, safe: true}).
-          and_yield('ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=10 -i /etc/ssh/aws.key hadoop@ec2-10.0.0.1.compute-1.amazonaws.com exit').
-          and_yield("Warning: Permanently added 'ec2-10.0.0.1.compute-1.amazonaws.com,10.0.0.1' (ECDSA) to the list of known hosts.")
+        expect(instance).to receive(:execute).with('aws', 'emr', 'ssh', '--cluster-id', 'j-XYZ', '--command', 'exit', env: { 'AWS_CONFIG_FILE' => '/etc/aws_config' }, fail_fast: true, safe: true)
+          .and_yield('ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=10 -i /etc/ssh/aws.key hadoop@ec2-10.0.0.1.compute-1.amazonaws.com exit')
+          .and_yield("Warning: Permanently added 'ec2-10.0.0.1.compute-1.amazonaws.com,10.0.0.1' (ECDSA) to the list of known hosts.")
       end
 
-      it { is_expected.to eq(['ssh', '-o', 'StrictHostKeyChecking=no', '-o', 'ServerAliveInterval=10', '-i', '/etc/ssh/aws.key', 'hadoop@ec2-10.0.0.1.compute-1.amazonaws.com', 'hive' , '-e', "'show tables;'"]) }
+      it { is_expected.to eq(['ssh', '-o', 'StrictHostKeyChecking=no', '-o', 'ServerAliveInterval=10', '-i', '/etc/ssh/aws.key', 'hadoop@ec2-10.0.0.1.compute-1.amazonaws.com', 'hive', '-e', "'show tables;'"]) }
     end
 
     context 'with action' do
-      let(:configuration) { { create_cluster: { options: {'--ami-version' =>  '3.5.0'} } } }
+      let(:configuration) { { create_cluster: { options: { '--ami-version' => '3.5.0' } } } }
       let(:attrs) { { action: 'create-cluster', extra: ['--instance-type', 'm1.large'] } }
       it { is_expected.to eq(['aws', 'emr', 'create-cluster', '--ami-version', '3.5.0', '--instance-type', 'm1.large']) }
     end
 
     context 'with action and option override (symbolized)' do
-      let(:configuration) { { create_cluster: { options: {:'--ami-version' => '3.5.0'} } } }
+      let(:configuration) { { create_cluster: { options: { :'--ami-version' => '3.5.0' } } } }
       let(:attrs) { { action: 'create-cluster', extra: ['--ami-version', '4.0.0', '--instance-type', 'm1.large'] } }
       it { is_expected.to eq(['aws', 'emr', 'create-cluster', '--ami-version', '4.0.0', '--instance-type', 'm1.large']) }
     end
 
     context 'with action and option override (stringified)' do
-      let(:configuration) { { 'create_cluster' => { 'options' => {'--ami-version' =>  '3.5.0'} } } }
+      let(:configuration) { { 'create_cluster' => { 'options' => { '--ami-version' => '3.5.0' } } } }
       let(:attrs) { { action: 'create-cluster', extra: ['--ami-version', '4.0.0', '--instance-type', 'm1.large'] } }
       it { is_expected.to eq(['aws', 'emr', 'create-cluster', '--ami-version', '4.0.0', '--instance-type', 'm1.large']) }
     end