shoulda_matchmakers 0.1.0

data/lib/support/to_discard/validate_acceptance_of.rb

@@ -0,0 +1,16 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveModelMatcher
+        module ValidateAcceptanceOf
+
+          def validate_acceptance_of_matcher_tests
+            acceptance_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::AcceptanceValidator).flatten
+            generate_validator_matcher_tests(acceptance_validators)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validate_confirmation_of.rb

@@ -0,0 +1,16 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveModelMatcher
+        module ValidateConfirmationOf
+
+          def validate_confirmation_of_matcher_tests
+            confirmation_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::ConfirmationValidator).flatten
+            generate_validator_matcher_tests(confirmation_validators)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validate_exclusion_of.rb

@@ -0,0 +1,145 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module ValidateExclusionOf
+
+
+          def validate_exclusion_of_matcher_tests
+            exclusion_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::ExclusionValidator).flatten
+            if exclusion_validators.present?
+              generate_exclusion_validator_matcher_tests(exclusion_validators)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_exclusion_validator_matcher_tests(exclusion_validators)
+            exclusion_tests = []
+            exclusion_validators.map do |exclusion_validator|
+              if conditional_options_exist(exclusion_validator.options)
+                exclusion_tests = exclusion_tests + generate_exclusion_conditional_tests(exclusion_validator)
+              else
+                exclusion_tests << generate_exclusion_test(exclusion_validator, exclusion_validator.options)
+              end
+            end
+            exclusion_tests = properly_line_space_tests(exclusion_tests)
+            exclusion_tests.flatten.compact.uniq.join("\n")
+          end
+
+          def generate_exclusion_test(exclusion_validator, exclusion_options)
+            exclusion_test = get_exclusion_test_core(exclusion_options, exclusion_validator.attributes[0])
+            exclusion_options_string = get_options_string(exclusion_options)
+            exclusion_options_string = exclusion_options_string.gsub(".", ".\n      ")
+            exclusion_test.concat(exclusion_options_string + "\n  end")
+            exclusion_test
+          end
+
+          def generate_exclusion_conditional_tests(exclusion_validator)
+            exclusion_conditional_tests = []
+            exclusion_options = parse_validator_options(exclusion_validator.options.dup)
+            if all_option_values_are_symbols(exclusion_options[:if_option_values]) &&
+                all_option_values_are_symbols(exclusion_options[:unless_option_values])
+              exclusion_conditional_tests << generate_exclusion_validating_test(exclusion_validator, exclusion_options[:non_conditional_options])
+              exclusion_conditional_tests = exclusion_conditional_tests + generate_exclusion_non_validating_tests(exclusion_validator, exclusion_options[:non_conditional_options])
+            # else
+              # Skip tests due to non-symbol conditions (see below)
+            end
+            exclusion_conditional_tests
+          end
+
+          def generate_exclusion_validating_test(exclusion_validator, exclusion_options)
+            exclusion_validating_test = compose_conditional_validating_context_string(exclusion_options)
+            validating_permutation = get_validating_true_false_permutation(exclusion_options)
+            exclusion_validating_test.concat(compose_conditional_before_strings(exclusion_options, validating_permutation))
+            validating_test = generate_exclusion_test(exclusion_validator, exclusion_options[:non_conditional_options])
+            validating_test = adjust_conditional_test_indentation(validating_test)
+            exclusion_validating_test.concat(validating_test + "\n  end")
+          end
+
+          def generate_exclusion_non_validating_tests(exclusion_validator, exclusion_options)
+            exclusion_non_validating_tests = []
+            possible_conditional_permutations = get_possible_true_false_permutations(exclusion_options)
+            validating_permutation = get_validating_true_false_permutation(exclusion_options)
+            non_validating_permutations = possible_conditional_permutations - [validating_permutation]
+            non_validating_permutations.each do |non_validating_permutation|
+              exclusion_non_validating_test = generate_exclusion_non_validating_test(exclusion_validator, exclusion_options, non_validating_permutation)
+              exclusion_non_validating_tests << exclusion_non_validating_test
+            end
+            exclusion_non_validating_tests[0] = exclusion_non_validating_tests[0].prepend("#\n# 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")
+            exclusion_non_validating_tests
+          end
+
+          def generate_exclusion_non_validating_test(exclusion_validator, exclusion_options, non_validating_permutation)
+            exclusion_non_validating_test = compose_conditional_non_validating_context_string(exclusion_options, non_validating_permutation)
+            exclusion_non_validating_test.concat(compose_conditional_before_strings(exclusion_options, non_validating_permutation))
+            non_validating_test = generate_exclusion_test(exclusion_validator, exclusion_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)
+            exclusion_non_validating_test.concat(non_validating_test)
+            exclusion_non_validating_test.concat("\n  end")
+          end
+
+          def get_exclusion_test_core(validator_options, validator_attribute)
+            exclusion_enumerable = validator_options[:in] || validator_options[:within]
+            if exclusion_enumerable.is_a?(Array)
+              "  it do\n    is_expected.to validate_exclusion_of(:#{ validator_attribute }).\n      in_array(#{ exclusion_enumerable })"
+            elsif exclusion_enumerable.is_a?(Range)
+              "  it do\n    is_expected.to validate_exclusion_of(:#{ validator_attribute }).\n      in_range(#{ exclusion_enumerable })"
+            elsif exclusion_enumerable.lambda?
+              "  #\n  # Note: Your 'in:/within:' configuration option value is a 'Lambda'\n" +
+              "  #       You will need to implement a customized test.\n" +
+              "  it do\n    skip(\"Remove this skip line once test customization has been implemented.\")\n    is_expected.to validate_exclusion_of(:#{ validator_attribute })"
+            # CONFIRMATION TODO: Confirm whether or not exclusion_enumerable could be a 'Proc' that isn't a 'lambda'
+            elsif exclusion_enumerable.respond_to?(:call)
+              "  #\n  # Note: Your 'in:/within:' configuration option value is a 'Proc'\n" +
+              "  #       You will need to implement a customized test.\n" +
+              "  it do\n    skip(\"Remove this skip line once test customization has been implemented.\")\n    is_expected.to validate_exclusion_of(:#{ validator_attribute })"
+            else
+              "  #\n  # Alert: Invalid 'in:/within:' enumerable object type: '#{ exclusion_enumerable.class.to_s }'\n" +
+              "  #          Valid exclusion 'in:/within:' enumerable object types: 'Array', 'Range'\n" +
+              "  #            (or a proc, lambda or symbol which returns an enumerable)\n" +
+              "  it do\n    skip(\"Remove this skip line once valid enumerable object type is provided.\")\n    is_expected.to validate_exclusion_of(:#{ validator_attribute })"
+            end
+          end
+
+
+          # def get_exclusion_test_options(options)
+          #   exclusion_test_options = ""
+          #   options.map do |option, option_value|
+          #     exclusion_test_option = get_exclusion_test_option(option, option_value)
+          #     exclusion_test_options.concat(".\n      " + exclusion_test_option) if exclusion_test_option.present?
+          #   end
+          #   exclusion_test_options
+          # end
+          #
+          # def get_exclusion_test_option(option, option_value)
+          #   case option
+          #     # IMPLEMENTATION TODO: Determine if 'allow_blank' is a valid option
+          #     # when :allow_blank
+          #     #   "allow_blank"
+          #     # IMPLEMENTATION TODO: Determine if 'allow_nil' is a valid option
+          #     # when :allow_nil
+          #     #   "allow_nil"
+          #     when :message
+          #       if option_value.include? '"'
+          #         "with_message('#{ option_value }')"
+          #       else
+          #         "with_message(\"#{ option_value }\")"
+          #       end
+          #     when :on
+          #       "on(:#{ option_value })"
+          #     else
+          #       # IMPLEMENTATION TODO: Possibly handle as an error or modify evaluation of option
+          #       ""
+          #   end
+          # end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validate_inclusion_of.rb

@@ -0,0 +1,94 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module ValidateInclusionOf
+
+
+          def validate_inclusion_of_matcher_tests
+            inclusion_tests = []
+            extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::InclusionValidator).flatten.map do |validator|
+              validator_options       = validator.options.dup
+              validator_if_option     = validator_options.delete(:if)
+              validator_unless_option = validator_options.delete(:unless)
+              validator.attributes.map do |attribute|
+                inclusion_tests << generate_inclusion_test_multiple_lines(validator_options, attribute)
+              end
+            end
+            inclusion_tests.flatten.compact.uniq.join("\n\n")
+          end
+
+
+          private
+
+            def generate_inclusion_test_multiple_lines(validator_options, attribute)
+              inclusion_test = get_inclusion_test_core(validator_options, attribute)
+              inclusion_test_options = get_inclusion_test_options(validator_options)
+              inclusion_test.concat(inclusion_test_options) if inclusion_test_options.present?
+              inclusion_test.concat("\n  end")
+              [inclusion_test]
+            end
+
+
+            def get_inclusion_test_core(validator_options, attribute)
+              inclusion_enumerable = validator_options[:in] || validator_options[:within]
+              if inclusion_enumerable.is_a?(Array)
+                "  it do\n    is_expected.to validate_inclusion_of(:#{ attribute }).\n      in_array(#{ inclusion_enumerable })"
+              elsif inclusion_enumerable.is_a?(Range)
+                "  it do\n    is_expected.to validate_inclusion_of(:#{ attribute }).\n      in_range(#{ inclusion_enumerable })"
+              elsif inclusion_enumerable.lambda?
+                "  #\n  # Note: Your 'in:/within:' configuration option value is a 'Lambda'\n" +
+                "  #       You will need to implement a customized test.\n" +
+                "  it do\n    skip(\"Remove this skip line once test customization has been implemented.\")\n    is_expected.to validate_inclusion_of(:#{ attribute })"
+              # CONFIRMATION TODO: Confirm whether or not inclusion_enumerable could be a 'Proc' that isn't a 'lambda'
+              elsif inclusion_enumerable.respond_to?(:call)
+                "  #\n  # Note: Your 'in:/within:' configuration option value is a 'Proc'\n" +
+                "  #       You will need to implement a customized test.\n" +
+                "  it do\n    skip(\"Remove this skip line once test customization has been implemented.\")\n    is_expected.to validate_inclusion_of(:#{ attribute })"
+              else
+                "  #\n  # Alert: Invalid 'in:/within:' enumerable object type: '#{ inclusion_enumerable.class.to_s }'\n" +
+                "  #          Valid inclusion 'in:/within:' enumerable object types: 'Array', 'Range'\n" +
+                "  #            (or a proc, lambda or symbol which returns an enumerable)\n" +
+                "  it do\n    skip(\"Remove this skip line once valid enumerable object type is provided.\")\n    is_expected.to validate_inclusion_of(:#{ attribute })"
+              end
+            end
+
+
+            def get_inclusion_test_options(options)
+              inclusion_test_options = ""
+              options.map do |option, option_value|
+                inclusion_test_option = get_inclusion_test_option(option, option_value)
+                inclusion_test_options.concat(".\n      " + inclusion_test_option) if inclusion_test_option.present?
+              end
+              inclusion_test_options
+            end
+
+
+            def get_inclusion_test_option(option, option_value)
+              # IMPLEMENTATION TODO: Determine if it is possible to implement 'with_low_message' and 'with_high_message'
+              case option
+                # IMPLEMENTATION TODO: Determine if 'allow_blank' is a valid option
+                # when :allow_blank
+                #   "allow_blank"
+                # IMPLEMENTATION TODO: Determine if 'allow_nil' is a valid option
+                # when :allow_nil
+                #   "allow_nil"
+                when :message
+                  if option_value.include? '"'
+                    "with_message('#{ option_value }')"
+                  else
+                    "with_message(\"#{ option_value }\")"
+                  end
+                when :on
+                  "on(:#{ option_value })"
+                else
+                  # IMPLEMENTATION TODO: Possibly handle as an error or modify evaluation of option
+                  ""
+              end
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validate_length_of.rb

@@ -0,0 +1,16 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveModelMatcher
+        module ValidateLengthOf
+
+          def validate_length_of_matcher_tests
+            length_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::LengthValidator).flatten
+            generate_validator_matcher_tests(length_validators)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validate_numericality_of.rb

@@ -0,0 +1,16 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveModelMatcher
+        module ValidateNumericalityOf
+
+          def validate_numericality_of_matcher_tests
+            numericality_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::NumericalityValidator).flatten
+            generate_validator_matcher_tests(numericality_validators)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validate_presence_of.rb

@@ -0,0 +1,16 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveModelMatcher
+        module ValidatePresenceOf
+
+          def validate_presence_of_matcher_tests
+            presence_validators = extract_validators(@active_record_model_sm_model, ::ActiveRecord::Validations::PresenceValidator).flatten
+            generate_validator_matcher_tests(presence_validators)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validate_uniqueness_of.rb

@@ -0,0 +1,16 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveRecordMatcher
+        module ValidateUniquenessOf
+
+          def validate_uniqueness_of_matcher_tests
+            uniqueness_validators = extract_validators(@active_record_model_sm_model, ::ActiveRecord::Validations::UniquenessValidator).flatten
+            generate_validator_matcher_tests(uniqueness_validators)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validation_old.rb

@@ -0,0 +1,37 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Validation
+
+        def wrap_conditional_validations validator, specs
+          # if_mock = if_condition_mock validator
+          # unless_mock = unless_condition_mock validator
+          # padding = if_mock.blank? && unless_mock.blank? ? '' : '    '
+          specs = specs.map do |spec|
+            "#{spec}"
+            # "#{padding}#{spec}"
+          end.uniq.join("\n")
+          # end.uniq.join("\n  ")
+          # if if_mock.blank? && unless_mock.blank?
+          #   specs
+          # else
+          #   "context \"with conditions\" do\n    before do\n#{if_mock}#{unless_mock}    end\n\n#{specs}\n  end\n"
+          # end
+        end
+
+        def if_condition_mock validator
+          if_condition = validator.options[:if]
+          return '' unless if_condition && if_condition.is_a?(Symbol)
+          "      allow(subject).to receive(:#{if_condition.to_s}).and_return(true)\n"
+        end
+
+        def unless_condition_mock validator
+          unless_condition = validator.options[:unless]
+          return '' unless unless_condition && unless_condition.is_a?(Symbol)
+          "      allow(subject).to receive(:#{unless_condition.to_s}).and_return(false)\n"
+        end
+
+      end
+    end
+  end
+end

data/lib/support/to_discard/validations.rb

@@ -0,0 +1,41 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveModelMatcher
+        module Validations
+
+          def validate_absence_of_matcher_tests
+            absence_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::AbsenceValidator).flatten
+            generate_validator_matcher_tests(absence_validators)
+          end
+
+          def validate_acceptance_of_matcher_tests
+            acceptance_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::AcceptanceValidator).flatten
+            generate_validator_matcher_tests(acceptance_validators)
+          end
+
+          def validate_confirmation_of_matcher_tests
+            confirmation_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::ConfirmationValidator).flatten
+            generate_validator_matcher_tests(confirmation_validators)
+          end
+
+          def validate_length_of_matcher_tests
+            length_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::LengthValidator).flatten
+            generate_validator_matcher_tests(length_validators)
+          end
+
+          def validate_numericality_of_matcher_tests
+            numericality_validators = extract_validators(@active_record_model_sm_model, ::ActiveModel::Validations::NumericalityValidator).flatten
+            generate_validator_matcher_tests(numericality_validators)
+          end
+
+          def validate_presence_of_matcher_tests
+            presence_validators = extract_validators(@active_record_model_sm_model, ::ActiveRecord::Validations::PresenceValidator).flatten
+            generate_validator_matcher_tests(presence_validators)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/support/to_discard/validations_conditional.rb

@@ -0,0 +1,146 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ConditionalValidations
+
+        # def generate_validation_tests(validator)
+        #
+        # end
+
+        def generate_conditional_validation_tests(validator)
+          validator_conditional_tests = []
+          if_option_values_are_symbols = true
+          unless_option_values_are_symbols = true
+          validator_options = validator.options.dup
+          if_option_values = validator_options.delete(:if)
+          unless_option_values = validator_options.delete(:unless)
+
+          if if_option_values.present?
+            if !if_option_values.is_a?(Array)
+              if_option_values = [if_option_values]
+            end
+            if_option_values_are_symbols = all_option_values_are_symbols(if_option_values)
+          else
+            if_option_values = []
+          end
+
+          if unless_option_values.present?
+            if !unless_option_values.is_a?(Array)
+              unless_option_values = [unless_option_values]
+            end
+            unless_option_values_are_symbols = all_option_values_are_symbols(unless_option_values)
+          else
+            unless_option_values = []
+          end
+
+          if if_option_values_are_symbols && unless_option_values_are_symbols
+
+            if_and_unless_option_values = if_option_values + unless_option_values
+            validator_conditional_test = "  context \""
+
+            if_and_unless_option_values.each_with_index do |option_value, index|
+
+              if index < if_option_values.size
+                validator_conditional_test.concat("if #{ option_value.to_s.chomp('?')} and ")
+              else
+                validator_conditional_test.concat("unless #{ option_value.to_s.chomp('?')} and ")
+              end
+            end
+
+            validator_conditional_test.chomp!(" and ").concat("\" do\n")
+
+            if_and_unless_option_values.each_with_index do |option_value, index|
+              if index < if_option_values.size
+                validator_conditional_test.concat("    before { allow(subject).to receive(:#{ option_value }).and_return(true) }\n")
+              else
+                validator_conditional_test.concat("    before { allow(subject).to receive(:#{ option_value }).and_return(false) }\n")
+              end
+            end
+
+            validator_conditional_test.concat("\n    it { is_expected.to validate_#{ validator.kind.to_s }_of(:#{ validator.attributes.first }) }\n  end")
+            validator_conditional_tests << [validator_conditional_test]
+
+            possible_conditional_permutations = get_possible_permutations(if_option_values.size + unless_option_values.size)
+            validating_permutation = get_validating_permutation(if_option_values.size, unless_option_values.size)
+            non_validating_permutations = possible_conditional_permutations - [validating_permutation]
+
+            non_validating_permutations.each do |non_validating_permutation|
+              validator_conditional_test = "  context \""
+
+              if_and_unless_option_values.each_with_index do |option_value, index|
+
+                if index < if_option_values.size
+                  if non_validating_permutation[index]
+                    # TRACE.debug "     *** TRUE CLASS WORKED!!!"
+                  end
+                  if non_validating_permutation[index]
+                    validator_conditional_test.concat("if #{ option_value.to_s.chomp('?')} and ")
+                  else
+                    validator_conditional_test.concat("if not #{ option_value.to_s.chomp('?')} and ")
+                  end
+                else
+                  if non_validating_permutation[index]
+                    validator_conditional_test.concat("if #{ option_value.to_s.chomp('?')} and ")
+                  else
+                    validator_conditional_test.concat("if not #{ option_value.to_s.chomp('?')} and ")
+                  end
+                end
+              end
+              validator_conditional_test.chomp!(" and ").concat("\" do\n")
+              if_and_unless_option_values.each_with_index do |option_value, index|
+                validator_conditional_test.concat("    before { allow(subject).to receive(:#{ option_value }).and_return(#{ non_validating_permutation[index] }) }\n")
+              end
+              validator_conditional_test.concat("\n    it { is_expected.not_to validate_#{ validator.kind.to_s }_of(:#{ validator.attributes.first }) }\n  end")
+              validator_conditional_tests << [validator_conditional_test]
+            end
+          # else
+            # Skip tests due to non-symbol conditions
+            # validator.attributes.map do |attribute|
+            #   skip = true
+            #   presence_test = generate_presence_test_single_line(validator_options, attribute, skip)
+            #   if presence_test[0].length > 80 || validator_options.count > 1
+            #     presence_test = generate_presence_test_multiple_lines(validator_options, attribute, skip)
+            #   end
+            #   presence_test_comment = "  # This test is currently skipped due to if: and/or unless: conditions that aren't symbols.\n"
+            #   presence_test_comment.concat("  # Provide ")
+            #   presence_test.prepend(presence_test_comment)
+            #   presence_tests << presence_test
+            # end
+          end
+          validator_conditional_tests
+        end
+
+
+        private
+
+        def all_option_values_are_symbols(option_values)
+          option_values_are_symbols = true
+          option_values.each do |option_value|
+            if !option_value.is_a?(Symbol)
+              option_values_are_symbols = false
+            end
+          end
+          option_values_are_symbols
+        end
+
+
+        def get_possible_permutations(number_of_option_values)
+          [true, false].repeated_permutation(number_of_option_values).to_a
+        end
+
+
+        def get_validating_permutation(if_option_values_size, unless_options_values_size)
+          validating_permutation = []
+          if_option_values_size.times do |n|
+            validating_permutation << true
+          end
+          unless_options_values_size.times do |n|
+            validating_permutation << false
+          end
+          validating_permutation
+        end
+
+      end
+    end
+  end
+end