shoulda_matchmakers 0.1.0 → 0.1.1

data/lib/support/to_discard/render_template_reconstruction.rb

@@ -1,188 +0,0 @@
-module ShouldaMatchmakers
-  module Controller
-    module ActionController
-      module Matchmaker
-        module RenderTemplate
-
-          def render_template_matcher_tests
-            render_template_occurrences = get_render_template_occurrences(@action_controller_controller_sm_model)
-            if render_template_occurrences.present?
-              generate_render_template_matcher_tests(render_template_occurrences)
-            else
-              []
-            end
-          end
-
-
-          private
-
-          def generate_render_template_matcher_tests(render_template_occurrences)
-            render_template_tests = []
-            render_template_occurrences.sort_by!{ |render_template| [render_template[:view_action], render_template[:view_action_http_method]] }
-            render_template_occurrences.each do |render_template|
-              render_template_test = "  describe '#{ render_template[:view_action_http_method] } ##{ render_template[:view_action] }' do\n"
-              render_template_test.concat("    before { #{ render_template[:view_action_http_method].downcase } :#{ render_template[:view_action] } }\n\n")
-              render_template_test.concat("    it { is_expected.to render_template('#{ render_template[:view_action] }') }\n")
-              render_template[:view_action_render_occurrences].sort_by!{ |render_occurrence| [render_occurrence[:render_view_type], render_occurrence[:render_view]] }
-              render_template[:view_action_render_occurrences].each do |render_occurrence|
-                if render_occurrence[:render_view_type] == "partial" && render_occurrence[:render_view].include?("/") ||
-                    render_occurrence[:render_view_type] == "file"
-                  render_template_test.concat("    it { is_expected.to render_template(#{ render_occurrence[:render_view_type] }: '")
-                elsif render_occurrence[:render_view_type] == "partial"
-                  render_template_test.concat("    it { is_expected.to render_template(#{ render_occurrence[:render_view_type] }: '_")
-                elsif render_occurrence[:render_view_type] == "unknown"
-                  render_template_test.concat("    # Unknown view type. Remove 'x' from 'xit' once view type identified (e.g. 'partial:', 'file:', etc.)\n")
-                  render_template_test.concat("    xit { is_expected.to render_template('")
-                else
-                  render_template_test.concat("    it { is_expected.to render_template('")
-                end
-                render_template_test.concat("#{ render_occurrence[:render_view] }') }\n")
-              end
-              render_template_test.concat("  end")
-              render_template_tests << render_template_test
-            end
-            render_template_tests = properly_line_space_tests(render_template_tests)
-            render_template_tests.flatten.compact.uniq.join("\n")
-          end
-
-
-          def get_render_template_occurrences(controller)
-            render_template_occurrences = []
-            app_views_path = Rails.root.join("app", "views").to_s + "/"
-            controller_views_path = app_views_path + controller.underscore.sub(/_controller$/, "/")
-            %w(erb haml slim).each do |view_file_format|
-              render_template_occurrences = render_template_occurrences + get_render_template_occurrences_by_file_type(app_views_path, controller_views_path, view_file_format)
-            end
-            render_template_occurrences
-          end
-
-          def get_render_template_occurrences_by_file_type(app_views_path, controller_views_path, view_file_format)
-            render_template_occurrences_by_file_type = []
-            Dir.glob(controller_views_path + "**/*.html." + view_file_format) do |view_file_path|
-              view_action_render_occurrences = []
-              File.open(view_file_path, 'r') do |view_file|
-                view_file.each_line do |line|
-                  if line =~ /(?:\s+render|=render)(?:\s+action:\s+|\s+:action\s+=\>\s+|\s+file:\s+|\s+:file\s+=\>\s+|\s+partial:\s+|\s+:partial\s+=\>\s+|\s+template:\s+|\s+:template\s+=\>\s+|\s+)["':][A-Za-z0-9_\/\.]+"*'*\s*$/
-                    render_view_type, render_view_path = line.match(/(?:\s+render|=render)(\s+action:\s+|\s+:action\s+=\>\s+|\s+file:\s+|\s+:file\s+=\>\s+|\s+partial:\s+|\s+:partial\s+=\>\s+|\s+template:\s+|\s+:template\s+=\>\s+|\s+)["':]([A-Za-z0-9_\/\.]+)/).captures
-                    if render_view_type.present?
-                      render_view_type = render_view_type.gsub(/\s+/,"").gsub(":", "").gsub("=>","")
-                    else
-                      render_view_type = get_render_view_type(app_views_path, view_file_path, render_view_path)
-                    end
-                    view_action_render_occurrence = { render_view_type: render_view_type, render_view: render_view_path }
-                    view_action_render_occurrences << view_action_render_occurrence
-                  end
-                end
-              end
-              if view_action_render_occurrences.present?
-                view_action = get_view_from_path(view_file_path).sub(".html." + view_file_format, "")
-                if render_template_containing_method_is_action(controller, view_action)
-                  route_controller = controller.underscore.sub(/_controller$/, "")
-                  view_action_route = Rails.application.routes.set.select { |route| route.defaults[:controller] == route_controller && route.defaults[:action] == view_action }
-                  view_action_http_method = view_action_route.first.constraints[:request_method].to_s.gsub("(?-mix:^","").gsub("$)","")
-                  render_template_occurrence = { view_action: view_action, view_action_http_method: view_action_http_method, view_action_render_occurrences: view_action_render_occurrences }
-                  render_template_occurrences_by_file_type << render_template_occurrence
-                end
-              end
-            end
-            render_template_occurrences_by_file_type
-          end
-
-          def get_render_view_type(app_views_path, view_file_path, render_view_path)
-            render_view_and_directory = get_internal_render_view_and_directory(app_views_path, view_file_path, render_view_path)
-            render_view_type = identify_internal_render_view_type(render_view_and_directory, app_views_path)
-            if render_view_type == "unknown" && render_view_path.include?("/")
-              render_view_and_directory = get_external_render_view_and_directory(render_view_path)
-              render_view_type = identify_external_render_view_type(render_view_and_directory)
-            end
-            render_view_type
-          end
-
-          def get_internal_render_view_and_directory(app_views_path, view_file_path, render_view_path)
-            if render_view_path.include?("/")
-              render_view_directory = get_view_directory_prepended(render_view_path,app_views_path)
-              render_view = get_view_from_path(render_view_path).sub(/^\s*_/,"")
-            else
-              render_view_directory = get_view_directory_from_path(view_file_path)
-              render_view = render_view_path.sub(/^\s*_/,"")
-            end
-            { directory: render_view_directory, view: render_view }
-          end
-
-
-          def get_external_render_view_and_directory(render_view_path)
-            render_view_directory = get_view_directory_from_path(render_view_path)
-            render_view = get_view_from_path(render_view_path)
-            { directory: render_view_directory, view: render_view }
-          end
-
-
-          def get_view_from_path(view_path)
-            view_path.scan(/\/([a-zA-z0-9.]+)$/).last.first
-          end
-
-
-          def get_view_directory_from_path(view_path)
-            view_path.sub(/\/[a-zA-z0-9.]+$/,"/")
-          end
-
-
-          def get_view_directory_prepended(view_path, prepend_path)
-            view_path.sub(/\/[a-zA-z0-9.]+$/,"/").prepend(prepend_path)
-          end
-
-
-          def identify_internal_render_view_type(render_view_and_directory, app_views_path)
-            render_view_type = "unknown"
-            if view_partial_exist(render_view_and_directory)
-              render_view_type = "partial"
-            elsif view_exist(render_view_and_directory)
-              render_view_controller_name = get_controller_name_from_view_directory_path(render_view_and_directory[:directory], app_views_path)
-              if render_view_controller_name.present? && render_template_containing_method_is_action(render_view_controller_name, render_view_and_directory[:view])
-                render_view_type = "action"
-              else
-                render_view_type = "template"
-              end
-            end
-            render_view_type
-          end
-
-
-          def identify_external_render_view_type(render_view_and_directory)
-            render_view_type = "unknown"
-            if view_partial_exist(render_view_and_directory) || view_exist(render_view_and_directory)
-              render_view_type = "file"
-            end
-            render_view_type
-          end
-
-
-          def view_exist(render_view_and_directory)
-            File.exist?(render_view_and_directory[:directory] + render_view_and_directory[:view] + ".html.erb") ||
-              File.exist?(render_view_and_directory[:directory] + render_view_and_directory[:view] + ".html.haml") ||
-              File.exist?(render_view_and_directory[:directory] + render_view_and_directory[:view] + ".html.slim")
-          end
-
-
-          def view_partial_exist(render_view_and_directory)
-            File.exist?(render_view_and_directory[:directory] + "_" + render_view_and_directory[:view] + ".html.erb") ||
-              File.exist?(render_view_and_directory[:directory] + "_" + render_view_and_directory[:view] + ".html.haml") ||
-              File.exist?(render_view_and_directory[:directory] + "_" + render_view_and_directory[:view] + ".html.slim")
-          end
-
-
-          def get_controller_name_from_view_directory_path(view_directory_path, app_views_path)
-            view_directory_path.sub(app_views_path, "").sub(/\/$/,"").concat("_controller").camelize
-          end
-
-
-          def render_template_containing_method_is_action(controller, action_candidate)
-            controller.constantize.instance_methods(false).include?(action_candidate.to_sym)
-          end
-
-
-        end
-      end
-    end
-  end
-end

data/lib/support/to_discard/use_around_action.rb

@@ -1,20 +0,0 @@
-module ShouldaMatchmakers
-  module Controller
-    module ActionController
-      module ActionControllerMatcher
-        module UseAroundAction
-
-          def use_around_action_matcher_tests
-            around_action_tests = []
-            around_actions.map do |action|
-              around_action_test = "  it { is_expected.to use_around_action(#{ action }) }"
-              around_action_tests << [around_action_test]
-            end
-            around_action_tests.flatten.compact.uniq.join("\n")
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/support/to_discard/use_before_action.rb

@@ -1,20 +0,0 @@
-module ShouldaMatchmakers
-  module Controller
-    module ActionController
-      module ActionControllerMatcher
-        module UseBeforeAction
-
-          def use_before_action_matcher_tests
-            before_action_tests = []
-            before_actions.map do |action|
-              before_action_test = "  it { is_expected.to use_before_action(#{ action }) }"
-              before_action_tests << [before_action_test]
-            end
-            before_action_tests.flatten.compact.uniq.join("\n")
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/support/to_discard/validate_absence_of.rb

@@ -1,16 +0,0 @@
-module ShouldaMatchmakers
-  module Model
-    module ActiveRecord
-      module ActiveModelMatcher
-        module ValidateAbsenceOf
-
-          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
-
-        end
-      end
-    end
-  end
-end

data/lib/support/to_discard/validate_acceptance_of.rb

@@ -1,16 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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