togglecraft 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e77c8218c124ce83fbdc25f2f2975f50ca69fde64b3109116e639580ac5be42
-  data.tar.gz: 872451734b10596e4b11337275454a998605a7966ff7e9f5d575c4764ff2a89e
+  metadata.gz: 7b9dd914fcd5b95e495b7f63183f53fa849a7f1bd7291548c39cf46d98a3be1d
+  data.tar.gz: 9f6f56bea1e188e1c2688c16b726140ae9700811db4d3406332defe8501b6f51
 SHA512:
-  metadata.gz: 3353a6384c9c2ab564c5244f0c015a723c403287213e6fa6542c0b8cbfbb49bf804d303f3c1d51510c1a07858884b2626a0128a05744d2d0a7e394ad6f1f43b0
-  data.tar.gz: 6a31210c7fb15839f8b5bbb2b85b37c13129f00ea26a57796d885331a5cf981e6c4eefaf7ad69fdd882a05a29acb2b9175321784892a750d087ef9deba4c4e96
+  metadata.gz: a55edef61bcbf57d1bfb8db39ec69ee26ad20406d472b429c6a231fb8437b100b43ccbe49fdd2addd69439e4ad06d187cf5e7562e00ea1c21c1ab50235374c12
+  data.tar.gz: da54c02f224ea950aa4f0e06564378bf25d9176987b0b25509a73320a23cf26de28cc491cb36219d4def4c5f076174715e433944776e355aa8a5390c0723bbac

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)

data/lib/togglecraft/evaluator.rb

@@ -18,12 +18,13 @@ module ToggleCraft
     end
 
     # Evaluate a boolean flag
-    # @param flag_key [String] The flag key
+    # @param flag_key [String, Symbol] The flag key
     # @param context [Hash] The evaluation context
     # @param default_value [Boolean] Default value if flag not found
     # @return [Boolean]
     def evaluate_boolean(flag_key, context = {}, default_value = false)
-      flag = @flags[flag_key]
+      # Normalize key to symbol for lookup (flags are stored with symbol keys)
+      flag = @flags[flag_key.to_sym]
 
       # Flag doesn't exist
       return default_value unless flag
@@ -56,7 +57,8 @@ module ToggleCraft
     # @param default_variant [String, nil] Default variant if flag not found
     # @return [String, nil]
     def evaluate_multivariate(flag_key, context = {}, default_variant = nil)
-      flag = @flags[flag_key]
+      # Normalize key to symbol for lookup (flags are stored with symbol keys)
+      flag = @flags[flag_key.to_sym]
 
       # Flag doesn't exist
       return default_variant unless flag
@@ -88,12 +90,13 @@ module ToggleCraft
     end
 
     # Evaluate a percentage rollout flag
-    # @param flag_key [String] The flag key
+    # @param flag_key [String, Symbol] The flag key
     # @param context [Hash] The evaluation context
     # @param default_value [Boolean] Default value if flag not found
     # @return [Boolean]
     def evaluate_percentage(flag_key, context = {}, default_value = false)
-      flag = @flags[flag_key]
+      # Normalize key to symbol for lookup (flags are stored with symbol keys)
+      flag = @flags[flag_key.to_sym]
 
       # Flag doesn't exist
       return default_value unless flag
@@ -158,10 +161,11 @@ module ToggleCraft
     end
 
     # Get the current percentage value of a flag
-    # @param flag_key [String] The flag key
+    # @param flag_key [String, Symbol] The flag key
     # @return [Integer, nil]
     def percentage(flag_key)
-      flag = @flags[flag_key]
+      # Normalize key to symbol for lookup (flags are stored with symbol keys)
+      flag = @flags[flag_key.to_sym]
 
       return nil unless flag && flag[:type] == 'percentage'
 
@@ -183,7 +187,7 @@ module ToggleCraft
 
         result = if result.nil?
                    condition_result
-                 else
+        else
                    # Apply combinator logic
                    case previous_combinator
                    when 'OR'
@@ -192,7 +196,7 @@ module ToggleCraft
                      # Default to AND
                      result && condition_result
                    end
-                 end
+        end
 
         previous_combinator = condition[:combinator] || 'AND'
 
@@ -252,7 +256,8 @@ module ToggleCraft
     # @param flag_key [String] The flag key
     # @return [Boolean]
     def has_flag?(flag_key)
-      @flags.key?(flag_key)
+      # Normalize key to symbol for lookup (flags are stored with symbol keys)
+      @flags.key?(flag_key.to_sym)
     end
 
     # Get all flag keys
@@ -262,10 +267,11 @@ module ToggleCraft
     end
 
     # Get flag metadata
-    # @param flag_key [String] The flag key
+    # @param flag_key [String, Symbol] The flag key
     # @return [Hash, nil]
     def flag_metadata(flag_key)
-      flag = @flags[flag_key]
+      # Normalize key to symbol for lookup (flags are stored with symbol keys)
+      flag = @flags[flag_key.to_sym]
       return nil unless flag
 
       metadata = {
@@ -285,12 +291,13 @@ module ToggleCraft
     end
 
     # Evaluate any flag type
-    # @param flag_key [String] The flag key
+    # @param flag_key [String, Symbol] The flag key
     # @param context [Hash] The evaluation context
     # @param default_value [Object] Default value
     # @return [Object]
     def evaluate(flag_key, context = {}, default_value = false)
-      flag = @flags[flag_key]
+      # Normalize key to symbol for lookup (flags are stored with symbol keys)
+      flag = @flags[flag_key.to_sym]
       return default_value unless flag
 
       case flag[:type]

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'cgi'
 require 'http'
 require 'json'
 
@@ -32,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
@@ -111,24 +112,30 @@ module ToggleCraft
       sse_url = "#{@url}/events?identifier=#{CGI.escape(channel_identifier)}"
       log "Connecting to #{sse_url}"
 
-      HTTP.get(sse_url) do |response|
-        raise "HTTP #{response.status}: #{response.status.reason}" unless response.status.success?
+      # Don't use block form - open connection and keep reference
+      response = HTTP.timeout(connect: 10, read: 300)
+                     .headers('Accept' => 'text/event-stream')
+                     .get(sse_url)
 
-        @connected = true
-        @reconnect_attempts = 0
-        @on_connect.call
-        start_heartbeat
+      raise "HTTP #{response.status}: #{response.status.reason}" unless response.status.success?
 
-        # Read SSE stream
-        buffer = ''
-        response.body.each do |chunk|
-          buffer += chunk
+      @connected = true
+      @reconnect_attempts = 0
+      @on_connect.call
+      start_heartbeat
+
+      # Read SSE stream using readpartial (body.each doesn't work properly)
+      buffer = ''
+      loop do
+        chunk = response.body.readpartial
+        break unless chunk # Connection closed
+
+        buffer += chunk
 
-          # Process complete SSE messages (ending with \n\n)
-          while buffer.include?("\n\n")
-            message, buffer = buffer.split("\n\n", 2)
-            process_sse_message(message)
-          end
+        # Process complete SSE messages (ending with \n\n)
+        while buffer.include?("\n\n")
+          message, buffer = buffer.split("\n\n", 2)
+          process_sse_message(message)
         end
       end
     rescue StandardError => e
@@ -197,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
@@ -256,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.0'
+  VERSION = '1.0.2'
 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.0
+  version: 1.0.2
 platform: ruby
 authors:
 - ToggleCraft