module Shoulda::ActiveRecord::Macros

def should_allow_mass_assignment_of(*attributes)
  ::ActiveSupport::Deprecation.warn("use: should allow_mass_assignment_of")
  get_options!(attributes)
  attributes.each do |attribute|
    should allow_mass_assignment_of(attribute)
  end
end

def should_allow_values_for(attribute, *good_values)
  ::ActiveSupport::Deprecation.warn("use: should allow_value")
  get_options!(good_values)
  good_values.each do |value|
    should allow_value(value).for(attribute)
  end
end

def should_belong_to(*associations)
  ::ActiveSupport::Deprecation.warn("use: should belong_to")
  dependent = get_options!(associations, :dependent)
  associations.each do |association|
    should belong_to(association).dependent(dependent)
  end
end

def should_ensure_length_at_least(attribute, min_length, opts = {})
  ::ActiveSupport::Deprecation.warn("use: should ensure_length_of.is_at_least")
  short_message = get_options!([opts], :short_message)
  should ensure_length_of(attribute).
    is_at_least(min_length).
    with_short_message(short_message)
end

def should_ensure_length_in_range(attribute, range, opts = {})
  ::ActiveSupport::Deprecation.warn("use: should ensure_length_of.is_at_least.is_at_most")
  short_message, long_message = get_options!([opts],
                                             :short_message,
                                             :long_message)
  should ensure_length_of(attribute).
    is_at_least(range.first).
    with_short_message(short_message).
    is_at_most(range.last).
    with_long_message(long_message)
end

def should_ensure_length_is(attribute, length, opts = {})
  ::ActiveSupport::Deprecation.warn("use: should ensure_length_of.is_equal_to")
  message = get_options!([opts], :message)
  should ensure_length_of(attribute).
    is_equal_to(length).
    with_message(message)
end

def should_ensure_value_in_range(attribute, range, opts = {})
  ::ActiveSupport::Deprecation.warn("use: should ensure_inclusion_of.in_range")
  message, low_message, high_message = get_options!([opts],
                                                    :message,
                                                    :low_message,
                                                    :high_message)
  should ensure_inclusion_of(attribute).
    in_range(range).
    with_message(message).
    with_low_message(low_message).
    with_high_message(high_message)
end

def should_have_and_belong_to_many(*associations)
  ::ActiveSupport::Deprecation.warn("use: should have_and_belong_to_many")
  get_options!(associations)
  associations.each do |association|
    should have_and_belong_to_many(association)
  end
end

def should_have_class_methods(*methods)
  ::ActiveSupport::Deprecation.warn
  get_options!(methods)
  klass = described_type
  methods.each do |method|
    should "respond to class method ##{method}" do
      assert_respond_to klass, method, "#{klass.name} does not have class method #{method}"
    end
  end
end

def should_have_db_columns(*columns)
  ::ActiveSupport::Deprecation.warn("use: should have_db_column")
  column_type, precision, limit, default, null, scale, sql_type =
    get_options!(columns, :type, :precision, :limit,
                          :default, :null, :scale, :sql_type)
  columns.each do |name|
    should have_db_column(name).
                of_type(column_type).
                with_options(:precision => precision, :limit    => limit,
                             :default   => default,   :null     => null,
                             :scale     => scale,     :sql_type => sql_type)
  end
end

def should_have_db_indices(*columns)
  ::ActiveSupport::Deprecation.warn("use: should have_db_index")
  unique = get_options!(columns, :unique)
  columns.each do |column|
    should have_db_index(column).unique(unique)
  end
end

def should_have_instance_methods(*methods)
  ::ActiveSupport::Deprecation.warn
  get_options!(methods)
  klass = described_type
  methods.each do |method|
    should "respond to instance method ##{method}" do
      assert_respond_to klass.new, method, "#{klass.name} does not have instance method #{method}"
    end
  end
end

def should_have_many(*associations)
  ::ActiveSupport::Deprecation.warn("use: should have_many")
  through, dependent = get_options!(associations, :through, :dependent)
  associations.each do |association|
    should have_many(association).through(through).dependent(dependent)
  end
end

def should_have_one(*associations)
  ::ActiveSupport::Deprecation.warn("use: should have_one")
  dependent, through = get_options!(associations, :dependent, :through)
  associations.each do |association|
    should have_one(association).dependent(dependent).through(through)
  end
end

def should_have_readonly_attributes(*attributes)
  ::ActiveSupport::Deprecation.warn("use: should have_readonly_attribute")
  get_options!(attributes)
  attributes.each do |attribute|
    should have_readonly_attribute(attribute)
  end
end

def should_not_allow_mass_assignment_of(*attributes)
  ::ActiveSupport::Deprecation.warn("use: should_not allow_mass_assignment_of")
  get_options!(attributes)
  attributes.each do |attribute|
    should_not allow_mass_assignment_of(attribute)
  end
end

def should_not_allow_values_for(attribute, *bad_values)
  ::ActiveSupport::Deprecation.warn("use: should_not allow_value")
  message = get_options!(bad_values, :message)
  bad_values.each do |value|
    should_not allow_value(value).for(attribute).with_message(message)
  end
end

def should_validate_acceptance_of(*attributes)
  ::ActiveSupport::Deprecation.warn("use: should validate_acceptance_of")
  message = get_options!(attributes, :message)
  attributes.each do |attribute|
    should validate_acceptance_of(attribute).with_message(message)
  end
end

def should_validate_numericality_of(*attributes)
  ::ActiveSupport::Deprecation.warn("use: should validate_numericality_of")
  message = get_options!(attributes, :message)
  attributes.each do |attribute|
    should validate_numericality_of(attribute).
      with_message(message)
  end
end

def should_validate_presence_of(*attributes)
  ::ActiveSupport::Deprecation.warn("use: should validate_presence_of")
  message = get_options!(attributes, :message)
  attributes.each do |attribute|
    should validate_presence_of(attribute).with_message(message)
  end
end

def should_validate_uniqueness_of(*attributes)
  ::ActiveSupport::Deprecation.warn("use: should validate_uniqueness_of")
  message, scope, case_sensitive = get_options!(attributes, :message, :scoped_to, :case_sensitive)
  scope = [*scope].compact
  case_sensitive = true if case_sensitive.nil?
  attributes.each do |attribute|
    matcher = validate_uniqueness_of(attribute).
      with_message(message).scoped_to(scope)
    matcher = matcher.case_insensitive unless case_sensitive
    should matcher
  end
end