class RuboCop::Cop::RSpec::SingleArgumentMessageChain


allow(foo).to receive(“bar.baz”)
allow(foo).to receive(:bar, :baz)
# also good
allow(foo).to receive(:bar).and_return(42)
# good
allow(foo).to receive_message_chain(:bar).and_return(42)
# bad
@example
Checks that chains of messages contain more than one element.

def autocorrect(corrector, node, method, arg) 

def autocorrect(corrector, node, method, arg)
  corrector.replace(node.loc.selector, replacement(method))
  autocorrect_hash_arg(corrector, arg) if single_key_hash?(arg)
  autocorrect_array_arg(corrector, arg) if arg.array_type?
end

def autocorrect_array_arg(corrector, arg) 

def autocorrect_array_arg(corrector, arg)
  value = arg.children.first
  corrector.replace(arg, value.source)
end

def autocorrect_hash_arg(corrector, arg) 

def autocorrect_hash_arg(corrector, arg)
  pair = arg.pairs.first
  corrector.replace(arg, key_to_arg(pair.key))
  corrector.insert_after(arg.parent.loc.end,
                         ".and_return(#{pair.value.source})")
end

def key_to_arg(node) 

def key_to_arg(node)
  node.sym_type? ? ":#{node.value}" : node.source
end

def on_send(node) 

def on_send(node)
  message_chain(node) do |arg|
    return if valid_usage?(arg)
    method = node.method_name
    msg = format(MSG, recommended: replacement(method), called: method)
    add_offense(node.loc.selector, message: msg) do |corrector|
      autocorrect(corrector, node, method, arg)
    end
  end
end

def replacement(method) 

def replacement(method)
  method.equal?(:receive_message_chain) ? 'receive' : 'stub'
end

def single_element_array?(node) 

def single_element_array?(node)
  node.child_nodes.one?
end

def valid_usage?(node) 

def valid_usage?(node)
  return true unless node.literal? || node.array_type?
  case node.type
  when :hash then !single_key_hash?(node)
  when :array then !single_element_array?(node)
  else node.to_s.include?('.')
  end
end