class RuboCop::Cop::Style::NumericLiterals


10_000_00 # typical representation of $10,000 in cents
# good unless Strict is set
1000
1_000_000
# good
1_0000
1_00_000
1000000
# bad
@example
of digits in them.
This cop checks for big numeric literals without _ between groups

def autocorrect(node) 

def autocorrect(node)
  lambda do |corrector|
    corrector.replace(node.source_range, format_number(node))
  end
end

def check(node) 

def check(node)
  int = integer_part(node)
  # TODO: handle non-decimal literals as well
  return if int.start_with?('0')
  return unless int.size >= min_digits
  case int
  when /^\d+$/
    add_offense(node) { self.max = int.size + 1 }
  when /\d{4}/, short_group_regex
    add_offense(node) do
      self.config_to_allow_offenses = { 'Enabled' => false }
    end
  end
end

def format_number(node) 

def format_number(node)
  int_part, float_part = node.source.split('.')
  int_part = Integer(int_part)
  formatted_int = int_part
                  .abs
                  .to_s
                  .reverse
                  .gsub(/...(?=.)/, '\&_')
                  .reverse
  formatted_int.insert(0, '-') if int_part < 0
  if float_part
    format('%<int>s.%<float>s', int: formatted_int, float: float_part)
  else
    formatted_int
  end
end

def max_parameter_name 

def max_parameter_name
  'MinDigits'
end

def min_digits 

def min_digits
  cop_config['MinDigits']
end

def on_float(node) 

def on_float(node)
  check(node)
end

def on_int(node) 

def on_int(node)
  check(node)
end

def short_group_regex 

def short_group_regex
  cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
end