shoulda_matchmakers 0.1.0

data/lib/controller/action_controller/matchmakers/redirect_to.rb

@@ -0,0 +1,126 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module RedirectTo
+
+
+          def redirect_to_matcher_tests
+            redirect_to_occurrences = get_redirect_to_occurrences(@app_controller_name)
+            if redirect_to_occurrences.present?
+              generate_redirect_to_matcher_tests(@app_controller_name, redirect_to_occurrences)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def get_redirect_to_occurrences(app_controller_name)
+            redirect_to_occurrences = []
+            app_controller_file_path = compose_extended_app_controller_file_path(app_controller_name)
+            if File.exists?(app_controller_file_path)
+              redirect_to_occurrences = parse_app_controller_for_redirect_to_occurrences(app_controller_file_path)
+            end
+            redirect_to_occurrences
+          end
+
+          def parse_app_controller_for_redirect_to_occurrences(app_controller_file_path)
+            redirect_to_occurrences = []
+            File.open(app_controller_file_path, 'r') do |app_controller_file|
+              current_app_controller_method = nil
+              continued_from_previous_line = false
+              app_controller_file.each_line do |app_controller_file_line|
+                if continued_from_previous_line
+                  redirect_location = app_controller_file_line.scan(/^\s+(:?[a-z0-9_]+)/).flatten.first
+                  if current_app_controller_method.present? && redirect_location.present?
+                    redirect_to_occurrences << { controller_action: current_app_controller_method, redirect_location: redirect_location }
+                  end
+                  continued_from_previous_line = false
+                elsif app_controller_file_line =~ /\s+def\s[A-Za-z0-9_][A-Za-z0-9_!\?=]+/
+                  current_app_controller_method = app_controller_file_line.scan(/\s+def\s([A-Za-z0-9_][A-Za-z0-9_!\?=]+)/).flatten.first
+                elsif app_controller_file_line =~ /^\s+redirect_to(?:\s+|\s*\()\s*:?[a-z0-9_]+/
+                  redirect_location = app_controller_file_line.scan(/^\s+redirect_to(?:\s+|\s*\()\s*(:?[a-z0-9_]+)/).flatten.first
+                  if current_app_controller_method.present? && redirect_location.present?
+                    redirect_to_occurrences << { controller_action: current_app_controller_method, redirect_location: redirect_location }
+                  end
+                elsif app_controller_file_line =~ /^\s+redirect_to(?:\s+|\s*\()\s*\n/
+                  continued_from_previous_line = true
+                end
+              end
+            end
+            redirect_to_occurrences
+          end
+
+          def generate_redirect_to_matcher_tests(app_controller_name, redirect_to_occurrences)
+            redirect_to_tests = []
+            app_controller_route_controller = compose_route_controller(app_controller_name)
+            redirect_to_occurrences.each do |redirect_to_occurrence|
+              app_controller_action_routes = get_app_controller_routes_by_action(app_controller_route_controller, redirect_to_occurrence[:controller_action])
+              app_controller_action_routes.each do |app_controller_action_route|
+                redirect_to_test = generate_redirect_to_test(app_controller_route_controller, app_controller_action_route, redirect_to_occurrence)
+                redirect_to_tests = append_element(redirect_to_test, redirect_to_tests)
+              end
+            end
+            format_tests(redirect_to_tests)
+          end
+
+          def generate_redirect_to_test(app_controller_route_controller, app_controller_action_route, redirect_to_occurrence)
+            if redirect_to_occurrence[:redirect_location] =~ /^:/
+              redirect_to_action_and_path_hash = compose_redirect_to_action_and_path_hash_for_action(app_controller_route_controller, redirect_to_occurrence[:redirect_location])
+            elsif redirect_to_occurrence[:redirect_location] =~ /_path$/
+              redirect_to_action_and_path_hash = compose_redirect_to_action_and_path_hash_for_path(app_controller_action_route, redirect_to_occurrence[:redirect_location])
+            else
+              redirect_to_action_and_path_hash = { action: "", path: "" }
+            end
+            if redirect_to_action_and_path_hash[:action].present? || redirect_to_action_and_path_hash[:path].present?
+              compose_redirect_to_test(app_controller_action_route, redirect_to_action_and_path_hash)
+            else
+              ""
+            end
+          end
+
+          def compose_redirect_to_action_and_path_hash_for_action(app_controller_route_controller, redirect_location)
+            redirect_to_action_and_path_hash = {}
+            redirect_routes = get_app_controller_routes_by_action(app_controller_route_controller, redirect_location)
+            redirect_to_action_and_path_hash[:action] = redirect_location
+            if redirect_routes.present? && redirect_routes.first.name.present?
+              redirect_to_action_and_path_hash[:path] = redirect_routes.first.name.concat("_path")
+            else
+              redirect_to_action_and_path_hash[:path] = ""
+            end
+            redirect_to_action_and_path_hash
+          end
+
+          def compose_redirect_to_action_and_path_hash_for_path(app_controller_action_route, redirect_location)
+            redirect_to_action_and_path_hash = {}
+            redirect_routes = get_app_controller_routes_by_path(redirect_location)
+            if redirect_routes.present? && redirect_routes.first.defaults[:controller] == app_controller_action_route.defaults[:controller]
+              redirect_to_action_and_path_hash[:action] = redirect_routes.first.defaults[:action]
+            else
+              redirect_to_action_and_path_hash[:action] = ""
+            end
+            redirect_to_action_and_path_hash[:path] = redirect_location
+            redirect_to_action_and_path_hash
+          end
+
+          def compose_redirect_to_test(app_controller_action_route, redirect_to_action_and_path_hash)
+            app_controller_route_http_method = get_route_http_method(app_controller_action_route)
+            app_controller_action = app_controller_action_route.defaults[:action].to_s
+            redirect_to_test = "  describe '#{ app_controller_route_http_method } ##{ app_controller_action }' do\n"
+            redirect_to_test.concat("    before { #{ app_controller_route_http_method.downcase } :#{ app_controller_action } }\n\n")
+            if redirect_to_action_and_path_hash[:path].present?
+              redirect_to_test.concat("    it { is_expected.to redirect_to(#{ redirect_to_action_and_path_hash[:path] }) }\n")
+            end
+            if redirect_to_action_and_path_hash[:action].present?
+              redirect_to_test.concat("    it { is_expected.to redirect_to(action: #{ redirect_to_action_and_path_hash[:action] }) }\n")
+            end
+            redirect_to_test.concat("  end\n")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/controller/action_controller/matchmakers/render_template.rb

@@ -0,0 +1,198 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module RenderTemplate
+
+
+          def render_template_matcher_tests
+            render_template_occurrences = get_render_template_occurrences(@app_controller_name)
+            if render_template_occurrences.present?
+              generate_render_template_matcher_tests(render_template_occurrences)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def get_render_template_occurrences(app_controller_name)
+            render_template_occurrences = []
+            app_views_path = Rails.root.join("app", "views").to_s + "/"
+            app_controller_views_path = app_views_path + app_controller_name.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_controller_name, app_views_path, app_controller_views_path, view_file_format)
+            end
+            render_template_occurrences
+          end
+
+          def get_render_template_occurrences_by_file_type(app_controller_name, app_views_path, app_controller_views_path, view_file_format)
+            render_template_occurrences_by_file_type = []
+            Dir.glob(app_controller_views_path + "**/*.html." + view_file_format) do |view_file_path|
+              view_action_render_occurrences = parse_controller_for_view_action_render_occurrences(view_file_path, app_views_path)
+              if view_action_render_occurrences.present?
+                view_action = get_view_from_path(view_file_path).sub(".html." + view_file_format, "")
+                if containing_method_is_action(app_controller_name, view_action)
+                  render_template_occurrence_hashes = compose_render_template_occurrence_hashes(app_controller_name, view_action, view_action_render_occurrences)
+                  render_template_occurrences_by_file_type = render_template_occurrences_by_file_type + render_template_occurrence_hashes
+                end
+              end
+            end
+            render_template_occurrences_by_file_type
+          end
+
+          def parse_controller_for_view_action_render_occurrences(view_file_path, app_views_path)
+            view_action_render_occurrences = []
+            File.open(view_file_path, 'r') do |view_file|
+              view_file.each_line do |view_file_line|
+                if view_file_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*$/
+                  view_action_render_occurrence = compose_view_action_render_occurrence_hash(app_views_path, view_file_path, view_file_line)
+                  view_action_render_occurrences = append_element(view_action_render_occurrence, view_action_render_occurrences)
+                end
+              end
+            end
+            view_action_render_occurrences
+          end
+
+          def compose_view_action_render_occurrence_hash(app_views_path, view_file_path, view_file_line)
+            render_view_type, render_view_path = view_file_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
+            { render_view_type: render_view_type, render_view: render_view_path }
+          end
+
+          def compose_render_template_occurrence_hashes(app_controller_name, view_action, view_action_render_occurrences)
+            render_template_occurrence_hashes = []
+            app_controller_routes_controller = compose_route_controller(app_controller_name)
+            view_action_routes = get_app_controller_routes_by_action(app_controller_routes_controller, view_action)
+            view_action_routes.each do |view_action_route|
+              view_action_http_method = get_route_http_method(view_action_route)
+              render_template_occurrence_hashes << { view_action: view_action, view_action_http_method: view_action_http_method, view_action_render_occurrences: view_action_render_occurrences }
+            end
+            render_template_occurrence_hashes
+          end
+
+          def generate_render_template_matcher_tests(render_template_occurrences)
+            render_template_tests = []
+            render_template_occurrences.sort_by!{ |rto| [rto[:view_action], rto[:view_action_http_method]] }
+            render_template_occurrences.each do |render_template_occurrence|
+              render_template_test = generate_render_template_test_initial(render_template_occurrence)
+              render_template_occurrence[:view_action_render_occurrences].sort_by!{ |varo| [varo[:render_view_type], varo[:render_view]] }
+              render_template_occurrence[:view_action_render_occurrences].each do |view_action_render_occurrence|
+                view_action_render_occurrence_test = generate_view_action_render_occurrence_test(view_action_render_occurrence)
+                render_template_test.concat(view_action_render_occurrence_test)
+              end
+              render_template_test.concat("  end")
+              render_template_tests = append_element(render_template_test, render_template_tests)
+            end
+            format_tests(render_template_tests)
+          end
+
+          def generate_render_template_test_initial(render_template_occurrence)
+            render_template_test = "  describe '#{ render_template_occurrence[:view_action_http_method] } ##{ render_template_occurrence[:view_action] }' do\n"
+            render_template_test.concat("    before { #{ render_template_occurrence[:view_action_http_method].downcase } :#{ render_template_occurrence[:view_action] } }\n\n")
+            render_template_test.concat("    it { is_expected.to render_template('#{ render_template_occurrence[:view_action] }') }\n")
+          end
+
+          def generate_view_action_render_occurrence_test(view_action_render_occurrence)
+            if view_action_render_occurrence[:render_view_type] == "partial" && view_action_render_occurrence[:render_view].include?("/") ||
+                view_action_render_occurrence[:render_view_type] == "file"
+              view_action_render_occurrence_test = "    it { is_expected.to render_template(#{ view_action_render_occurrence[:render_view_type] }: '"
+            elsif view_action_render_occurrence[:render_view_type] == "partial"
+              view_action_render_occurrence_test = "    it { is_expected.to render_template(#{ view_action_render_occurrence[:render_view_type] }: '_"
+            elsif view_action_render_occurrence[:render_view_type] == "unknown"
+              view_action_render_occurrence_test = "    # Unknown view type. Remove 'x' from 'xit' once view type identified (e.g. 'partial:', 'file:', etc.)\n"
+              view_action_render_occurrence_test.concat("    xit { is_expected.to render_template('")
+            else
+              view_action_render_occurrence_test = "    it { is_expected.to render_template('"
+            end
+            view_action_render_occurrence_test.concat("#{ view_action_render_occurrence[:render_view] }') }\n")
+          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? && 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
+
+        end
+      end
+    end
+  end
+end

data/lib/controller/action_controller/matchmakers/render_with_layout.rb

@@ -0,0 +1,72 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module RenderWithLayout
+
+
+          def render_with_layout_matcher_tests
+            render_with_layout_occurrences = get_render_with_layout_occurrences(@app_controller_name)
+            if render_with_layout_occurrences.present?
+              generate_render_with_layout_matcher_tests(@app_controller_name, render_with_layout_occurrences)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def get_render_with_layout_occurrences(app_controller_name)
+            render_with_layout_occurrences = []
+            app_controller_file_path = compose_extended_app_controller_file_path(app_controller_name)
+            if File.exists?(app_controller_file_path)
+              render_with_layout_occurrences = parse_app_controller_for_render_with_layout_occurrences(app_controller_file_path)
+            end
+            render_with_layout_occurrences
+          end
+
+          def parse_app_controller_for_render_with_layout_occurrences(app_controller_file_path)
+            render_with_layout_occurrences = []
+            current_app_controller_method = nil
+            File.open(app_controller_file_path, 'r') do |app_controller_file|
+              app_controller_file.each_line do |app_controller_file_line|
+                if app_controller_file_line =~ /\s+def\s[A-Za-z0-9_][A-Za-z0-9_!\?=]+/
+                  current_app_controller_method = app_controller_file_line.scan(/\s+def\s([A-Za-z0-9_][A-Za-z0-9_!\?=]+)/).flatten.first
+                elsif app_controller_file_line.include?(" render layout:")
+                  render_with_layout_layout = app_controller_file_line.scan(/\s+render\slayout:\s['"]([a-z0-9_]+)/).flatten.first
+                  if current_app_controller_method.present? && render_with_layout_layout.present?
+                    render_with_layout_occurrences << { controller_action: current_app_controller_method, layout: render_with_layout_layout }
+                  end
+                end
+              end
+            end
+            render_with_layout_occurrences
+          end
+
+          def generate_render_with_layout_matcher_tests(app_controller_name, render_with_layout_occurrences)
+            render_with_layout_tests = []
+            render_with_layout_occurrences.sort_by!{ |rwlo| [rwlo[:controller_action], rwlo[:layout]] }
+            render_with_layout_occurrences.each do |render_with_layout_occurrence|
+              app_controller_route_controller = compose_route_controller(app_controller_name)
+              app_controller_action_routes = get_app_controller_routes_by_action(app_controller_route_controller, render_with_layout_occurrence[:controller_action])
+              app_controller_action_routes.each do |app_controller_action_route|
+                render_with_layout_test = generate_render_with_layout_test(app_controller_action_route, render_with_layout_occurrence)
+                append_element(render_with_layout_test, render_with_layout_tests)
+              end
+            end
+            format_tests(render_with_layout_tests)
+          end
+
+          def generate_render_with_layout_test(app_controller_action_route, render_with_layout_occurrence)
+            app_controller_route_http_method = get_route_http_method(app_controller_action_route)
+            render_with_layout_test = "  describe '#{ app_controller_route_http_method } ##{ render_with_layout_occurrence[:controller_action] }' do\n"
+            render_with_layout_test.concat("    before { #{ app_controller_route_http_method.downcase } :#{ render_with_layout_occurrence[:controller_action] } }\n\n")
+            render_with_layout_test.concat("    it { is_expected.to render_with_layout('#{ render_with_layout_occurrence[:layout] }') }\n  end\n")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/controller/action_controller/matchmakers/rescue_from.rb

@@ -0,0 +1,96 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module RescueFrom
+
+
+          def rescue_from_matcher_tests
+            rescue_from_occurrences = get_rescue_from_occurrences(@app_controller_name)
+            if rescue_from_occurrences.present?
+              generate_rescue_from_matcher_tests(rescue_from_occurrences)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def get_rescue_from_occurrences(app_controller_name)
+            rescue_from_occurrences = []
+            app_controller_file_path = compose_extended_app_controller_file_path(app_controller_name)
+            if File.exists?(app_controller_file_path)
+              rescue_from_occurrences = parse_app_controller_for_rescue_from_occurrences(app_controller_file_path)
+            end
+            rescue_from_occurrences
+          end
+
+          def parse_app_controller_for_rescue_from_occurrences(app_controller_file_path)
+            rescue_from_occurrences = []
+            rescue_from_occurrence = {}
+            continued_from_previous_line = false
+            File.open(app_controller_file_path, 'r') do |app_controller_file|
+              app_controller_file.each_line do |app_controller_file_line|
+                if continued_from_previous_line
+                  if app_controller_file_line =~ /^\s*with:\s+[A-Za-z0-9:_]+\s*$/
+                    rescue_from_handler = app_controller_file_line.scan(/^\s*with:\s+([A-Za-z0-9:_]+)/).flatten.first
+                    rescue_from_occurrence[:handler] = rescue_from_handler
+                    rescue_from_occurrences << rescue_from_occurrence
+                    rescue_from_occurrence = {}
+                    continued_from_previous_line = false
+                  elsif !app_controller_file_line =~ /\s*\n/
+                    rescue_from_occurrence[:handler] = ":unidentified_rescue_from_handler"
+                    rescue_from_occurrences << rescue_from_occurrence
+                    rescue_from_occurrence = {}
+                    continued_from_previous_line = false
+                  end
+                elsif app_controller_file_line =~ /^\s+rescue_from(?:\s+|\s*\()[A-Za-z0-9:]+\s*\)?,\s*with:\s+[A-Za-z0-9:_]+\s*$/
+                  rescue_from_exception, rescue_from_handler = app_controller_file_line.match(/^\s+rescue_from(?:\s+|\s*\()([A-Za-z0-9:]+)\s*\)?,\s*with:\s+([A-Za-z0-9:_]+)/).captures
+                  rescue_from_occurrence = { exception: rescue_from_exception, handler: rescue_from_handler }
+                  rescue_from_occurrences << rescue_from_occurrence
+                  rescue_from_occurrence = {}
+                  continued_from_previous_line = false
+                elsif app_controller_file_line =~ /^\s+rescue_from(?:\s+|\s*\()[A-Za-z0-9:]+\s*\)?,\s*$/
+                  rescue_from_exception = app_controller_file_line.scan(/^\s+rescue_from(?:\s+|\s*\()([A-Za-z0-9:]+)/).flatten.first
+                  rescue_from_occurrence = { exception: rescue_from_exception }
+                  continued_from_previous_line = true
+                elsif app_controller_file_line =~ /\s+rescue_from(?:\s+|\s*\()[A-Za-z0-9:]+\s*\)?/
+                  rescue_from_exception = app_controller_file_line.scan(/^\s+rescue_from(?:\s+|\s*\()([A-Za-z0-9:]+)/).flatten.first
+                  rescue_from_occurrence = { exception: rescue_from_exception, handler: ":unidentified_rescue_from_handler" }
+                  rescue_from_occurrences << rescue_from_occurrence
+                  rescue_from_occurrence = {}
+                  continued_from_previous_line = false
+                end
+              end
+            end
+            rescue_from_occurrences
+          end
+
+          def generate_rescue_from_matcher_tests(rescue_from_occurrences)
+            rescue_from_tests = []
+            rescue_from_occurrences.each do |rescue_from_occurrence|
+              rescue_from_test = generate_rescue_from_test(rescue_from_occurrence)
+              rescue_from_tests = append_element(rescue_from_test, rescue_from_tests)
+            end
+            format_tests(rescue_from_tests)
+          end
+
+          def generate_rescue_from_test(rescue_from_occurrence)
+            if rescue_from_occurrence[:handler] == ":unidentified_rescue_from_handler"
+              rescue_from_test = "# A rescue_from occurrence contains complexities that make it difficult for ShouldaMatchmakers to parse completely.\n"
+              rescue_from_test.concat("# Examine the rescue_from occurrence for '#{ rescue_from_occurrence[:exception] }' to determine the appropriate\n")
+              rescue_from_test.concat("# syntax for the test and any required values, such as ':unidentified_rescue_from_handler' below.\n")
+              rescue_from_test.concat("# Remove 'x' from 'xit' once the proper syntax has been established and required values have been provided.\n")
+              rescue_from_test.concat("  xit do\n    is_expected.to rescue_from(#{ rescue_from_occurrence[:exception] }).\n")
+            else
+              rescue_from_test = "  it do\n    is_expected.to rescue_from(#{ rescue_from_occurrence[:exception] }).\n"
+            end
+            rescue_from_test.concat("      with(#{ rescue_from_occurrence[:handler] })\n  end\n")
+          end
+
+        end
+      end
+    end
+  end
+end