class Shoulda::Matchers::ActionController::PermitMatcher

def actual_permitted_parameter_names
  @_actual_permitted_parameter_names ||= begin
    options =
      if subparameter_name
        { for: subparameter_name }
      else
        {}
      end
    parameters_double_registry.permitted_parameter_names(options)
  end
end

def add_params(params)
  request_params.merge!(params)
  self
end

def default_verb
  case action
  when :create then :post
  when :update then RailsShim.verb_for_update
  end
end

def description
  "(for #{verb.upcase} ##{action}) " + expectation
end

def ensure_action_and_verb_present!
  if action.blank?
    raise ActionNotDefinedError
  end
  if verb.blank?
    raise VerbNotDefinedError
  end
end

def expectation
  String.new('restrict parameters ').tap do |message|
    if subparameter_name
      message << "on #{subparameter_name.inspect} "
    end
    message << 'to '\
      "#{format_parameter_names(expected_permitted_parameter_names)}"
  end
end

def failure_message
  "Expected #{verb.upcase} ##{action} to #{expectation},"\
  "\nbut #{reality}."
end

def failure_message_when_negated
  "Expected #{verb.upcase} ##{action} not to #{expectation},"\
  "\nbut it did."
end

def for(action, options = {})
  @action = action
  @verb = options.fetch(:verb, default_verb)
  @request_params = options.fetch(:params, {})
  self
end

def format_parameter_names(parameter_names)
  parameter_names.map(&:inspect).to_sentence
end

def in_context(context)
  @context = context
  self
end

def initialize(expected_permitted_parameter_names)
  @expected_permitted_parameter_names =
    expected_permitted_parameter_names
  @action = nil
  @verb = nil
  @request_params = {}
  @subparameter_name = nil
  @parameters_double_registry = CompositeParametersDoubleRegistry.new
end

def matches?(controller)
  @controller = controller
  ensure_action_and_verb_present!
  parameters_double_registry.register
  Doublespeak.with_doubles_activated do
    params = { params: request_params }
    context.__send__(verb, action, **params)
  end
  unpermitted_parameter_names.empty?
end

def on(subparameter_name)
  @subparameter_name = subparameter_name
  self
end

def parameter_names_as_sentence
  expected_permitted_parameter_names.map(&:inspect).to_sentence
end

def reality
  if actual_permitted_parameter_names.empty?
    'it did not restrict any parameters'
  else
    'the restricted parameters were '\
    "#{format_parameter_names(actual_permitted_parameter_names)}"\
    ' instead'
  end
end

def unpermitted_parameter_names
  expected_permitted_parameter_names - actual_permitted_parameter_names
end