masking 0.0.1

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'rake/notes/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop notes]

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'masking'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'pry'
+Pry.start

data/bin/masking_profile

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'masking'
+require 'masking/cli'
+
+require 'ruby-prof'
+
+original_stdout = $stdout.clone
+$stdout.reopen(File.new(File::NULL, 'w'))
+
+result = RubyProf.profile do
+  Masking::Cli.new(ARGV).run
+end
+
+$stdout.reopen(original_stdout)
+
+flat_result_file = Pathname(__dir__).join('../profile/flat.txt')
+RubyProf::FlatPrinterWithLineNumbers.new(result).tap do |flat_printer|
+  flat_printer.print(File.new(flat_result_file, 'w'))
+  puts "flat result is saved at #{flat_result_file}"
+end
+
+# it can produce big file. just comment out if you don't want to use it
+graph_file = Pathname(__dir__).join('../profile/graph.txt')
+RubyProf::GraphPrinter.new(result).tap do |graph_html_printer|
+  graph_html_printer.print(File.new(graph_file, 'w'))
+  puts "graph result is saved at #{graph_file}"
+end
+
+# it can produce huge html file. just comment out if you don't want to use it
+graph_html_file = Pathname(__dir__).join('../profile/graph.html')
+RubyProf::GraphHtmlPrinter.new(result).tap do |graph_html_printer|
+  graph_html_printer.print(File.new(graph_html_file, 'w'))
+  puts "graph html is saved at #{graph_html_file}"
+end
+
+# # this is quite slow so commented out. but it's useful
+# call_stack_html_file = Pathname(__dir__).join('../profile/call_stack.html')
+# RubyProf::CallStackPrinter.new(result).tap do |call_stack_html_printer|
+#   call_stack_html_printer.print(File.new(call_stack_html_file, 'w'))
+#   puts "call stack html is saved at #{call_stack_html_file}"
+# end
+
+# # I'm not sure how to read this
+# call_graph_dot_file = Pathname(__dir__).join('../profile/call_graph.dot')
+# RubyProf::DotPrinter.new(result).tap do |dot_printer|
+#   dot_printer.print(File.new(call_graph_dot_file, 'w'))
+#   puts "call graph dot file is saved at #{call_graph_dot_file}"
+# end
+
+# # I'm not sure how to read this
+# call_tree_dir = Pathname(__dir__).join('../profile/call_tree')
+# RubyProf::CallTreePrinter.new(result).tap do |call_tree_printer|
+#   call_tree_printer.print(path: File.dirname(call_tree_dir) , profile: File.basename(call_tree_dir))
+#   puts "call tree file is saved at #{call_tree_dir}"
+# end

data/bin/setup

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+if [[ ! -a masking.yml ]]; then
+  cp masking.yml.sample masking.yml
+fi

data/exe/masking

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'masking'
+require 'masking/cli'
+
+Masking::Cli.new(ARGV).run

data/lib/masking.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'masking/version'
+require 'masking/cli'
+require 'masking/config'
+require 'masking/sql_dump_line'
+
+module Masking
+  class << self
+    def run
+      Main.new.run
+    end
+  end
+
+  class Main
+    def initialize(input: $stdin, output: $stdout)
+      @input  = input.set_encoding(Encoding::ASCII_8BIT, Encoding::ASCII_8BIT)
+      @output = output.set_encoding(Encoding::ASCII_8BIT, Encoding::ASCII_8BIT)
+    end
+
+    def run
+      input.each_line do |line|
+        output.print SQLDumpLine.new(line).output
+      end
+    end
+
+    private
+
+    attr_reader :input, :output
+  end
+end

data/lib/masking/cli.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'masking/config'
+require 'masking/errors'
+require 'masking/cli/error_message'
+require 'optparse'
+
+module Masking
+  class Cli
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def run
+      option_parser.parse(argv)
+      Masking.run
+    rescue Masking::Error => error
+      warn(Masking::Cli::ErrorMessage.new(error).message(config_file_path: Masking.config.target_columns_file_path))
+      exit(false)
+    end
+
+    private
+
+    attr_reader :argv
+
+    def option_parser
+      OptionParser.new do |parser|
+        parser.banner = 'Usage: masking [options]'
+
+        define_config_option(parser)
+      end
+    end
+
+    def define_config_option(parser)
+      parser.on('-cFILE_PATH', '--config=FILE_PATH', 'specify config file. default: masking.yml') do |file_path|
+        Masking.configure do |config|
+          config.target_columns_file_path = file_path
+        end
+      end
+    end
+  end
+end

data/lib/masking/cli/error_message.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'ostruct'
+
+module Masking
+  class Cli
+    class ErrorMessage
+      def initialize(error_class)
+        @error_class = error_class
+      end
+
+      def message(**keyword_args)
+        error_message(keyword_args)
+      end
+
+      private
+
+      attr_reader :error_class
+
+      YAML_FILE_PATH = Pathname('lib/masking/cli/error_messages.yml')
+
+      def error_messages
+        @error_messages = YAML.safe_load(YAML_FILE_PATH.read)
+      end
+
+      def error_message(keyword_args)
+        ERB.new(
+          error_messages.fetch(error_class.to_s)
+        ).result(
+          OpenStruct.new(keyword_args).instance_eval { binding }
+        )
+      end
+    end
+  end
+end

data/lib/masking/cli/error_messages.yml

@@ -0,0 +1,6 @@
+Masking::Error::ConfigFileDoesNotExist:
+  "ERROR: config file (<%= config_file_path %>) does not exist"
+Masking::Error::ConfigFileIsNotFile:
+  "ERROR: config file (<%= config_file_path %>) is not file"
+Masking::Error::ConfigFileIsNotValidYaml:
+  "ERROR: config file (<%= config_file_path %>) is not valid yaml format"

data/lib/masking/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'masking/config/target_columns'
+
+module Masking
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+
+  class Config
+    DEFAULT_TARGET_COLUMNS_YAML_PATH = Pathname('masking.yml')
+    attr_reader :target_columns_file_path
+
+    def initialize
+      @target_columns_file_path = DEFAULT_TARGET_COLUMNS_YAML_PATH
+    end
+
+    def target_columns_file_path=(val)
+      @target_columns_file_path = Pathname(val)
+      @target_columns = TargetColumns.new(target_columns_file_path)
+    end
+
+    def target_columns
+      @target_columns ||= TargetColumns.new(target_columns_file_path)
+    end
+  end
+end

data/lib/masking/config/target_columns.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'masking/config/target_columns/table'
+require 'masking/config/target_columns/column'
+require 'masking/errors'
+
+module Masking
+  class Config
+    # TODO: find better naming of TargetColumns
+    class TargetColumns
+      attr_reader :file_path
+
+      def initialize(file_path)
+        @file_path = file_path
+
+        raise Masking::Error::ConfigFileDoesNotExist unless file_path.exist?
+        raise Masking::Error::ConfigFileIsNotFile unless file_path.file?
+      end
+
+      def contains?(table_name:)
+        data.key?(table_name)
+      end
+
+      # TODO: refactoring
+      def columns(table_name:)
+        tables.find { |table| table.name == table_name.to_sym }&.columns
+      end
+
+      def ==(other)
+        file_path == other.file_path
+      end
+
+      private
+
+      def data
+        @data ||= YAML.safe_load(file_path.read, [Date, Time])
+      rescue Psych::SyntaxError
+        raise Masking::Error::ConfigFileIsNotValidYaml
+      end
+
+      # TODO: extract to other class
+      def tables
+        @tables ||= [].tap do |arr|
+          data.each do |table_name, columns|
+            arr << Table.new(table_name, columns: columns)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/masking/config/target_columns/column.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'masking/config/target_columns/method'
+
+module Masking
+  class Config
+    class TargetColumns
+      class Column
+        attr_reader :name, :table_name, :method_value
+
+        def initialize(name, table_name:, method_value:)
+          @name         = name.to_sym
+          @table_name   = table_name.to_sym
+          @method_value = method_value
+          @method       = Method.new(method_value)
+        end
+
+        def masked_value
+          method.call
+        end
+
+        def ==(other)
+          name == other.name && table_name == other.table_name && method_value == other.method_value
+        end
+
+        private
+
+        attr_reader :method
+      end
+    end
+  end
+end

data/lib/masking/config/target_columns/method.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+Dir[Pathname(__FILE__).dirname.join('method/*.rb').to_s].each(&method(:require))
+require 'forwardable'
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        extend Forwardable
+
+        def initialize(method)
+          @method_type = mapping(method.class).new(method)
+        end
+
+        def_delegator :@method_type, :call
+
+        private
+
+        # rubocop:disable Layout/AlignHash
+        MAPPING = {
+          ::String     => StringBinaryDistinctor,
+          ::Integer    => Integer,
+          ::Float      => Float,
+          ::Date       => Date,
+          ::Time       => Time,
+          ::TrueClass  => Boolean,
+          ::FalseClass => Boolean,
+          ::NilClass   => Null
+        }.freeze
+        # rubocop:enable Layout/AlignHash
+
+        def mapping(klass)
+          MAPPING[klass] || raise(UnknownType)
+        end
+
+        class UnknownType < RuntimeError; end
+      end
+    end
+  end
+end

data/lib/masking/config/target_columns/method/binary.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class Binary
+          def initialize(value)
+            @binary = value
+          end
+
+          def call
+            "_binary '#{binary}'".b
+          end
+
+          private
+
+          attr_reader :binary
+        end
+      end
+    end
+  end
+end

data/lib/masking/config/target_columns/method/boolean.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class Boolean
+          def initialize(value)
+            @boolean = value
+          end
+
+          def call
+            boolean_format.to_s
+          end
+
+          private
+
+          attr_reader :boolean
+
+          # NOTE: 11.1.1 Numeric Type Overview, chapter BOOL, BOOLEAN
+          #       https://dev.mysql.com/doc/refman/8.0/en/numeric-type-overview.html
+          def boolean_format
+            boolean ? 1 : 0
+          end
+        end
+      end
+    end
+  end
+end