master_data_tool 0.21.1 → 0.23.0

data/lib/master_data_tool/import/executor.rb

@@ -3,53 +3,41 @@
 module MasterDataTool
   module Import
     class Executor
-      def initialize(spec_config:,
-                     dry_run: true,
-                     verify: true,
-                     only_import_tables: [],
-                     except_import_tables: [],
-                     only_verify_tables: [],
-                     except_verify_tables: [],
-                     skip_no_change: true,
-                     silent: false,
-                     delete_all_ignore_foreign_key: false,
-                     override_identifier: nil,
-                     report_printer: nil)
+      def initialize(spec_config:, import_config: nil, verify_config: nil,
+                     dry_run: true, verify: true, silent: false,
+                     override_identifier: nil, report_printer: nil)
 
         @spec_config = spec_config
+        @import_config = import_config || MasterDataTool::Import::Config.default_config
+        @verify_config = verify_config || MasterDataTool::Verify::Config.default_config
+
         @dry_run = dry_run
         @verify = verify
-        @only_import_tables = Array(only_import_tables)
-        @except_import_tables = Array(except_import_tables)
-        @only_verify_tables = Array(only_verify_tables)
-        @except_verify_tables = Array(except_verify_tables)
-        @skip_no_change = skip_no_change
         @silent = silent
-        @delete_all_ignore_foreign_key = delete_all_ignore_foreign_key
+
         @override_identifier = override_identifier
-        @report_printer = report_printer || MasterDataTool::Report::DefaultPrinter.new(spec_config)
+        @report_printer = report_printer || MasterDataTool::Report::DefaultPrinter.new(spec_config: spec_config)
         @report_printer.silent = silent
-        @master_data_statuses = []
+
+        @master_data_statuses_by_name = {}
       end
 
       def execute
-        spec_config.application_record_class.transaction do
-          MasterDataTool::MasterDataStatus.transaction do
-            print_execute_options
-            load_master_data_statuses
+        transaction do
+          print_execute_options
+          load_master_data_statuses
 
-            master_data_collection = build_master_data_collection
+          master_data_collection = build_master_data_collection
 
-            import_all!(master_data_collection)
-            verify_all!(master_data_collection) if verify
-            save_master_data_statuses!(master_data_collection)
+          import_all!(master_data_collection)
+          verify_all!(master_data_collection) if verify
+          save_master_data_statuses!(master_data_collection)
 
-            print_affected_tables(master_data_collection)
+          print_affected_tables(master_data_collection)
 
-            raise DryRunError if dry_run
+          raise DryRunError if dry_run
 
-            master_data_collection
-          end
+          master_data_collection
         end
       rescue DryRunError
         puts "[DryRun] end"
@@ -57,25 +45,33 @@ module MasterDataTool
 
       private
 
-      attr_reader :master_data_statuses, :spec_config, :dry_run, :verify, :only_import_tables, :except_import_tables, :only_verify_tables,
-                  :except_verify_tables, :skip_no_change, :silent, :delete_all_ignore_foreign_key, :override_identifier, :report_printer
+      attr_reader :master_data_statuses_by_name, :spec_config, :import_config, :verify_config,
+                  :dry_run, :verify, :silent, :override_identifier, :report_printer
+
+      def transaction
+        spec_config.application_record_class.transaction do
+          MasterDataTool::MasterDataStatus.transaction do
+            yield
+          end
+        end
+      end
 
       def print_execute_options
         return if silent
 
         puts "==== execute ===="
         instance_variables.each do |k|
-          puts "#{k}: #{instance_variable_get(k)}"
+          puts "#{k}: #{instance_variable_get(k).inspect}"
         end
         puts "================="
       end
 
       def build_master_data_collection
         MasterDataCollection.new.tap do |collection|
-          MasterDataTool::MasterDataFileCollection.new(spec_config.spec_name, override_identifier: override_identifier).each do |master_data_file|
+          MasterDataTool::MasterDataFileCollection.new(spec_name: spec_config.spec_name, override_identifier: override_identifier).each do |master_data_file|
             load_skip = load_skip_table?(master_data_file)
-            master_data = MasterData.build(spec_config, master_data_file, load: !load_skip)
-            collection.append(master_data)
+            master_data = MasterData.build(spec_config: spec_config, master_data_file: master_data_file, load: !load_skip)
+            collection.append(master_data: master_data)
           end
         end
       end
@@ -83,19 +79,19 @@ module MasterDataTool
       def import_all!(master_data_collection)
         master_data_collection.each do |master_data|
           next unless master_data.loaded?
-          next if import_skip_table?(master_data.table_name)
+          next if import_config.skip_table?(master_data.table_name)
 
-          report = master_data.import!(dry_run: dry_run, delete_all_ignore_foreign_key: delete_all_ignore_foreign_key)
-          report.print(report_printer)
+          report = master_data.import!(import_config: import_config, dry_run: dry_run)
+          report.print(printer: report_printer)
         end
       end
 
       def verify_all!(master_data_collection)
         master_data_collection.each do |master_data|
-          next if verify_skip_table?(master_data.table_name)
+          next if verify_config.skip_table?(master_data.table_name)
 
-          report = master_data.verify!(ignore_fail: dry_run)
-          report.print(report_printer)
+          report = master_data.verify!(verify_config: verify_config, ignore_fail: dry_run)
+          report.print(printer: report_printer)
         end
       end
 
@@ -104,10 +100,10 @@ module MasterDataTool
         master_data_collection.each do |master_data|
           next unless master_data.loaded?
 
-          records << MasterDataTool::MasterDataStatus.build(spec_config.spec_name, master_data.master_data_file)
+          records << MasterDataTool::MasterDataStatus.build(spec_name: spec_config.spec_name, master_data_file: master_data.master_data_file)
         end
 
-        MasterDataTool::MasterDataStatus.import_records!(records, dry_run: dry_run)
+        MasterDataTool::MasterDataStatus.import_records!(records: records, dry_run: dry_run)
       end
 
       def print_affected_tables(master_data_collection)
@@ -116,57 +112,34 @@ module MasterDataTool
           next unless master_data.affected?
 
           report = master_data.print_affected_table
-          report&.print(report_printer)
+          report&.print(printer: report_printer)
         end
       end
 
       def load_skip_table?(master_data_file)
-        return true if import_skip_table?(master_data_file.table_name)
-        return false unless skip_no_change
+        return true if import_config.skip_table?(master_data_file.table_name)
+        return false unless import_config.skip_no_change
 
-        master_data_status = master_data_statuses.dig(master_data_file.table_name)
+        master_data_status = master_data_statuses_by_name[master_data_file.table_name]
         return false unless master_data_status
 
         !master_data_status.will_change?(master_data_file)
       end
 
-      def import_skip_table?(table_name)
-        need_skip_table?(table_name, only_import_tables, except_import_tables)
-      end
-
-      def verify_skip_table?(table_name)
-        need_skip_table?(table_name, only_verify_tables, except_verify_tables)
-      end
-
-      # 1. onlyを指定した時点でそのリストに含まれるものだけになるべき
-      # 2. exceptのリストはどんな状況でも除外されるべき
-      # 3. それ以外はすべて実行する
-      def need_skip_table?(table_name, only, except)
-        only_result = only.presence&.include?(table_name)
-        except_result = except.presence&.include?(table_name)
-
-        # onlyが指定された時点でデフォルトはskipとする
-        default = only_result.nil? ? false : true
-        return true if except_result == true
-        return false if only_result == true
-
-        default
-      end
-
       def extract_master_data_csv_paths
-        pattern = MasterDataTool.config.csv_dir_for(spec_config.spec_name).join('*.csv').to_s
+        pattern = MasterDataTool.config.csv_dir_for(spec_name: spec_config.spec_name).join('*.csv').to_s
         Pathname.glob(pattern).select(&:file?)
       end
 
       def overridden_master_data_csv_paths
         return [] unless override_identifier
 
-        pattern = MasterDataTool.config.csv_dir_for(spec_config.spec_name, override_identifier).join('*.csv').to_s
+        pattern = MasterDataTool.config.csv_dir_for(spec_name: spec_config.spec_name, override_identifier: override_identifier).join('*.csv').to_s
         Pathname.glob(pattern).select(&:file?)
       end
 
       def load_master_data_statuses
-        @master_data_statuses = MasterDataTool::MasterDataStatus.fetch_all
+        @master_data_statuses_by_name = MasterDataTool::MasterDataStatus.all.index_by(&:name)
       end
     end
   end

data/lib/master_data_tool/import.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
+require_relative "import/config"
 require_relative "import/executor"

data/lib/master_data_tool/master_data.rb

@@ -2,17 +2,16 @@
 
 module MasterDataTool
   class MasterData
-    attr_reader :master_data_file, :model_klass, :columns, :new_records, :updated_records, :no_change_records, :deleted_records,
-                :before_count, :after_count, :spec_config
+    BULK_INSERT_SIZE = 1000
 
-    # @param [MasterDataTool::MasterDataFile] master_data_file
-    def initialize(spec_config, master_data_file, model_klass)
+    attr_reader :master_data_file, :model_klass, :columns, :spec_config
+
+    def initialize(spec_config:, master_data_file:, model_klass:)
       @spec_config = spec_config
       @master_data_file = master_data_file
       @model_klass = model_klass
 
       @loaded = false
-
       @columns = []
       @new_records = []
       @updated_records = []
@@ -21,26 +20,26 @@ module MasterDataTool
     end
 
     class << self
-      def build(spec_config, master_data_file, load: false)
+      def build(spec_config:, master_data_file:, load: false)
         model_klass = Object.const_get(master_data_file.table_name.classify)
-        new(spec_config, master_data_file, model_klass).tap do |record|
+        new(spec_config: spec_config, master_data_file: master_data_file, model_klass: model_klass).tap do |record|
           record.load if load
         end
       end
     end
 
     def basename
-      @master_data_file.basename
+      master_data_file.basename
     end
 
     def load
-      csv = CSV.read(@master_data_file.path, headers: true, skip_blanks: true)
-      old_records_by_id = @model_klass.all.index_by(&:id)
+      csv = CSV.read(master_data_file.path, headers: true, skip_blanks: true)
+      old_records_by_id = model_klass.all.index_by(&:id)
 
       csv_records_by_id = build_records_from_csv(csv, old_records_by_id)
       deleted_ids = old_records_by_id.keys - csv_records_by_id.keys
 
-      @columns = csv.headers
+      self.columns = csv.headers
 
       csv_records_by_id.each do |_, record|
         if record.new_record?
@@ -74,25 +73,25 @@ module MasterDataTool
     end
 
     def new_records
-      raise MasterDataTool::NotLoadedError unless @loaded
+      raise MasterDataTool::NotLoadedError unless loaded?
 
       @new_records
     end
 
     def updated_records
-      raise MasterDataTool::NotLoadedError unless @loaded
+      raise MasterDataTool::NotLoadedError unless loaded?
 
       @updated_records
     end
 
     def no_change_records
-      raise MasterDataTool::NotLoadedError unless @loaded
+      raise MasterDataTool::NotLoadedError unless loaded?
 
       @no_change_records
     end
 
     def deleted_records
-      raise MasterDataTool::NotLoadedError unless @loaded
+      raise MasterDataTool::NotLoadedError unless loaded?
 
       @deleted_records
     end
@@ -115,34 +114,42 @@ module MasterDataTool
     end
 
     def table_name
-      @model_klass.table_name
+      model_klass.table_name
     end
 
-    def import!(dry_run: true, delete_all_ignore_foreign_key: false)
-      raise MasterDataTool::NotLoadedError unless @loaded
+    def import!(import_config:, dry_run: true)
+      raise MasterDataTool::NotLoadedError unless loaded?
 
-      MasterDataTool::Report::ImportReport.new(self).tap do |report|
+      ignore_foreign_key_when_delete = import_config.ignore_foreign_key_when_delete
+
+      MasterDataTool::Report::ImportReport.new(master_data: self).tap do |report|
         return report if dry_run
         return report unless affected?
 
-        disable_foreign_key_checks if delete_all_ignore_foreign_key
-        @model_klass.delete_all
-        enable_foreign_key_checks if delete_all_ignore_foreign_key
+        disable_foreign_key_checks if ignore_foreign_key_when_delete
+        model_klass.delete_all
+        enable_foreign_key_checks if ignore_foreign_key_when_delete
 
-        # マスターデータ間の依存がある場合に投入順制御するのは大変なのでこのタイミングでのバリデーションはしない
-        @model_klass.import(import_records, validate: false, on_duplicate_key_update: @columns, timestamps: true)
+        import_records.each_slice(BULK_INSERT_SIZE) do |chunked_import_records|
+          records = chunked_import_records.map { |obj| obj.attributes.slice(*columns) }
+          model_klass.insert_all(records)
+        end
       end
     end
 
-    def verify!(ignore_fail: false)
-      MasterDataTool::Report::VerifyReport.new(self).tap do |report|
-        scoped = @model_klass.all
-        scoped = scoped.preload(preload_associations) if preload_associations
-        scoped = scoped.eager_load(eager_load_associations) if eager_load_associations
+    def verify!(verify_config:, ignore_fail: false)
+      MasterDataTool::Report::VerifyReport.new(master_data: self).tap do |report|
+        preload_associations = decide_preload_associations(verify_config)
+        eager_load_associations = decide_eager_load_associations(verify_config)
+
+        scoped = model_klass.all
+        scoped = scoped.preload(preload_associations) unless preload_associations.empty?
+        scoped = scoped.eager_load(eager_load_associations) unless eager_load_associations.empty?
 
         scoped.find_each do |record|
           valid = record.valid?
-          report.append(MasterDataTool::Report::VerifyReport.build_verify_record_report(self, record, valid))
+          report.append(report: MasterDataTool::Report::VerifyReport.build_verify_record_report(master_data: self, record: record, valid: valid))
+
           next if valid
           next if ignore_fail
 
@@ -158,24 +165,29 @@ module MasterDataTool
       return unless loaded?
       return unless affected?
 
-      MasterDataTool::Report::PrintAffectedTableReport.new(self)
+      MasterDataTool::Report::PrintAffectedTableReport.new(master_data: self)
     end
 
     private
 
-    def preload_associations
-      @preload_associations ||= spec_config.preload_associations.dig(@model_klass.to_s.to_sym)
+    attr_writer :loaded, :columns, :new_records, :updated_records,
+                :no_change_records, :deleted_records
+
+    def decide_preload_associations(verify_config)
+      preload_associations = model_klass.reflections.values.select(&:belongs_to?).map(&:name).map(&:to_sym) if verify_config.preload_belongs_to_associations
+      preload_associations += verify_config.preload_associations.dig(model_klass.to_s.to_sym)&.map(&:to_sym) || []
+      preload_associations.uniq
     end
 
-    def eager_load_associations
-      @eager_load_associations ||= spec_config.eager_load_associations.dig(@model_klass.to_s.to_sym)
+    def decide_eager_load_associations(verify_config)
+      verify_config.eager_load_associations.dig(model_klass.to_s.to_sym)&.map(&:to_sym) || []
     end
 
     def build_records_from_csv(csv, old_records_by_id)
       {}.tap do |records|
         csv.each do |row|
           id = row['id'].to_i
-          record = old_records_by_id[id] || @model_klass.new(id: id)
+          record = old_records_by_id[id] || model_klass.new(id: id)
 
           csv.headers.each do |key|
             record[key.to_s] = row[key]

data/lib/master_data_tool/master_data_collection.rb

@@ -6,7 +6,7 @@ module MasterDataTool
       @collection = []
     end
 
-    def append(master_data)
+    def append(master_data:)
       @collection << master_data
     end
 

data/lib/master_data_tool/master_data_file.rb

@@ -3,7 +3,7 @@ module MasterDataTool
   class MasterDataFile
     attr_reader :spec_name, :table_name, :path, :override_identifier
 
-    def initialize(spec_name, table_name, path, override_identifier)
+    def initialize(spec_name:, table_name:, path:, override_identifier:)
       @spec_name = spec_name
       @table_name = table_name
       @path = path
@@ -12,9 +12,9 @@ module MasterDataTool
     end
 
     class << self
-      def build(spec_name, path, override_identifier)
-        table_name = MasterDataTool.resolve_table_name(spec_name, path, override_identifier)
-        new(spec_name, table_name, path, override_identifier)
+      def build(spec_name:, path:, override_identifier:)
+        table_name = MasterDataTool.resolve_table_name(spec_name: spec_name, csv_path: path, override_identifier: override_identifier)
+        new(spec_name: spec_name, table_name: table_name, path: path, override_identifier: override_identifier)
       end
     end
 

data/lib/master_data_tool/master_data_file_collection.rb

@@ -2,7 +2,7 @@
 
 module MasterDataTool
   class MasterDataFileCollection
-    def initialize(spec_name, override_identifier: nil)
+    def initialize(spec_name:, override_identifier: nil)
       @spec_name = spec_name
       @override_identifier = override_identifier
       @collection = build
@@ -13,7 +13,7 @@ module MasterDataTool
     def each
       return enum_for(:each) unless block_given?
 
-      @collection.each do |file|
+      collection.each do |file|
         yield file
       end
     end
@@ -24,8 +24,10 @@ module MasterDataTool
 
     private
 
+    attr_reader :spec_name, :override_identifier, :collection
+
     def build
-      files = extract_master_data_csv_paths.presence&.index_by(&:table_name)
+      files = extract_master_data_csv_paths.presence&.index_by(&:table_name) || {}
       overridden_files = overridden_master_data_csv_paths.presence&.index_by(&:table_name) || {}
 
       table_names = (files.keys + overridden_files.keys).uniq
@@ -35,18 +37,18 @@ module MasterDataTool
     end
 
     def extract_master_data_csv_paths
-      pattern = MasterDataTool.config.csv_dir_for(@spec_name).join('*.csv').to_s
+      pattern = MasterDataTool.config.csv_dir_for(spec_name: spec_name).join('*.csv').to_s
       Pathname.glob(pattern).select(&:file?).map do |path|
-        MasterDataFile.build(@spec_name, path, nil)
+        MasterDataFile.build(spec_name: spec_name, path: path, override_identifier: nil)
       end
     end
 
     def overridden_master_data_csv_paths
-      return [] if @override_identifier.blank?
+      return [] if override_identifier.blank?
 
-      pattern = MasterDataTool.config.csv_dir_for(@spec_name, @override_identifier).join('*.csv').to_s
+      pattern = MasterDataTool.config.csv_dir_for(spec_name: spec_name, override_identifier: override_identifier).join('*.csv').to_s
       Pathname.glob(pattern).select(&:file?).map do |path|
-        MasterDataFile.build(@spec_name, path, @override_identifier)
+        MasterDataFile.build(spec_name: spec_name, path: path, override_identifier: override_identifier)
       end
     end
   end

data/lib/master_data_tool/master_data_status.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'active_record'
-require 'activerecord-import'
 require 'openssl'
 
 module MasterDataTool
@@ -20,28 +19,38 @@ module MasterDataTool
       version != self.class.decide_version(master_data_file.path)
     end
 
-    class << self
-      def fetch_all
-        all.index_by(&:name)
-      end
+    def model_klass
+      Object.const_get(name.classify)
+    end
 
-      def build(spec_name, master_data_file)
+    class << self
+      def build(spec_name:, master_data_file:)
         version = decide_version(master_data_file.path)
-        new(spec_name: spec_name, name: MasterDataTool.resolve_table_name(spec_name, master_data_file.path, master_data_file.override_identifier), version: version)
+        name = MasterDataTool.resolve_table_name(spec_name: spec_name, csv_path: master_data_file.path, override_identifier: master_data_file.override_identifier)
+        new(spec_name: spec_name, name: name, version: version)
       end
 
-      def import_records!(records, dry_run: true)
+      def import_records!(records:, dry_run: true)
         if dry_run
           pp records
           return
         end
 
-        import!(records, validate: true, on_duplicate_key_update: %w[name version], timestamps: true)
+        return if records.empty?
+
+        import_records = records.map { |obj| obj.attributes.slice(*import_columns) }
+        upsert_all(import_records, update_only: %w[version])
       end
 
       def decide_version(csv_path)
         OpenSSL::Digest::SHA256.hexdigest(File.open(csv_path).read)
       end
+
+      private
+
+      def import_columns
+        %w[spec_name name version]
+      end
     end
   end
 end

data/lib/master_data_tool/report/core.rb

@@ -5,11 +5,11 @@ module MasterDataTool
     module Core
       attr_reader :master_data
 
-      def initialize(master_data)
+      def initialize(master_data:)
         @master_data = master_data
       end
 
-      def print(printer)
+      def print(printer:)
         raise NotImplementedError
       end
 

data/lib/master_data_tool/report/default_printer.rb

@@ -5,7 +5,7 @@ module MasterDataTool
     class DefaultPrinter
       include Printer
 
-      def print(message)
+      def print(message:)
         return if silent
         return if message.blank?
 

data/lib/master_data_tool/report/import_report.rb

@@ -5,14 +5,12 @@ module MasterDataTool
     class ImportReport
       include Core
 
-      attr_reader :reports
-
-      def print(printer)
+      def print(printer:)
         reports.each do |_, report|
           if report.is_a?(Array)
-            report.each { |r| printer.print(convert_to_ltsv(r)) }
+            report.each { |r| printer.print(message: convert_to_ltsv(r)) }
           else
-            printer.print(convert_to_ltsv(report))
+            printer.print(message: convert_to_ltsv(report))
           end
         end
       end
@@ -27,12 +25,12 @@ module MasterDataTool
         label = :count_report
         {}.tap do |report|
           report[label] = []
-          report[label] << {operation: :import, label: :count, table_name: master_data.table_name, before: master_data.before_count, after: master_data.after_count}
-          report[label] << {operation: :import, label: :affected, table_name: master_data.table_name, affected: master_data.affected?}
-          report[label] << {operation: :import, label: :new_count, table_name: master_data.table_name, count: master_data.new_records.count}
-          report[label] << {operation: :import, label: :updated_count, table_name: master_data.table_name, count: master_data.updated_records.count}
-          report[label] << {operation: :import, label: :no_change_count, table_name: master_data.table_name, count: master_data.no_change_records.count}
-          report[label] << {operation: :import, label: :deleted_count, table_name: master_data.table_name, count: master_data.deleted_records.count}
+          report[label] << { operation: :import, label: :count, table_name: master_data.table_name, before: master_data.before_count, after: master_data.after_count }
+          report[label] << { operation: :import, label: :affected, table_name: master_data.table_name, affected: master_data.affected? }
+          report[label] << { operation: :import, label: :new_count, table_name: master_data.table_name, count: master_data.new_records.count }
+          report[label] << { operation: :import, label: :updated_count, table_name: master_data.table_name, count: master_data.updated_records.count }
+          report[label] << { operation: :import, label: :no_change_count, table_name: master_data.table_name, count: master_data.no_change_records.count }
+          report[label] << { operation: :import, label: :deleted_count, table_name: master_data.table_name, count: master_data.deleted_records.count }
         end
       end
 
@@ -41,7 +39,7 @@ module MasterDataTool
         {}.tap do |report|
           report[label] = []
           master_data.new_records.each do |record|
-            report[label] << {operation: :import, label: :detail, table_name: master_data.table_name, status: :new, id: record.id}
+            report[label] << { operation: :import, label: :detail, table_name: master_data.table_name, status: :new, id: record.id }
           end
         end
       end
@@ -51,7 +49,7 @@ module MasterDataTool
         {}.tap do |report|
           report[label] = []
           master_data.updated_records.each do |record|
-            report[label] << {operation: :import, label: :detail, table_name: master_data.table_name, status: :updated, id: record.id, detail: record.changes_to_save}
+            report[label] << { operation: :import, label: :detail, table_name: master_data.table_name, status: :updated, id: record.id, detail: record.changes_to_save }
           end
         end
       end
@@ -61,7 +59,7 @@ module MasterDataTool
         {}.tap do |report|
           report[label] = []
           master_data.no_change_records.each do |record|
-            report[label] << {operation: :import, label: :detail, table_name: master_data.table_name, status: :no_change, id: record.id}
+            report[label] << { operation: :import, label: :detail, table_name: master_data.table_name, status: :no_change, id: record.id }
           end
         end
       end
@@ -71,7 +69,7 @@ module MasterDataTool
         {}.tap do |report|
           report[label] = []
           master_data.deleted_records.each do |record|
-            report[label] << {operation: :import, label: :detail, table_name: master_data.table_name, status: :deleted, id: record.id}
+            report[label] << { operation: :import, label: :detail, table_name: master_data.table_name, status: :deleted, id: record.id }
           end
         end
       end

data/lib/master_data_tool/report/print_affected_table_report.rb

@@ -5,8 +5,8 @@ module MasterDataTool
     class PrintAffectedTableReport
       include Core
 
-      def print(printer)
-        printer.print(convert_to_ltsv({operation: :affected_table, table_name: master_data.table_name}))
+      def print(printer:)
+        printer.print(message: convert_to_ltsv({ operation: :affected_table, table_name: master_data.table_name }))
       end
     end
   end

data/lib/master_data_tool/report/printer.rb

@@ -6,12 +6,12 @@ module MasterDataTool
       attr_reader :spec_config
       attr_accessor :silent
 
-      def initialize(spec_config, silent: false)
+      def initialize(spec_config:, silent: false)
         @spec_config = spec_config
         @silent = silent
       end
 
-      def print(message)
+      def print(message:)
         return if silent
 
         raise NotImplementedError