Module: RuboCop::Cop::HashShorthandSyntax

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 195

def breakdown_value_types_of_hash(hash_node)
  hash_node.pairs.group_by do |pair_node|
    if pair_node.value_omission?
      :value_omitted
    elsif require_hash_value?(pair_node.key.source, pair_node)
      :value_needed
    else
      :value_omittable
    end
  end
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 143

def def_node_that_require_parentheses(node)
  last_pair = node.parent.pairs.last
  return unless last_pair.key.source == last_pair.value.source
  return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
  return if dispatch_node.assignment_method?
  return if dispatch_node.parenthesized?
  return if dispatch_node.parent && parentheses?(dispatch_node.parent)
  return if last_expression?(dispatch_node) && !requires_parentheses_context?(dispatch_node)

  def_node = node.each_ancestor(:call, :super, :yield).first

  DefNode.new(def_node) unless def_node && def_node.arguments.empty?
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 224

def each_omittable_value_pair(hash_value_type_breakdown, &block)
  hash_value_type_breakdown[:value_omittable]&.each(&block)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 220

def each_omitted_value_pair(hash_value_type_breakdown, &block)
  hash_value_type_breakdown[:value_omitted]&.each(&block)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 121

def enforced_shorthand_syntax
  cop_config.fetch('EnforcedShorthandSyntax', 'always')
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 157

def find_ancestor_method_dispatch_node(node)
  return unless (ancestor = node.parent.parent)
  return unless ancestor.type?(:call, :super, :yield)
  return if brackets?(ancestor)

  ancestor
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 108

def hash_rockets_enforced?(hash_node)
  style == :hash_rockets || force_hash_rockets?(hash_node.pairs) ||
    no_mixed_keys_enforces_hash_rockets?(hash_node.pairs)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 207

def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
  hash_value_type_breakdown.keys.size > 1
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 211

def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
  hash_value_type_breakdown[:value_needed]&.any?
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 215

def ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
  hash_value_type_breakdown.keys == [:value_omittable] &&
    enforced_shorthand_syntax == 'either_consistent'
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 102

def ignore_hash_shorthand_syntax?(pair_node)
  target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
    %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
    !pair_node.parent.hash_type? || hash_rockets_enforced?(pair_node.parent)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 96

def ignore_mixed_hash_shorthand_syntax?(hash_node)
  target_ruby_version <= 3.0 ||
    !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
    !hash_node.hash_type? || hash_rockets_enforced?(hash_node)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 257

def keyword_value?(pair_node)
  KEYWORDS.include?(pair_node.key.value)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 180

def last_expression?(node)
  return false if node.right_sibling
  return true unless (assignment_node = node.each_ancestor.find(&:assignment?))
  return last_expression?(assignment_node.parent) if assignment_node.parent&.assignment?

  !assignment_node.right_sibling
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 228

def mixed_shorthand_syntax_check(hash_value_type_breakdown)
  if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
    each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
      next if keyword_value?(pair_node)

      hash_key_source = pair_node.key.source
      replacement = "#{hash_key_source}: #{hash_key_source}"
      register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
    end
  else
    each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
      hash_key_source = pair_node.key.source
      replacement = "#{hash_key_source}:"
      register_offense(pair_node, DO_NOT_MIX_OMIT_VALUE_MSG, replacement)
    end
  end
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 113

def no_mixed_keys_enforces_hash_rockets?(pairs)
  case style
  when :no_mixed_keys then !sym_indices?(pairs) || pairs.first.delimiter == '=>'
  when :ruby19_no_mixed_keys then !sym_indices?(pairs)
  else false
  end
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 246

def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
  return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
  return if ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)

  each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
    hash_key_source = pair_node.key.source
    replacement = "#{hash_key_source}:"
    register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
  end
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 41

def on_hash_for_mixed_shorthand(hash_node)
  return if ignore_mixed_hash_shorthand_syntax?(hash_node)

  hash_value_type_breakdown = breakdown_value_types_of_hash(hash_node)

  if hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
    mixed_shorthand_syntax_check(hash_value_type_breakdown)
  else
    no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
  end
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 53

def on_pair(node)
  return if ignore_hash_shorthand_syntax?(node)

  hash_key_source = node.key.source

  if enforced_shorthand_syntax == 'always'
    return if node.value_omission? || require_hash_value?(hash_key_source, node)

    message = OMIT_HASH_VALUE_MSG
    replacement = "#{hash_key_source}:"
    self.config_to_allow_offenses = { 'Enabled' => false }
  else
    return if !node.value_omission? || keyword_value?(node)

    message = EXPLICIT_HASH_VALUE_MSG
    replacement = "#{hash_key_source}: #{hash_key_source}"
  end

  register_offense(node, message, replacement)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 76

def register_offense(node, message, replacement) # rubocop:disable Metrics/AbcSize
  add_offense(node.value, message: message) do |corrector|
    corrector.replace(node, replacement)

    next unless (def_node = def_node_that_require_parentheses(node))

    last_argument = def_node.last_argument
    if last_argument.nil? || !last_argument.hash_type?
      next corrector.replace(node, replacement)
    end

    white_spaces = range_between(def_node.selector.end_pos,
                                 def_node.first_argument.source_range.begin_pos)
    next if node.parent.braces?

    corrector.replace(white_spaces, '(')
    corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
  end
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 125

def require_hash_value?(hash_key_source, node)
  return true if !node.key.sym_type? || require_hash_value_for_around_hash_literal?(node)

  hash_value = node.value
  return true unless hash_value.type?(:send, :lvar)

  hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 134

def require_hash_value_for_around_hash_literal?(node)
  return false unless (method_dispatch_node = find_ancestor_method_dispatch_node(node))

  !node.parent.braces? &&
    !use_element_of_hash_literal_as_receiver?(method_dispatch_node, node.parent) &&
    use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 188

def requires_parentheses_context?(node)
  parent = node.parent
  return false unless parent

  parent.type?(:call, :if, :super, :until, :while, :yield)
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 169

def use_element_of_hash_literal_as_receiver?(ancestor, parent)
  # `{value:}.do_something` is a valid syntax.
  ancestor.send_type? && ancestor.receiver == parent
end

# File 'lib/rubocop/cop/mixin/hash_shorthand_syntax.rb', line 174

def use_modifier_form_without_parenthesized_method_call?(ancestor)
  return false if ancestor.respond_to?(:parenthesized?) && ancestor.parenthesized?

  ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
end