flipper 0.16.0 → 1.4.0

data/flipper.gemspec

@@ -6,14 +6,13 @@ plugin_files = []
 plugin_test_files = []
 
 Dir['flipper-*.gemspec'].map do |gemspec|
-  spec = eval(File.read(gemspec))
+  spec = Gem::Specification.load(gemspec)
   plugin_files << spec.files
   plugin_test_files << spec.files
 end
 
 ignored_files = plugin_files
 ignored_files << Dir['script/*']
-ignored_files << '.travis.yml'
 ignored_files << '.gitignore'
 ignored_files << 'Guardfile'
 ignored_files.flatten!.uniq!
@@ -23,17 +22,21 @@ ignored_test_files.flatten!.uniq!
 
 Gem::Specification.new do |gem|
   gem.authors       = ['John Nunemaker']
-  gem.email         = ['nunemaker@gmail.com']
-  gem.summary       = 'Feature flipper for ANYTHING'
-  gem.description   = 'Feature flipper is the act of enabling/disabling features in your application, ideally without re-deploying or changing anything in your code base. Flipper makes this extremely easy to do with any backend you would like to use.'
-  gem.homepage      = 'https://github.com/jnunemaker/flipper'
+  gem.email         = 'support@flippercloud.io'
+  gem.summary       = 'Beautiful, performant feature flags for Ruby and Rails.'
+  gem.homepage      = 'https://www.flippercloud.io/docs'
   gem.license       = 'MIT'
 
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.bindir = "exe"
+  gem.executables   = `git ls-files -- exe/*`.split("\n").map { |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n") - ignored_files + ['lib/flipper/version.rb']
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n") - ignored_test_files
   gem.name          = 'flipper'
   gem.require_paths = ['lib']
   gem.version       = Flipper::VERSION
   gem.metadata      = Flipper::METADATA
+
+  gem.add_dependency 'concurrent-ruby', '< 2'
+
+  gem.required_ruby_version = ">= #{Flipper::REQUIRED_RUBY_VERSION}"
 end

data/lib/flipper/actor.rb

@@ -2,15 +2,22 @@
 # to Flipper::Feature#enabled?.
 module Flipper
   class Actor
-    attr_reader :flipper_id
+    attr_reader :flipper_id, :flipper_properties
 
-    def initialize(flipper_id)
+    def initialize(flipper_id, flipper_properties = {})
       @flipper_id = flipper_id
+      @flipper_properties = flipper_properties
     end
 
     def eql?(other)
-      self.class.eql?(other.class) && @flipper_id == other.flipper_id
+      self.class.eql?(other.class) &&
+        @flipper_id == other.flipper_id &&
+        @flipper_properties == other.flipper_properties
     end
     alias_method :==, :eql?
+
+    def hash
+      flipper_id.hash
+    end
   end
 end

data/lib/flipper/adapter.rb

@@ -1,7 +1,3 @@
-require "set"
-require "flipper/feature"
-require "flipper/adapters/sync/synchronizer"
-
 module Flipper
   # Adding a module include so we have some hooks for stuff down the road
   module Adapter
@@ -16,16 +12,26 @@ module Flipper
           boolean: nil,
           groups: Set.new,
           actors: Set.new,
+          expression: nil,
           percentage_of_actors: nil,
           percentage_of_time: nil,
         }
       end
+
+      def from(source)
+        return source if source.is_a?(Flipper::Adapter)
+        source.adapter
+      end
+    end
+
+    def read_only?
+      false
     end
 
     # Public: Get all features and gate values in one call. Defaults to one call
     # to features and another to get_multi. Feel free to override per adapter to
     # make this more efficient.
-    def get_all
+    def get_all(**kwargs)
       instances = features.map { |key| Flipper::Feature.new(key, self) }
       get_multi(instances)
     end
@@ -43,14 +49,50 @@ module Flipper
 
     # Public: Ensure that adapter is in sync with source adapter provided.
     #
-    # Returns result of Synchronizer#call.
-    def import(source_adapter)
-      Adapters::Sync::Synchronizer.new(self, source_adapter, raise: true).call
+    # source - The source dsl, adapter or export to import.
+    #
+    # Returns true if successful.
+    def import(source)
+      Adapters::Sync::Synchronizer.new(self, self.class.from(source), raise: true).call
+      true
+    end
+
+    # Public: Exports the adapter in a given format for a given format version.
+    #
+    # Returns a Flipper::Export instance.
+    def export(format: :json, version: 1)
+      Flipper::Exporter.build(format: format, version: version).call(self)
     end
 
     # Public: Default config for a feature's gate values.
     def default_config
       self.class.default_config
     end
+
+    # Public: default name of the adapter
+    def name
+      @name ||= self.class.name.split('::').last.split(/(?=[A-Z])/).join('_').downcase.to_sym
+    end
+
+    # Public: Returns a string representation of the adapter stack for debugging.
+    # Shows the full chain of wrapped adapters.
+    #
+    # Examples:
+    #   "memoizable -> active_support_cache_store -> active_record"
+    #   "memoizable -> failover(primary: redis, secondary: memory)"
+    #
+    # Returns a String.
+    def adapter_stack
+      if respond_to?(:adapter) && adapter
+        "#{name} -> #{adapter.adapter_stack}"
+      else
+        name.to_s
+      end
+    end
   end
 end
+
+require "set"
+require "flipper/exporter"
+require "flipper/feature"
+require "flipper/adapters/sync/synchronizer"

data/lib/flipper/adapter_builder.rb

@@ -0,0 +1,44 @@
+module Flipper
+  # Builds an adapter from a stack of adapters.
+  #
+  #   adapter = Flipper::AdapterBuilder.new do
+  #     use Flipper::Adapters::Strict
+  #     use Flipper::Adapters::Memoizable
+  #     store Flipper::Adapters::Memory
+  #   end.to_adapter
+  #
+  class AdapterBuilder
+    def initialize(&block)
+      @stack = []
+
+      # Default to memory adapter
+      store Flipper::Adapters::Memory
+
+      block.arity == 0 ? instance_eval(&block) : block.call(self) if block
+    end
+
+    if RUBY_VERSION >= '3.0'
+      def use(klass, *args, **kwargs, &block)
+        @stack.push ->(adapter) { klass.new(adapter, *args, **kwargs, &block) }
+      end
+    else
+      def use(klass, *args, &block)
+        @stack.push ->(adapter) { klass.new(adapter, *args, &block) }
+      end
+    end
+
+    if RUBY_VERSION >= '3.0'
+      def store(adapter, *args, **kwargs, &block)
+        @store = adapter.respond_to?(:call) ? adapter : -> { adapter.new(*args, **kwargs, &block) }
+      end
+    else
+      def store(adapter, *args, &block)
+        @store = adapter.respond_to?(:call) ? adapter : -> { adapter.new(*args, &block) }
+      end
+    end
+
+    def to_adapter
+      @stack.reverse.inject(@store.call) { |adapter, wrapper| wrapper.call(adapter) }
+    end
+  end
+end

data/lib/flipper/adapters/actor_limit.rb

@@ -0,0 +1,54 @@
+require "flipper/adapters/wrapper"
+
+module Flipper
+  module Adapters
+    class ActorLimit < Wrapper
+      LimitExceeded = Class.new(Flipper::Error)
+
+      attr_reader :limit
+
+      class << self
+        # Returns whether sync mode is enabled for the current thread.
+        # When sync mode is enabled, actor limits are not enforced,
+        # allowing sync operations to bring local state in line with
+        # remote state regardless of limits.
+        def sync_mode
+          Thread.current[:flipper_actor_limit_sync_mode]
+        end
+
+        def sync_mode=(value)
+          Thread.current[:flipper_actor_limit_sync_mode] = value
+        end
+
+        # Executes a block with sync mode enabled. Actor limits will
+        # not be enforced within the block.
+        def with_sync_mode
+          old_value = sync_mode
+          self.sync_mode = true
+          yield
+        ensure
+          self.sync_mode = old_value
+        end
+      end
+
+      def initialize(adapter, limit = 100)
+        super(adapter)
+        @limit = limit
+      end
+
+      def enable(feature, gate, resource)
+        if gate.is_a?(Flipper::Gates::Actor) && !self.class.sync_mode && over_limit?(feature)
+          raise LimitExceeded, "Actor limit of #{@limit} exceeded for feature #{feature.key}. See https://www.flippercloud.io/docs/features/actors#limitations"
+        else
+          super
+        end
+      end
+
+      private
+
+      def over_limit?(feature)
+        feature.actors_value.size >= @limit
+      end
+    end
+  end
+end

data/lib/flipper/adapters/cache_base.rb

@@ -0,0 +1,161 @@
+module Flipper
+  module Adapters
+    # Base class for caching adapters. Inherit from this and then override
+    # cache_fetch, cache_read_multi, cache_write, and cache_delete.
+    class CacheBase
+      include ::Flipper::Adapter
+
+      # Public: The adapter being cached.
+      attr_reader :adapter
+
+      # Public: The ActiveSupport::Cache::Store to cache with.
+      attr_reader :cache
+
+      # Public: The ttl for all cached data.
+      attr_reader :ttl
+
+      # Public: The cache key where the set of known features is cached.
+      attr_reader :features_cache_key
+
+      # Public: The cache key where the set of all features with gates is cached.
+      attr_reader :get_all_cache_key
+
+      # Public: Alias expires_in to ttl for compatibility.
+      alias_method :expires_in, :ttl
+
+      def initialize(adapter, cache, ttl = 300, prefix: nil)
+        @adapter = adapter
+        @cache = cache
+        @ttl = ttl
+
+        @cache_version = 'v1'.freeze
+        @namespace = "flipper/#{@cache_version}"
+        @namespace = @namespace.prepend(prefix) if prefix
+        @features_cache_key = "#{@namespace}/features"
+        @get_all_cache_key = "#{@namespace}/get_all"
+      end
+
+      # Public: Expire the cache for the set of all features with gates.
+      def expire_get_all_cache
+        cache_delete @get_all_cache_key
+      end
+
+      # Public: Expire the cache for the set of known feature names.
+      def expire_features_cache
+        cache_delete @features_cache_key
+        expire_get_all_cache
+      end
+
+      # Public: Expire the cache for a given feature.
+      def expire_feature_cache(key)
+        cache_delete feature_cache_key(key)
+        expire_get_all_cache
+      end
+
+      # Public
+      def features
+        read_feature_keys
+      end
+
+      # Public
+      def add(feature)
+        result = @adapter.add(feature)
+        expire_features_cache
+        result
+      end
+
+      # Public
+      def remove(feature)
+        result = @adapter.remove(feature)
+        expire_features_cache
+        expire_feature_cache(feature.key)
+        result
+      end
+
+      # Public
+      def clear(feature)
+        result = @adapter.clear(feature)
+        expire_feature_cache(feature.key)
+        result
+      end
+
+      # Public
+      def get(feature)
+        read_feature(feature)
+      end
+
+      # Public
+      def get_multi(features)
+        read_many_features(features)
+      end
+
+      # Public
+      def get_all(**kwargs)
+        cache_fetch(@get_all_cache_key) {
+          result = read_all_features(**kwargs)
+          cache_write @features_cache_key, result.keys.to_set
+          result
+        }
+      end
+
+      # Public
+      def enable(feature, gate, thing)
+        result = @adapter.enable(feature, gate, thing)
+        expire_feature_cache(feature.key)
+        result
+      end
+
+      # Public
+      def disable(feature, gate, thing)
+        result = @adapter.disable(feature, gate, thing)
+        expire_feature_cache(feature.key)
+        result
+      end
+
+      # Public: Generate the cache key for a given feature.
+      #
+      # key - The String or Symbol feature key.
+      def feature_cache_key(key)
+        "#{@namespace}/feature/#{key}"
+      end
+
+      private
+
+      def read_all_features(**kwargs)
+        @adapter.get_all(**kwargs)
+      end
+
+      # Private: Returns the Set of known feature keys.
+      def read_feature_keys
+        cache_fetch(@features_cache_key) { @adapter.features }
+      end
+
+      # Private: Read through caching for a single feature.
+      def read_feature(feature)
+        cache_fetch(feature_cache_key(feature.key)) { @adapter.get(feature) }
+      end
+
+      # Private: Given an array of features, attempts to read through cache in
+      # as few network calls as possible.
+      def read_many_features(features)
+        keys = features.map { |feature| feature_cache_key(feature.key) }
+        cache_result = cache_read_multi(keys)
+        uncached_features = features.reject { |feature| cache_result[feature_cache_key(feature)] }
+
+        if uncached_features.any?
+          response = @adapter.get_multi(uncached_features)
+          response.each do |key, value|
+            cache_write feature_cache_key(key), value
+            cache_result[feature_cache_key(key)] = value
+          end
+        end
+
+        result = {}
+        features.each do |feature|
+          result[feature.key] = cache_result[feature_cache_key(feature.key)]
+        end
+        result
+      end
+    end
+  end
+end

data/lib/flipper/adapters/dual_write.rb

@@ -0,0 +1,63 @@
+module Flipper
+  module Adapters
+    class DualWrite
+      include ::Flipper::Adapter
+
+      attr_reader :local, :remote
+
+      # Public: Build a new sync instance.
+      #
+      # local - The local flipper adapter that should serve reads.
+      # remote - The remote flipper adapter that writes should go to first (in
+      #          addition to the local adapter).
+      def initialize(local, remote, options = {})
+        @local = local
+        @remote = remote
+      end
+
+      def adapter_stack
+        "#{name}(local: #{@local.adapter_stack}, remote: #{@remote.adapter_stack})"
+      end
+
+      def features
+        @local.features
+      end
+
+      def get(feature)
+        @local.get(feature)
+      end
+
+      def get_multi(features)
+        @local.get_multi(features)
+      end
+
+      def get_all(**kwargs)
+        @local.get_all(**kwargs)
+      end
+
+      def add(feature)
+        @remote.add(feature).tap { @local.add(feature) }
+      end
+
+      def remove(feature)
+        @remote.remove(feature).tap { @local.remove(feature) }
+      end
+
+      def clear(feature)
+        @remote.clear(feature).tap { @local.clear(feature) }
+      end
+
+      def enable(feature, gate, thing)
+        @remote.enable(feature, gate, thing).tap do
+          @local.enable(feature, gate, thing)
+        end
+      end
+
+      def disable(feature, gate, thing)
+        @remote.disable(feature, gate, thing).tap do
+          @local.disable(feature, gate, thing)
+        end
+      end
+    end
+  end
+end

data/lib/flipper/adapters/failover.rb

@@ -0,0 +1,85 @@
+module Flipper
+  module Adapters
+    class Failover
+      include ::Flipper::Adapter
+
+      # Public: Build a new failover instance.
+      #
+      # primary   - The primary flipper adapter.
+      # secondary - The secondary flipper adapter which services reads when
+      #             the primary adapter is unavailable.
+      # options   - Hash of options:
+      #             :dual_write - Boolean, whether to update secondary when
+      #                           primary is updated
+      #             :errors - Array of exception types for which to failover
+
+      attr_reader :primary, :secondary
+
+      def initialize(primary, secondary, options = {})
+        @primary = primary
+        @secondary = secondary
+
+        @dual_write = options.fetch(:dual_write, false)
+        @errors = options.fetch(:errors, [ StandardError ])
+      end
+
+      def adapter_stack
+        "#{name}(primary: #{@primary.adapter_stack}, secondary: #{@secondary.adapter_stack})"
+      end
+
+      def features
+        @primary.features
+      rescue *@errors
+        @secondary.features
+      end
+
+      def get(feature)
+        @primary.get(feature)
+      rescue *@errors
+        @secondary.get(feature)
+      end
+
+      def get_multi(features)
+        @primary.get_multi(features)
+      rescue *@errors
+        @secondary.get_multi(features)
+      end
+
+      def get_all(**kwargs)
+        @primary.get_all(**kwargs)
+      rescue *@errors
+        @secondary.get_all(**kwargs)
+      end
+
+      def add(feature)
+        @primary.add(feature).tap do
+          @secondary.add(feature) if @dual_write
+        end
+      end
+
+      def remove(feature)
+        @primary.remove(feature).tap do
+          @secondary.remove(feature) if @dual_write
+        end
+      end
+
+      def clear(feature)
+        @primary.clear(feature).tap do
+          @secondary.clear(feature) if @dual_write
+        end
+      end
+
+      def enable(feature, gate, thing)
+        @primary.enable(feature, gate, thing).tap do
+          @secondary.enable(feature, gate, thing) if @dual_write
+        end
+      end
+
+      def disable(feature, gate, thing)
+        @primary.disable(feature, gate, thing).tap do
+          @secondary.disable(feature, gate, thing) if @dual_write
+        end
+      end
+    end
+  end
+end

data/lib/flipper/adapters/failsafe.rb

@@ -0,0 +1,72 @@
+module Flipper
+  module Adapters
+    class Failsafe
+      include ::Flipper::Adapter
+
+      # Public: Build a new Failsafe instance.
+      #
+      # adapter   - Flipper adapter to guard.
+      # options   - Hash of options:
+      #             :errors - Array of exception types for which to fail safe
+
+      def initialize(adapter, options = {})
+        @adapter = adapter
+        @errors = options.fetch(:errors, [StandardError])
+      end
+
+      def features
+        @adapter.features
+      rescue *@errors
+        Set.new
+      end
+
+      def add(feature)
+        @adapter.add(feature)
+      rescue *@errors
+        false
+      end
+
+      def remove(feature)
+        @adapter.remove(feature)
+      rescue *@errors
+        false
+      end
+
+      def clear(feature)
+        @adapter.clear(feature)
+      rescue *@errors
+        false
+      end
+
+      def get(feature)
+        @adapter.get(feature)
+      rescue *@errors
+        {}
+      end
+
+      def get_multi(features)
+        @adapter.get_multi(features)
+      rescue *@errors
+        {}
+      end
+
+      def get_all(**kwargs)
+        @adapter.get_all(**kwargs)
+      rescue *@errors
+        {}
+      end
+
+      def enable(feature, gate, thing)
+        @adapter.enable(feature, gate, thing)
+      rescue *@errors
+        false
+      end
+
+      def disable(feature, gate, thing)
+        @adapter.disable(feature, gate, thing)
+      rescue *@errors
+        false
+      end
+    end
+  end
+end