togglecraft 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffa98d6abdac97120d6cdfd774cd8da1e99fd1b88e2bfb2f978a500c50388f4e
-  data.tar.gz: 5fcf387b554e526d25bc28c430650b5ee3849c1eff0523b11117fd570959a7eb
+  metadata.gz: 33360223d2f26e037faa039bc9c8033cda78f7597e90dac2b2998e9a921daab7
+  data.tar.gz: 8522409a6d3d4b8e6ed49a7db8da1ef8bba17f4c498523b9c9a2c0c48440ef6b
 SHA512:
-  metadata.gz: f07746457dfdd5ecd50882359a8ffad9e107ee4f90ff21a599dc815794b7fb3a21b0a9245b4f5f4c64bc010afc6467856f52503b5318a31661deae4ac8c0a22f
-  data.tar.gz: 1e00cbc1d6be11cc76186de12a926d4a23338ff5818a44ee5b86ecb24bcbda6ea2771a9fe485dada25362584a727b8d03d859cd482f4e2df5d63407ed9802abb
+  metadata.gz: 92920a17fdadae7951231d95455e1a4925d3c1be1db3beef2286c389208e6ff989126665605e5b7fcf49c7b9056a1a7785aaf62a5be9addd605cae36842734ee
+  data.tar.gz: 44f8e14db2f45b284396b774291394df7a5d904bd596f6d94c3d5dab0c65d9b6700585416a9f8b1f3cddf18e4389f66fae360f509e7368acd1f2e8164695fc50

data/lib/togglecraft/cache.rb

@@ -13,11 +13,11 @@ module ToggleCraft
     def initialize(adapter: :memory, ttl: 300)
       @default_ttl = ttl
       @adapter = case adapter
-                 when :memory
+      when :memory
                    CacheAdapters::MemoryAdapter.new
-                 else
+      else
                    adapter
-                 end
+      end
       @cleanup_thread = nil
       start_cleanup
     end

data/lib/togglecraft/client.rb

@@ -26,7 +26,8 @@ module ToggleCraft
         enable_rollout_stage_polling: true,
         rollout_stage_check_interval: 60,
         fetch_jitter: 1500, # milliseconds
-        api_domain: 'https://togglecraft.io'
+        api_domain: 'https://togglecraft.io',
+        heartbeat_domain: 'https://togglecraft.io' # Default heartbeat domain
       }.merge(options).merge(sdk_key: sdk_key)
 
       # Initialize components
@@ -334,7 +335,6 @@ module ToggleCraft
           max_reconnect_interval: @config[:max_reconnect_interval],
           max_reconnect_attempts: @config[:max_reconnect_attempts],
           slow_reconnect_interval: @config[:slow_reconnect_interval],
-          heartbeat_domain: @config[:heartbeat_domain],
           debug: @config[:debug],
           on_message: method(:handle_flags_update),
           on_connect: method(:handle_connect),
@@ -393,7 +393,8 @@ module ToggleCraft
       @fetch_in_progress.make_true
 
       begin
-        versioned_url = "#{@config[:api_domain]}/api/v1/flags/#{@project_key.get}/#{@environment_key.get}/v/#{version}"
+        # API domain always hardcoded to production
+        versioned_url = "https://togglecraft.io/api/v1/flags/#{@project_key.get}/#{@environment_key.get}/v/#{version}"
         log "Fetching flags from #{versioned_url}"
 
         response = HTTP.timeout(10).get(versioned_url)
@@ -428,6 +429,9 @@ module ToggleCraft
       # Update cache
       @cache&.set_all_flags(payload[:flags] || {})
 
+      # Clear evaluation cache for all updated flags
+      clear_evaluation_cache_for_flags(payload[:flags]&.keys || [])
+
       # Initialize rollout stage tracking
       initialize_rollout_stage_tracking
 

data/lib/togglecraft/evaluator.rb

@@ -187,7 +187,7 @@ module ToggleCraft
 
         result = if result.nil?
                    condition_result
-                 else
+        else
                    # Apply combinator logic
                    case previous_combinator
                    when 'OR'
@@ -196,7 +196,7 @@ module ToggleCraft
                      # Default to AND
                      result && condition_result
                    end
-                 end
+        end
 
         previous_combinator = condition[:combinator] || 'AND'
 

data/lib/togglecraft/shared_sse_connection.rb

@@ -158,7 +158,6 @@ module ToggleCraft
         max_reconnect_interval: @config[:max_reconnect_interval],
         max_reconnect_attempts: @config[:max_reconnect_attempts],
         slow_reconnect_interval: @config[:slow_reconnect_interval],
-        heartbeat_domain: @config[:heartbeat_domain],
         debug: @debug,
         on_message: method(:handle_message),
         on_connect: method(:handle_connect),

data/lib/togglecraft/sse_connection.rb

@@ -33,10 +33,10 @@ module ToggleCraft
       @should_reconnect = true
 
       # Callbacks
-      @on_message = options[:on_message] || proc {}
-      @on_connect = options[:on_connect] || proc {}
-      @on_disconnect = options[:on_disconnect] || proc {}
-      @on_error = options[:on_error] || proc {}
+      @on_message = options[:on_message] || proc { }
+      @on_connect = options[:on_connect] || proc { }
+      @on_disconnect = options[:on_disconnect] || proc { }
+      @on_error = options[:on_error] || proc { }
 
       # Threads
       @connection_thread = nil
@@ -204,8 +204,8 @@ module ToggleCraft
         log "Max fast reconnection attempts reached, switching to slow mode (every #{interval}s)"
       else
         @reconnect_attempts += 1
-        interval = [@options[:reconnect_interval] * (2**(@reconnect_attempts - 1)),
-                    @options[:max_reconnect_interval]].min
+        interval = [ @options[:reconnect_interval] * (2**(@reconnect_attempts - 1)),
+                    @options[:max_reconnect_interval] ].min
         log "Scheduling reconnection attempt #{@reconnect_attempts}/" \
             "#{@options[:max_reconnect_attempts]} in #{interval}s"
       end
@@ -263,7 +263,8 @@ module ToggleCraft
       end
 
       begin
-        heartbeat_url = "#{@options[:heartbeat_domain]}/api/v1/heartbeat"
+        # Heartbeat always goes to production API (hardcoded)
+        heartbeat_url = "https://togglecraft.io/api/v1/heartbeat"
         log "Sending heartbeat to #{heartbeat_url}"
 
         response = HTTP.timeout(10)

data/lib/togglecraft/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ToggleCraft
-  VERSION = '1.0.1'
+  VERSION = '1.0.3'
 end

data/spec/togglecraft/cache/memory_adapter_spec.rb

@@ -30,12 +30,12 @@ RSpec.describe ToggleCraft::CacheAdapters::MemoryAdapter do
       adapter.set('string', 'text')
       adapter.set('number', 123)
       adapter.set('hash', { foo: 'bar' })
-      adapter.set('array', [1, 2, 3])
+      adapter.set('array', [ 1, 2, 3 ])
 
       expect(adapter.get('string')).to eq('text')
       expect(adapter.get('number')).to eq(123)
       expect(adapter.get('hash')).to eq({ foo: 'bar' })
-      expect(adapter.get('array')).to eq([1, 2, 3])
+      expect(adapter.get('array')).to eq([ 1, 2, 3 ])
     end
   end
 

data/spec/togglecraft/cache_spec.rb

@@ -48,13 +48,13 @@ RSpec.describe ToggleCraft::Cache do
       cache.set('string', 'text')
       cache.set('number', 123)
       cache.set('hash', { foo: 'bar' })
-      cache.set('array', [1, 2, 3])
+      cache.set('array', [ 1, 2, 3 ])
       cache.set('boolean', true)
 
       expect(cache.get('string')).to eq('text')
       expect(cache.get('number')).to eq(123)
       expect(cache.get('hash')).to eq({ foo: 'bar' })
-      expect(cache.get('array')).to eq([1, 2, 3])
+      expect(cache.get('array')).to eq([ 1, 2, 3 ])
       expect(cache.get('boolean')).to be true
     end
   end

data/spec/togglecraft/client_spec.rb

@@ -203,7 +203,7 @@ RSpec.describe ToggleCraft::Client do
       it 'accepts context for evaluation' do
         context = { user: { id: '123', role: 'admin' } }
         result = client.enabled?('boolean-flag', context)
-        expect([true, false]).to include(result)
+        expect([ true, false ]).to include(result)
       end
 
       it 'caches evaluation results when cache is enabled' do
@@ -261,7 +261,7 @@ RSpec.describe ToggleCraft::Client do
       it 'evaluates percentage flags' do
         context = { user: { id: '123' } }
         result = client.in_percentage?('percentage-flag', context)
-        expect([true, false]).to include(result)
+        expect([ true, false ]).to include(result)
       end
 
       it 'returns default value for missing flags' do
@@ -297,7 +297,7 @@ RSpec.describe ToggleCraft::Client do
         expect(client.evaluate('boolean-flag')).to be true
         expect(%w[control variant-a]).to include(client.evaluate('multivariate-flag', { user: { id: '123' } }))
         result = client.evaluate('percentage-flag', { user: { id: '123' } })
-        expect([true, false]).to include(result)
+        expect([ true, false ]).to include(result)
       end
 
       it 'returns default for missing flags' do
@@ -396,7 +396,7 @@ RSpec.describe ToggleCraft::Client do
         client.send(:emit, :reconnecting)
         client.send(:emit, :rollout_stage_changed, {})
 
-        expect(events_received).to eq([:ready, :flags_updated, :error, :disconnected, :reconnecting, :rollout_stage_changed])
+        expect(events_received).to eq([ :ready, :flags_updated, :error, :disconnected, :reconnecting, :rollout_stage_changed ])
       end
 
       it 'handles errors in event listeners gracefully' do

data/spec/togglecraft/evaluator_spec.rb

@@ -41,7 +41,7 @@ RSpec.describe ToggleCraft::Evaluator do
                                  rules: [
                                    {
                                      conditions: [
-                                       { attribute: 'user.role', operator: 'equals', values: ['admin'] }
+                                       { attribute: 'user.role', operator: 'equals', values: [ 'admin' ] }
                                      ],
                                      value: true
                                    }
@@ -110,7 +110,7 @@ RSpec.describe ToggleCraft::Evaluator do
                                  rules: [
                                    {
                                      conditions: [
-                                       { attribute: 'user.plan', operator: 'equals', values: ['premium'] }
+                                       { attribute: 'user.plan', operator: 'equals', values: [ 'premium' ] }
                                      ],
                                      variant: 'premium-variant'
                                    }
@@ -179,7 +179,7 @@ RSpec.describe ToggleCraft::Evaluator do
                                  rules: [
                                    {
                                      conditions: [
-                                       { attribute: 'user.beta_tester', operator: 'equals', values: ['true'] }
+                                       { attribute: 'user.beta_tester', operator: 'equals', values: [ 'true' ] }
                                      ],
                                      enabled: true
                                    }
@@ -301,8 +301,8 @@ RSpec.describe ToggleCraft::Evaluator do
     it 'returns true when all AND conditions pass' do
       rule = {
         conditions: [
-          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'AND' },
-          { attribute: 'user.active', operator: 'equals', values: ['true'], combinator: 'AND' }
+          { attribute: 'user.role', operator: 'equals', values: [ 'admin' ], combinator: 'AND' },
+          { attribute: 'user.active', operator: 'equals', values: [ 'true' ], combinator: 'AND' }
         ]
       }
       context = { user: { role: 'admin', active: 'true' } }
@@ -313,8 +313,8 @@ RSpec.describe ToggleCraft::Evaluator do
     it 'returns false when any AND condition fails' do
       rule = {
         conditions: [
-          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'AND' },
-          { attribute: 'user.active', operator: 'equals', values: ['true'], combinator: 'AND' }
+          { attribute: 'user.role', operator: 'equals', values: [ 'admin' ], combinator: 'AND' },
+          { attribute: 'user.active', operator: 'equals', values: [ 'true' ], combinator: 'AND' }
         ]
       }
       context = { user: { role: 'admin', active: 'false' } }
@@ -325,8 +325,8 @@ RSpec.describe ToggleCraft::Evaluator do
     it 'returns true when any OR condition passes' do
       rule = {
         conditions: [
-          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'OR' },
-          { attribute: 'user.role', operator: 'equals', values: ['superuser'], combinator: 'OR' }
+          { attribute: 'user.role', operator: 'equals', values: [ 'admin' ], combinator: 'OR' },
+          { attribute: 'user.role', operator: 'equals', values: [ 'superuser' ], combinator: 'OR' }
         ]
       }
       context = { user: { role: 'superuser' } }
@@ -337,9 +337,9 @@ RSpec.describe ToggleCraft::Evaluator do
     it 'handles mixed AND/OR combinators' do
       rule = {
         conditions: [
-          { attribute: 'user.role', operator: 'equals', values: ['admin'], combinator: 'OR' },
-          { attribute: 'user.department', operator: 'equals', values: ['engineering'], combinator: 'AND' },
-          { attribute: 'user.level', operator: 'gt', values: ['5'] }
+          { attribute: 'user.role', operator: 'equals', values: [ 'admin' ], combinator: 'OR' },
+          { attribute: 'user.department', operator: 'equals', values: [ 'engineering' ], combinator: 'AND' },
+          { attribute: 'user.level', operator: 'gt', values: [ '5' ] }
         ]
       }
 

data/spec/togglecraft/sse_connection_spec.rb

@@ -312,7 +312,7 @@ RSpec.describe ToggleCraft::SSEConnection do
       )
 
       conn.instance_variable_get(:@on_message).call({ test: 'data' })
-      expect(messages).to eq([{ test: 'data' }])
+      expect(messages).to eq([ { test: 'data' } ])
 
       conn.disconnect
     end

data/spec/togglecraft/utils_spec.rb

@@ -230,75 +230,75 @@ RSpec.describe ToggleCraft::Utils do
   describe '.evaluate_operator' do
     describe 'equals operator' do
       it 'returns true when values are equal (case-insensitive)' do
-        expect(described_class.evaluate_operator('test', 'equals', ['test'])).to be true
-        expect(described_class.evaluate_operator('Test', 'equals', ['test'])).to be true
-        expect(described_class.evaluate_operator('TEST', 'equals', ['test'])).to be true
+        expect(described_class.evaluate_operator('test', 'equals', [ 'test' ])).to be true
+        expect(described_class.evaluate_operator('Test', 'equals', [ 'test' ])).to be true
+        expect(described_class.evaluate_operator('TEST', 'equals', [ 'test' ])).to be true
       end
 
       it 'returns false when values are not equal' do
-        expect(described_class.evaluate_operator('test', 'equals', ['other'])).to be false
+        expect(described_class.evaluate_operator('test', 'equals', [ 'other' ])).to be false
       end
 
       it 'handles numeric values' do
-        expect(described_class.evaluate_operator(123, 'equals', [123])).to be true
-        expect(described_class.evaluate_operator(123, 'equals', ['123'])).to be true
+        expect(described_class.evaluate_operator(123, 'equals', [ 123 ])).to be true
+        expect(described_class.evaluate_operator(123, 'equals', [ '123' ])).to be true
       end
     end
 
     describe 'not_equals operator' do
       it 'returns false when values are equal' do
-        expect(described_class.evaluate_operator('test', 'not_equals', ['test'])).to be false
+        expect(described_class.evaluate_operator('test', 'not_equals', [ 'test' ])).to be false
       end
 
       it 'returns true when values are not equal' do
-        expect(described_class.evaluate_operator('test', 'not_equals', ['other'])).to be true
+        expect(described_class.evaluate_operator('test', 'not_equals', [ 'other' ])).to be true
       end
 
       it 'returns true for nil values' do
-        expect(described_class.evaluate_operator(nil, 'not_equals', ['test'])).to be true
+        expect(described_class.evaluate_operator(nil, 'not_equals', [ 'test' ])).to be true
       end
     end
 
     describe 'contains operator' do
       it 'returns true when attribute contains value' do
-        expect(described_class.evaluate_operator('hello world', 'contains', ['world'])).to be true
-        expect(described_class.evaluate_operator('HELLO WORLD', 'contains', ['world'])).to be true
+        expect(described_class.evaluate_operator('hello world', 'contains', [ 'world' ])).to be true
+        expect(described_class.evaluate_operator('HELLO WORLD', 'contains', [ 'world' ])).to be true
       end
 
       it 'returns false when attribute does not contain value' do
-        expect(described_class.evaluate_operator('hello world', 'contains', ['xyz'])).to be false
+        expect(described_class.evaluate_operator('hello world', 'contains', [ 'xyz' ])).to be false
       end
     end
 
     describe 'not_contains operator' do
       it 'returns false when attribute contains value' do
-        expect(described_class.evaluate_operator('hello world', 'not_contains', ['world'])).to be false
+        expect(described_class.evaluate_operator('hello world', 'not_contains', [ 'world' ])).to be false
       end
 
       it 'returns true when attribute does not contain value' do
-        expect(described_class.evaluate_operator('hello world', 'not_contains', ['xyz'])).to be true
+        expect(described_class.evaluate_operator('hello world', 'not_contains', [ 'xyz' ])).to be true
       end
     end
 
     describe 'starts_with operator' do
       it 'returns true when attribute starts with value' do
-        expect(described_class.evaluate_operator('hello world', 'starts_with', ['hello'])).to be true
-        expect(described_class.evaluate_operator('HELLO WORLD', 'starts_with', ['hello'])).to be true
+        expect(described_class.evaluate_operator('hello world', 'starts_with', [ 'hello' ])).to be true
+        expect(described_class.evaluate_operator('HELLO WORLD', 'starts_with', [ 'hello' ])).to be true
       end
 
       it 'returns false when attribute does not start with value' do
-        expect(described_class.evaluate_operator('hello world', 'starts_with', ['world'])).to be false
+        expect(described_class.evaluate_operator('hello world', 'starts_with', [ 'world' ])).to be false
       end
     end
 
     describe 'ends_with operator' do
       it 'returns true when attribute ends with value' do
-        expect(described_class.evaluate_operator('hello world', 'ends_with', ['world'])).to be true
-        expect(described_class.evaluate_operator('HELLO WORLD', 'ends_with', ['world'])).to be true
+        expect(described_class.evaluate_operator('hello world', 'ends_with', [ 'world' ])).to be true
+        expect(described_class.evaluate_operator('HELLO WORLD', 'ends_with', [ 'world' ])).to be true
       end
 
       it 'returns false when attribute does not end with value' do
-        expect(described_class.evaluate_operator('hello world', 'ends_with', ['hello'])).to be false
+        expect(described_class.evaluate_operator('hello world', 'ends_with', [ 'hello' ])).to be false
       end
     end
 
@@ -313,8 +313,8 @@ RSpec.describe ToggleCraft::Utils do
       end
 
       it 'handles numeric values' do
-        expect(described_class.evaluate_operator(1, 'in', [1, 2, 3])).to be true
-        expect(described_class.evaluate_operator(4, 'in', [1, 2, 3])).to be false
+        expect(described_class.evaluate_operator(1, 'in', [ 1, 2, 3 ])).to be true
+        expect(described_class.evaluate_operator(4, 'in', [ 1, 2, 3 ])).to be false
       end
     end
 
@@ -334,170 +334,170 @@ RSpec.describe ToggleCraft::Utils do
 
     describe 'gt operator' do
       it 'returns true when attribute is greater than value' do
-        expect(described_class.evaluate_operator(10, 'gt', [5])).to be true
-        expect(described_class.evaluate_operator(5.5, 'gt', [5])).to be true
+        expect(described_class.evaluate_operator(10, 'gt', [ 5 ])).to be true
+        expect(described_class.evaluate_operator(5.5, 'gt', [ 5 ])).to be true
       end
 
       it 'returns false when attribute is less than or equal to value' do
-        expect(described_class.evaluate_operator(5, 'gt', [10])).to be false
-        expect(described_class.evaluate_operator(5, 'gt', [5])).to be false
+        expect(described_class.evaluate_operator(5, 'gt', [ 10 ])).to be false
+        expect(described_class.evaluate_operator(5, 'gt', [ 5 ])).to be false
       end
 
       it 'handles string numeric values' do
-        expect(described_class.evaluate_operator('10', 'gt', ['5'])).to be true
+        expect(described_class.evaluate_operator('10', 'gt', [ '5' ])).to be true
       end
     end
 
     describe 'gte operator' do
       it 'returns true when attribute is greater than or equal to value' do
-        expect(described_class.evaluate_operator(10, 'gte', [5])).to be true
-        expect(described_class.evaluate_operator(5, 'gte', [5])).to be true
+        expect(described_class.evaluate_operator(10, 'gte', [ 5 ])).to be true
+        expect(described_class.evaluate_operator(5, 'gte', [ 5 ])).to be true
       end
 
       it 'returns false when attribute is less than value' do
-        expect(described_class.evaluate_operator(5, 'gte', [10])).to be false
+        expect(described_class.evaluate_operator(5, 'gte', [ 10 ])).to be false
       end
     end
 
     describe 'lt operator' do
       it 'returns true when attribute is less than value' do
-        expect(described_class.evaluate_operator(5, 'lt', [10])).to be true
+        expect(described_class.evaluate_operator(5, 'lt', [ 10 ])).to be true
       end
 
       it 'returns false when attribute is greater than or equal to value' do
-        expect(described_class.evaluate_operator(10, 'lt', [5])).to be false
-        expect(described_class.evaluate_operator(5, 'lt', [5])).to be false
+        expect(described_class.evaluate_operator(10, 'lt', [ 5 ])).to be false
+        expect(described_class.evaluate_operator(5, 'lt', [ 5 ])).to be false
       end
     end
 
     describe 'lte operator' do
       it 'returns true when attribute is less than or equal to value' do
-        expect(described_class.evaluate_operator(5, 'lte', [10])).to be true
-        expect(described_class.evaluate_operator(5, 'lte', [5])).to be true
+        expect(described_class.evaluate_operator(5, 'lte', [ 10 ])).to be true
+        expect(described_class.evaluate_operator(5, 'lte', [ 5 ])).to be true
       end
 
       it 'returns false when attribute is greater than value' do
-        expect(described_class.evaluate_operator(10, 'lte', [5])).to be false
+        expect(described_class.evaluate_operator(10, 'lte', [ 5 ])).to be false
       end
     end
 
     describe 'between operator' do
       it 'returns true when attribute is between min and max (inclusive)' do
-        expect(described_class.evaluate_operator(5, 'between', [1, 10])).to be true
-        expect(described_class.evaluate_operator(1, 'between', [1, 10])).to be true
-        expect(described_class.evaluate_operator(10, 'between', [1, 10])).to be true
+        expect(described_class.evaluate_operator(5, 'between', [ 1, 10 ])).to be true
+        expect(described_class.evaluate_operator(1, 'between', [ 1, 10 ])).to be true
+        expect(described_class.evaluate_operator(10, 'between', [ 1, 10 ])).to be true
       end
 
       it 'returns false when attribute is outside range' do
-        expect(described_class.evaluate_operator(0, 'between', [1, 10])).to be false
-        expect(described_class.evaluate_operator(11, 'between', [1, 10])).to be false
+        expect(described_class.evaluate_operator(0, 'between', [ 1, 10 ])).to be false
+        expect(described_class.evaluate_operator(11, 'between', [ 1, 10 ])).to be false
       end
 
       it 'returns false when condition values are insufficient' do
-        expect(described_class.evaluate_operator(5, 'between', [1])).to be false
+        expect(described_class.evaluate_operator(5, 'between', [ 1 ])).to be false
       end
 
       it 'handles decimal values' do
-        expect(described_class.evaluate_operator(5.5, 'between', [5, 6])).to be true
+        expect(described_class.evaluate_operator(5.5, 'between', [ 5, 6 ])).to be true
       end
     end
 
     describe 'regex operator' do
       it 'returns true when attribute matches regex' do
-        expect(described_class.evaluate_operator('test123', 'regex', ['^test\\d+$'])).to be true
-        expect(described_class.evaluate_operator('user@example.com', 'regex', ['^[^@]+@[^@]+$'])).to be true
+        expect(described_class.evaluate_operator('test123', 'regex', [ '^test\\d+$' ])).to be true
+        expect(described_class.evaluate_operator('user@example.com', 'regex', [ '^[^@]+@[^@]+$' ])).to be true
       end
 
       it 'returns false when attribute does not match regex' do
-        expect(described_class.evaluate_operator('test', 'regex', ['^\\d+$'])).to be false
+        expect(described_class.evaluate_operator('test', 'regex', [ '^\\d+$' ])).to be false
       end
 
       it 'returns false for invalid regex' do
-        expect(described_class.evaluate_operator('test', 'regex', ['[invalid'])).to be false
+        expect(described_class.evaluate_operator('test', 'regex', [ '[invalid' ])).to be false
       end
 
       it 'handles complex patterns' do
-        expect(described_class.evaluate_operator('192.168.1.1', 'regex', ['^\\d+\\.\\d+\\.\\d+\\.\\d+$'])).to be true
+        expect(described_class.evaluate_operator('192.168.1.1', 'regex', [ '^\\d+\\.\\d+\\.\\d+\\.\\d+$' ])).to be true
       end
     end
 
     describe 'semver operators' do
       describe 'semver_eq' do
         it 'returns true for equal versions' do
-          expect(described_class.evaluate_operator('1.2.3', 'semver_eq', ['1.2.3'])).to be true
+          expect(described_class.evaluate_operator('1.2.3', 'semver_eq', [ '1.2.3' ])).to be true
         end
 
         it 'returns false for different versions' do
-          expect(described_class.evaluate_operator('1.2.3', 'semver_eq', ['1.2.4'])).to be false
+          expect(described_class.evaluate_operator('1.2.3', 'semver_eq', [ '1.2.4' ])).to be false
         end
       end
 
       describe 'semver_gt' do
         it 'returns true when attribute version is greater' do
-          expect(described_class.evaluate_operator('2.0.0', 'semver_gt', ['1.0.0'])).to be true
-          expect(described_class.evaluate_operator('1.1.0', 'semver_gt', ['1.0.0'])).to be true
+          expect(described_class.evaluate_operator('2.0.0', 'semver_gt', [ '1.0.0' ])).to be true
+          expect(described_class.evaluate_operator('1.1.0', 'semver_gt', [ '1.0.0' ])).to be true
         end
 
         it 'returns false when attribute version is less or equal' do
-          expect(described_class.evaluate_operator('1.0.0', 'semver_gt', ['2.0.0'])).to be false
-          expect(described_class.evaluate_operator('1.0.0', 'semver_gt', ['1.0.0'])).to be false
+          expect(described_class.evaluate_operator('1.0.0', 'semver_gt', [ '2.0.0' ])).to be false
+          expect(described_class.evaluate_operator('1.0.0', 'semver_gt', [ '1.0.0' ])).to be false
         end
       end
 
       describe 'semver_gte' do
         it 'returns true when attribute version is greater or equal' do
-          expect(described_class.evaluate_operator('2.0.0', 'semver_gte', ['1.0.0'])).to be true
-          expect(described_class.evaluate_operator('1.0.0', 'semver_gte', ['1.0.0'])).to be true
+          expect(described_class.evaluate_operator('2.0.0', 'semver_gte', [ '1.0.0' ])).to be true
+          expect(described_class.evaluate_operator('1.0.0', 'semver_gte', [ '1.0.0' ])).to be true
         end
 
         it 'returns false when attribute version is less' do
-          expect(described_class.evaluate_operator('1.0.0', 'semver_gte', ['2.0.0'])).to be false
+          expect(described_class.evaluate_operator('1.0.0', 'semver_gte', [ '2.0.0' ])).to be false
         end
       end
 
       describe 'semver_lt' do
         it 'returns true when attribute version is less' do
-          expect(described_class.evaluate_operator('1.0.0', 'semver_lt', ['2.0.0'])).to be true
+          expect(described_class.evaluate_operator('1.0.0', 'semver_lt', [ '2.0.0' ])).to be true
         end
 
         it 'returns false when attribute version is greater or equal' do
-          expect(described_class.evaluate_operator('2.0.0', 'semver_lt', ['1.0.0'])).to be false
-          expect(described_class.evaluate_operator('1.0.0', 'semver_lt', ['1.0.0'])).to be false
+          expect(described_class.evaluate_operator('2.0.0', 'semver_lt', [ '1.0.0' ])).to be false
+          expect(described_class.evaluate_operator('1.0.0', 'semver_lt', [ '1.0.0' ])).to be false
         end
       end
 
       describe 'semver_lte' do
         it 'returns true when attribute version is less or equal' do
-          expect(described_class.evaluate_operator('1.0.0', 'semver_lte', ['2.0.0'])).to be true
-          expect(described_class.evaluate_operator('1.0.0', 'semver_lte', ['1.0.0'])).to be true
+          expect(described_class.evaluate_operator('1.0.0', 'semver_lte', [ '2.0.0' ])).to be true
+          expect(described_class.evaluate_operator('1.0.0', 'semver_lte', [ '1.0.0' ])).to be true
         end
 
         it 'returns false when attribute version is greater' do
-          expect(described_class.evaluate_operator('2.0.0', 'semver_lte', ['1.0.0'])).to be false
+          expect(described_class.evaluate_operator('2.0.0', 'semver_lte', [ '1.0.0' ])).to be false
         end
       end
     end
 
     describe 'nil attribute handling' do
       it 'returns false for most operators when attribute is nil' do
-        expect(described_class.evaluate_operator(nil, 'equals', ['test'])).to be false
-        expect(described_class.evaluate_operator(nil, 'contains', ['test'])).to be false
-        expect(described_class.evaluate_operator(nil, 'in', ['test'])).to be false
+        expect(described_class.evaluate_operator(nil, 'equals', [ 'test' ])).to be false
+        expect(described_class.evaluate_operator(nil, 'contains', [ 'test' ])).to be false
+        expect(described_class.evaluate_operator(nil, 'in', [ 'test' ])).to be false
       end
 
       it 'returns true for not_equals when attribute is nil' do
-        expect(described_class.evaluate_operator(nil, 'not_equals', ['test'])).to be true
+        expect(described_class.evaluate_operator(nil, 'not_equals', [ 'test' ])).to be true
       end
 
       it 'returns true for not_in when attribute is nil' do
-        expect(described_class.evaluate_operator(nil, 'not_in', ['test'])).to be true
+        expect(described_class.evaluate_operator(nil, 'not_in', [ 'test' ])).to be true
       end
     end
 
     describe 'unknown operator' do
       it 'returns false and warns for unknown operator' do
         expect do
-          result = described_class.evaluate_operator('test', 'unknown_op', ['value'])
+          result = described_class.evaluate_operator('test', 'unknown_op', [ 'value' ])
           expect(result).to be false
         end.to output(/Unknown operator: unknown_op/).to_stderr
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: togglecraft
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - ToggleCraft