rollout 2.6.2 → 3.2.0

data/spec/spec_helper.rb

@@ -5,23 +5,96 @@ require 'simplecov'
 SimpleCov.start
 
 require 'bundler/setup'
-require 'redis'
 require 'rollout'
 
-$redis = Redis.new(
-  host: ENV.fetch('REDIS_HOST', '127.0.0.1'),
-  port: ENV.fetch('REDIS_PORT', '6379'),
-  db: ENV.fetch('REDIS_DB', '7'),
-)
+class RolloutMemoryBackend
+  def initialize
+    @features = {}
+    @events = Hash.new { |hash, key| hash[key] = [] }
+    @global_events = []
+  end
+
+  def fetch_feature(name)
+    state = @features[name.to_s]
+    return Rollout::FeatureState.new(name: name, percentage: 0) unless state
+
+    state.deep_clone
+  end
+
+  def fetch_features(names)
+    names.map { |name| fetch_feature(name) }
+  end
+
+  def feature_names
+    @features.keys
+  end
+
+  def feature_exists?(name)
+    @features.key?(name.to_s)
+  end
+
+  def save_feature(state)
+    @features[state.name] = state.deep_clone
+  end
+
+  def delete_feature(name)
+    @features.delete(name.to_s)
+  end
+
+  def clear_features
+  end
+
+  def mutate_feature(name)
+    mutation = yield fetch_feature(name)
+    save_feature(mutation.fetch(:state))
+    event = mutation[:event]
+    if event
+      @events[name.to_s] << event
+      @global_events << event if mutation[:global]
+    end
+    mutation
+  end
+
+  def feature_events(name, limit: nil)
+    limited_events(@events[name.to_s], limit)
+  end
+
+  def global_events(limit: nil)
+    limited_events(@global_events, limit)
+  end
+
+  def feature_updated_at(_name)
+  end
+
+  def delete_feature_events(name)
+    @events.delete(name.to_s)
+  end
+
+  def delete_feature_with_history(name, event:, history_length:)
+    existed = feature_exists?(name)
+    delete_feature(name)
+    delete_feature_events(name)
+    if existed && event
+      @global_events << event
+      @global_events = @global_events.last(history_length)
+    end
+  end
+
+  private
+
+  def limited_events(events, limit)
+    return events if limit.nil?
+    raise ArgumentError, "limit must be an Integer" unless limit.is_a?(Integer)
+    raise ArgumentError, "limit must be >= 0" if limit < 0
+
+    events.last(limit)
+  end
+end
 
 RSpec.configure do |config|
   config.example_status_persistence_file_path = '.rspec_status'
 
-  # config.disable_monkey_patching!
-
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
-
-  config.before { $redis.flushdb }
 end

data/spec/support/backend_contract.rb

@@ -0,0 +1,95 @@
+require "date"
+
+RSpec.shared_examples "a rollout feature backend" do
+  def empty_state(name)
+    Rollout::FeatureState.new(name: name, percentage: 0)
+  end
+
+  def json_metadata
+    {
+      "description" => "New navigation",
+      "updated_at" => 1,
+      "enabled" => true,
+      "ratio" => 0.5,
+      "owner" => nil,
+      "label" => :beta,
+      "released_at" => Time.utc(2026, 1, 1),
+      "day" => Date.new(2026, 1, 1),
+      "labels" => ["a", { "nested" => :ok }],
+    }
+  end
+
+  it "returns an empty state for a missing feature" do
+    state = backend.fetch_feature(:chat)
+
+    expect(state).to eq empty_state(:chat)
+  end
+
+  it "preserves fetch_features order and duplicates" do
+    backend.save_feature(Rollout::FeatureState.new(name: :chat, percentage: 25))
+
+    states = backend.fetch_features([:chat, :missing, :chat])
+
+    expect(states.map(&:name)).to eq %w[chat missing chat]
+    expect(states.map(&:percentage)).to eq [25.0, 0.0, 25.0]
+  end
+
+  it "returns no features for an empty fetch_features request" do
+    expect(backend.fetch_features([])).to eq []
+  end
+
+  it "round-trips a double-precision percentage" do
+    percentage = 33.333333333333336
+    backend.save_feature(Rollout::FeatureState.new(name: :chat, percentage: percentage))
+
+    expect(backend.fetch_feature(:chat).percentage).to eq percentage
+  end
+
+  it "does not share nested data with a fetched state" do
+    backend.save_feature(
+      Rollout::FeatureState.new(name: :chat, percentage: 0, data: { "labels" => ["a"] }),
+    )
+
+    backend.fetch_feature(:chat).data["labels"] << "b"
+
+    expect(backend.fetch_feature(:chat).data).to eq("labels" => ["a"])
+  end
+
+  it "does not share nested data with a saved state" do
+    state = Rollout::FeatureState.new(name: :chat, percentage: 0, data: { "labels" => ["a"] })
+    backend.save_feature(state)
+
+    state.data["labels"] << "b"
+
+    expect(backend.fetch_feature(:chat).data).to eq("labels" => ["a"])
+  end
+
+  it "returns the same canonical metadata after save_feature" do
+    state = Rollout::FeatureState.new(name: :chat, percentage: 0, data: json_metadata)
+    backend.save_feature(state)
+
+    expect(backend.fetch_feature(:chat)).to eq state
+    expect(state.data["label"]).to eq "beta"
+    expect(state.data["labels"]).to eq ["a", { "nested" => "ok" }]
+  end
+
+  it "tracks existence and names after save and delete" do
+    backend.save_feature(Rollout::FeatureState.new(name: :chat, percentage: 25))
+
+    expect(backend.feature_exists?(:chat)).to be_truthy
+    expect(backend.feature_names).to eq ["chat"]
+
+    backend.delete_feature(:chat)
+
+    expect(backend.feature_exists?(:chat)).to be_falsey
+    expect(backend.fetch_feature(:chat)).to eq empty_state(:chat)
+  end
+
+  it "does not persist when mutate_feature's block raises" do
+    expect {
+      backend.mutate_feature(:chat) { raise "nope" }
+    }.to raise_error("nope")
+
+    expect(backend.feature_exists?(:chat)).to be_falsey
+  end
+end

data/spec/support/history_contract.rb

@@ -0,0 +1,174 @@
+RSpec.shared_examples "a rollout history backend" do
+  let(:rollout) { Rollout.new(adapter: backend, logging: logging) }
+  let(:logging) { true }
+  let(:feature) { :foo }
+
+  it "persists feature events oldest-to-newest" do
+    rollout.activate_percentage(feature, 50)
+    rollout.activate_percentage(feature, 75)
+    rollout.activate_group(feature, :hipsters)
+
+    events = rollout.logging.events(feature)
+    expect(events.map(&:name)).to eq %w[update update update]
+    expect(events.map { |event| event.data }).to eq [
+      { before: { percentage: 0 }, after: { percentage: 50 } },
+      { before: { percentage: 50 }, after: { percentage: 75 } },
+      { before: { groups: [] }, after: { groups: ["hipsters"] } },
+    ]
+    expect(rollout.logging.updated_at(feature)).to_not be_nil
+  end
+
+  it "does not write a history event when a double-precision percentage is unchanged" do
+    percentage = 33.333333333333336
+    rollout.activate_percentage(feature, percentage)
+
+    expect do
+      rollout.activate_percentage(feature, percentage)
+    end.not_to change { rollout.logging.events(feature).count }
+
+    expect(rollout.get(feature).percentage).to eq percentage
+  end
+
+  it "persists metadata changes and actor context" do
+    rollout.logging.with_context(actor: "alice") do
+      rollout.with_feature(feature) do |current|
+        current.percentage = 25.0
+        current.data.update(description: "New navigation")
+      end
+    end
+
+    event = rollout.logging.last_event(feature)
+    expect(event.data).to eq(
+      before: { percentage: 0, "data.description": nil },
+      after: { percentage: 25.0, "data.description": "New navigation" },
+    )
+    expect(event.context).to eq(actor: "alice")
+    expect(rollout.logging.events(feature).count).to eq 1
+  end
+
+  context "history truncation" do
+    let(:logging) { { history_length: 1 } }
+
+    it "keeps only the configured number of events" do
+      rollout.activate_percentage(feature, 25)
+      rollout.activate_percentage(feature, 30)
+
+      expect(rollout.logging.events(feature).map { |event| event.data[:after][:percentage] }).to eq [30]
+    end
+  end
+
+  context "global logs" do
+    let(:logging) { { global: true } }
+
+    it "logs changes across features oldest-to-newest" do
+      rollout.activate_percentage("foo", 25)
+      rollout.activate_percentage("bar", 30)
+      rollout.activate_percentage("baz", 40)
+
+      expect(rollout.logging.global_events.map(&:feature)).to eq %w[foo bar baz]
+      expect(rollout.logging.global_events(limit: 2).map(&:feature)).to eq %w[bar baz]
+    end
+  end
+
+  it "removes feature history on delete" do
+    rollout.activate_percentage(feature, 25)
+    rollout.delete(feature)
+
+    expect(rollout.logging.events(feature)).to eq []
+  end
+
+  it "records a global-only delete event for an existing feature" do
+    logged_rollout = Rollout.new(adapter: backend, logging: { global: true, history_length: 2 })
+    logged_rollout.activate_percentage(feature, 25)
+    logged_rollout.logging.with_context(actor: "alice") { logged_rollout.delete(feature) }
+
+    event = logged_rollout.logging.global_events.last
+    expect(event.name).to eq "delete"
+    expect(event.feature).to eq feature.to_s
+    expect(event.data).to eq({})
+    expect(event.context).to eq(actor: "alice")
+    expect(logged_rollout.logging.events(feature)).to eq []
+    expect(logged_rollout.logging.updated_at(feature)).to be_nil
+    expect(backend.feature_names.map(&:to_s)).not_to include(feature.to_s)
+  end
+
+  it "does not record deletions of missing features and honors global history length" do
+    logged_rollout = Rollout.new(adapter: backend, logging: { global: true, history_length: 1 })
+    logged_rollout.activate_percentage(feature, 25)
+    logged_rollout.delete(feature)
+    expect(logged_rollout.logging.global_events.map(&:name)).to eq ["delete"]
+
+    logged_rollout.delete(feature)
+
+    expect(logged_rollout.logging.global_events.map(&:name)).to eq ["delete"]
+  end
+
+  it "does not add a delete event when global history is disabled" do
+    logged_rollout = Rollout.new(adapter: backend, logging: { global: false })
+    logged_rollout.activate_percentage(feature, 25)
+
+    logged_rollout.delete(feature)
+
+    expect(logged_rollout.logging.global_events).to eq []
+    expect(logged_rollout.logging.events(feature)).to eq []
+  end
+
+  it "does not retain a delete event when history length is zero" do
+    logged_rollout = Rollout.new(adapter: backend, logging: { global: true, history_length: 0 })
+    logged_rollout.activate_percentage(feature, 25)
+
+    logged_rollout.delete(feature)
+
+    expect(logged_rollout.logging.global_events).to eq []
+    expect(logged_rollout.logging.events(feature)).to eq []
+  end
+
+  it "keeps feature history on clear!" do
+    rollout.activate_percentage(feature, 25)
+    rollout.clear!
+
+    expect(rollout.features).to eq []
+    expect(rollout.logging.events(feature).map { |event| event.data[:after][:percentage] }).to eq [25, 0]
+  end
+
+  it "keeps feature history when deleting without logging" do
+    rollout.activate_percentage(feature, 25)
+
+    Rollout.new(adapter: backend).delete(feature)
+
+    expect(rollout.exists?(feature)).to be_falsey
+    expect(rollout.logging.events(feature)).not_to eq []
+  end
+
+  it "logging.delete removes feature history only" do
+    rollout.activate_percentage(feature, 25)
+    rollout.logging.delete(feature)
+
+    expect(rollout.logging.events(feature)).to eq []
+    expect(rollout.logging.updated_at(feature)).to be_nil
+    expect(rollout.get(feature).percentage).to eq 25
+  end
+
+  it "adapter delete_feature preserves history" do
+    rollout.activate_percentage(feature, 25)
+    rollout.adapter.delete_feature(feature)
+
+    expect(rollout.exists?(feature)).to be_falsey
+    expect(rollout.logging.events(feature)).not_to eq []
+  end
+
+  it "returns the newest events oldest-to-newest when limited" do
+    rollout.activate_percentage(feature, 25)
+    rollout.activate_percentage(feature, 50)
+    rollout.activate_percentage(feature, 75)
+
+    expect(rollout.logging.events(feature, limit: 2).map { |event| event.data[:after][:percentage] }).to eq [50, 75]
+    expect(rollout.logging.events(feature, limit: 0)).to eq []
+    expect(rollout.logging.last_event(feature).data[:after][:percentage]).to eq 75
+  end
+
+  it "rejects an invalid history limit" do
+    expect { rollout.logging.events(feature, limit: -1) }.to raise_error(ArgumentError)
+    expect { rollout.adapter.feature_events(feature, limit: 1.5) }.to raise_error(ArgumentError)
+  end
+end

data/spec/support/rollout_backend_integration.rb

@@ -0,0 +1,77 @@
+RSpec.shared_examples "a rollout backend integration" do
+  let(:rollout) { Rollout.new(adapter: backend) }
+
+  it "persists combined feature state" do
+    rollout.with_feature(:chat) do |feature|
+      feature.percentage = 10.5
+      feature.groups = [:employees]
+      feature.users = ["123"]
+      feature.data.update(description: "New navigation", label: :beta)
+    end
+
+    feature = rollout.get(:chat)
+    expect(feature.percentage).to eq 10.5
+    expect(feature.groups).to eq [:employees]
+    expect(feature.users).to eq %w[123]
+    expect(feature.data).to eq("description" => "New navigation", "label" => "beta")
+    expect(rollout.exists?(:chat)).to eq true
+    expect(rollout.features).to eq [:chat]
+  end
+
+  it "persists metadata that contains pipes" do
+    rollout.activate_user(:chat, 8)
+    rollout.set_feature_data(:chat, "|call||text|" => "a|bunch|of|stuff")
+
+    expect(rollout.get(:chat).data).to include("|call||text|" => "a|bunch|of|stuff")
+    expect(rollout.get(:chat).users).to eq %w[8]
+  end
+
+  it "clears users, groups, percentage, and data on deactivate" do
+    rollout.activate_user(:chat, 42)
+    rollout.activate_group(:chat, :employees)
+    rollout.activate_percentage(:chat, 50)
+    rollout.set_feature_data(:chat, description: "foo")
+
+    rollout.deactivate(:chat)
+
+    expect(rollout.features).to eq [:chat]
+    expect(rollout.get(:chat).to_hash).to eq(
+      percentage: 0,
+      users: [],
+      groups: [],
+      data: {},
+    )
+  end
+
+  it "keeps users, groups, and data on deactivate_percentage" do
+    rollout.activate_user(:chat, 42)
+    rollout.activate_group(:chat, :employees)
+    rollout.activate_percentage(:chat, 50)
+    rollout.set_feature_data(:chat, description: "foo")
+
+    rollout.deactivate_percentage(:chat)
+
+    expect(rollout.get(:chat).percentage).to eq 0
+    expect(rollout.get(:chat).users).to eq %w[42]
+    expect(rollout.get(:chat).groups).to eq [:employees]
+    expect(rollout.get(:chat).data).to eq("description" => "foo")
+  end
+
+  it "removes the feature on delete" do
+    rollout.activate(:chat)
+    rollout.delete(:chat)
+
+    expect(rollout.features).to eq []
+    expect(rollout.exists?(:chat)).to eq false
+    expect(rollout.get(:chat).percentage).to eq 0
+  end
+
+  it "clears persisted features" do
+    rollout.activate(:signup)
+    rollout.activate(:chat)
+    rollout.clear!
+
+    expect(rollout.features).to eq []
+    expect(rollout.exists?(:chat)).to eq false
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rollout
 version: !ruby/object:Gem::Version
-  version: 2.6.2
+  version: 3.2.0
 platform: ruby
 authors:
 - James Golick
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-06 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: observer
@@ -24,26 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: redis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -64,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +122,13 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: '0.17'
-description: Feature flippers with redis.
+description: Feature flippers.
 email:
 - jamesgolick@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".circleci/config.yml"
 - ".github/workflows/release.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
@@ -161,15 +140,22 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docs/upgrading-to-v3.md
 - lib/rollout.rb
 - lib/rollout/feature.rb
+- lib/rollout/feature_state.rb
 - lib/rollout/logging.rb
 - lib/rollout/version.rb
 - rollout.gemspec
 - spec/rollout/feature_spec.rb
+- spec/rollout/feature_state_spec.rb
 - spec/rollout/logging_spec.rb
+- spec/rollout/memory_backend_contract_spec.rb
 - spec/rollout_spec.rb
 - spec/spec_helper.rb
+- spec/support/backend_contract.rb
+- spec/support/history_contract.rb
+- spec/support/rollout_backend_integration.rb
 homepage: https://github.com/FetLife/rollout
 licenses:
 - MIT
@@ -189,9 +175,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.5.1
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Feature flippers with redis.
+summary: Feature flippers.
 test_files: []

data/.circleci/config.yml

@@ -1,119 +0,0 @@
-version: 2.1
-
-workflows:
-  main:
-    jobs:
-      - ruby33
-      - ruby31
-      - ruby32
-      - ruby30
-      - ruby27
-      - ruby26
-      - ruby25
-      - ruby24
-
-executors:
-  ruby33:
-    docker:
-      - image: cimg/ruby:3.3
-      - image: cimg/redis:7.2
-  ruby32:
-    docker:
-      - image: cimg/ruby:3.2
-      - image: cimg/redis:7.2
-  ruby31:
-    docker:
-      - image: cimg/ruby:3.1
-      - image: cimg/redis:7.2
-  ruby30:
-    docker:
-      - image: cimg/ruby:3.0
-      - image: cimg/redis:7.2
-  ruby27:
-    docker:
-      - image: cimg/ruby:2.7
-      - image: cimg/redis:7.2
-  ruby26:
-    docker:
-      - image: cimg/ruby:2.7
-      - image: cimg/redis:7.2
-  ruby25:
-    docker:
-      - image: cimg/ruby:2.7
-      - image: cimg/redis:7.2
-  ruby24:
-    docker:
-      - image: cimg/ruby:2.4
-      - image: cimg/redis:7.2
-
-commands:
-  test:
-    steps:
-      - run:
-          name: Bundle Install
-          command: bundle check --path vendor/bundle || bundle install
-
-      - run:
-          name: Run rspec
-          command: |
-            bundle exec rspec --format documentation --format RspecJunitFormatter --out test_results/rspec.xml
-
-jobs:
-  ruby33:
-    executor: ruby33
-    steps:
-      - checkout
-      - test
-
-      - run:
-          name: Report Test Coverage
-          command: |
-            wget https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 -O cc-test-reporter
-            chmod +x cc-test-reporter
-            ./cc-test-reporter format-coverage -t simplecov -o coverage/codeclimate.json coverage/.resultset.json
-            ./cc-test-reporter upload-coverage -i coverage/codeclimate.json
-
-      - store_test_results:
-          path: test_results
-
-  ruby32:
-    executor: ruby30
-    steps:
-      - checkout
-      - test
-
-  ruby31:
-    executor: ruby30
-    steps:
-      - checkout
-      - test
-
-  ruby30:
-    executor: ruby30
-    steps:
-      - checkout
-      - test
-
-  ruby27:
-    executor: ruby27
-    steps:
-      - checkout
-      - test
-
-  ruby26:
-    executor: ruby27
-    steps:
-      - checkout
-      - test
-
-  ruby25:
-    executor: ruby27
-    steps:
-      - checkout
-      - test
-
-  ruby24:
-    executor: ruby24
-    steps:
-      - checkout
-      - test