BARN-77: allow context parameter overrides in ParameterSubstitution helper methods

Author: cgaroutte

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parameter_substitution (2.1.0)
+    parameter_substitution (3.0.0.pre.0)
       activesupport (>= 6.0)
       builder (~> 3.2)
       invoca-utils (~> 0.3)

lib/parameter_substitution.rb

@@ -63,27 +63,35 @@ def configure
       ParameterSubstitution.config = config
     end
 
-    def find_tokens(string_with_tokens, mapping: {}, parameter_start: "<", parameter_end: ">")
-      parse_expression(context_from_string(string_with_tokens, mapping, parameter_start: parameter_start, parameter_end: parameter_end)).substitution_parameter_names
+    def find_tokens(string_with_tokens, mapping: {}, context_overrides: nil)
+      context = build_context(string_with_tokens, mapping, context_overrides)
+      parse_expression(context).substitution_parameter_names
     end
 
-    def find_formatters(string_with_tokens, mapping: {}, parameter_start: "<", parameter_end: ">")
-      parse_expression(context_from_string(string_with_tokens, mapping, parameter_start: parameter_start, parameter_end: parameter_end)).method_names
+    def find_formatters(string_with_tokens, mapping: {}, context_overrides: nil)
+      context = build_context(string_with_tokens, mapping, context_overrides)
+      parse_expression(context).method_names
     end
 
-    def find_warnings(string_with_tokens, mapping: {}, parameter_start: "<", parameter_end: ">")
-      parse_expression(context_from_string(string_with_tokens, mapping, parameter_start: parameter_start, parameter_end: parameter_end)).parameter_and_method_warnings || []
+    def find_warnings(string_with_tokens, mapping: {}, context_overrides: nil)
+      context = build_context(string_with_tokens, mapping, context_overrides)
+      parse_expression(context).parameter_and_method_warnings || []
     end
 
     private
 
-    def context_from_string(string_with_tokens, mapping, parameter_start: "<", parameter_end: ">")
-      ParameterSubstitution::Context.new(
+    # Build context with optional overrides
+    # @param [String] string_with_tokens The input string containing tokens
+    # @param [Hash] mapping The mapping of parameters to values
+    # @param [Hash, nil] context_overrides Optional overrides for context attributes
+    # @return [ParameterSubstitution::Context] The constructed context
+    def build_context(string_with_tokens, mapping, context_overrides)
+      base_options = {
         input: string_with_tokens,
-        mapping:,
-        parameter_start:,
-        parameter_end:
-      )
+        mapping: mapping
+      }
+
+      ParameterSubstitution::Context.new(**base_options.merge(context_overrides || {}))
     end
 
     def parse_expression(context)

lib/parameter_substitution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class ParameterSubstitution
-  VERSION = "2.1.0"
+  VERSION = "3.0.0-0"
 end

spec/lib/parameter_substitution_spec.rb

@@ -86,11 +86,13 @@ def self.find(_key); end
           let(:square_expression) { "[call.start_time.blank_if_nil][do_a_barrel_roll.downcase]" }
 
           it "returns tokens up to first dot when no mapping is provided" do
-            expect(ParameterSubstitution.find_tokens(square_expression, parameter_start: "[", parameter_end: "]")).to eq(['call', 'do_a_barrel_roll'])
+            context_overrides = { parameter_start: "[", parameter_end: "]" }
+            expect(ParameterSubstitution.find_tokens(square_expression, context_overrides: context_overrides)).to eq(['call', 'do_a_barrel_roll'])
           end
 
           it "returns tokens that exist in mapping when one is provided" do
-            expect(ParameterSubstitution.find_tokens(square_expression, mapping: mapping, parameter_start: "[", parameter_end: "]")).to eq(['call.start_time', 'do_a_barrel_roll'])
+            context_overrides = { parameter_start: "[", parameter_end: "]" }
+            expect(ParameterSubstitution.find_tokens(square_expression, mapping: mapping, context_overrides: context_overrides)).to eq(['call.start_time', 'do_a_barrel_roll'])
           end
         end
       end
@@ -108,18 +110,20 @@ def self.find(_key); end
           let(:square_expression) { "[call.start_time.blank_if_nil][do_a_barrel_roll.downcase]" }
 
           it "returns all formatters after first dot when no mapping is provided" do
-            expect(ParameterSubstitution.find_formatters(square_expression, parameter_start: "[", parameter_end: "]")).to eq(['start_time', 'blank_if_nil', 'downcase'])
+            context_overrides = { parameter_start: "[", parameter_end: "]" }
+            expect(ParameterSubstitution.find_formatters(square_expression, context_overrides: context_overrides)).to eq(['start_time', 'blank_if_nil', 'downcase'])
           end
 
           it "returns formatters after all tokens when mapping is provided" do
-            expect(ParameterSubstitution.find_formatters(square_expression, mapping: mapping, parameter_start: "[", parameter_end: "]")).to eq(['blank_if_nil', 'downcase'])
+            context_overrides = { parameter_start: "[", parameter_end: "]" }
+            expect(ParameterSubstitution.find_formatters(square_expression, mapping: mapping, context_overrides: context_overrides)).to eq(['blank_if_nil', 'downcase'])
           end
         end
       end
 
       context '#find_warnings' do
         let(:expression_with_valid_params) { "<foo>" }
-        let(:expression_with_bad_paramss) { "<bobby><bobby2>" }
+        let(:expression_with_bad_params) { "<bobby><bobby2>" }
         let(:expression_with_bad_methods) { "<foo.test1.test2><foo.test3.test4><black.test1.test2>" }
         let(:expression_with_bad_params_and_methods) { "<bobby.test1.test2><bobby2.test3.test4>" }
         let(:expression_with_mixed_bad_params_and_methods) { "<bobby.test1.test2><foo.test3.test4>" }
@@ -133,7 +137,7 @@ def self.find(_key); end
 
         context "when there are invalid parameters" do
           it "returns 2 warnings" do
-            expect(ParameterSubstitution.find_warnings(expression_with_bad_paramss)).to eq(["Unknown param 'bobby'", "Unknown param 'bobby2'"])
+            expect(ParameterSubstitution.find_warnings(expression_with_bad_params)).to eq(["Unknown param 'bobby'", "Unknown param 'bobby2'"])
           end
         end
 
@@ -158,17 +162,20 @@ def self.find(_key); end
           let(:square_expression_with_bad_methods) { "[foo.test1.test2][foo.test3.test4][black.test1.test2]" }
 
           it "returns empty array for valid parameters" do
-            expect(ParameterSubstitution.find_warnings(square_expression_with_valid_params, mapping: default_mapping, parameter_start: "[", parameter_end: "]"))
+            context_overrides = { parameter_start: "[", parameter_end: "]" }
+            expect(ParameterSubstitution.find_warnings(square_expression_with_valid_params, mapping: default_mapping, context_overrides: context_overrides))
               .to eq([])
           end
 
           it "returns warnings for invalid parameters" do
-            expect(ParameterSubstitution.find_warnings(square_expression_with_bad_params, parameter_start: "[", parameter_end: "]"))
+            context_overrides = { parameter_start: "[", parameter_end: "]" }
+            expect(ParameterSubstitution.find_warnings(square_expression_with_bad_params, context_overrides: context_overrides))
               .to eq(["Unknown param 'bobby'", "Unknown param 'bobby2'"])
           end
 
           it "returns warnings for invalid methods" do
-            expect(ParameterSubstitution.find_warnings(square_expression_with_bad_methods, mapping: default_mapping, parameter_start: "[", parameter_end: "]"))
+            context_overrides = { parameter_start: "[", parameter_end: "]" }
+            expect(ParameterSubstitution.find_warnings(square_expression_with_bad_methods, mapping: default_mapping, context_overrides: context_overrides))
               .to eq(["Unknown methods 'test1', 'test2', 'test3', 'test4' used on parameter 'foo'",
                       "Unknown methods 'test1', 'test2' used on parameter 'black'"])
           end