flipper 0.16.0 → 1.4.0

data/lib/flipper/adapters/pstore.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'pstore'
 require 'set'
 require 'flipper'
@@ -9,22 +10,14 @@ module Flipper
     class PStore
       include ::Flipper::Adapter
 
-      FeaturesKey = :flipper_features
-
-      # Public: The name of the adapter.
-      attr_reader :name
-
       # Public: The path to where the file is stored.
       attr_reader :path
 
-      # Public: PStore's thread_safe option.
-      attr_reader :thread_safe
-
       # Public
-      def initialize(path = 'flipper.pstore', thread_safe = false)
+      def initialize(path = 'flipper.pstore', thread_safe = true)
         @path = path
         @store = ::PStore.new(path, thread_safe)
-        @name = :pstore
+        @features_key = :flipper_features
       end
 
       # Public: The set of known features.
@@ -37,7 +30,7 @@ module Flipper
       # Public: Adds a feature to the set of known features.
       def add(feature)
         @store.transaction do
-          set_add FeaturesKey, feature.key
+          set_add @features_key, feature.key
         end
         true
       end
@@ -46,7 +39,7 @@ module Flipper
       # all the values for the feature.
       def remove(feature)
         @store.transaction do
-          set_delete FeaturesKey, feature.key
+          set_delete @features_key, feature.key
           clear_gates(feature)
         end
         true
@@ -73,7 +66,7 @@ module Flipper
         end
       end
 
-      def get_all
+      def get_all(**kwargs)
         @store.transaction do
           features = read_feature_keys.map { |key| Flipper::Feature.new(key, self) }
           read_many_features(features)
@@ -84,10 +77,15 @@ module Flipper
       def enable(feature, gate, thing)
         @store.transaction do
           case gate.data_type
-          when :boolean, :integer
+          when :boolean
+            clear_gates(feature)
+            write key(feature, gate), thing.value.to_s
+          when :integer
             write key(feature, gate), thing.value.to_s
           when :set
             set_add key(feature, gate), thing.value.to_s
+          when :json
+            write key(feature, gate), Typecast.to_json(thing.value)
           else
             raise "#{gate} is not supported by this adapter yet"
           end
@@ -109,6 +107,10 @@ module Flipper
           @store.transaction do
             set_delete key(feature, gate), thing.value.to_s
           end
+        when :json
+          @store.transaction do
+            delete key(feature, gate)
+          end
         else
           raise "#{gate} is not supported by this adapter yet"
         end
@@ -135,7 +137,7 @@ module Flipper
       end
 
       def read_feature_keys
-        set_members FeaturesKey
+        set_members @features_key
       end
 
       def read_many_features(features)
@@ -150,12 +152,16 @@ module Flipper
         result = {}
 
         feature.gates.each do |gate|
+          key = key(feature, gate)
           result[gate.key] =
             case gate.data_type
             when :boolean, :integer
-              read key(feature, gate)
+              read key
             when :set
-              set_members key(feature, gate)
+              set_members key
+            when :json
+              value = read(key)
+              Typecast.from_json(value)
             else
               raise "#{gate} is not supported by this adapter yet"
             end
@@ -213,3 +219,7 @@ module Flipper
     end
   end
 end
+
+Flipper.configure do |config|
+  config.adapter { Flipper::Adapters::PStore.new }
+end

data/lib/flipper/adapters/read_only.rb

@@ -3,8 +3,8 @@ require 'flipper'
 module Flipper
   module Adapters
     # Public: Adapter that wraps another adapter and raises for any writes.
-    class ReadOnly
-      include ::Flipper::Adapter
+    class ReadOnly < Wrapper
+      WRITE_METHODS = %i[add remove clear enable disable]
 
       class WriteAttempted < Error
         def initialize(message = nil)
@@ -12,49 +12,16 @@ module Flipper
         end
       end
 
-      # Internal: The name of the adapter.
-      attr_reader :name
-
-      # Public
-      def initialize(adapter)
-        @adapter = adapter
-        @name = :read_only
-      end
-
-      def features
-        @adapter.features
-      end
-
-      def get(feature)
-        @adapter.get(feature)
-      end
-
-      def get_multi(features)
-        @adapter.get_multi(features)
+      def read_only?
+        true
       end
 
-      def get_all
-        @adapter.get_all
-      end
+      private
 
-      def add(_feature)
-        raise WriteAttempted
-      end
-
-      def remove(_feature)
-        raise WriteAttempted
-      end
-
-      def clear(_feature)
-        raise WriteAttempted
-      end
-
-      def enable(_feature, _gate, _thing)
-        raise WriteAttempted
-      end
+      def wrap(method, *args, **kwargs)
+        raise WriteAttempted if WRITE_METHODS.include?(method)
 
-      def disable(_feature, _gate, _thing)
-        raise WriteAttempted
+        yield
       end
     end
   end

data/lib/flipper/adapters/strict.rb

@@ -0,0 +1,45 @@
+module Flipper
+  module Adapters
+    # An adapter that ensures a feature exists before checking it.
+    class Strict < Wrapper
+      attr_reader :handler
+
+      class NotFound < ::Flipper::Error
+        def initialize(name)
+          super "Could not find feature #{name.inspect}. Call `Flipper.add(#{name.inspect})` to create it."
+        end
+      end
+
+      def initialize(adapter, handler = nil, &block)
+        super(adapter)
+        @handler = block || handler
+      end
+
+      def get(feature)
+        assert_feature_exists(feature)
+        super
+      end
+
+      def get_multi(features)
+        features.each { |feature| assert_feature_exists(feature) }
+        super
+      end
+
+      private
+
+      def assert_feature_exists(feature)
+        return if @adapter.features.include?(feature.key)
+
+        case handler
+        when Proc then handler.call(feature)
+        when :warn then warn NotFound.new(feature.key).message
+        when :noop, false, nil
+         # noop
+        else # truthy or :raise
+         raise NotFound.new(feature.key)
+        end
+      end
+
+    end
+  end
+end

data/lib/flipper/adapters/sync/feature_synchronizer.rb

@@ -9,6 +9,7 @@ module Flipper
       class FeatureSynchronizer
         extend Forwardable
 
+        def_delegator :@local_gate_values, :expression, :local_expression
         def_delegator :@local_gate_values, :boolean, :local_boolean
         def_delegator :@local_gate_values, :actors, :local_actors
         def_delegator :@local_gate_values, :groups, :local_groups
@@ -17,6 +18,7 @@ module Flipper
         def_delegator :@local_gate_values, :percentage_of_time,
                       :local_percentage_of_time
 
+        def_delegator :@remote_gate_values, :expression, :remote_expression
         def_delegator :@remote_gate_values, :boolean, :remote_boolean
         def_delegator :@remote_gate_values, :actors, :remote_actors
         def_delegator :@remote_gate_values, :groups, :remote_groups
@@ -40,8 +42,9 @@ module Flipper
             @feature.enable
           else
             @feature.disable if local_boolean_enabled?
-            sync_actors
             sync_groups
+            sync_actors
+            sync_expression
             sync_percentage_of_actors
             sync_percentage_of_time
           end
@@ -49,6 +52,16 @@ module Flipper
 
         private
 
+        def sync_expression
+          return if local_expression == remote_expression
+
+          if remote_expression.nil?
+            @feature.disable_expression
+          else
+            @feature.enable_expression remote_expression
+          end
+        end
+
         def sync_actors
           remote_actors_added = remote_actors - local_actors
           remote_actors_added.each do |flipper_id|

data/lib/flipper/adapters/sync/interval_synchronizer.rb

@@ -7,11 +7,6 @@ module Flipper
         # Private: Number of seconds between syncs (default: 10).
         DEFAULT_INTERVAL = 10
 
-        # Private
-        def self.now
-          Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
-        end
-
         # Public: The Float or Integer number of seconds between invocations of
         # the wrapped synchronizer.
         attr_reader :interval
@@ -19,7 +14,7 @@ module Flipper
         # Public: Initializes a new interval synchronizer.
         #
         # synchronizer - The Synchronizer to call when the interval has passed.
-        # interval - The Integer number of milliseconds between invocations of
+        # interval - The Integer number of seconds between invocations of
         #            the wrapped synchronizer.
         def initialize(synchronizer, interval: nil)
           @synchronizer = synchronizer
@@ -46,7 +41,7 @@ module Flipper
         end
 
         def now
-          self.class.now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
         end
       end
     end

data/lib/flipper/adapters/sync/synchronizer.rb

@@ -1,5 +1,6 @@
 require "flipper/feature"
 require "flipper/gate_values"
+require "flipper/adapters/actor_limit"
 require "flipper/adapters/sync/feature_synchronizer"
 
 module Flipper
@@ -15,28 +16,34 @@ module Flipper
         #          adapter should be brought in line with.
         # options - The Hash of options.
         #           :instrumenter - The instrumenter used to instrument.
+        #           :raise - Should errors be raised (default: true).
+        #           :cache_bust - Should cache busting be used for remote get_all (default: false).
         def initialize(local, remote, options = {})
           @local = local
           @remote = remote
           @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
           @raise = options.fetch(:raise, true)
+          @cache_bust = options.fetch(:cache_bust, false)
         end
 
         # Public: Forces a sync.
         def call
-          @instrumenter.instrument("synchronizer_call.flipper") { sync }
+          @instrumenter.instrument("synchronizer_call.flipper") do
+            Flipper::Adapters::ActorLimit.with_sync_mode { sync }
+          end
         end
 
         private
 
         def sync
           local_get_all = @local.get_all
-          remote_get_all = @remote.get_all
+          remote_get_all = @remote.get_all(cache_bust: @cache_bust)
 
           # Sync all the gate values.
           remote_get_all.each do |feature_key, remote_gates_hash|
-            feature = Feature.new(feature_key, @local)
-            local_gates_hash = local_get_all[feature_key] || @local.default_config
+            feature = Feature.new(feature_key, @local, instrumenter: @instrumenter)
+            # Check if feature_key is in hash before accessing to prevent unintended hash modification
+            local_gates_hash = local_get_all.key?(feature_key) ? local_get_all[feature_key] : @local.default_config
             local_gate_values = GateValues.new(local_gates_hash)
             remote_gate_values = GateValues.new(remote_gates_hash)
             FeatureSynchronizer.new(feature, local_gate_values, remote_gate_values).call
@@ -44,11 +51,11 @@ module Flipper
 
           # Add features that are missing in local and present in remote.
           features_to_add = remote_get_all.keys - local_get_all.keys
-          features_to_add.each { |key| Feature.new(key, @local).add }
+          features_to_add.each { |key| Feature.new(key, @local, instrumenter: @instrumenter).add }
 
           # Remove features that are present in local and missing in remote.
           features_to_remove = local_get_all.keys - remote_get_all.keys
-          features_to_remove.each { |key| Feature.new(key, @local).remove }
+          features_to_remove.each { |key| Feature.new(key, @local, instrumenter: @instrumenter).remove }
 
           nil
         rescue => exception

data/lib/flipper/adapters/sync.rb

@@ -8,21 +8,17 @@ module Flipper
     class Sync
       include ::Flipper::Adapter
 
-      # Public: The name of the adapter.
-      attr_reader :name
-
       # Public: The synchronizer that will keep the local and remote in sync.
-      attr_reader :synchronizer
+      attr_reader :synchronizer, :local, :remote
 
       # Public: Build a new sync instance.
       #
       # local - The local flipper adapter that should serve reads.
-      # remote - The remote flipper adpater that should serve writes and update
+      # remote - The remote flipper adapter that should serve writes and update
       #          the local on an interval.
       # interval - The Float or Integer number of seconds between syncs from
       # remote to local. Default value is set in IntervalSynchronizer.
       def initialize(local, remote, options = {})
-        @name = :sync
         @local = local
         @remote = remote
         @synchronizer = options.fetch(:synchronizer) do
@@ -34,62 +30,60 @@ module Flipper
           synchronizer = Synchronizer.new(@local, @remote, sync_options)
           IntervalSynchronizer.new(synchronizer, interval: options[:interval])
         end
-        sync
+        synchronize
+      end
+
+      def adapter_stack
+        "#{name}(local: #{@local.adapter_stack}, remote: #{@remote.adapter_stack})"
       end
 
       def features
-        sync
+        synchronize
         @local.features
       end
 
       def get(feature)
-        sync
+        synchronize
         @local.get(feature)
       end
 
       def get_multi(features)
-        sync
+        synchronize
         @local.get_multi(features)
       end
 
-      def get_all
-        sync
-        @local.get_all
+      def get_all(**kwargs)
+        synchronize
+        @local.get_all(**kwargs)
       end
 
       def add(feature)
-        result = @remote.add(feature)
-        @local.add(feature)
-        result
+        @remote.add(feature).tap { @local.add(feature) }
       end
 
       def remove(feature)
-        result = @remote.remove(feature)
-        @local.remove(feature)
-        result
+        @remote.remove(feature).tap { @local.remove(feature) }
       end
 
       def clear(feature)
-        result = @remote.clear(feature)
-        @local.clear(feature)
-        result
+        @remote.clear(feature).tap { @local.clear(feature) }
       end
 
       def enable(feature, gate, thing)
-        result = @remote.enable(feature, gate, thing)
-        @local.enable(feature, gate, thing)
-        result
+        @remote.enable(feature, gate, thing).tap do
+          @local.enable(feature, gate, thing)
+        end
       end
 
       def disable(feature, gate, thing)
-        result = @remote.disable(feature, gate, thing)
-        @local.disable(feature, gate, thing)
-        result
+        @remote.disable(feature, gate, thing).tap do
+          @local.disable(feature, gate, thing)
+        end
       end
 
       private
 
-      def sync
+      def synchronize
         @synchronizer.call
       end
     end

data/lib/flipper/adapters/wrapper.rb

@@ -0,0 +1,54 @@
+module Flipper
+  module Adapters
+    # A base class for any adapter that wraps another adapter. By default, all methods
+    # delegate to the wrapped adapter. Implement `#wrap` to customize the behavior of
+    # all delegated methods, or override individual methods as needed.
+    class Wrapper
+      include Flipper::Adapter
+
+      METHODS = [
+        :import,
+        :export,
+        :features,
+        :add,
+        :remove,
+        :clear,
+        :get,
+        :get_multi,
+        :get_all,
+        :enable,
+        :disable,
+      ].freeze
+
+      attr_reader :adapter
+
+      def initialize(adapter)
+        @adapter = adapter
+      end
+
+      METHODS.each do |method|
+        if RUBY_VERSION >= '3.0'
+          define_method(method) do |*args, **kwargs|
+            wrap(method, *args, **kwargs) { @adapter.public_send(method, *args, **kwargs) }
+          end
+        else
+          define_method(method) do |*args|
+            wrap(method, *args) { @adapter.public_send(method, *args) }
+          end
+        end
+      end
+
+      # Override this method to customize the behavior of all delegated methods, and just yield to
+      # the block to call the wrapped adapter.
+      if RUBY_VERSION >= '3.0'
+        def wrap(method, *args, **kwargs, &block)
+          block.call
+        end
+      else
+        def wrap(method, *args, &block)
+          block.call
+        end
+      end
+    end
+  end
+end