module QuickShoulda::Generator::Validation

Constants

AllowsValidators
AttrsFilters
Filters
InclusionOptions
OptionMethods

Public Class Methods

included(base) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 39
def self.included(base)
  base.class_eval do
    attr_accessor :validation_type
  end
end

Public Instance Methods

generate_validations(model) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 45
def generate_validations(model)
  model.validators.map { |validator| generate_for_validator(validator) }.compact.flatten
end

Private Instance Methods

_validation_type(validator) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 62
def _validation_type(validator)
  validation_type = validator.class.to_s.scan(/([^:]+)Validator/)
  unless validation_type.empty?
    validator = validation_type.first.first.downcase
    validator if AllowsValidators.include? validator
  end          
end
attrs_filter(attrs) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 58
def attrs_filter(attrs)
  attrs.select { |attr| !(AttrsFilters.include? attr.to_s) }
end
generate_allow_shouldas(type, strings, attribute) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 86
def generate_allow_shouldas(type, strings, attribute)          
  should_suffix = type.to_s == 'matched_strings' ? '' : '_not'
  strings.map { |string| "it { should#{should_suffix} allow_value('#{string}').for(:#{attribute}) }" }
end
generate_for_validator(validator) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 51
def generate_for_validator(validator)          
  if @validation_type = _validation_type(validator)            
    return if ( attrs = attrs_filter(validator.attributes) ).empty?
    generate_shouldas(attrs, validator.options)
  end
end
generate_shoulda(attribute, options) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 74
def generate_shoulda(attribute, options)
  unless validation_type == 'format'
    [ "it { should #{shoulda_matcher_method}(:#{attribute})#{shoulda_option_methods_chain(options)} }" ]
  else
    generate_shouldas_for_format_validation(attribute, options)
  end
end
generate_shouldas(attributes, options) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 70
def generate_shouldas(attributes, options)
  attributes.map { |attribute| generate_shoulda(attribute, options) }.flatten
end
generate_shouldas_for_format_validation(attribute, options) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 82
def generate_shouldas_for_format_validation(attribute, options)          
  RandomString.generate(options[:with]).map { |type, strings| generate_allow_shouldas(type, strings, attribute) }.flatten
end
pass_filter?(option) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 124
def pass_filter?(option)
  !Filters[option.to_sym] || Filters[option.to_sym].include?(validation_type)
end
shoulda_matcher_method() click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 91
def shoulda_matcher_method
  prefix = ('exclusion|inclusion|length' =~ /#{validation_type}/) ? 'ensure' : 'validate'
  "#{prefix}_#{validation_type}_of"
end
shoulda_method_without_value(method) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 133
def shoulda_method_without_value(method)
  ".#{method}"
end
shoulda_normal_option_method(method, value) click to toggle source

.is_at_least(50)

# File lib/quick_shoulda/generator/validation.rb, line 129
def shoulda_normal_option_method(method, value)
  ".#{method}#{value_transform(value)}"
end
shoulda_option_method(option, value) click to toggle source
# File lib/quick_shoulda/generator/validation.rb, line 101
def shoulda_option_method(option, value)          
  method = shoulda_option_method_name(option, value)          
  return unless method

  case method
    when OptionMethods[:scope] 
      shoulda_scope_to_method(value)
    when OptionMethods[:only_integer], OptionMethods[:case_insensitive]
      shoulda_method_without_value(method)
    else 
      shoulda_normal_option_method(method, value)
    end          
end
shoulda_option_method_name(option, value) click to toggle source

.is_at_least .is_at_most

# File lib/quick_shoulda/generator/validation.rb, line 117
def shoulda_option_method_name(option, value)
  return unless pass_filter?(option)
  option_method = OptionMethods[option.to_sym]
  option_method = option_method[value.class.to_s.downcase.to_sym] if option_method.is_a?(Hash)
  option_method
end
shoulda_option_methods_chain(options) click to toggle source

.is_at_least(50).is_at_max(100)

# File lib/quick_shoulda/generator/validation.rb, line 97
def shoulda_option_methods_chain(options)
  options.map { |option, value| shoulda_option_method(option, value) }.compact.join
end
shoulda_scope_to_method(value) click to toggle source

.scoped_to(:username).scoped_to(:account)

# File lib/quick_shoulda/generator/validation.rb, line 138
def shoulda_scope_to_method(value)
  method = OptionMethods[:scope]
  ([] << value).flatten.map { | v | ".#{method}#{value_transform(v)}" }.join
end