flipper 0.28.3 → 1.4.2

data/examples/expressions.rb

@@ -0,0 +1,237 @@
+require 'bundler/setup'
+require 'flipper'
+
+def assert(value)
+  if value
+    p value
+  else
+    puts "Expected true but was #{value}. Please correct."
+    exit 1
+  end
+end
+
+def refute(value)
+  if value
+    puts "Expected false but was #{value}. Please correct."
+    exit 1
+  else
+    p value
+  end
+end
+
+def reset
+  Flipper.disable_expression :something
+end
+
+class User < Struct.new(:id, :flipper_properties)
+  include Flipper::Identifier
+end
+
+class Org < Struct.new(:id, :flipper_properties)
+  include Flipper::Identifier
+end
+
+org = Org.new(1, {
+  "type" => "Org",
+  "id" => 1,
+})
+
+user = User.new(1, {
+  "type" => "User",
+  "id" => 1,
+  "plan" => "basic",
+  "age" => 39,
+  "team_user" => true,
+})
+
+admin_user = User.new(2, {
+  "type" => "User",
+  "id" => 2,
+  "admin" => true,
+  "team_user" => true,
+})
+
+other_user = User.new(3, {
+  "type" => "User",
+  "id" => 3,
+  "plan" => "plus",
+  "age" => 18,
+  "org_admin" => true,
+})
+
+age_expression = Flipper.property(:age).gte(21)
+plan_expression = Flipper.property(:plan).eq("basic")
+admin_expression = Flipper.property(:admin).eq(true)
+
+puts "Single Expression"
+refute Flipper.enabled?(:something, user)
+
+puts "Enabling single expression"
+Flipper.enable :something, plan_expression
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling single expression"
+reset
+refute Flipper.enabled?(:something, user)
+
+puts "\n\nAny Expression"
+any_expression = Flipper.any(plan_expression, age_expression)
+refute Flipper.enabled?(:something, user)
+
+puts "Enabling any expression"
+Flipper.enable :something, any_expression
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling any expression"
+reset
+refute Flipper.enabled?(:something, user)
+
+puts "\n\nAll Expression"
+all_expression = Flipper.all(plan_expression, age_expression)
+refute Flipper.enabled?(:something, user)
+
+puts "Enabling all expression"
+Flipper.enable :something, all_expression
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling all expression"
+reset
+refute Flipper.enabled?(:something, user)
+
+puts "\n\nNested Expression"
+nested_expression = Flipper.any(admin_expression, all_expression)
+refute Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Enabling nested expression"
+Flipper.enable :something, nested_expression
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling nested expression"
+reset
+refute Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nBoolean Expression"
+boolean_expression = Flipper.boolean(true)
+Flipper.enable :something, boolean_expression
+assert Flipper.enabled?(:something)
+assert Flipper.enabled?(:something, user)
+reset
+
+puts "\n\nSet of Actors Expression"
+set_of_actors_expression = Flipper.any(
+  Flipper.property(:flipper_id).eq("User;1"),
+  Flipper.property(:flipper_id).eq("User;3"),
+)
+Flipper.enable :something, set_of_actors_expression
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, other_user)
+refute Flipper.enabled?(:something, admin_user)
+reset
+
+puts "\n\n% of Actors Expression"
+percentage_of_actors = Flipper.property(:flipper_id).percentage_of_actors(30)
+Flipper.enable :something, percentage_of_actors
+refute Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, other_user)
+assert Flipper.enabled?(:something, admin_user)
+reset
+
+puts "\n\n% of Actors Per Type Expression"
+percentage_of_actors_per_type = Flipper.any(
+  Flipper.all(
+    Flipper.property(:type).eq("User"),
+    Flipper.property(:flipper_id).percentage_of_actors(40),
+  ),
+  Flipper.all(
+    Flipper.property(:type).eq("Org"),
+    Flipper.property(:flipper_id).percentage_of_actors(10),
+  )
+)
+Flipper.enable :something, percentage_of_actors_per_type
+refute Flipper.enabled?(:something, user) # not in the 40% enabled for Users
+assert Flipper.enabled?(:something, other_user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, org) # not in the 10% of enabled for Orgs
+reset
+
+puts "\n\nPercentage of Time Expression"
+percentage_of_time_expression = Flipper.random(100).lt(50)
+Flipper.enable :something, percentage_of_time_expression
+results = (1..10000).map { |n| Flipper.enabled?(:something, user) }
+enabled, disabled = results.partition { |r| r }
+p enabled: enabled.size
+p disabled: disabled.size
+assert (4_700..5_200).include?(enabled.size)
+assert (4_700..5_200).include?(disabled.size)
+reset
+
+puts "\n\nChanging single expression to all expression"
+Flipper.enable :something, plan_expression
+Flipper.enable :something, Flipper.expression(:something).all.add(age_expression)
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nChanging single expression to any expression"
+Flipper.enable :something, plan_expression
+Flipper.enable :something, Flipper.expression(:something).any.add(age_expression, admin_expression)
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nChanging single expression to any expression by adding to condition"
+Flipper.enable :something, plan_expression
+Flipper.enable :something, Flipper.expression(:something).add(admin_expression)
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nEnabling based on time (epoch)"
+scheduled_epoch = Flipper.now.gte(Flipper.time(Time.now.to_i - 86_400))
+Flipper.enable :something, scheduled_epoch
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+assert Flipper.enabled?(:something, other_user)
+reset
+
+puts "\n\nEnabling based on time (datetime)"
+past_time = (Time.now.utc - 86_400).iso8601
+scheduled_datetime = Flipper.now.gte(Flipper.time(past_time))
+Flipper.enable :something, scheduled_datetime
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+assert Flipper.enabled?(:something, other_user)
+reset
+
+puts "\n\nDisabling after a time (expiring feature)"
+future_time = (Time.now.utc + 86_400).iso8601
+expiring_expression = Flipper.now.lt(Flipper.time(future_time))
+Flipper.enable :something, expiring_expression
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+assert Flipper.enabled?(:something, other_user)
+reset
+
+puts "\n\nEnabling within a time window"
+start_time = (Time.now.utc - 86_400).iso8601
+end_time = (Time.now.utc + 86_400).iso8601
+time_window = Flipper.all(
+  Flipper.now.gte(Flipper.time(start_time)),
+  Flipper.now.lt(Flipper.time(end_time))
+)
+Flipper.enable :something, time_window
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+assert Flipper.enabled?(:something, other_user)

data/examples/strict.rb

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+require 'flipper'
+
+adapter = Flipper::Adapters::Strict.new(Flipper::Adapters::Memory.new)
+flipper = Flipper.new(adapter)
+
+begin
+  puts "Checking :unknown_feature, which should raise an error."
+  flipper.enabled?(:unknown_feature)
+  warn "An error was not raised, but should have been"
+  exit 1
+rescue Flipper::Adapters::Strict::NotFound => exception
+  puts "Ok, the exepcted error was raised: #{exception.message}"
+end
+
+puts "Flipper.add(:new_feature)"
+flipper.add(:new_feature)
+puts "Flipper.enabled?(:new_feature) => #{flipper.enabled?(:new_feature)}"

data/exe/flipper

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "flipper/cli"
+
+Flipper::CLI.run(ARGV)

data/flipper-cloud.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/flipper/version', __FILE__)
+require File.expand_path('../lib/flipper/metadata', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['John Nunemaker']
+  gem.email         = 'support@flippercloud.io'
+  gem.summary       = '[DEPRECATED] This gem has been merged into the `flipper` gem'
+  gem.license       = 'MIT'
+  gem.homepage      = 'https://www.flippercloud.io'
+
+  gem.files         = [ 'lib/flipper-cloud.rb', 'lib/flipper/version.rb' ]
+  gem.name          = 'flipper-cloud'
+  gem.require_paths = ['lib']
+  gem.version       = Flipper::VERSION
+  gem.metadata      = Flipper::METADATA
+
+  gem.add_dependency 'flipper', "~> #{Flipper::VERSION}"
+end

data/flipper.gemspec

@@ -6,7 +6,7 @@ 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
@@ -22,11 +22,13 @@ 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.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.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'
@@ -35,4 +37,6 @@ Gem::Specification.new do |gem|
   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,14 +2,17 @@
 # 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?
 

data/lib/flipper/adapter.rb

@@ -12,6 +12,7 @@ module Flipper
           boolean: nil,
           groups: Set.new,
           actors: Set.new,
+          expression: nil,
           percentage_of_actors: nil,
           percentage_of_time: nil,
         }
@@ -23,10 +24,14 @@ module Flipper
       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
@@ -63,6 +68,27 @@ module Flipper
     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
 

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

@@ -3,8 +3,7 @@ module Flipper
     class DualWrite
       include ::Flipper::Adapter
 
-      # Public: The name of the adapter.
-      attr_reader :name, :local, :remote
+      attr_reader :local, :remote
 
       # Public: Build a new sync instance.
       #
@@ -12,11 +11,14 @@ module Flipper
       # remote - The remote flipper adapter that writes should go to first (in
       #          addition to the local adapter).
       def initialize(local, remote, options = {})
-        @name = :dual_write
         @local = local
         @remote = remote
       end
 
+      def adapter_stack
+        "#{name}(local: #{@local.adapter_stack}, remote: #{@remote.adapter_stack})"
+      end
+
       def features
         @local.features
       end
@@ -29,8 +31,8 @@ module Flipper
         @local.get_multi(features)
       end
 
-      def get_all
-        @local.get_all
+      def get_all(**kwargs)
+        @local.get_all(**kwargs)
       end
 
       def add(feature)