masking 0.0.1

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class Date
+          def initialize(value)
+            @date = value
+          end
+
+          def call
+            "'#{date_format}'"
+          end
+
+          private
+
+          attr_reader :date
+          FORMAT = '%Y-%m-%d'
+
+          def date_format
+            date.strftime(FORMAT)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class Float
+          def initialize(value)
+            @float = value
+          end
+
+          def call
+            float.to_s
+          end
+
+          private
+
+          attr_reader :float
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class Integer
+          def initialize(value)
+            @integer = value
+          end
+
+          def call
+            integer.to_s
+          end
+
+          private
+
+          attr_reader :integer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class Null
+          def initialize(*); end
+
+          def call
+            'NULL'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class String
+          def initialize(value)
+            @string   = value
+            @sequence = 0
+          end
+
+          def call
+            "'#{output}'".b
+          end
+
+          private
+
+          attr_reader :string
+          SEQUENTIAL_NUMBER_PLACEHOLDER = /%{n}/.freeze
+
+          def output
+            string.sub(SEQUENTIAL_NUMBER_PLACEHOLDER, sequence.to_s)
+          end
+
+          def sequence
+            @sequence += 1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'masking/config/target_columns/method/binary'
+require 'masking/config/target_columns/method/string'
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        module StringBinaryDistinctor
+          class << self
+            def new(value)
+              binary?(value) ? Binary.new(value) : String.new(value)
+            end
+
+            private
+
+            # NOTE: this is referenced code from standard library
+            #   ruby/psych: Rely on encoding tags to determine if string should be dumped as binary
+            #   https://github.com/ruby/psych/commit/8949a47b8cee31e03e21608406ba116adcf74054
+            #   https://github.com/ruby/psych/issues/278
+            #   https://github.com/ruby/psych/blob/e01839af57df559b26f74e906062be6c692c89c8/lib/psych/visitors/yaml_tree.rb#L419-L421
+            def binary?(string)
+              string.encoding == Encoding::ASCII_8BIT
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Masking
+  class Config
+    class TargetColumns
+      class Method
+        class Time
+          def initialize(value)
+            @time = value
+          end
+
+          def call
+            "'#{time_format}'"
+          end
+
+          private
+
+          attr_reader :time
+          FORMAT = '%Y-%m-%d %H:%M:%S'
+
+          def time_format
+            time.strftime(FORMAT)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'masking/config/target_columns/column'
+
+module Masking
+  class Config
+    class TargetColumns
+      class Table
+        attr_reader :name, :columns
+
+        def initialize(name, columns:)
+          @name = name.to_sym
+          @columns = columns.map do |column, method_value|
+            Masking::Config::TargetColumns::Column.new(column, table_name: self.name, method_value: method_value)
+          end
+        end
+
+        def ==(other)
+          name == other.name
+        end
+      end
+    end
+  end
+end

data/lib/masking/data_mask_processor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'masking/config/target_columns'
+require 'masking/insert_statement'
+
+module Masking
+  # TODO: find better naming/modeling of DataMaskProcessor
+  class DataMaskProcessor
+    class << self
+      def process(insert_statement_line, target_columns: ::Masking.config.target_columns)
+        new(insert_statement_line, target_columns: target_columns).send(:process)
+      end
+    end
+
+    private
+
+    attr_reader :raw_line, :target_columns, :insert_statement
+
+    def initialize(insert_statement_line, target_columns:)
+      @raw_line         = insert_statement_line
+      @target_columns   = target_columns
+      @insert_statement = InsertStatement.new(insert_statement_line)
+    end
+
+    # TODO: define insert_statement.mask_values(column, mask_method) method & refactoring
+    # rubocop:disable Metrics/AbcSize
+    def process
+      return raw_line unless target_table?
+
+      target_columns.columns(table_name: insert_statement.table).each do |target_column|
+        insert_statement.values.map do |value|
+          value[target_column.name] = target_column.masked_value if value.column?(target_column.name)
+        end
+      end
+
+      insert_statement.sql
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def target_table?
+      target_columns.contains?(table_name: insert_statement.table)
+    end
+  end
+end

data/lib/masking/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Masking
+  class Error < StandardError
+    class ConfigFileDoesNotExist < Error; end
+    class ConfigFileIsNotFile < Error; end
+    class ConfigFileIsNotValidYaml < Error; end
+  end
+end

data/lib/masking/insert_statement.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'masking/insert_statement/value'
+require 'masking/insert_statement/sql_builder'
+
+module Masking
+  class InsertStatement
+    attr_reader :raw_statement, :table
+
+    def initialize(raw_statement)
+      @raw_statement = raw_statement
+
+      PARSE_REGEXP.match(raw_statement).tap do |match_data|
+        @table           = match_data[:table]
+        @columns_section = match_data[:columns_section]
+        @values_section  = match_data[:values_section]
+      end
+    end
+
+    def columns
+      # NOTE: define and extract to ColumnSet class?
+      @columns ||= columns_section.scan(COLUMNS_REGEXP).flatten.map(&:to_sym)
+    end
+
+    def values
+      # NOTE: define and extract to ValueSet class?
+      @values ||= values_section.split(VALUE_ROW_SPLITTER)
+                                .tap { |rows| rows.each_with_index { |_, i| recursive_pattern_value_concat(rows, i) } }
+                                .map { |row| row.scan(values_regexp).flatten }
+                                .map { |data| Value.new(columns: columns, data: data) }
+    end
+
+    def sql
+      SQLBuilder.build(table: table, columns: columns, values: values)
+    end
+
+    private
+
+    attr_reader :columns_section, :values_section
+
+    VALUE_ROW_SPLITTER = '),('
+    PARSE_REGEXP = /INSERT INTO `(?<table>.+)` \((?<columns_section>.+)\) VALUES (?<values_section>.+);/.freeze
+    COLUMNS_REGEXP = /`(.*?)`/.freeze
+
+    # NOTE: in mysqldump,
+    #   integer/float/NULL type has dumped without single quote. e.g. -123 / 2.4 / NULL
+    #   string/time type has dumped with single quote. e.g. 'string' / '2018-08-22 13:27:34'
+    #   binary/blob type has dumped with _binary prefix. e.g. _binary 'binarydata'
+    #   if there is single quote inside of value, it will dumped with escape. e.g. 'chikahiro\'s item'
+    #   in number, there could be include Scientific notation e.g. 1.2E3 / -1.2E-3 / 1e+030 / 9.71726e-17
+    #     refs: https://dev.mysql.com/doc/refman/5.7/en/precision-math-numbers.html
+    NUMBER_REGEXP      = '[+eE0-9.-]+'
+    NULL_REGEXP        = 'NULL'
+    STRING_TIME_REGEXP = "'.*?'"
+    BINARY_REGEXP      = "_binary '.*?'"
+
+    VALUE_REGEXP = "(#{NUMBER_REGEXP}|#{NULL_REGEXP}|#{STRING_TIME_REGEXP}|#{BINARY_REGEXP})"
+
+    def values_regexp
+      @values_regexp ||= /^\(?#{([VALUE_REGEXP] * columns.count).join(?,)}\)?$/
+    end
+
+    # Check single quote count on each value, and just continue if it's even number.
+    # if it's odd, concat with next row (it means a value contains "),(" pattern)
+    #   e.g. INSERT ... VALUES (123,'string ),( abc'),(456,'ab');
+    # refs: implementation of parsing CSV on ruby standard library FasterCSV (ja): https://www.clear-code.com/blog/2018/12/25.html
+    def recursive_pattern_value_concat(value_rows, index)
+      return if value_rows[index].gsub(/\\\\/, '').gsub(/\\'/, '').scan(/'/).count.even?
+
+      value_rows[index] += VALUE_ROW_SPLITTER + value_rows.delete_at(index + 1)
+      recursive_pattern_value_concat(value_rows, index)
+    end
+  end
+end

data/lib/masking/insert_statement/sql_builder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Masking
+  class InsertStatement
+    class SQLBuilder
+      class << self
+        def build(table:, columns:, values:)
+          new(table: table, columns: columns, values: values).send(:build)
+        end
+      end
+
+      private
+
+      attr_reader :table, :columns, :values
+      def initialize(table:, columns:, values:)
+        @table   = table
+        @columns = columns
+        @values  = values
+      end
+
+      def build
+        %(INSERT INTO `#{table}` #{columns_section} VALUES #{values_section};\n)
+      end
+
+      def columns_section
+        '(' + columns.map { |column| "`#{column}`" }.join(', ') + ')'
+      end
+
+      def values_section
+        values.map(&:phrase).join(?,)
+      end
+    end
+  end
+end

data/lib/masking/insert_statement/value.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Masking
+  class InsertStatement
+    class Value < ::SimpleDelegator
+      def initialize(columns:, data:)
+        @columns = columns
+        @data    = Struct.new(*columns).new(*data)
+        # NOTE: is it better to get rid of SimpleDelegator, store data in instance variable and define accesor for it?
+        super(@data)
+      end
+
+      def phrase
+        '(' + to_a.join(?,) + ')'
+      end
+
+      # override for make comparable
+      # NOTE: original #== method comapares struct subclass
+      def ==(other)
+        to_h == other.to_h
+      end
+
+      def column?(column_name)
+        @columns.include?(column_name.to_sym)
+      end
+    end
+  end
+end

data/lib/masking/sql_dump_line.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'masking/data_mask_processor'
+
+module Masking
+  class SQLDumpLine
+    def initialize(line)
+      @line = line
+    end
+
+    def output
+      insert_statement? ? DataMaskProcessor.process(line) : line
+    end
+
+    private
+
+    attr_reader :line
+    INSERT_STATEMENT_REGEXP = /^INSERT/.freeze
+
+    def insert_statement?
+      line.match?(INSERT_STATEMENT_REGEXP)
+    end
+  end
+end

data/lib/masking/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Masking
+  VERSION = '0.0.1'
+end