nacha 0.1.8 → 0.1.12

data/lib/nacha/parser.rb

@@ -1,33 +1,43 @@
 # frozen_string_literal: true
 
+require 'byebug'
 require 'nacha'
 require 'nacha/parser_context'
 
+# Nacha Parser - deal with figuring out what record type a line is
 class Nacha::Parser
-  DEFAULT_RECORD_TYPES = ['Nacha::Record::FileHeader',
-                         'Nacha::Record::Filler'].freeze
+  DEFAULT_RECORD_TYPES = [
+    'Nacha::Record::FileHeader',
+    'Nacha::Record::AdvFileHeader',
+    'Nacha::Record::Filler'
+  ].freeze
 
   attr_reader :context
 
   def initialize
     @context = Nacha::ParserContext.new
-    reset!
   end
 
-  def reset!; end
-
   def parse_file(file)
-    @context.parser_started_at = Time.now
+    @context.parser_started_at = Time.now.utc
     @context.file_name = file
     parse_string(file.read)
   end
 
+  def detect_possible_record_types(line)
+    Nacha.ach_record_types.filter_map do |record_type|
+      record_type if record_type.matcher.match?(line)
+    end
+  end
+
   def parse_string(str)
     line_num = -1
     records = []
-    @context.parser_started_at ||= Time.now
-    str.scan(/(.{94}|(\A[^\n]+))/).each do |line|
-      line = line.first.strip
+    @context.parser_started_at ||= Time.now.utc
+    str.scan(/(.{0,94})[\r\n]*/).each do |line|
+      line = line.compact.first.strip
+      next if line.empty? || line.start_with?('#') # Skip empty lines and comments
+
       line_num += 1
       @context.line_number = line_num
       @context.line_length = line.length
@@ -39,12 +49,13 @@ class Nacha::Parser
   def process(line, line_num, previous = nil)
     @context.line_errors = []
     parent = previous
-    record = nil
 
     record_types = valid_record_types(parent)
+
     while record_types
-      record = parse_by_types(line, record_types)
+      record = parse_first_by_types(line, record_types)
       break if record || !parent
+
       record.validate if record
       parent = parent.parent
       record_types = valid_record_types(parent)
@@ -67,11 +78,17 @@ class Nacha::Parser
     child.parent = parent
   end
 
-  def parse_by_types(line, record_types)
-    record_types.detect do |rt|
-      record_type = Object.const_get(rt)
-      record = record_type.parse(line) if record_type.matcher =~ line
-      return record if record
+  def parse_first_by_types(line, record_types)
+    record_types.lazy.filter_map do |rt|
+      record_type = rt.is_a?(Class) ? rt : Object.const_get(rt)
+      record_type.parse(line) if record_type.matcher.match?(line)
+    end.first
+  end
+
+  def parse_all_by_types(line, record_types)
+    record_types.filter_map do |rt|
+      record_type = rt.is_a?(Class) ? rt : Object.const_get(rt)
+      record_type.parse(line) if record_type.matcher.match?(line)
     end
   end
 end

data/lib/nacha/parser_context.rb

@@ -2,13 +2,9 @@
 # frozen_string_literal: true
 
 class Nacha::ParserContext
-  attr_accessor :file_name
-  attr_accessor :line_number
-  attr_accessor :line_length
-  attr_accessor :line_errors
-  attr_accessor :parser_started_at
-  attr_accessor :parser_ended_at # nil 'till the end of parsing
-  attr_accessor :previous_record
+  attr_accessor :file_name, :line_number, :line_length, :line_errors,
+    :parser_started_at, :previous_record,
+    :parser_ended_at # nil 'till the end of parsing
   attr_reader :validated
 
   def initialize(opts = {})
@@ -16,7 +12,7 @@ class Nacha::ParserContext
     @line_number = opts[:line_number] || 0
     @line_length = opts[:line_length] || 0
     @current_line_errors = []
-    @parser_started_at = Time.now
+    @parser_started_at = Time.now.utc
     @parser_ended_at = nil
     @previous_record = nil
     @validated = false
@@ -29,5 +25,4 @@ class Nacha::ParserContext
   def valid?
     @valid ||= errors.empty?
   end
-
 end

data/lib/nacha/record/ack_entry_detail.rb

@@ -1,22 +1,29 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'nacha/record/base.rb'
-require 'nacha/record/detail_record_type.rb'
+require 'nacha/record/base'
+require 'nacha/record/detail_record_type'
 
 module Nacha
   module Record
     class AckEntryDetail < Nacha::Record::Base
       include DetailRecordType
+
       nacha_field :record_type_code, inclusion: 'M', contents: 'C6', position: 1..1
       nacha_field :transaction_code, inclusion: 'M', contents: 'Numeric', position: 2..3
-      nacha_field :receiving_dfi_identification, inclusion: 'M', contents: 'TTTTAAAAC', position: 4..12
-      nacha_field :dfi_account_number, inclusion: 'R', contents: 'Alphameric', position: 13..29
+      nacha_field :receiving_dfi_identification,
+        inclusion: 'M', contents: 'TTTTAAAAC', position: 4..12
+      nacha_field :dfi_account_number,
+        inclusion: 'R', contents: 'Alphameric', position: 13..29
       nacha_field :amount, inclusion: 'M', contents: '$$$$$$$$¢¢', position: 30..39
-      nacha_field :originl_entry_trace_number, inclusion: 'M', contents: 'Numeric', position: 40..54
-      nacha_field :receiving_company_name, inclusion: 'R', contents: 'Alphameric', position: 55..76
-      nacha_field :discretionary_data, inclusion: 'O', contents: 'Alphameric', position: 77..78
-      nacha_field :addenda_record_indicator, inclusion: 'M', contents: 'Numeric', position: 79..79
+      nacha_field :originl_entry_trace_number,
+        inclusion: 'M', contents: 'Numeric', position: 40..54
+      nacha_field :receiving_company_name,
+        inclusion: 'R', contents: 'Alphameric', position: 55..76
+      nacha_field :discretionary_data,
+        inclusion: 'O', contents: 'Alphameric', position: 77..78
+      nacha_field :addenda_record_indicator,
+        inclusion: 'M', contents: 'Numeric', position: 79..79
       nacha_field :trace_number, inclusion: 'M', contents: 'Numeric', position: 80..94
     end
   end

data/lib/nacha/record/adv_batch_control.rb

@@ -1,20 +1,27 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'nacha/record/base.rb'
-require 'nacha/record/batch_control_record_type.rb'
+require 'nacha/record/base'
+require 'nacha/record/batch_control_record_type'
 
 module Nacha
   module Record
+    # The AdvBatchControl record is used to control the batch of adv entry detail records.
     class AdvBatchControl < Nacha::Record::Base
+      include BatchControlRecordType
+
       nacha_field :record_type_code, inclusion: 'M', contents: 'C8', position: 1..1
       nacha_field :service_class_code, inclusion: 'M', contents: 'Numeric', position: 2..4
       nacha_field :entry_addenda_count, inclusion: 'M', contents: 'Numeric', position: 5..10
       nacha_field :entry_hash, inclusion: 'M', contents: 'Numeric', position: 11..20
-      nacha_field :total_debit_entry_dollar_amount, inclusion: 'M', contents: '$$$$$$$$$$$$$$$$$$¢¢', position: 21..40
-      nacha_field :total_credit_entry_dollar_amount, inclusion: 'M', contents: '$$$$$$$$$$$$$$$$$$¢¢', position: 41..60
-      nacha_field :ach_operator_data, inclusion: 'O', contents: 'Alphameric', position: 61..79
-      nacha_field :originating_dfi_identification, inclusion: 'M', contents: 'TTTAAAA', position: 80..87
+      nacha_field :total_debit_entry_dollar_amount,
+        inclusion: 'M', contents: '$$$$$$$$$$$$$$$$$$¢¢', position: 21..40
+      nacha_field :total_credit_entry_dollar_amount,
+        inclusion: 'M', contents: '$$$$$$$$$$$$$$$$$$¢¢', position: 41..60
+      nacha_field :ach_operator_data,
+        inclusion: 'O', contents: 'Alphameric', position: 61..79
+      nacha_field :originating_dfi_identification,
+        inclusion: 'M', contents: 'TTTAAAA', position: 80..87
       nacha_field :batch_number, inclusion: 'M', contents: 'Numeric', position: 88..94
     end
   end

data/lib/nacha/record/adv_entry_detail.rb

@@ -1,13 +1,14 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'nacha/record/base.rb'
-require 'nacha/record/detail_record_type.rb'
+require 'nacha/record/base'
+require 'nacha/record/detail_record_type'
 
 module Nacha
   module Record
     class AdvEntryDetail < Nacha::Record::Base
       include DetailRecordType
+
       nacha_field :record_type_code, inclusion: 'M', contents: 'C6', position: 1..1
       nacha_field :transaction_code, inclusion: 'M', contents: 'Numeric', position: 2..3
       nacha_field :receiving_dfi_identification, inclusion: 'M', contents: 'TTTTAAAAC', position: 4..12

data/lib/nacha/record/adv_file_control.rb

@@ -1,24 +1,25 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'nacha/record/base.rb'
-require 'nacha/record/file_control_record_type.rb'
+require 'nacha/record/base'
+require 'nacha/record/file_control_record_type'
 
 module Nacha
   module Record
     class AdvFileControl < Nacha::Record::Base
+      include FileControlRecordType
+
       nacha_field :record_type_code, inclusion: 'M', contents: 'C9', position: 1..1
       nacha_field :batch_count, inclusion: 'M', contents: 'Numeric', position: 2..7
       nacha_field :block_count, inclusion: 'M', contents: 'Numeric', position: 8..13
-      nacha_field :entry_addenda_count, inclusion: 'M', contents: 'Numeric', position: 14..21
+      nacha_field :entry_addenda_count,
+        inclusion: 'M', contents: 'Numeric', position: 14..21
       nacha_field :entry_hash, inclusion: 'M', contents: 'Numeric', position: 22..31
-      nacha_field :total_debit_entry_dollar_amount_in_file, inclusion: 'M', contents: '$$$$$$$$$$¢¢', position: 32..51
-      nacha_field :total_credit_entry_dollar_amount_in_file, inclusion: 'M', contents: '$$$$$$$$$$¢¢', position: 52..71
+      nacha_field :total_debit_entry_dollar_amount_in_file,
+        inclusion: 'M', contents: '$$$$$$$$$$¢¢', position: 32..51
+      nacha_field :total_credit_entry_dollar_amount_in_file,
+        inclusion: 'M', contents: '$$$$$$$$$$¢¢', position: 52..71
       nacha_field :reserved, inclusion: 'M', contents: 'C', position: 72..94
-
-#      def initialize
-#        create_fields_from_definition
-#      end
     end
   end
 end

data/lib/nacha/record/adv_file_header.rb

@@ -1,26 +1,31 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'nacha/record/base.rb'
-require 'nacha/record/file_header_record_type.rb'
+require 'nacha/record/base'
+require 'nacha/record/file_header_record_type'
 
 module Nacha
   module Record
     class AdvFileHeader < Nacha::Record::Base
       include FileHeaderRecordType
+
       nacha_field :record_type_code, inclusion: 'M', contents: 'C1', position: 1..1
       nacha_field :priority_code, inclusion: 'R', contents: 'Numeric', position: 2..3
-      nacha_field :immediate_destination, inclusion: 'M', contents: 'bTTTTAAAAC', position: 4..13
-      nacha_field :immediate_origin, inclusion: 'M', contents: 'bTTTTAAAAC', position: 14..23
+      nacha_field :immediate_destination, inclusion: 'M',
+        contents: 'bTTTTAAAAC', position: 4..13
+      nacha_field :immediate_origin, inclusion: 'M',
+        contents: 'bTTTTAAAAC', position: 14..23
       nacha_field :file_creation_date, inclusion: 'M', contents: 'YYMMDD', position: 24..29
       nacha_field :file_creation_time, inclusion: 'M', contents: 'HHMM', position: 30..33
       nacha_field :file_id_modifier, inclusion: 'M', contents: 'A-Z0-9', position: 34..34
       nacha_field :record_size, inclusion: 'M', contents: 'C094', position: 35..37
       nacha_field :blocking_factor, inclusion: 'M', contents: 'C10', position: 38..39
       nacha_field :format_code, inclusion: 'M', contents: 'C1', position: 40..40
-      nacha_field :immediate_destination_name, inclusion: 'M', contents: 'Alphameric', position: 41..63
-      nacha_field :immediate_origin_name, inclusion: 'M', contents: 'Alphameric', position: 64..86
-      nacha_field :reference_code, inclusion: 'M', contents: 'Alphameric', position: 87..94
+      nacha_field :immediate_destination_name, inclusion: 'M',
+        contents: 'Alphameric', position: 41..63
+      nacha_field :immediate_origin_name, inclusion: 'M',
+        contents: 'Alphameric', position: 64..86
+      nacha_field :reference_code, inclusion: 'M', contents: 'CADV FILE', position: 87..94
     end
   end
 end

data/lib/nacha/record/arc_entry_detail.rb

@@ -1,8 +1,8 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'nacha/record/base.rb'
-require 'nacha/record/detail_record_type.rb'
+require 'nacha/record/base'
+require 'nacha/record/detail_record_type'
 
 module Nacha
   module Record

data/lib/nacha/record/base.rb

@@ -4,42 +4,47 @@ require 'json'
 require 'nacha/field'
 require 'nacha/record/validations/field_validations'
 
+# :reek:TooManyInstanceVariables, :reek:TooManyMethods
 module Nacha
   module Record
+    # Base class for all Nacha records.
     class Base
       include Validations::FieldValidations
 
-      attr_accessor :children, :parent, :fields
-      attr_reader :name, :validations, :errors, :original_input_line
-      attr_accessor :line_number
+      attr_reader :children, :name, :validations, :original_input_line, :fields
+      # :reek:Attribute
+      attr_accessor :parent, :line_number
 
+      # :reek:ManualDispatch
       def initialize(opts = {})
         @children = []
+        @parent = nil
         @errors = []
         @original_input_line = nil
+        @line_number = nil
+        @dirty = false
+        @fields = {}
         create_fields_from_definition
-        opts.each do |k, v|
-          setter = "#{k}="
-          next unless respond_to? setter
-
+        opts.each do |key, value|
+          setter = "#{key}="
           # rubocop:disable GitlabSecurity/PublicSend
-          send(setter, v) unless v.nil?
+          public_send(setter, value) if value && respond_to?(setter)
           # rubocop:enable GitlabSecurity/PublicSend
         end
       end
 
       class << self
+        # :reek:LongParameterList, :reek:ManualDispatch
         def nacha_field(name, inclusion:, contents:, position:)
+          Nacha.add_ach_record_type(self)
           definition[name] = { inclusion: inclusion,
                                contents: contents,
                                position: position,
-                               name: name}
-          validation_method = "valid_#{name}".to_sym
+                               name: name }
+          validation_method = :"valid_#{name}"
           return unless respond_to?(validation_method)
 
-          validations[name] ||= []
-          validations[name] << validation_method
-          Nacha.add_ach_record_type(self)
+          (validations[name] ||= []) << validation_method
         end
 
         def definition
@@ -51,90 +56,94 @@ module Nacha
         end
 
         def unpack_str
-          @unpack_str ||= definition.values.collect do |d|
-            Nacha::Field.unpack_str(d)
+          @unpack_str ||= definition.values.collect do |field_def|
+            Nacha::Field.unpack_str(field_def)
           end.join.freeze
         end
 
-        def old_matcher
-          @matcher ||=
-            Regexp.new('\A' + definition.values.collect do |d|
-                         if d[:contents] =~ /\AC(.+)\z/ || d['contents'] =~ /\AC(.+)\z/
-                           Regexp.last_match(1)
-                         else
-                           '.' * (d[:position] || d['position']).size
-                         end
-                       end.join + '\z')
-        end
-
-        # A more strict matcher that accounts for numeric and date fields
-        # and allows for spaces in those fields, but not alphabetic characters
-        # Also matches strings that might not be long enough.
-        #
-        # Processes the definition in reverse order to allow later fields to be
-        # skipped if they are not present in the input string.
+        # :reek:TooManyStatements
+        # rubocop:disable Layout/BlockAlignment,
+        # rubocop:disable Style/StringConcatenation:
         def matcher
-          return @matcher if @matcher
-
-          output_started = false
-          skipped_output = false
-          @matcher ||=
-            Regexp.new('\A' + definition.values.reverse.collect do |d|
-                         if d[:contents] =~ /\AC(.+)\z/
+          @matcher ||= begin
+            output_started = false
+            skipped_output = false
+            Regexp.new('\A' + definition.values.reverse.collect do |field|
+                         contents = field[:contents]
+                         position = field[:position]
+                         size = position.size
+                         if contents =~ /\AC(.+)\z/
                            last_match = Regexp.last_match(1)
-                           if last_match =~ /\A  *\z/
+                           if last_match.match?(/  */) && !output_started
                              skipped_output = true
                              ''
                            else
                              output_started = true
                              last_match
                            end
-                         elsif d[:contents] =~ /\ANumeric\z/
+                         elsif contents.match?(/\ANumeric\z/) || contents.match?(/\AYYMMDD\z/)
                            output_started = true
-                           '[0-9 ]' + "{#{(d[:position] || d['position']).size}}"
-                         elsif d[:contents] =~ /\AYYMMDD\z/
-                           if output_started
-                             '[0-9 ]' + "{#{(d[:position] || d['position']).size}}"
-                           else
-                             skipped_output = true
-                             ''
-                           end
+                           '[0-9 ]' + "{#{size}}"
+                         elsif output_started
+                           '.' + "{#{size}}"
                          else
-                           if output_started
-                             '.' + "{#{(d[:position] || d['position']).size}}"
-                           else
-                             skipped_output = true
-                             ''
-                           end
+                           skipped_output = true
+                           ''
                          end
                        end.reverse.join + (skipped_output ? '.*' : '') + '\z')
+          end
         end
-
+        # rubocop:enable Layout/BlockAlignment,
+        # rubocop:enable Style/StringConcatenation:
 
         def parse(ach_str)
-          rec = new
+          rec = new(original_input_line: ach_str)
           ach_str.unpack(unpack_str).zip(rec.fields.values) do |input_data, field|
             field.data = input_data
           end
-          rec.original_input_line = ach_str
           rec.validate
           rec
         end
-      end # end class methods
 
+        def record_type
+          Nacha.record_name(self)
+        end
+
+        # :reek:ManualDispatch, :reek:TooManyStatements
+        def to_h
+          fields = definition.transform_values do |field_def|
+            {
+              inclusion: field_def[:inclusion],
+              contents: field_def[:contents],
+              position: field_def[:position].to_s
+            }
+          end
+
+          fields[:child_record_types] = child_record_types.to_a
+          fields[:child_record_types] ||= []
+          fields[:klass] = name.to_s
+
+          { record_type.to_sym => fields }
+        end
+
+        def to_json(*_args)
+          JSON.pretty_generate(to_h)
+        end
+      end
+
+      # :reek:FeatureEnvy
       def original_input_line=(line)
         @original_input_line = line.dup if line.is_a?(String)
       end
 
       def create_fields_from_definition
-        @fields ||= {}
         definition.each_pair do |field_name, field_def|
           @fields[field_name.to_sym] = Nacha::Field.new(field_def)
         end
       end
 
       def record_type
-        Nacha.record_name(self.class)
+        self.class.record_type
       end
 
       def human_name
@@ -144,14 +153,14 @@ module Nacha
       def to_h
         { nacha_record_type: record_type,
           metadata: {
+            klass: self.class.name,
             errors: errors,
             line_number: @line_number,
             original_input_line: original_input_line
-          }
-        }.merge(
-          @fields.keys.map do |key|
-            [key, @fields[key].to_json_output]
-          end.to_h)
+          } }.merge(
+            @fields.keys.to_h do |key|
+              [key, @fields[key].to_json_output]
+            end)
       end
 
       def to_json(*_args)
@@ -164,17 +173,18 @@ module Nacha
         end.join
       end
 
-      def to_html(opts = {})
+      def to_html(_opts = {})
         record_error_class = nil
 
-        field_html = @fields.keys.collect do |key|
-          record_error_class ||= 'error' if @fields[key].errors.any?
-          @fields[key].to_html
+        field_html = @fields.values.collect do |field|
+          record_error_class ||= 'error' if field.errors.any?
+          field.to_html
         end.join
-        "<div class=\"nacha-record tooltip #{record_type} #{record_error_class}\">" +
-          "<span class=\"nacha-field\" data-name=\"record-number\">#{"%05d" % [line_number]}&nbsp;|&nbsp</span>" +
-          field_html +
-          "<span class=\"record-type\" data-name=\"record-type\">#{human_name}</span>" +
+        "<div class=\"nacha-record tooltip #{record_type} #{record_error_class}\">" \
+          "<span class=\"nacha-field\" data-name=\"record-number\">#{format('%05d',
+            line_number)}&nbsp;|&nbsp</span>" \
+          "#{field_html}" \
+          "<span class=\"record-type\" data-name=\"record-type\">#{human_name}</span>" \
           "</div>"
       end
 
@@ -188,19 +198,10 @@ module Nacha
 
       def validate
         # Run field-level validations first
-        @fields.values.each(&:validate)
-
+        @fields.each_value(&:validate)
         # Then run record-level validations that might depend on multiple fields
-        self.class.definition.keys.each do |field|
-          next unless self.class.validations[field]
-
-          # rubocop:disable GitlabSecurity/PublicSend
-          field_data = send(field)
-
-          self.class.validations[field].map do |validation_method|
-            self.class.send(validation_method, field_data)
-          end
-          # rubocop:enable GitlabSecurity/PublicSend
+        self.class.definition.each_key do |field|
+          run_record_level_validations_for(field)
         end
       end
 
@@ -224,7 +225,8 @@ module Nacha
       #   # Assuming transaction_code is "201" and DEBIT_TRANSACTION_CODES includes "201"
       #   debit? #=> true
       #
-      #   # Assuming transaction_code is "100" and DEBIT_TRANSACTION_CODES does not include "100"
+      #   # Assuming transaction_code is "100" and DEBIT_TRANSACTION_CODES
+      #   # does not include "100"
       #   debit? #=> false
       #
       #   # Assuming transaction_code is nil
@@ -263,7 +265,8 @@ module Nacha
       #   # Assuming transaction_code is "101" and CREDIT_TRANSACTION_CODES includes "101"
       #   credit? #=> true
       #
-      #   # Assuming transaction_code is "200" and CREDIT_TRANSACTION_CODES does not include "200"
+      #   # Assuming transaction_code is "200" and CREDIT_TRANSACTION_CODES
+      #   # does not include "200"
       #   credit? #=> false
       #
       #   # Assuming transaction_code is nil
@@ -289,37 +292,54 @@ module Nacha
       end
 
       def errors
-        (@errors + @fields.values.map { |field| field.errors }).flatten
+        (@errors + @fields.values.map(&:errors)).flatten
       end
 
-
       def add_error(err_string)
         @errors << err_string
       end
 
-      def respond_to?(method_name, include_private = false)
-        field_name = method_name.to_s.gsub(/=$/, '').to_sym
+      # :reek:TooManyStatements
+      def method_missing(method_name, *args, &block)
+        method = method_name.to_s
+        field_name = method.gsub(/=$/, '').to_sym
+        field = @fields[field_name]
+        return super unless field
 
-        definition[field_name] || super
+        if method.end_with?('=')
+          assign_field_data(field, args)
+        else
+          field
+        end
       end
 
-      def method_missing(method_name, *args, &block)
+      def respond_to_missing?(method_name, *)
         field_name = method_name.to_s.gsub(/=$/, '').to_sym
-        is_assignment = (/[^=]*=$/o =~ method_name.to_s)
-        if @fields[field_name]
-          if is_assignment
-            # @fields[field_name].send(:data=,*args)
-            # rubocop:disable GitlabSecurity/PublicSend
-            @fields[field_name].public_send(:data=, *args)
-            # rubocop:enable GitlabSecurity/PublicSend
-            @dirty = true
-          else
-            # @fields[field_name].data
-            @fields[field_name]
-          end
-        else
-          super
+        definition[field_name] || super
+      end
+
+      private
+
+      def assign_field_data(field, args)
+        # rubocop:disable GitlabSecurity/PublicSend
+        field.public_send(:data=, *args)
+        # rubocop:enable GitlabSecurity/PublicSend
+        @dirty = true
+      end
+
+      # :reek:TooManyStatements
+      def run_record_level_validations_for(field)
+        klass = self.class
+        validations = klass.validations[field]
+        return unless validations
+
+        # rubocop:disable GitlabSecurity/PublicSend
+        field_data = send(field)
+
+        validations.each do |validation_method|
+          klass.send(validation_method, field_data)
         end
+        # rubocop:enable GitlabSecurity/PublicSend
       end
     end
   end