From be18f711d6a11f6304726ddee3b7343318252aa6 Mon Sep 17 00:00:00 2001
From: Sam Carlton <sam@sam.lc>
Date: Sat, 4 Jun 2022 19:13:57 -0500
Subject: [PATCH] Add suppor for underscores in filter values

---
 helpers/stork/browser.js | 31 ++++++++++++++++++++++++-------
 test/prebuild/filters.js | 21 ++++++++++++++++++---
 2 files changed, 42 insertions(+), 10 deletions(-)

diff --git a/helpers/stork/browser.js b/helpers/stork/browser.js
index a5e881d..7b096a1 100644
--- a/helpers/stork/browser.js
+++ b/helpers/stork/browser.js
@@ -228,29 +228,33 @@ export class StorkClient {
 }
 
 
+const statusFilterSeparator = '_'
+
 export class StorkFilters {
     constructor({
         initialFilters = {}
     } = {}) {
+        this.initialFilters = initialFilters
+
         this.filters = {
             ...initialFilters
         }
     }
 
-
-
     get filtersForQuery () {
         return Object.entries( this.filters ).map( ([ filterKey, filterValue ]) => {
-            return `${ filterKey }_${ filterValue }`
+            return `${ filterKey }${ statusFilterSeparator }${ filterValue }`
         } ).join(' ')
     }
 
     isQueryValue ( filterNameOrQueryValue ) {
-        return filterNameOrQueryValue.includes('_')
+        return filterNameOrQueryValue.includes( statusFilterSeparator )
     }
 
     getKeyAndValue ( filterQueryValue ) {
-        const [ key, value ] = filterQueryValue.split('_')
+        const key = filterQueryValue.substring(0, filterQueryValue.indexOf( statusFilterSeparator ))
+        const value = filterQueryValue.substring(filterQueryValue.indexOf( statusFilterSeparator )+1)
+
         return { key, value }
     }
 
@@ -265,6 +269,13 @@ export class StorkFilters {
         }
     }
 
+    removeFilter ( filterName ) {
+        // Throw error if it's not a valid filter name
+        if ( this.isQueryValue( filterName ) ) throw new Error(`${ filterName } is not a valid filter name`)
+
+        delete this.filters[ filterName ]
+    }
+
     toggleFilter ( filterNameOrQueryValue, filterValue = null ) {
 
         const fromString = this.getFilterNameAndValueFromString( filterNameOrQueryValue )
@@ -272,8 +283,9 @@ export class StorkFilters {
         const filterName = fromString.key
         filterValue = filterValue || fromString.value
 
-        if ( !!this.filters[ filterName ] ) {
-            delete this.filters[ filterName ]
+        // If the filter is already set, remove it
+        if ( this.hasFilter( filterName ) ) {
+            this.removeFilter( filterName )
 
             return
         }
@@ -290,8 +302,13 @@ export class StorkFilters {
 
         const {
             key : filterName,
+            value : filterValue = null
         } = this.getFilterNameAndValueFromString( filterNameOrQueryValue )
 
+        // If this filter is a name and value, check if it's set
+        if ( isString( filterValue ) ) {
+            return !!this.filters[ filterName ] && this.filters[ filterName ] === filterValue
+        }
 
         return !!this.filters[ filterName ]
     }
diff --git a/test/prebuild/filters.js b/test/prebuild/filters.js
index a0bcbaa..af12ccf 100644
--- a/test/prebuild/filters.js
+++ b/test/prebuild/filters.js
@@ -22,14 +22,29 @@ test('Can Toggle off existing filter' , async t => {
     filters.toggleFilter('test', 'yes')
     filters.toggleFilter('status', 'native')
 
-    t.deepEqual(filters.hasFilter('test'), true)
+    t.deepEqual(filters.hasFilter('test'), true, 'Has test filter')
 
-    t.deepEqual(filters.filtersForQuery, 'test_yes status_native')
+    t.deepEqual(filters.filtersForQuery, 'test_yes status_native', 'Has correct filters for query')
 
     filters.toggleFilter('status_native')
 
-    t.deepEqual(filters.filtersForQuery, 'test_yes')
+    t.deepEqual(filters.filtersForQuery, 'test_yes', 'Has only test filter')
 })
 
 
+test('Can handle query values with multiple underscores', async t => {
+    const filters = new StorkFilters({
+        initialFilters: {
+            'test': 'value_with_multiple_underscores'
+        }
+    })
+
+    t.log( 'filters.filtersForQuery', filters.filtersForQuery )
+
+    t.assert( filters.hasFilter( 'test_value_with_multiple_underscores' ) , 'Has correct filters for query' )
+})
+
 // Can handle query values with multiple underscores
+
+
+// Can update existing filter