shoulda_matchmakers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a89f47e57114fcca2dc77c4c79a23a5ea277bc32
+  data.tar.gz: be011754779db03bd674e9c01bbf8581facd864e
+SHA512:
+  metadata.gz: 8e4a59e5ed17a4fa4cf2ecfb8eed4dca6dea9ff538d4d1562125f19beff6790bb29dcbda7a07192f8cfb3460292c898273f3198bdc11b1abc77adb9aa65cf525
+  data.tar.gz: 13cd5034e269701147394e088625648bda2bc638b2610b0044a3fa6eccdf1e20a75946818294649311486888210fcd5e7564b5167bc7d4c39431dbc00e382add

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 App-o-matix Software
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,21 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ShouldaMatchmakers'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/controller/action_controller/action_controller_controller_sm_model.rb

@@ -0,0 +1,53 @@
+require_relative 'matchmakers/callbacks'
+require_relative 'matchmakers/filter_param'
+require_relative 'matchmakers/permit'
+require_relative 'matchmakers/redirect_to'
+require_relative 'matchmakers/render_template'
+require_relative 'matchmakers/render_with_layout'
+require_relative 'matchmakers/rescue_from'
+require_relative 'matchmakers/respond_with'
+require_relative 'matchmakers/route'
+require_relative 'matchmakers/set_flash'
+require_relative 'matchmakers/set_session'
+require_relative 'action_controller_controller_sm_model_helper'
+
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      class ActionControllerControllerSmModel
+
+        ### Includes ###
+        include Rails.application.routes.url_helpers
+        include ActionDispatch::Routing
+
+        include Matchmaker::Callbacks
+        include Matchmaker::FilterParam
+        include Matchmaker::Permit
+        include Matchmaker::RedirectTo
+        include Matchmaker::RenderTemplate
+        include Matchmaker::RenderWithLayout
+        include Matchmaker::RespondWith
+        include Matchmaker::RescueFrom
+        include Matchmaker::Route
+        include Matchmaker::SetFlash
+        include Matchmaker::SetSession
+        include ActionControllerControllerSmModelHelper
+
+
+        ### Attribute Accessors ###
+        attr_accessor :app_controller_name,
+                      :working_generated_code_line_length
+
+
+        ### Methods ###
+        def initialize(app_controller_name, app_action_controller_descendants_names, code_line_length)
+          @app_controller_name = app_controller_name
+          @app_action_controller_descendants_names = app_action_controller_descendants_names
+          @working_generated_code_line_length = code_line_length
+        end
+
+      end
+    end
+  end
+end
+

data/lib/controller/action_controller/action_controller_controller_sm_model_helper.rb

@@ -0,0 +1,73 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module ActionControllerControllerSmModelHelper
+
+        def compose_extended_app_controller_file_path(app_controller_name)
+          # Rails.root.join("app", "controllers").to_s + "/" + get_controller_file_path(controller).concat(".rb")
+          Rails.root.join("app", "controllers").to_s + "/" + app_controller_name.to_s.underscore.concat(".rb")
+        end
+
+        def get_app_controller_file_path(app_controller_name)
+          app_controller_name.constantize.controller_path
+        end
+
+        def get_app_controller_routes_by_action(app_controller_name, app_controller_action)
+          Rails.application.routes.set.select { |route| route.defaults[:controller] == app_controller_name && route.defaults[:action] == app_controller_action }
+        end
+
+        def get_app_controller_routes_by_path(app_controller_path)
+          Rails.application.routes.set.select { |route| route.name == app_controller_path.to_s.chomp("_path") }
+        end
+
+        def compose_route_controller(app_controller_name)
+          app_controller_name.underscore.sub(/_controller$/, "")
+        end
+
+        def get_route_http_method(route)
+          route.constraints[:request_method].to_s.gsub("(?-mix:^","").gsub("$)","")
+        end
+
+        def containing_method_is_action(app_controller_name, app_controller_action_candidate)
+          app_controller_name.constantize.instance_methods(false).include?(app_controller_action_candidate.to_sym)
+        end
+
+        def append_element(element, element_set)
+          if element.present?
+            element_set << element
+          end
+          element_set
+        end
+
+        def format_tests(tests)
+          formatted_tests = properly_line_space_tests(tests)
+          formatted_tests.flatten.compact.uniq.join("\n")
+        end
+
+        def properly_line_space_tests(tests)
+          tests_properly_line_spaced = []
+          previous_test = ""
+          tests.each do |test|
+            if (test.include?("\n") && previous_test.present?) ||
+                 (!test.include?("\n") && previous_test.include?("\n"))
+              test_properly_line_spaced = "\n" + test
+            else
+              test_properly_line_spaced = test
+            end
+            tests_properly_line_spaced << test_properly_line_spaced
+            previous_test = test
+          end
+          tests_properly_line_spaced
+        end
+
+      end
+    end
+  end
+end
+
+# Reject procs
+# # TRACE.debug "ALL ACTIONS:"
+# # TRACE.debug all_actions.inspect
+# selected_actions.map(&:raw_filter).reject{ |action| action.class == Proc }
+# all_actions.map { |action| action.is_a?(Symbol) ? ":#{ action }" : action.to_s }
+

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

@@ -0,0 +1,56 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module Callbacks
+
+
+          def use_action_matcher_tests(action_kind)
+            use_actions = get_use_actions(@app_controller_name, action_kind)
+            if use_actions.present?
+              generate_use_action_matcher_tests(use_actions)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_use_action_matcher_tests(use_actions)
+            use_action_tests = []
+            use_actions.each do |use_action|
+              use_action_test = generate_use_action_test(use_action)
+              use_action_tests = append_element(use_action_test, use_action_tests)
+            end
+            format_tests(use_action_tests)
+          end
+
+          def generate_use_action_test(use_action)
+            if use_action[:filter] == "verify_authenticity_token" || use_action[:filter] == "verify_same_origin_request"
+              use_action_test = "# IMPLEMENTATION TODO: Need to determine proper implementation of tests involving CSRF token\n"
+              use_action_test.concat("  xit { is_expected.to use_#{ use_action[:kind] }_action(:#{ use_action[:filter] }) }")
+            else
+              use_action_test = "  it { is_expected.to use_#{ use_action[:kind] }_action(:#{ use_action[:filter] }) }"
+            end
+            use_action_test
+          end
+
+          def get_use_actions(app_controller_name, kind = nil)
+            selected_actions_hashes = []
+            all_actions = app_controller_name.constantize._process_action_callbacks
+            if kind
+              selected_actions = all_actions.select { |f| f.kind == kind }
+              selected_actions = selected_actions.map(&:raw_filter).reject{ |action| action.class == Proc }
+              selected_actions.each do |selected_action|
+                selected_actions_hashes << { kind: kind.to_s, filter: selected_action.to_s }
+              end
+            end
+            selected_actions_hashes
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module FilterParam
+
+
+          def filter_param_matcher_tests
+            filter_params = Rails.application.config.filter_parameters
+            if @app_controller_name == "ApplicationController" && filter_params.present?
+              generate_filter_param_matcher_tests(filter_params)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def generate_filter_param_matcher_tests(filter_params)
+            filter_param_tests = []
+            multiple_params_tests_collections = []
+            filter_params.each do |param|
+              if param.is_a? Symbol
+                filter_param_test = "  it { is_expected.to filter_param(:#{ param }) }"
+                filter_param_tests = append_element(filter_param_test, filter_param_tests)
+              else
+                if param.to_s.include? "|"
+                  # IMPLEMENTATION TODO: Determine if this is correct implementation for filtered parameters defined together, separated by boolean '|' operators.
+                  params_array = param.to_s.sub("(?-mix:^((?-mix", "").gsub("|", ",:").gsub("::", ":").sub("))$)", "").split(',')
+                  multiple_params_tests_collection = compose_multiple_params_tests_collection(params_array)
+                  multiple_params_tests_collections = append_element(multiple_params_tests_collection, multiple_params_tests_collections)
+                else
+                  # IMPLEMENTATION TODO: Determine if this is correct implementation for filtered parameter regexes
+                  param_regex = param.to_s.sub("(?-mix:", "/").sub("$)", "$/")
+                  filter_param_test = "  it { is_expected.to filter_param(#{ param_regex }) }"
+                  filter_param_tests = append_element(filter_param_test, filter_param_tests)
+                end
+              end
+            end
+            filter_param_tests = filter_param_tests + multiple_params_tests_collections
+            format_tests(filter_param_tests)
+          end
+
+          def compose_multiple_params_tests_collection(params_array)
+            multiple_params_tests_collection = compose_multiple_params_tests_collection_comment(params_array)
+            params_array.each_with_index do |single_param, index|
+              multiple_params_tests_collection.concat("  it { is_expected.to filter_param(#{ single_param }) }")
+              if index < params_array.size - 1
+                multiple_params_tests_collection.concat("\n")
+              end
+            end
+           multiple_params_tests_collection
+          end
+
+          def compose_multiple_params_tests_collection_comment(params_array)
+            collection_comment = "# IMPLEMENTATION TODO: Determine if this is proper implementation of filtered parameters defined together, separated by boolean operators.\n"
+            collection_comment.concat("# The following filtered parameters are defined together in the app, separated by the '|' boolean operator:\n# ")
+            params_array.each do |single_param|
+              collection_comment.concat(single_param + ", ")
+            end
+            collection_comment.chomp!(", ").concat("\n")
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,510 @@
+# IMPLEMENTATION TODO: Determine if the variables used in this matcher generator represent the appropriate values, as shown here:
+#
+# it do
+#   params = {
+#     <params_class>: {
+#       <permitted_params_def.permitted_params.each>: <sample_value>
+#     }
+#   }
+#   should permit(:<permitted_params_def.permitted_params.each>).
+#     for(:<calling_class_method>, params: params).
+#     on(:<calling_class>)
+# end
+#
+
+require 'controller/action_controller/permitted_params_definition'
+
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module Permit
+
+
+          def permit_matcher_tests
+            app_controller_permitted_params_defs = get_app_controller_permitted_params_defs(@app_controller_name)
+            if app_controller_permitted_params_defs.present?
+              app_controller_permitted_params_defs_and_calls =
+                add_app_controller_permitted_params_calls_to_defs(app_controller_permitted_params_defs)
+              permit_matcher_tests = generate_permit_matcher_tests(app_controller_permitted_params_defs_and_calls)
+              permit_matcher_tests
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def get_app_controller_permitted_params_defs(app_controller_name)
+            app_controller_file_path = compose_extended_app_controller_file_path(app_controller_name)
+            if File.exists?(app_controller_file_path)
+              app_controller_permitted_params_defs = parse_app_controller_for_permitted_params_defs(app_controller_name, app_controller_file_path)
+              app_controller_permitted_params_defs
+            else
+              []
+            end
+          end
+
+          def parse_app_controller_for_permitted_params_defs(app_controller_name, app_controller_file_path)
+            current_app_controller_method = ""
+            parsing_params = false
+            app_controller_permitted_params_def = nil
+            app_controller_permitted_params_defs = []
+            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|
+                simplified_params_line = app_controller_file_line
+                if continued_from_previous_line
+                  app_controller_permitted_params_def.permitted_params_string.concat(app_controller_file_line)
+                  if app_controller_permitted_params_def.params_array_type == "space_delimited_array_of_symbols" ||
+                      (app_controller_permitted_params_def.params_array_type == "" && app_controller_file_line.include?("%i"))
+                    app_controller_permitted_params_def.params_array_type = "space_delimited_array_of_symbols" if app_controller_permitted_params_def.params_array_type == ""
+                    app_controller_permitted_params_def = update_permitted_params_def(app_controller_permitted_params_def, app_controller_file_line)
+                  elsif app_controller_permitted_params_def.params_array_type == "comma_delimited_array_of_symbols" ||
+                      (app_controller_permitted_params_def.params_array_type == "" && app_controller_file_line =~ /^\s+(?::[a-z_][a-z0-9_]*(?:\s*|\s*,?\s*))+(?:\)|\n)/)
+                    app_controller_permitted_params_def.params_array_type = "comma_delimited_array_of_symbols" if app_controller_permitted_params_def.params_array_type == ""
+                    app_controller_permitted_params_def = update_permitted_params_def(app_controller_permitted_params_def, app_controller_file_line)
+                  elsif app_controller_permitted_params_def.params_array_type == "other" ||
+                      (app_controller_permitted_params_def.params_array_type == "" && app_controller_file_line =~ /^\s+[a-zA-Z:_\[]/)
+                    app_controller_permitted_params_def.params_array_type = "other" if app_controller_permitted_params_def.params_array_type == ""
+                    app_controller_permitted_params_def = update_permitted_params_def(app_controller_permitted_params_def, app_controller_file_line)
+                  end
+                  # IMPLEMENTATION TODO: Determine if possible to handle more complex params list containing nested parens
+                  if app_controller_file_line.include?("(") && !(app_controller_file_line.include?("%i") || app_controller_permitted_params_def.params_array_type == "space_delimited_array_of_symbols")
+                    app_controller_permitted_params_def = nil
+                    parsing_params = false
+                    continued_from_previous_line = false
+                  elsif app_controller_file_line.include?(")")
+                    app_controller_permitted_params_def.permitted_params.flatten!
+                    app_controller_permitted_params_def.permitted_params.uniq!
+                    if app_controller_permitted_params_def.params_array_type == "comma_delimited_array_of_symbols"
+                      app_controller_permitted_params_def.permitted_params = app_controller_permitted_params_def.permitted_params.each{ |permitted_param| permitted_param.sub!(":", "") }
+                    end
+                    app_controller_permitted_params_defs = append_element(app_controller_permitted_params_def, app_controller_permitted_params_defs)
+                    app_controller_permitted_params_def = nil
+                    parsing_params = false
+                    continued_from_previous_line = false
+                  end
+                elsif app_controller_file_line =~ /\s+def\s[A-Za-z0-9_][A-Za-z0-9_!\?=]+/
+                  current_app_controller_method = update_current_app_controller_method(app_controller_file_line)
+                else
+                  if app_controller_file_line =~ /params\.require\(\s*:/ && current_app_controller_method.present?
+                    app_controller_permitted_params_def = create_app_controller_permitted_params_def(app_controller_name, current_app_controller_method, app_controller_file_line)
+                    simplified_params_line = remove_params_require_from_line(simplified_params_line)
+                  end
+                  if app_controller_file_line =~ /permit\(/ && app_controller_permitted_params_def.present? && app_controller_permitted_params_def.params_class.present?
+                    if !app_controller_permitted_params_def.permitted_params_string.include?("permit(")
+                      app_controller_permitted_params_def.permitted_params_string.concat(app_controller_file_line)
+                    end
+                    simplified_params_line = remove_permit_from_line(simplified_params_line)
+                    if simplified_params_line.include?("(") && !simplified_params_line.include?("%i")
+                      app_controller_permitted_params_def = nil
+                    else
+                      parsing_params = true
+                    end
+                  end
+                  if parsing_params
+                    if app_controller_file_line =~ /permit\(\s*%i/
+                      app_controller_permitted_params_def.params_array_type = "space_delimited_array_of_symbols"
+                      app_controller_permitted_params_def = update_permitted_params_def(app_controller_permitted_params_def, simplified_params_line)
+                    elsif app_controller_file_line =~ /permit\(\s*:[a-z_]/
+                      app_controller_permitted_params_def.params_array_type = "comma_delimited_array_of_symbols"
+                      app_controller_permitted_params_def = update_permitted_params_def(app_controller_permitted_params_def, simplified_params_line)
+                    elsif app_controller_file_line =~ /permit\(\s*(?:::|[a-zA-Z\[])/
+                      app_controller_permitted_params_def.params_array_type = "other"
+                      app_controller_permitted_params_def = update_permitted_params_def(app_controller_permitted_params_def, simplified_params_line)
+                    end
+                    if simplified_params_line.include?(")")
+                      app_controller_permitted_params_def.permitted_params.flatten!
+                      app_controller_permitted_params_def.permitted_params.uniq!
+                      if app_controller_permitted_params_def.params_array_type == "comma_delimited_array_of_symbols"
+                        app_controller_permitted_params_def.permitted_params = app_controller_permitted_params_def.permitted_params.each{ |permitted_param| permitted_param.sub!(":", "") }
+                      end
+                      app_controller_permitted_params_defs = append_element(app_controller_permitted_params_def, app_controller_permitted_params_defs)
+                      app_controller_permitted_params_def = nil
+                      parsing_params = false
+                    else
+                      continued_from_previous_line = true
+                    end
+                  end
+                end
+              end
+            end
+            app_controller_permitted_params_defs
+          end
+
+          def update_permitted_params_def(permitted_params_def, file_line)
+            case permitted_params_def.params_array_type
+              when "comma_delimited_array_of_symbols"
+                update_permitted_params_def_comma_delimited_array_of_symbols_type(permitted_params_def, file_line)
+              when "space_delimited_array_of_symbols"
+                update_permitted_params_def_space_delimited_array_of_symbols_type(permitted_params_def, file_line)
+              when "other"
+                update_permitted_params_def_other_type(permitted_params_def)
+              else
+                permitted_params_def
+            end
+          end
+
+          def update_permitted_params_def_comma_delimited_array_of_symbols_type(permitted_params_def, file_line)
+            updated_permitted_params_def = permitted_params_def.dup
+            permitted_params_contained_in_line = file_line.scan(/((?::[a-z_][a-z0-9_]*\s*,?\s*)+)(?:\)|\n)/)
+            if permitted_params_contained_in_line.present?
+              permitted_params_string = permitted_params_contained_in_line.flatten.first
+              permitted_params = permitted_params_string.gsub(" ", "").split(",")
+              if permitted_params.select{ |permitted_param| permitted_param.first != ":"}.count > 0
+                updated_permitted_params_def.params_array_type = "other"
+                updated_permitted_params_def.permitted_params = []
+              else
+                permitted_params.uniq!
+                updated_permitted_params_def.permitted_params = updated_permitted_params_def.permitted_params + permitted_params
+              end
+            end
+            updated_permitted_params_def
+          end
+
+          def update_permitted_params_def_other_type(permitted_params_def)
+            updated_permitted_params_def = permitted_params_def.dup
+            updated_permitted_params_def.permitted_params = []
+            updated_permitted_params_def
+          end
+
+          def update_permitted_params_def_space_delimited_array_of_symbols_type(permitted_params_def, file_line)
+            updated_permitted_params_def = permitted_params_def.dup
+            permitted_params_contained_in_line = file_line.scan(/(?!:[a-z0-9_]+)(?:\s|\)|\n)((?:[a-z][a-z0-9_]*\s*)+)(?:\)|\n)/)
+            if permitted_params_contained_in_line.present?
+              permitted_params_string = permitted_params_contained_in_line.flatten.first
+              permitted_params = permitted_params_string.gsub(/\n/," ").gsub(/\s+/, " ").split(" ")
+              if permitted_params.select{ |permitted_param| permitted_param.first[/[^a-z_]/] == permitted_param.first }.count > 0
+                updated_permitted_params_def.params_array_type = "other"
+                updated_permitted_params_def.permitted_params = []
+              else
+                permitted_params.uniq!
+                updated_permitted_params_def.permitted_params = updated_permitted_params_def.permitted_params + permitted_params
+              end
+            end
+            updated_permitted_params_def
+          end
+
+          def remove_params_require_from_line(file_line)
+            file_line.sub(/params\.require\(\s*:[a-z][a-z0-9_]*\s*\)/, "")
+          end
+
+          def remove_permit_from_line(file_line)
+            file_line.sub(/\.permit\(/, "")
+          end
+
+          def create_app_controller_permitted_params_def(defining_controller, defining_method, app_controller_file_line)
+            params_class = app_controller_file_line.scan(/params\.require\(\s*(:[a-z][a-z0-9_]*)\s*\)/).flatten.first
+            ::ShouldaMatchmakers::Controller::ActionController::PermittedParamsDefinition.new(defining_controller, defining_method, params_class)
+          end
+
+          def add_app_controller_permitted_params_calls_to_defs(app_controller_permitted_params_defs)
+            permitted_params_defs = app_controller_permitted_params_defs.dup
+            permitted_params_defs.each do |permitted_params_def|
+              @app_action_controller_descendants_names.each do |app_action_controller_controller_name|
+                app_controller_file_path = compose_extended_app_controller_file_path(app_action_controller_controller_name)
+                if File.exists?(app_controller_file_path)
+                  File.open(app_controller_file_path, 'r') do |app_controller_file|
+                    current_app_controller_method = nil
+                    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 = update_current_app_controller_method(app_controller_file_line)
+                      else
+                        if app_controller_file_line =~ /\(\s*[a-zA-Z0-9_:\s,@]*#{ permitted_params_def.defining_method }/
+                          permitted_params_def.calls <<
+                              get_permitted_params_call_hash(permitted_params_def.defining_method, app_action_controller_controller_name, current_app_controller_method, app_controller_file_line)
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+              if permitted_params_def.calls == []
+                call_hash = { calling_controller: "unidentified_calling_controller", calling_method: "unidentified_calling_method",
+                              calling_class: "unidentified_calling_class", calling_class_method: "unidentified_calling_class_method",
+                              call_implementation: "missing" }
+                permitted_params_def.calls << call_hash
+              end
+            end
+            permitted_params_defs
+          end
+
+          def get_permitted_params_call_hash(defining_method, calling_controller_name, calling_method, file_line)
+            if file_line =~ /(?:::)?[A-Z][a-zA-Z0-9:]*\.[a-z]+[a-z0-9_]*\(\s*#{ defining_method }\s*\)/
+              calling_class, calling_class_method = file_line.match(/((?:::)?[A-Z][a-zA-Z0-9:]*)\.([a-z]+[a-z0-9_]*)\(\s*#{ defining_method }\s*\)/).captures
+              { calling_controller: calling_controller_name, calling_method: calling_method,
+                calling_class: calling_class, calling_class_method: calling_class_method,
+                call_implementation: "simple" }
+            elsif file_line =~ /[a-zA-Z0-9:@_]+\.[a-z]+[a-z0-9_]*\([a-zA-Z0-9_:\s,@]*#{ defining_method }/
+              calling_class, calling_class_method = file_line.match(/([a-zA-Z0-9:@_]+)\.([a-z]+[a-z0-9_]*)\([a-zA-Z0-9_:\s,@]*#{ defining_method }/).captures
+              { calling_controller: calling_controller_name, calling_method: calling_method,
+                calling_class: calling_class, calling_class_method: calling_class_method,
+                call_implementation: "complex" }
+            else
+              { calling_controller: calling_controller_name, calling_method: calling_method,
+                calling_class: "unidentified_calling_class", calling_class_method: "unidentified_calling_class_method",
+                call_implementation: "complex" }
+            end
+          end
+
+          def generate_permit_matcher_tests(permitted_params_defs)
+            permit_tests = []
+            permitted_params_defs.each do |permitted_params_def|
+              permitted_params_def.calls.each do |call|
+                if call[:call_implementation] == "missing"
+                  permit_test = "# Unable to locate params definition call. Locate params definition call to identify missing values\n"
+                  permit_test.concat("# (see :unidentified_calling_class and :unidentified_calling_class_method below).\n")
+                  permit_test.concat("# Remove 'x' from 'xit' once these missing values and any additional required values have been provided.\n")
+                  permit_test.concat("  xit do\n")
+                elsif call[:call_implementation] == "complex"
+                  if call[:calling_class] == "unidentified_calling_class" || call[:calling_class_method] == "unidentified_calling_class_method"
+                    permit_test = "# Unable to identify params definition calling class and/or calling class method. Examine params definition call\n"
+                    permit_test.concat("# in the '#{ call[:calling_method] }' method of '#{ call[:calling_controller] }' to identify these missing values.\n")
+                    permit_test.concat("# Remove 'x' from 'xit' once these missing values and any additional required values have been provided.\n")
+                    permit_test.concat("  xit do\n")
+                  else
+                    permit_test = "# Params definition call contains complexities that make it difficult for ShouldaMatchmakers to parse completely.\n"
+                    permit_test.concat("# Examine params definition call in the '#{ call[:calling_method] }' method of '#{ call[:calling_controller] }' to identify any additional required values.\n")
+                    permit_test.concat("# Remove 'x' from 'xit' once all required values have been provided.\n")
+                    permit_test.concat("  xit do\n")
+                  end
+                else
+                  permit_test = "  it do\n"
+                end
+                permit_test.concat(compose_permit_test_params_portion(permitted_params_def))
+                permit_test.concat(compose_permit_test_expectation_portion(permitted_params_def))
+                permit_test.concat(compose_permit_test_for_portion(call[:calling_class_method]))
+                permit_test.concat(compose_permit_test_on_portion(call[:calling_class]))
+                permit_tests << permit_test
+              end
+            end
+            format_tests(permit_tests)
+          end
+
+          def compose_permit_test_params_portion(permitted_params_def)
+            permit_test_params_portion = "    params = {\n      #{ permitted_params_def.params_class.to_s[1..-1] }: {\n"
+            if permitted_params_def.params_array_type == "other"
+              permit_test_params_portion.concat("        # Complex params definition. See comment above.")
+            else
+              permitted_params_def.permitted_params.each do |permitted_param|
+                permit_test_params_portion.concat("        #{ permitted_param.to_s }: '',\n")
+              end
+              permit_test_params_portion.chomp!(",\n")
+            end
+            permit_test_params_portion.concat("\n      }\n    }\n")
+          end
+
+          def compose_permit_test_expectation_portion(permitted_params_def)
+            permit_test_expectation_portion = "    is_expected.to permit(\n"
+            if permitted_params_def.params_array_type == "other"
+              permit_test_expectation_portion.concat("        # Complex params definition. See comment above.")
+            else
+              permitted_params_def.permitted_params.each do |permitted_param|
+                permit_test_expectation_portion.concat("      :#{ permitted_param },\n")
+              end
+              permit_test_expectation_portion.chomp!(",\n")
+            end
+            permit_test_expectation_portion.concat("\n    ).\n")
+          end
+
+          def compose_permit_test_for_portion(calling_class_method)
+            if calling_class_method.present?
+              "      for(:#{ calling_class_method }, params: params).\n"
+            else
+              "      for(:unidentified_calling_class_method, params: params).\n"
+            end
+          end
+
+          def compose_permit_test_on_portion(calling_class)
+            if calling_class.present?
+              if calling_class.underscore.include?("/")
+                # IMPLEMENTATION TODO: Determine if this is the proper implementation of calling class (colon/quotes) when it is a path (i.e. namespaced).
+                "      on(:'#{ calling_class.underscore }')\n  end"
+              else
+                "      on(:#{ calling_class.underscore })\n  end"
+              end
+            else
+              "      on(unidentified_calling_class)\n  end"
+            end
+          end
+
+          def update_current_app_controller_method(line)
+            line.scan(/\s+def\s([A-Za-z0-9_][A-Za-z0-9_!\?=]+)/).flatten.first
+          end
+
+        end
+      end
+    end
+  end
+end
+
+
+# TODO: Nested Attributes
+# def protected_branch_params
+#   params.require(:protected_branch).permit(:name,
+#                                            merge_access_levels_attributes: [:access_level, :id],
+#                                            push_access_levels_attributes: [:access_level, :id])
+# end
+
+
+# TODO:
+# params.require(:runner).permit(Ci::Runner::FORM_EDITABLE)
+
+# TODO:
+# params.require(:list).permit(:position).merge(id: params[:id])
+
+# TODO:
+# allowed_fields = NotificationSetting::EMAIL_EVENTS.dup
+# allowed_fields << :level
+# params.require(:notification_setting).permit(allowed_fields)
+
+# TODO:
+# def project_params
+#   project_feature_attributes =
+#     {
+#       project_feature_attributes:
+#         [
+#           :issues_access_level, :builds_access_level,
+#           :wiki_access_level, :merge_requests_access_level, :snippets_access_level
+#         ]
+#     }
+#
+#   params.require(:project).permit(
+#     :name, :path, :description, :issues_tracker, :tag_list, :runners_token,
+#     :container_registry_enabled,
+#     :issues_tracker_id, :default_branch,
+#     :visibility_level, :import_url, :last_activity_at, :namespace_id, :avatar,
+#     :build_allow_git_fetch, :build_timeout_in_minutes, :build_coverage_regex,
+#     :public_builds, :only_allow_merge_if_build_succeeds, :request_access_enabled,
+#     :lfs_enabled, project_feature_attributes
+#   )
+# end
+
+# TODO:
+# def configure_permitted_parameters
+#   devise_parameter_sanitizer.permit(:sign_in, keys: [:username, :email, :password, :login, :remember_me, :otp_attempt])
+# end
+
+# TODO:
+# def auth_params
+#   params.permit(:service, :scope, :account, :client_id)
+# end
+
+# TODO:
+# def application_params
+#   params[:doorkeeper_application].permit(:name, :redirect_uri)
+# end
+
+# TODO:
+# def service_params
+#   dynamic_params = @service.event_channel_names + @service.event_names
+#   service_params = params.permit(:id, service: ALLOWED_PARAMS + dynamic_params)
+#
+#   if service_params[:service].is_a?(Hash)
+#     FILTER_BLANK_PARAMS.each do |param|
+#       service_params[:service].delete(param) if service_params[:service][param].blank?
+#     end
+#   end
+#
+#   service_params
+# end
+
+# TODO:
+# def project_params
+#   params.require(:variable).permit([:id, :key, :value, :_destroy])
+# end
+
+# TODO:
+# def issue_params
+#   params.require(:issue).permit(
+#     :title, :assignee_id, :position, :description, :confidential,
+#     :milestone_id, :due_date, :state_event, :task_num, :lock_version, label_ids: []
+#   )
+# end
+
+# TODO:
+# def application_setting_params
+#   restricted_levels = params[:application_setting][:restricted_visibility_levels]
+#   if restricted_levels.nil?
+#     params[:application_setting][:restricted_visibility_levels] = []
+#   else
+#     restricted_levels.map! do |level|
+#       level.to_i
+#     end
+#   end
+#
+#   import_sources = params[:application_setting][:import_sources]
+#   if import_sources.nil?
+#     params[:application_setting][:import_sources] = []
+#   else
+#     import_sources.map! do |source|
+#       source.to_str
+#     end
+#   end
+#
+#   enabled_oauth_sign_in_sources = params[:application_setting].delete(:enabled_oauth_sign_in_sources)
+#
+#   params[:application_setting][:disabled_oauth_sign_in_sources] =
+#     AuthHelper.button_based_providers.map(&:to_s) -
+#     Array(enabled_oauth_sign_in_sources)
+#   params.delete(:domain_blacklist_raw) if params[:domain_blacklist_file]
+#
+#   params.require(:application_setting).permit(
+#     :default_projects_limit,
+#     :default_branch_protection,
+#     :signup_enabled,
+#     :signin_enabled,
+#     :require_two_factor_authentication,
+#     :two_factor_grace_period,
+#     :gravatar_enabled,
+#     :sign_in_text,
+#     :after_sign_up_text,
+#     :help_page_text,
+#     :home_page_url,
+#     :after_sign_out_path,
+#     :max_attachment_size,
+#     :session_expire_delay,
+#     :default_project_visibility,
+#     :default_snippet_visibility,
+#     :default_group_visibility,
+#     :domain_whitelist_raw,
+#     :domain_blacklist_enabled,
+#     :domain_blacklist_raw,
+#     :domain_blacklist_file,
+#     :version_check_enabled,
+#     :admin_notification_email,
+#     :user_oauth_applications,
+#     :user_default_external,
+#     :shared_runners_enabled,
+#     :shared_runners_text,
+#     :max_artifacts_size,
+#     :metrics_enabled,
+#     :metrics_host,
+#     :metrics_port,
+#     :metrics_pool_size,
+#     :metrics_timeout,
+#     :metrics_method_call_threshold,
+#     :metrics_sample_interval,
+#     :recaptcha_enabled,
+#     :recaptcha_site_key,
+#     :recaptcha_private_key,
+#     :sentry_enabled,
+#     :sentry_dsn,
+#     :akismet_enabled,
+#     :akismet_api_key,
+#     :koding_enabled,
+#     :koding_url,
+#     :email_author_in_body,
+#     :repository_checks_enabled,
+#     :metrics_packet_size,
+#     :send_user_confirmation_email,
+#     :container_registry_token_expire_delay,
+#     :repository_storage,
+#     :enabled_git_access_protocol,
+#     restricted_visibility_levels: [],
+#     import_sources: [],
+#     disabled_oauth_sign_in_sources: []
+#   )
+# end