flipper 0.28.3 → 1.4.2

data/lib/flipper/typecast.rb

@@ -1,8 +1,10 @@
 require 'set'
+require "flipper/serializers/json"
+require "flipper/serializers/gzip"
 
 module Flipper
-  module Typecast
-    TruthMap = {
+  class Typecast
+    TRUTH_MAP = {
       true    => true,
       1       => true,
       'true'  => true,
@@ -13,7 +15,7 @@ module Flipper
     #
     # Returns true or false.
     def self.to_boolean(value)
-      !!TruthMap[value]
+      !!TRUTH_MAP[value]
     end
 
     # Internal: Convert value to an integer.
@@ -36,17 +38,25 @@ module Flipper
       raise ArgumentError, "#{value.inspect} cannot be converted to a float"
     end
 
-    # Internal: Convert value to a percentage.
+    # Internal: Convert value to a number.
     #
     # Returns a Integer or Float representation of the value.
     # Raises ArgumentError if conversion is not possible.
-    def self.to_percentage(value)
-      result_to_f = value.to_f
-      result_to_i = result_to_f.to_i
-      result_to_f == result_to_i ? result_to_i : result_to_f
+    def self.to_number(value)
+      case value
+      when Numeric
+        value
+      when String
+        value.include?('.') ? to_float(value) : to_integer(value)
+      when NilClass
+        0
+      else
+        value.to_f
+      end
     rescue NoMethodError
-      raise ArgumentError, "#{value.inspect} cannot be converted to a percentage"
+      raise ArgumentError, "#{value.inspect} cannot be converted to a number"
     end
+    singleton_class.send(:alias_method, :to_percentage, :to_number)
 
     # Internal: Convert value to a set.
     #
@@ -71,6 +81,8 @@ module Flipper
           normalized_value = case value
           when Array, Set
             value.to_set
+          when Hash
+            value
           else
             value ? value.to_s : value
           end
@@ -79,5 +91,21 @@ module Flipper
       end
       normalized_source
     end
+
+    def self.to_json(source)
+      Serializers::Json.serialize(source)
+    end
+
+    def self.from_json(source)
+      Serializers::Json.deserialize(source)
+    end
+
+    def self.to_gzip(source)
+      Serializers::Gzip.serialize(source)
+    end
+
+    def self.from_gzip(source)
+      Serializers::Gzip.deserialize(source)
+    end
   end
 end

data/lib/flipper/types/percentage.rb

@@ -4,7 +4,7 @@ module Flipper
   module Types
     class Percentage < Type
       def initialize(value)
-        value = Typecast.to_percentage(value)
+        value = Typecast.to_number(value)
 
         if value < 0 || value > 100
           raise ArgumentError,

data/lib/flipper/version.rb

@@ -1,3 +1,13 @@
 module Flipper
-  VERSION = '0.28.3'.freeze
+  VERSION = '1.4.2'.freeze
+
+  REQUIRED_RUBY_VERSION = '2.6'.freeze
+  NEXT_REQUIRED_RUBY_VERSION = '3.0'.freeze
+
+  REQUIRED_RAILS_VERSION = '5.2'.freeze
+  NEXT_REQUIRED_RAILS_VERSION = '6.1.0'.freeze
+
+  def self.deprecated_ruby_version?
+    Gem::Version.new(RUBY_VERSION) < Gem::Version.new(NEXT_REQUIRED_RUBY_VERSION)
+  end
 end

data/lib/flipper.rb

@@ -56,18 +56,66 @@ module Flipper
   # Public: All the methods delegated to instance. These should match the
   # interface of Flipper::DSL.
   def_delegators :instance,
-                 :enabled?, :enable, :disable, :bool, :boolean,
-                 :enable_actor, :disable_actor, :actor,
+                 :enabled?, :enable, :disable,
+                 :enable_expression, :disable_expression,
+                 :expression, :add_expression, :remove_expression,
+                 :enable_actor, :disable_actor,
                  :enable_group, :disable_group,
                  :enable_percentage_of_actors, :disable_percentage_of_actors,
-                 :actors, :percentage_of_actors,
                  :enable_percentage_of_time, :disable_percentage_of_time,
-                 :time, :percentage_of_time,
                  :features, :feature, :[], :preload, :preload_all,
-                 :adapter, :add, :exist?, :remove, :import, :export,
-                 :memoize=, :memoizing?,
+                 :adapter, :adapter_stack, :add, :exist?, :remove, :import, :export,
+                 :memoize=, :memoizing?, :read_only?,
                  :sync, :sync_secret # For Flipper::Cloud. Will error for OSS Flipper.
 
+  def any(*args)
+    Expression.build({ Any: args.flatten })
+  end
+
+  def all(*args)
+    Expression.build({ All: args.flatten })
+  end
+
+  def constant(value)
+    Expression.build(value)
+  end
+
+  def property(name)
+    Expression.build({ Property: name })
+  end
+
+  def string(value)
+    Expression.build({ String: value })
+  end
+
+  def number(value)
+    Expression.build({ Number: value })
+  end
+
+  def boolean(value)
+    Expression.build({ Boolean: value })
+  end
+
+  def random(max)
+    Expression.build({ Random: max })
+  end
+
+  def now
+    Expression.build({ Now: [] })
+  end
+
+  def time(value)
+    Expression.build({ Time: value })
+  end
+
+  def feature_enabled(name)
+    Expression.build({ FeatureEnabled: name })
+  end
+
+  def feature_disabled(name)
+    feature_enabled(name).eq(false)
+  end
+
   # Public: Use this to register a group by name.
   #
   # name - The Symbol name of the group.
@@ -142,9 +190,13 @@ end
 
 require 'flipper/actor'
 require 'flipper/adapter'
+require 'flipper/adapters/wrapper'
+require 'flipper/adapters/actor_limit'
+require 'flipper/adapters/instrumented'
 require 'flipper/adapters/memoizable'
 require 'flipper/adapters/memory'
-require 'flipper/adapters/instrumented'
+require 'flipper/adapters/strict'
+require 'flipper/adapter_builder'
 require 'flipper/configuration'
 require 'flipper/dsl'
 require 'flipper/errors'
@@ -157,6 +209,7 @@ require 'flipper/middleware/memoizer'
 require 'flipper/middleware/setup_env'
 require 'flipper/poller'
 require 'flipper/registry'
+require 'flipper/expression'
 require 'flipper/type'
 require 'flipper/types/actor'
 require 'flipper/types/boolean'
@@ -167,4 +220,4 @@ require 'flipper/types/percentage_of_time'
 require 'flipper/typecast'
 require 'flipper/version'
 
-require "flipper/railtie" if defined?(Rails::Railtie)
+require "flipper/engine" if defined?(Rails)

data/lib/generators/flipper/setup_generator.rb

@@ -0,0 +1,68 @@
+require 'rails/generators/active_record'
+
+module Flipper
+  module Generators
+    class SetupGenerator < ::Rails::Generators::Base
+      desc 'Peform any necessary steps to install Flipper'
+      source_paths << File.expand_path('templates', __dir__)
+
+      class_option :token, type: :string, default: nil, aliases: '-t',
+        desc: "Your personal environment token for Flipper Cloud"
+
+      def generate_initializer
+        template 'initializer.rb', 'config/initializers/flipper.rb'
+      end
+
+      def generate_active_record
+        invoke 'flipper:active_record' if defined?(Flipper::Adapters::ActiveRecord)
+      end
+
+      def configure_cloud_token
+        return unless options[:token]
+
+        configure_with_dotenv || configure_with_credentials
+      end
+
+      private
+
+      def configure_with_dotenv
+        ['.env.development', '.env.local', '.env'].detect do |file|
+          next unless exists?(file)
+          append_to_file file, "\nFLIPPER_CLOUD_TOKEN=#{options[:token]}\n"
+        end
+      end
+
+      def configure_with_credentials
+        return unless exists?("config/credentials.yml.enc") && (ENV["RAILS_MASTER_KEY"] || exists?("config/master.key"))
+
+        content = "flipper:\n  cloud_token: #{options[:token]}\n"
+        action InjectIntoEncryptedFile.new(self, Rails.application.credentials, content, after: /\z/)
+      end
+
+      # Check if a file exists in the destination root
+      def exists?(path)
+        File.exist?(File.expand_path(path, destination_root))
+      end
+
+      # Action to inject content into ActiveSupport::EncryptedFile
+      class InjectIntoEncryptedFile < Thor::Actions::InjectIntoFile
+        def initialize(base, encrypted_file, data, config)
+          @encrypted_file = encrypted_file
+          super(base, encrypted_file.content_path, data, config)
+        end
+
+        def content
+          @content ||= @encrypted_file.read
+        end
+
+        def replace!(regexp, string, force)
+          if force || !replacement_present?
+            success = content.gsub!(regexp, string)
+            @encrypted_file.write content unless pretend?
+            success
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/flipper/templates/initializer.rb

@@ -0,0 +1,45 @@
+Rails.application.configure do
+  ## Memoization ensures that only one adapter call is made per feature per request.
+  ## For more info, see https://www.flippercloud.io/docs/optimization#memoization
+  # config.flipper.memoize = true
+
+  ## Flipper preloads all features before each request, which is recommended if:
+  ##   * you have a limited number of features (< 100?)
+  ##   * most of your requests depend on most of your features
+  ##   * you have limited gate data combined across all features (< 1k enabled gates, like individual actors, across all features)
+  ##
+  ## For more info, see https://www.flippercloud.io/docs/optimization#preloading
+  # config.flipper.preload = true
+
+  ## Warn or raise an error if an unknown feature is checked
+  ## Can be set to `:warn`, `:raise`, or `false`
+  # config.flipper.strict = Rails.env.development? && :warn
+
+  ## Show Flipper checks in logs
+  # config.flipper.log = true
+
+  ## Reconfigure Flipper to use the Memory adapter and disable Cloud in tests
+  # config.flipper.test_help = true
+
+  ## The path that Flipper Cloud will use to sync features
+  # config.flipper.cloud_path = "_flipper"
+
+  ## The instrumenter that Flipper will use. Defaults to ActiveSupport::Notifications.
+  # config.flipper.instrumenter = ActiveSupport::Notifications
+end
+
+Flipper.configure do |config|
+  ## Configure other adapters that you want to use here:
+  ## See http://flippercloud.io/docs/adapters
+  # config.use Flipper::Adapters::ActiveSupportCacheStore, Rails.cache, expires_in: 5.minutes
+end
+
+## Register a group that can be used for enabling features.
+##
+##   Flipper.enable_group :my_feature, :admins
+##
+## See https://www.flippercloud.io/docs/features#enablement-group
+#
+# Flipper.register(:admins) do |actor|
+#  actor.respond_to?(:admin?) && actor.admin?
+# end

data/lib/generators/flipper/templates/update/migrations/01_create_flipper_tables.rb.erb

@@ -0,0 +1,22 @@
+class CreateFlipperTables < ActiveRecord::Migration<%= migration_version %>
+  def up
+    create_table :flipper_features do |t|
+      t.string :key, null: false
+      t.timestamps null: false
+    end
+    add_index :flipper_features, :key, unique: true
+
+    create_table :flipper_gates do |t|
+      t.string :feature_key, null: false
+      t.string :key, null: false
+      t.string :value
+      t.timestamps null: false
+    end
+    add_index :flipper_gates, [:feature_key, :key, :value], unique: true
+  end
+
+  def down
+    drop_table :flipper_gates
+    drop_table :flipper_features
+  end
+end

data/lib/generators/flipper/templates/update/migrations/02_change_flipper_gates_value_to_text.rb.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class ChangeFlipperGatesValueToText < ActiveRecord::Migration<%= migration_version %>
+  def up
+    # Ensure this incremental update migration is idempotent
+    return unless connection.column_exists? :flipper_gates, :value, :string
+
+    if index_exists? :flipper_gates, [:feature_key, :key, :value]
+      remove_index :flipper_gates, [:feature_key, :key, :value]
+    end
+    change_column :flipper_gates, :value, :text
+    add_index :flipper_gates, [:feature_key, :key, :value], unique: true, length: { value: 255 }
+  end
+
+  def down
+    change_column :flipper_gates, :value, :string
+  end
+end

data/lib/generators/flipper/update_generator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module Flipper
+  module Generators
+    #
+    # Rails generator used for updating Flipper in a Rails application.
+    # Run it with +bin/rails g flipper:update+ in your console.
+    #
+    class UpdateGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      TEMPLATES = File.join(File.dirname(__FILE__), 'templates/update')
+      source_paths << TEMPLATES
+
+      # Generates incremental migration files unless they already exist.
+      # All migrations should be idempotent e.g. +add_index+ is guarded with +if_index_exists?+
+      def update_migration_files
+        migration_templates = Dir.children(File.join(TEMPLATES, 'migrations')).sort
+        migration_templates.each do |template_file|
+          destination_file = template_file.match(/^\d*_(.*\.rb)/)[1] # 01_create_flipper_tables.rb.erb => create_flipper_tables.rb
+          migration_template "migrations/#{template_file}", File.join(db_migrate_path, destination_file), skip: true
+        end
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::STRING.to_f}]"
+      end
+    end
+  end
+end

data/package-lock.json

@@ -0,0 +1,41 @@
+{
+  "name": "flipper",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "hasInstallScript": true,
+      "dependencies": {
+        "@popperjs/core": "^2.11.8",
+        "bootstrap": "^5.3.3"
+      }
+    },
+    "node_modules/@popperjs/core": {
+      "version": "2.11.8",
+      "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz",
+      "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/popperjs"
+      }
+    },
+    "node_modules/bootstrap": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.3.tgz",
+      "integrity": "sha512-8HLCdWgyoMguSO9o+aH+iuZ+aht+mzW0u3HIMzVu7Srrpv7EBBxTnrFlSCskwdY1+EOFQSm7uMJhNQHkdPcmjg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/twbs"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/bootstrap"
+        }
+      ],
+      "peerDependencies": {
+        "@popperjs/core": "^2.11.8"
+      }
+    }
+  }
+}

data/package.json

@@ -0,0 +1,10 @@
+{
+  "private": true,
+  "dependencies": {
+    "@popperjs/core": "^2.11.8",
+    "bootstrap": "^5.3.3"
+  },
+  "scripts": {
+    "postinstall": "script/vendor-assets"
+  }
+}

data/spec/fixtures/environment.rb

@@ -0,0 +1 @@
+# Placeholder for config/environment.rb

data/spec/flipper/adapter_builder_spec.rb

@@ -0,0 +1,72 @@
+RSpec.describe Flipper::AdapterBuilder do
+  describe "#initialize" do
+    it "instance_eval's block with no arg" do
+      called = false
+      self_in_block = nil
+
+      described_class.new do
+        called = true
+        self_in_block = self
+      end
+
+      expect(self_in_block).to be_instance_of(described_class)
+      expect(called).to be(true)
+    end
+
+    it "evals block with arg" do
+      called = false
+      self_outside_block = self
+      self_in_block = nil
+
+      described_class.new do |arg|
+        called = true
+        self_in_block = self
+        expect(arg).to be_instance_of(described_class)
+      end
+
+      expect(self_in_block).to be(self_outside_block)
+      expect(called).to be(true)
+    end
+  end
+
+  describe "#use" do
+    it "wraps the store adapter with the given adapter" do
+      subject.use(Flipper::Adapters::Memoizable)
+      subject.use(Flipper::Adapters::Strict, :warn)
+
+      memoizable_adapter = subject.to_adapter
+      strict_adapter = memoizable_adapter.adapter
+      memory_adapter = strict_adapter.adapter
+
+      expect(memoizable_adapter).to be_instance_of(Flipper::Adapters::Memoizable)
+      expect(strict_adapter).to be_instance_of(Flipper::Adapters::Strict)
+      expect(strict_adapter.handler).to be(:warn)
+      expect(memory_adapter).to be_instance_of(Flipper::Adapters::Memory)
+    end
+
+    it "passes block to adapter initializer" do
+      expected_block = lambda {}
+      adapter_class = double('adapter class')
+
+      subject.use(adapter_class, &expected_block)
+
+      expect(adapter_class).to receive(:new) { |&block| expect(block).to be(expected_block) }.and_return(:adapter)
+      expect(subject.to_adapter).to be(:adapter)
+    end
+  end
+
+  describe "#store" do
+    it "defaults to memory adapter" do
+      expect(subject.to_adapter).to be_instance_of(Flipper::Adapters::Memory)
+    end
+
+    it "only saves one store" do
+      require "flipper/adapters/pstore"
+      subject.store(Flipper::Adapters::PStore)
+      expect(subject.to_adapter).to be_instance_of(Flipper::Adapters::PStore)
+
+      subject.store(Flipper::Adapters::Memory)
+      expect(subject.to_adapter).to be_instance_of(Flipper::Adapters::Memory)
+    end
+  end
+end

data/spec/flipper/adapter_spec.rb

@@ -6,6 +6,7 @@ RSpec.describe Flipper::Adapter do
       boolean: nil,
       groups: Set.new,
       actors: Set.new,
+      expression: nil,
       percentage_of_actors: nil,
       percentage_of_time: nil,
     }
@@ -142,4 +143,24 @@ RSpec.describe Flipper::Adapter do
       expect(export.features.dig("search", :boolean)).to eq("true")
     end
   end
+
+  describe "#adapter_stack" do
+    it "returns the adapter name for a simple adapter" do
+      adapter = Flipper::Adapters::Memory.new
+      expect(adapter.adapter_stack).to eq("memory")
+    end
+
+    it "returns the chain for wrapped adapters" do
+      memory = Flipper::Adapters::Memory.new
+      memoizable = Flipper::Adapters::Memoizable.new(memory)
+      expect(memoizable.adapter_stack).to eq("memoizable -> memory")
+    end
+
+    it "returns the chain for deeply nested adapters" do
+      memory = Flipper::Adapters::Memory.new
+      strict = Flipper::Adapters::Strict.new(memory)
+      memoizable = Flipper::Adapters::Memoizable.new(strict)
+      expect(memoizable.adapter_stack).to eq("memoizable -> strict -> memory")
+    end
+  end
 end

data/spec/flipper/adapters/actor_limit_spec.rb

@@ -0,0 +1,75 @@
+require "flipper/adapters/actor_limit"
+
+RSpec.describe Flipper::Adapters::ActorLimit do
+  it_should_behave_like 'a flipper adapter' do
+    let(:limit) { 5 }
+    let(:adapter) { Flipper::Adapters::ActorLimit.new(Flipper::Adapters::Memory.new, limit) }
+
+    subject { adapter }
+
+    describe '#enable' do
+      it "fails when limit exceeded" do
+        5.times { |i| feature.enable Flipper::Actor.new("User;#{i}") }
+
+        expect {
+          feature.enable Flipper::Actor.new("User;6")
+        }.to raise_error(Flipper::Adapters::ActorLimit::LimitExceeded)
+      end
+
+      it "allows exceeding limit when in sync mode" do
+        5.times { |i| feature.enable Flipper::Actor.new("User;#{i}") }
+
+        described_class.with_sync_mode do
+          expect {
+            feature.enable Flipper::Actor.new("User;6")
+          }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe '.sync_mode' do
+    after do
+      described_class.sync_mode = nil
+    end
+
+    it 'defaults to nil/falsy' do
+      expect(described_class.sync_mode).to be_falsy
+    end
+
+    it 'can be set and read' do
+      described_class.sync_mode = true
+      expect(described_class.sync_mode).to be true
+    end
+  end
+
+  describe '.with_sync_mode' do
+    after do
+      described_class.sync_mode = nil
+    end
+
+    it 'sets sync_mode to true within block' do
+      described_class.with_sync_mode do
+        expect(described_class.sync_mode).to be true
+      end
+    end
+
+    it 'restores previous value after block' do
+      expect(described_class.sync_mode).to be_falsy
+      described_class.with_sync_mode { }
+      expect(described_class.sync_mode).to be_falsy
+    end
+
+    it 'restores previous value even on exception' do
+      expect {
+        described_class.with_sync_mode { raise "boom" }
+      }.to raise_error("boom")
+      expect(described_class.sync_mode).to be_falsy
+    end
+
+    it 'returns the block result' do
+      result = described_class.with_sync_mode { 42 }
+      expect(result).to eq(42)
+    end
+  end
+end

data/spec/flipper/adapters/dual_write_spec.rb

@@ -55,15 +55,28 @@ RSpec.describe Flipper::Adapters::DualWrite do
 
   it 'updates remote and local for #enable' do
     feature = sync[:search]
-    subject.enable feature, feature.gate(:boolean), local.boolean
+    subject.enable feature, feature.gate(:boolean), Flipper::Types::Boolean.new(true)
     expect(remote_adapter.count(:enable)).to be(1)
     expect(local_adapter.count(:enable)).to be(1)
   end
 
   it 'updates remote and local for #disable' do
     feature = sync[:search]
-    subject.disable feature, feature.gate(:boolean), local.boolean(false)
+    subject.disable feature, feature.gate(:boolean), Flipper::Types::Boolean.new(false)
     expect(remote_adapter.count(:disable)).to be(1)
     expect(local_adapter.count(:disable)).to be(1)
   end
+
+  describe '#adapter_stack' do
+    it 'returns the tree representation' do
+      expect(subject.adapter_stack).to eq("dual_write(local: operation_logger -> memory, remote: operation_logger -> memory)")
+    end
+
+    it 'shows nested adapters in the tree' do
+      memory = Flipper::Adapters::Memory.new
+      strict = Flipper::Adapters::Strict.new(Flipper::Adapters::Memory.new)
+      adapter = described_class.new(memory, strict)
+      expect(adapter.adapter_stack).to eq("dual_write(local: memory, remote: strict -> memory)")
+    end
+  end
 end