shoulda_matchmakers 0.1.0

data/lib/model/active_record/factory_sm_model.rb

@@ -0,0 +1,28 @@
+require_relative 'active_record_model_sm_model_helper'
+require_relative 'factory_sm_model_helper'
+
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      class FactorySmModel
+
+        ### Includes ###
+        include ActiveRecordModelSmModelHelper
+        include FactorySmModelHelper
+
+
+        ### Attribute Accessors ###
+        attr_accessor :app_class_name,
+                      :working_generated_code_line_length
+
+
+        ### Methods ###
+        def initialize(app_class_name, code_line_length)
+          @app_class_name = app_class_name
+          @working_generated_code_line_length = code_line_length
+        end
+
+      end
+    end
+  end
+end

data/lib/model/active_record/factory_sm_model_helper.rb

@@ -0,0 +1,124 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module FactorySmModelHelper
+
+
+        def factory_attributes
+          attributes_for_factory = get_validation_attributes(@app_class_name)
+          attributes_for_factory = attributes_for_factory | get_required_attributes(@app_class_name)
+          attributes_for_factory = attributes_for_factory - get_attributes_with_defaults(@app_class_name)
+          attributes_for_factory = attributes_for_factory.flatten.compact.uniq.sort
+          factory_attributes_string = ""
+          attributes_for_factory.each do |attribute|
+            factory_attributes_string.concat("    # " + attribute.to_s + "\n")
+          end
+          factory_attributes_string
+        end
+
+
+        private
+
+        def get_validation_attributes(app_class_name)
+          validation_attributes = []
+          validation_attributes = validation_attributes | get_absence_attributes(app_class_name)
+          validation_attributes = validation_attributes | get_acceptance_attributes(app_class_name)
+          validation_attributes = validation_attributes | get_confirmation_attributes(app_class_name)
+          validation_attributes = validation_attributes | get_exclusion_attributes(app_class_name)
+          validation_attributes = validation_attributes | get_inclusion_attributes(app_class_name)
+          validation_attributes = validation_attributes | get_length_attributes(app_class_name)
+          validation_attributes = validation_attributes | get_numericality_attributes(app_class_name)
+          validation_attributes = validation_attributes | get_presence_attributes(app_class_name)
+          validation_attributes | get_uniqueness_attributes(app_class_name)
+        end
+
+        def get_attributes_with_defaults(app_class_name)
+          app_class_name.constantize.columns.select{ |column| !column.default.nil? }.map(&:name).map(&:to_sym)
+          # The following line of code doesn't work for the class 'SuperAdminUser', but only that class.
+          # app_class_name.constantize.column_defaults.select{ |attribute, default| !default.nil? }.keys.map(&:to_sym)
+        end
+
+        def get_required_attributes(app_class_name)
+          required_attributes = []
+          required_attributes.concat(app_class_name.constantize.columns.select{ |column| !column.null }.map(&:name))
+          required_attributes.map(&:to_sym) - [:id, :encrypted_password, :created_at, :updated_at]
+        end
+
+        def get_absence_attributes(app_class_name)
+          absence_attributes = []
+          extract_validators(app_class_name, ::ActiveModel::Validations::AbsenceValidator).flatten.map do |validator|
+            absence_attributes.concat(validator.attributes)
+          end
+          absence_attributes
+        end
+
+        def get_acceptance_attributes(app_class_name)
+          acceptance_attributes = []
+          extract_validators(app_class_name, ::ActiveModel::Validations::AcceptanceValidator).flatten.map do |validator|
+            acceptance_attributes.concat(validator.attributes)
+          end
+          acceptance_attributes
+        end
+
+        def get_confirmation_attributes(app_class_name)
+          confirmation_attributes = []
+          extract_validators(app_class_name, ::ActiveModel::Validations::ConfirmationValidator).flatten.map do |validator|
+            confirmation_attributes.concat(validator.attributes)
+          end
+          confirmation_attributes
+        end
+
+        def get_exclusion_attributes(app_class_name)
+          exclusion_attributes = []
+          extract_validators(app_class_name, ::ActiveModel::Validations::ExclusionValidator).flatten.map do |validator|
+            exclusion_attributes.concat(validator.attributes)
+          end
+          exclusion_attributes
+        end
+
+        def get_inclusion_attributes(app_class_name)
+          inclusion_attributes = []
+          extract_validators(app_class_name, ::ActiveModel::Validations::InclusionValidator).flatten.map do |validator|
+            inclusion_attributes.concat(validator.attributes)
+          end
+          inclusion_attributes
+        end
+
+        def get_length_attributes(app_class_name)
+          length_attributes = []
+          extract_validators(app_class_name, ::ActiveModel::Validations::LengthValidator).flatten.map do |validator|
+            length_attributes.concat(validator.attributes)
+          end
+          length_attributes
+        end
+
+        def get_numericality_attributes(app_class_name)
+          numericality_attributes = []
+          extract_validators(app_class_name, ::ActiveModel::Validations::NumericalityValidator).flatten.map do |validator|
+            numericality_attributes.concat(validator.attributes)
+          end
+          numericality_attributes
+        end
+
+        def get_presence_attributes(app_class_name)
+          presence_attributes = []
+          extract_validators(app_class_name, ::ActiveRecord::Validations::PresenceValidator).flatten.map do |validator|
+            presence_attributes.concat(validator.attributes)
+          end
+          presence_attributes
+        end
+
+        def get_uniqueness_attributes(app_class_name)
+          uniqueness_attributes = []
+          extract_validators(app_class_name, ::ActiveRecord::Validations::UniquenessValidator).flatten.map do |validator|
+            uniqueness_attributes.concat(validator.attributes)
+          end
+          uniqueness_attributes
+        end
+
+      end
+    end
+  end
+end
+
+

data/lib/model/active_record/matchmakers/accept_nested_attributes_for.rb

@@ -0,0 +1,66 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module AcceptNestedAttributesFor
+
+
+          def accept_nested_attributes_for_matcher_tests
+            nested_attributes_options = @app_class_name.constantize.nested_attributes_options
+            if nested_attributes_options.present?
+              generate_accept_nested_attributes_for_matcher_tests(nested_attributes_options)
+            else
+              []
+            end
+           end
+
+
+          private
+
+          def generate_accept_nested_attributes_for_matcher_tests(nested_attributes_options)
+            nested_attributes_tests = []
+            nested_attributes_options.map do |class_name, options|
+              nested_attributes_class_name = class_name.to_s
+              nested_attributes_options = trim_options(options)
+              nested_attributes_test = generate_nested_attributes_test(nested_attributes_class_name, nested_attributes_options)
+              nested_attributes_tests = append_element(nested_attributes_test, nested_attributes_tests)
+            end
+            format_tests(nested_attributes_tests)
+          end
+
+          def generate_nested_attributes_test(nested_attributes_class_name, nested_attributes_options)
+            nested_attributes_test = generate_nested_attributes_test_single_line(nested_attributes_class_name, nested_attributes_options)
+            if nested_attributes_test.length > @working_generated_code_line_length
+              nested_attributes_test = generate_nested_attributes_test_multiple_lines(nested_attributes_class_name, nested_attributes_options)
+            end
+            nested_attributes_test
+          end
+
+          def generate_nested_attributes_test_single_line(nested_attributes_class_name, nested_attributes_options)
+            nested_attributes_test = "  it { is_expected.to accept_nested_attributes_for(:#{ nested_attributes_class_name })"
+            nested_attributes_options_string = get_options_string(nested_attributes_options)
+            nested_attributes_test.concat(nested_attributes_options_string + " }")
+            nested_attributes_test
+          end
+
+          def generate_nested_attributes_test_multiple_lines(nested_attributes_class_name, nested_attributes_options)
+            nested_attributes_test = "  it do\n    is_expected.to accept_nested_attributes_for(:#{ nested_attributes_class_name })"
+            nested_attributes_options_string = get_options_string(nested_attributes_options)
+            nested_attributes_options_string = nested_attributes_options_string.gsub(".", ".\n      ")
+            nested_attributes_test.concat(nested_attributes_options_string + "\n  end")
+            nested_attributes_test
+          end
+
+          def trim_options(options)
+            options_untrimmed = options.dup
+            options_trimmed = {}
+            options_untrimmed.delete(:allow_destroy) if options[:allow_destroy].to_s == "false"
+            options_untrimmed.delete(:update_only)   if options[:update_only].to_s   == "false"
+            options_trimmed.merge(options_untrimmed)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/allow_value.rb

@@ -0,0 +1,137 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module AllowValue
+
+
+          def allow_value_matcher_tests
+            allow_value_validators = extract_validators(@app_class_name, ::ActiveModel::Validations::FormatValidator)
+            if allow_value_validators.present?
+              generate_allow_value_matcher_tests(allow_value_validators)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_allow_value_matcher_tests(validators)
+            allow_value_tests = []
+            validators.map do |validator|
+              if conditional_options_exist(validator.options)
+                allow_value_tests = allow_value_tests + generate_conditional_allow_value_tests(validator)
+              else
+                allow_value_test = generate_allow_value_test(validator, validator.options)
+                allow_value_tests = append_element(allow_value_test, allow_value_tests)
+                allow_value_expected_not_to_test = generate_allow_value_expected_not_to_test(allow_value_test)
+                allow_value_tests = append_element(allow_value_expected_not_to_test, allow_value_tests)
+              end
+            end
+            format_tests(allow_value_tests)
+          end
+
+          def generate_allow_value_test(validator, validator_options)
+            allow_value_test = "  xit { is_expected.to allow_values('','').for(:#{ validator.attributes.first })"
+            allow_value_options_string = get_options_string(validator_options)
+            allow_value_test.concat(allow_value_options_string + " }")
+            if allow_value_test.length > @working_generated_code_line_length
+              allow_value_test = generate_allow_value_test_multiple_lines(validator, allow_value_options_string)
+            end
+            allow_value_test_comment = get_allow_value_test_comment(validator)
+            allow_value_test.prepend(allow_value_test_comment)
+          end
+
+          def generate_allow_value_test_multiple_lines(validator, allow_value_options_string)
+            allow_value_test = "  xit do\n    is_expected.to allow_values('','').\n      for(:#{ validator.attributes.first })"
+            allow_value_options_string = allow_value_options_string.gsub(".", ".\n      ")
+            allow_value_test.concat(allow_value_options_string).concat("\n  end")
+          end
+
+          def generate_allow_value_expected_not_to_test(allow_value_test)
+            if allow_value_test.include?("DO NOT MATCH")
+              allow_value_test.sub("DO NOT MATCH", "MATCH").gsub("is_expected.to", "is_expected.not_to")
+            else
+              allow_value_test.sub("MATCH", "DO NOT MATCH").gsub("is_expected.to", "is_expected.not_to")
+            end
+          end
+
+          def generate_conditional_allow_value_tests(validator)
+            conditional_allow_value_tests = []
+            allow_value_options = parse_validator_options(validator.options.dup)
+            if all_option_values_are_symbols(allow_value_options[:if_option_values]) &&
+                all_option_values_are_symbols(allow_value_options[:unless_option_values])
+              conditional_allow_value_validating_test = generate_conditional_allow_value_validating_test(validator, allow_value_options)
+              conditional_allow_value_tests = append_element(conditional_allow_value_validating_test, conditional_allow_value_tests)
+              conditional_allow_value_non_validating_tests = generate_conditional_allow_value_non_validating_tests(validator, allow_value_options)
+              conditional_allow_value_tests = conditional_allow_value_tests + conditional_allow_value_non_validating_tests
+            # else
+              # Skip tests due to non-symbol conditions (see below)
+            end
+            conditional_allow_value_tests
+          end
+
+          def generate_conditional_allow_value_validating_test(validator, allow_value_options)
+            conditional_validating_test = compose_conditional_validating_context_string(allow_value_options)
+            validating_permutation = get_validating_true_false_permutation(allow_value_options)
+            conditional_validating_test.concat(compose_conditional_before_strings(allow_value_options, validating_permutation))
+            validating_test = generate_allow_value_test(validator, allow_value_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
+
+          def generate_conditional_allow_value_non_validating_tests(validator, allow_value_options)
+            conditional_non_validating_tests = []
+            possible_conditional_permutations = get_possible_true_false_permutations(allow_value_options)
+            validating_permutation = get_validating_true_false_permutation(allow_value_options)
+            non_validating_permutations = possible_conditional_permutations - [validating_permutation]
+            non_validating_permutations.each do |non_validating_permutation|
+              conditional_non_validating_test = generate_conditional_allow_value_non_validating_test(validator, allow_value_options, non_validating_permutation)
+              conditional_non_validating_tests = append_element(conditional_non_validating_test, conditional_non_validating_tests)
+            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
+
+          def generate_conditional_allow_value_non_validating_test(validator, allow_value_options, non_validating_permutation)
+            conditional_non_validating_test = compose_conditional_non_validating_context_string(allow_value_options, non_validating_permutation)
+            conditional_non_validating_test.concat(compose_conditional_before_strings(allow_value_options, non_validating_permutation))
+            non_validating_test = generate_allow_value_test(validator, allow_value_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
+
+          def get_allow_value_test_comment(validator)
+            allow_value_test_comment = ""
+            if validator.options.key? :with
+              expected_to_match_value_format = get_value_format(validator.options[:with].source.to_s)
+              allow_value_test_comment = "#\n# Enter values that MATCH this format: #{ expected_to_match_value_format }\n"
+            elsif validator.options.key? :without
+              expected_to_match_value_format = get_value_format(validator.options[:without].source.to_s)
+              allow_value_test_comment = "#\n# Enter values that DO NOT MATCH this format: #{ expected_to_match_value_format }\n"
+            end
+            allow_value_test_comment
+          end
+
+          def get_value_format(format)
+            # IMPLEMENTATION TODO: Add additional predefined Rails regexp's, if they exist
+            uri_regexp_string = URI.regexp.to_s.gsub(/^\(\?x-mi:/,"").gsub('\/', '/').chomp(")")
+            case format
+              when uri_regexp_string
+                "URI.regexp"
+              else
+                format
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/associations.rb

@@ -0,0 +1,52 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module Associations
+
+
+          def association_matcher_tests(association_type)
+            association_type_instances = @app_class_name.constantize.reflect_on_all_associations(association_type.to_sym)
+            if association_type_instances.present?
+              generate_association_matcher_tests(association_type, association_type_instances)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_association_matcher_tests(association_type, association_type_instances)
+            association_tests = []
+            association_type_instances = association_type_instances.map{ |ati| { association_class_name: ati.name, association_options: ati.options } }
+            association_type_instances.each do |association_type_instance|
+              association_test = generate_association_test_single_line(association_type, association_type_instance)
+              if association_test.length > @working_generated_code_line_length
+                association_test = generate_association_test_multiple_lines(association_type, association_type_instance)
+              end
+              association_tests = append_element(association_test, association_tests)
+            end
+            format_tests(association_tests)
+          end
+
+          def generate_association_test_single_line(association_type, association_type_instance)
+            association_matcher = association_type.sub("belongs", "belong").sub("has", "have")
+            association_test = "  it { is_expected.to #{ association_matcher }(:#{ association_type_instance[:association_class_name].to_s })"
+            association_options_string = get_options_string(association_type_instance[:association_options])
+            association_test.concat(association_options_string + " }")
+          end
+
+          def generate_association_test_multiple_lines(association_type, association_type_instance)
+            association_matcher = association_type.sub("belongs", "belong").sub("has", "have")
+            association_test = "  it do\n    is_expected.to #{ association_matcher }(:#{ association_type_instance[:association_class_name].to_s })"
+            association_options_string = get_options_string(association_type_instance[:association_options])
+            association_options_string = association_options_string.gsub(".", ".\n      ")
+            association_test.concat(association_options_string + "\n  end")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/model/active_record/matchmakers/define_enum_for.rb

@@ -0,0 +1,53 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module Matchmaker
+        module DefineEnumFor
+
+
+          def define_enum_for_matcher_tests
+            defined_enums = @app_class_name.constantize.defined_enums
+            if defined_enums.present?
+              generate_define_enum_for_matcher_tests(defined_enums)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_define_enum_for_matcher_tests(defined_enums)
+            define_enum_tests = []
+            defined_enums.each do |attribute, enum_hash|
+              define_enum_test = generate_enum_qualifier_examples(attribute, enum_hash)
+              define_enum_test.concat("  it { is_expected.to define_enum_for(:#{ attribute }) }")
+              define_enum_tests = append_element(define_enum_test, define_enum_tests)
+            end
+            format_tests(define_enum_tests)
+          end
+
+          def generate_enum_qualifier_examples(attribute, enum_hash)
+            enum_names = get_enum_names(enum_hash)
+            define_enum_test = "# You can use the 'with' qualifier to test that your enum has been defined with a certain set of known values.\n"
+            if enum_names.join.length < 40
+              define_enum_test.concat("# Example: 'it { is_expected.to define_enum_for(:#{ attribute }).with(#{ enum_names }) }'\n")
+            else
+              define_enum_test.concat("# Example: 'it { is_expected.to define_enum_for(:#{ attribute }).with([#{ enum_names[0] }, #{ enum_names[1] }, ...]) }'\n")
+            end
+            define_enum_test.concat("#\n# Source: https://github.com/thoughtbot/shoulda-matchers/blob/master/lib/shoulda/matchers/active_record/define_enum_for_matcher.rb\n#\n")
+          end
+
+          def get_enum_names(enum_hash)
+            enum_names = []
+            enum_hash.keys.each do |enum_name|
+              enum_names = append_element(enum_name.to_sym, enum_names)
+            end
+            enum_names
+          end
+
+        end
+      end
+    end
+  end
+end