class Shoulda::Matchers::ActiveModel::Qualifiers::IgnoreInterferenceByWriter

def always?
  setting == :always
end

def changed?
  @changed
end

def condition_matches?(value)
  if condition.respond_to?(:call)
    condition.call(value)
  else
    value.public_send(condition)
  end
end

def considering?(value)
  case setting
  when :always then true
  when :never then false
  else condition_matches?(value)
  end
end

def default_to(argument)
  temporary_ignore_interference_by_writer =
    IgnoreInterferenceByWriter.new(argument)
  unless changed?
    @setting = temporary_ignore_interference_by_writer.setting
    @condition = temporary_ignore_interference_by_writer.condition
  end
  self
end

def initialize(argument = :always)
  set(argument)
  @changed = false
end

def invalid_argument_error(invalid_argument)
  ArgumentError.new(<<-ERROR)
gument: #{invalid_argument.inspect}.
nterference_by_writer takes one of three arguments:
, either :never or :always.
n, either true (which means always) or false (which means
ith a single key, :when, and a single value, which is either
 of a method or a Proc.
  ERROR
end

def never?
  setting == :never
end

def set(argument)
  if argument.is_a?(self.class)
    @setting = argument.setting
    @condition = argument.condition
  else
    case argument
    when true, :always
      @setting = :always
    when false, :never
      @setting = :never
    else
      @setting = :sometimes
      if argument.is_a?(Hash)
        @condition = argument.fetch(:when)
      else
        raise invalid_argument_error(argument)
      end
    end
  end
  @changed = true
  self
rescue KeyError
  raise invalid_argument_error(argument)
end