Merge pull request #69 from Invoca/BARN-63_find_tokens_alternative_parameter_start_end

Barn 63 find tokens alternative parameter start end

Author: cgaroutte

CHANGELOG.md

@@ -4,6 +4,13 @@ Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 Note: This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2025-11-06
+### Added
+- Added optional `parameter_start` and `parameter_end` arguments for the following methods:
+  - `ParameterSubstitution.find_tokens`
+  - `ParameterSubstitution.find_formatters`
+  - `ParameterSubstitution.find_warnings`
+
 ## [2.0.0] - 2024-07-11
 ### Removed
 - Remove support for eol ruby versions 2.7

Gemfile.lock

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

lib/parameter_substitution.rb

@@ -63,22 +63,27 @@ def configure
       ParameterSubstitution.config = config
     end
 
-    def find_tokens(string_with_tokens, mapping: {})
-      parse_expression(context_from_string(string_with_tokens, mapping)).substitution_parameter_names
+    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
     end
 
-    def find_formatters(string_with_tokens, mapping: {})
-      parse_expression(context_from_string(string_with_tokens, mapping)).method_names
+    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
     end
 
-    def find_warnings(string_with_tokens, mapping: {})
-      parse_expression(context_from_string(string_with_tokens, mapping)).parameter_and_method_warnings || []
+    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 || []
     end
 
     private
 
-    def context_from_string(string_with_tokens, mapping)
-      ParameterSubstitution::Context.new(input: string_with_tokens, mapping: mapping)
+    def context_from_string(string_with_tokens, mapping, parameter_start: "<", parameter_end: ">")
+      ParameterSubstitution::Context.new(
+        input: string_with_tokens,
+        mapping:,
+        parameter_start:,
+        parameter_end:
+      )
     end
 
     def parse_expression(context)

lib/parameter_substitution/version.rb

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

spec/lib/parameter_substitution_spec.rb

@@ -81,6 +81,18 @@ def self.find(_key); end
         it "returns tokens that exist in mapping when one is provided" do
           expect(ParameterSubstitution.find_tokens(expression, mapping: mapping)).to eq(['call.start_time', 'do_a_barrel_roll'])
         end
+
+        context 'with non-default delimiters' do
+          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'])
+          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'])
+          end
+        end
       end
 
       context '#find_formatters' do
@@ -91,6 +103,18 @@ def self.find(_key); end
         it "returns formatters after all tokens when mapping is provided" do
           expect(ParameterSubstitution.find_formatters(expression, mapping: mapping)).to eq(['blank_if_nil', 'downcase'])
         end
+
+        context 'with non-default delimiters' do
+          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'])
+          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'])
+          end
+        end
       end
 
       context '#find_warnings' do
@@ -127,6 +151,28 @@ def self.find(_key); end
               .to eq(["Unknown param 'bobby' and methods 'test1', 'test2'", "Unknown param 'bobby2' and methods 'test3', 'test4'"])
           end
         end
+
+        context "with non-default delimiters" do
+          let(:square_expression_with_valid_params) { "[foo]" }
+          let(:square_expression_with_bad_params) { "[bobby][bobby2]" }
+          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: "]"))
+              .to eq([])
+          end
+
+          it "returns warnings for invalid parameters" do
+            expect(ParameterSubstitution.find_warnings(square_expression_with_bad_params, parameter_start: "[", parameter_end: "]"))
+              .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: "]"))
+              .to eq(["Unknown methods 'test1', 'test2', 'test3', 'test4' used on parameter 'foo'",
+                      "Unknown methods 'test1', 'test2' used on parameter 'black'"])
+          end
+        end
       end
     end