class AWS::Record::LengthValidator

def interpolate message_with_placeholders, values
  msg = message_with_placeholders.dup
  values.each_pair do |key,value|
    msg.gsub!(/%\{#{key}\}/, value.to_s)
  end
  msg
end

def setup record_class
  ensure_at_least_one(:within, :exactly, :minimum, :maximum)
  ensure_exclusive(:within, :exactly, [:minimum, :maximum])
  ensure_type(Range, :within)
  ensure_type(Integer, :exactly, :minimum, :maximum)
  ensure_type(String, :too_long, :too_short, :wrong_length)
end

def too_long max, got
  msg = options[:too_long] ||
    "is too long (maximum is %{maximum} characters)"
  interpolate(msg, :maximum => max, :length => got)
end

def too_short min, got
  msg = options[:too_short] ||
    "is too short (minimum is %{minimum} characters)"
  interpolate(msg, :minimum => min, :length => got)
end

def validate_attribute record, attribute_name, value_or_values
  each_value(value_or_values) do |value|
    length = value.respond_to?(:length) ? value.length : value.to_s.length
    if exact = options[:exactly]
      unless length == exact
        record.errors.add(attribute_name, wrong_length(exact, length))
      end
    end
    if within = options[:within]
      if length < within.first
        record.errors.add(attribute_name, too_short(within.first, length))
      end
      if length > within.last
        record.errors.add(attribute_name, too_long(within.last, length))
      end
    end
    if min = options[:minimum]
      if length < min
        record.errors.add(attribute_name, too_short(min, length))
      end
    end
    if max = options[:maximum]
      if length > max
        record.errors.add(attribute_name, too_long(max, length))
      end
    end
  end
end

def wrong_length exactly, got
  msg = options[:wrong_length] ||
    "is the wrong length (should be %{exactly} characters)"
  interpolate(msg, :exactly => exactly, :length => got)
end