module ShouldaMatchmakers::Model::ActiveRecord::Matchmaker::Validations
Public Instance Methods
validator_matcher_tests(validation_type)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 8 def validator_matcher_tests(validation_type) validators = extract_validators(@app_class_name, validation_type) if validators.present? generate_validation_matcher_tests(validators) else [] end end
Private Instance Methods
custom_exclusion_inclusion_test_required(exclusion_inclusion_option)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 114 def custom_exclusion_inclusion_test_required(exclusion_inclusion_option) exclusion_inclusion_enumerable = exclusion_inclusion_option[:in] || exclusion_inclusion_option[:within] if exclusion_inclusion_enumerable.is_a?(Array) || exclusion_inclusion_enumerable.is_a?(Range) false else true end end
generate_conditional_non_validating_test(validator, validator_options, non_validating_permutation)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 104 def generate_conditional_non_validating_test(validator, validator_options, non_validating_permutation) conditional_non_validating_test = compose_conditional_non_validating_context_string(validator_options, non_validating_permutation) conditional_non_validating_test.concat(compose_conditional_before_strings(validator_options, non_validating_permutation)) non_validating_test = generate_validation_test(validator, validator_options[:non_conditional_options]) non_validating_test.sub!("is_expected.to","is_expected.not_to") non_validating_test = adjust_conditional_test_indentation(non_validating_test) conditional_non_validating_test.concat(non_validating_test) conditional_non_validating_test.concat("\n end") end
generate_conditional_non_validating_tests(validator, validator_options)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 88 def generate_conditional_non_validating_tests(validator, validator_options) conditional_non_validating_tests = [] possible_conditional_permutations = get_possible_true_false_permutations(validator_options) validating_permutation = get_validating_true_false_permutation(validator_options) non_validating_permutations = possible_conditional_permutations - [validating_permutation] non_validating_permutations.each do |non_validating_permutation| conditional_non_validating_test = generate_conditional_non_validating_test(validator, validator_options, non_validating_permutation) conditional_non_validating_tests << conditional_non_validating_test end if validator.options.key?(:unless) conditional_non_validating_tests[0] = conditional_non_validating_tests[0].prepend("# For more natural readability of 'is_expected.not_to' context lines, 'unless' is represented by 'if not'\n# and 'unless not' is represented by 'if'.\n#\n") end conditional_non_validating_tests[0] = conditional_non_validating_tests[0].prepend("# Conditional non-validating test(s)\n#\n") conditional_non_validating_tests end
generate_conditional_validating_test(validator, validator_options)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 79 def generate_conditional_validating_test(validator, validator_options) conditional_validating_test = compose_conditional_validating_context_string(validator_options) validating_permutation = get_validating_true_false_permutation(validator_options) conditional_validating_test.concat(compose_conditional_before_strings(validator_options, validating_permutation)) validating_test = generate_validation_test(validator, validator_options[:non_conditional_options]) validating_test = adjust_conditional_test_indentation(validating_test) conditional_validating_test.concat(validating_test).concat("\n end").prepend("# Conditional validating test\n#\n") end
generate_conditional_validation_tests(validator)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 61 def generate_conditional_validation_tests(validator) conditional_validation_tests = [] validator_options = parse_validator_options(validator.options.dup) if (validator.kind == :exclusion || validator.kind == :inclusion) && validator_options[:non_conditional_options].present? validator_options[:non_conditional_options] = refine_exclusion_inclusion_non_conditional_option(validator_options[:non_conditional_options]) end if all_option_values_are_symbols(validator_options[:if_option_values]) && all_option_values_are_symbols(validator_options[:unless_option_values]) conditional_validating_test = generate_conditional_validating_test(validator, validator_options) conditional_validation_tests = append_element(conditional_validating_test, conditional_validation_tests) conditional_non_validating_tests = generate_conditional_non_validating_tests(validator, validator_options) conditional_validation_tests = conditional_validation_tests + conditional_non_validating_tests # else # Skip tests due to non-symbol conditions (see below) end conditional_validation_tests end
generate_validation_matcher_tests(validators)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 20 def generate_validation_matcher_tests(validators) validation_tests = [] validators.map do |validator| if conditional_options_exist(validator.options) conditional_validation_tests = generate_conditional_validation_tests(validator) validation_tests = validation_tests + conditional_validation_tests else validation_test = generate_validation_test(validator, validator.options) validation_tests = append_element(validation_test, validation_tests) end end format_tests(validation_tests) end
generate_validation_test(validator, validator_options)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 34 def generate_validation_test(validator, validator_options) validation_test = " it { is_expected.to validate_#{ validator.kind.to_s }_of(:#{ validator.attributes.first.to_s })" if (validator.kind == :exclusion || validator.kind == :inclusion) && custom_exclusion_inclusion_test_required(validator_options) validation_test.sub!(" it {", " xit {") custom_exclusion_inclusion_test_comment = get_custom_exclusion_inclusion_test_comment(validator_options) validation_test.prepend(custom_exclusion_inclusion_test_comment).concat(" }") else if validator.kind == :exclusion || validator.kind == :inclusion refined_validator_options = refine_exclusion_inclusion_non_conditional_option(validator_options) else refined_validator_options = validator_options end validator_options_string = get_options_string(refined_validator_options) validation_test.concat(validator_options_string + " }") if validation_test.length > @working_generated_code_line_length validation_test = generate_validation_test_multiple_lines(validator, validator_options_string) end end validation_test end
generate_validation_test_multiple_lines(validator, validator_options_string)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 55 def generate_validation_test_multiple_lines(validator, validator_options_string) validation_test = " it do\n is_expected.to validate_#{ validator.kind.to_s }_of(:#{ validator.attributes.first })" validator_options_string = validator_options_string.gsub(".", ".\n ") validation_test.concat(validator_options_string).concat("\n end") end
get_custom_exclusion_inclusion_test_comment(exclusion_inclusion_option)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 123 def get_custom_exclusion_inclusion_test_comment(exclusion_inclusion_option) exclusion_inclusion_enumerable = exclusion_inclusion_option[:in] || exclusion_inclusion_option[:within] # CONFIRMATION TODO: Confirm whether or not enumerable could be a 'Proc' that isn't a 'lambda' custom_exclusion_inclusion_test_comment = if exclusion_inclusion_enumerable.lambda? "# Note: Your 'in:/within:' configuration option value is a 'Lambda'." + " You will need to implement a customized test.\n" elsif exclusion_inclusion_enumerable.respond_to?(:call) "# Note: Your 'in:/within:' configuration option value is a 'Proc'." + " You will need to implement a customized test.\n" else "# Alert: Invalid 'in:/within:' enumerable object type: '#{ exclusion_enumerable.class.name.to_s }'\n" + "# Valid exclusion 'in:/within:' enumerable object types: 'Array', 'Range'" + " (or a proc, lambda or symbol which returns an enumerable)\n" end custom_exclusion_inclusion_test_comment.concat("# Remove the 'x' from 'xit' once test customization has been implemented.\n") end
refine_exclusion_inclusion_non_conditional_option(exclusion_inclusion_option)
click to toggle source
# File lib/model/active_record/matchmakers/validations.rb, line 140 def refine_exclusion_inclusion_non_conditional_option(exclusion_inclusion_option) refined_exclusion_inclusion_option = {} exclusion_inclusion_enumerable = exclusion_inclusion_option[:in] || exclusion_inclusion_option[:within] if exclusion_inclusion_enumerable.is_a?(Array) refined_exclusion_inclusion_option = { in_array: exclusion_inclusion_enumerable } elsif exclusion_inclusion_enumerable.is_a?(Range) refined_exclusion_inclusion_option = { in_range: exclusion_inclusion_enumerable } end refined_exclusion_inclusion_option end