flipper 0.26.0 → 1.3.6

data/lib/flipper.rb

@@ -56,28 +56,60 @@ 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,
-                 :memoize=, :memoizing?,
+                 :adapter, :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
+
   # Public: Use this to register a group by name.
   #
   # name - The Symbol name of the group.
   # block - The block that should be used to determine if the group matches a
-  #         given thing.
+  #         given actor.
   #
   # Examples
   #
-  #   Flipper.register(:admins) { |thing|
-  #     thing.respond_to?(:admin?) && thing.admin?
+  #   Flipper.register(:admins) { |actor|
+  #     actor.respond_to?(:admin?) && actor.admin?
   #   }
   #
   # Returns a Flipper::Group.
@@ -142,9 +174,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'
@@ -155,7 +191,9 @@ require 'flipper/instrumenters/noop'
 require 'flipper/identifier'
 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'
@@ -164,5 +202,6 @@ require 'flipper/types/percentage'
 require 'flipper/types/percentage_of_actors'
 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/fixtures/flipper_pstore_1679087600.json

@@ -0,0 +1,46 @@
+{
+  "version": 1,
+  "features": {
+    "search": {
+      "boolean": null,
+      "actors": [
+        "john",
+        "another",
+        "testing"
+      ],
+      "percentage_of_actors": null,
+      "percentage_of_time": null,
+      "groups": [
+        "admins"
+      ]
+    },
+    "new_pricing": {
+      "boolean": "true",
+      "actors": [],
+      "percentage_of_actors": null,
+      "percentage_of_time": null,
+      "groups": []
+    },
+    "google_analytics_tag": {
+      "boolean": null,
+      "actors": [],
+      "percentage_of_actors": "100",
+      "percentage_of_time": null,
+      "groups": []
+    },
+    "help_scout_tag": {
+      "boolean": null,
+      "actors": [],
+      "percentage_of_actors": null,
+      "percentage_of_time": "50",
+      "groups": []
+    },
+    "nope": {
+      "boolean": null,
+      "actors": [],
+      "percentage_of_actors": null,
+      "percentage_of_time": null,
+      "groups": []
+    }
+  }
+}

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,
     }
@@ -30,9 +31,9 @@ RSpec.describe Flipper::Adapter do
   end
 
   describe '#import' do
-    it 'returns nothing' do
+    it 'returns true' do
       result = destination_flipper.import(source_flipper)
-      expect(result).to be(nil)
+      expect(result).to be(true)
     end
 
     it 'can import from one adapter to another' do
@@ -114,5 +115,32 @@ RSpec.describe Flipper::Adapter do
       destination_flipper.import(source_flipper)
       expect(destination_flipper.features.map(&:key)).to eq([])
     end
+
+    it 'can import an export' do
+      source_flipper.enable(:search)
+      source_flipper.enable(:google_analytics, Flipper::Actor.new("User;1"))
+
+      destination_flipper.import(source_flipper.export)
+
+      feature = destination_flipper[:search]
+      expect(feature.boolean_value).to be(true)
+
+      feature = destination_flipper[:google_analytics]
+      expect(feature.actors_value).to eq(Set["User;1"])
+    end
+  end
+
+  describe "#export" do
+    it "exports features" do
+      source_flipper.enable(:search)
+      export = source_flipper.export
+      expect(export.features.dig("search", :boolean)).to eq("true")
+    end
+
+    it "exports with arguments" do
+      source_flipper.enable(:search)
+      export = source_flipper.export(format: :json, version: 1)
+      expect(export.features.dig("search", :boolean)).to eq("true")
+    end
   end
 end

data/spec/flipper/adapters/actor_limit_spec.rb

@@ -0,0 +1,20 @@
+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
+    end
+  end
+end

data/spec/flipper/adapters/dual_write_spec.rb

@@ -55,14 +55,14 @@ 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

data/spec/flipper/adapters/http/client_spec.rb

@@ -0,0 +1,61 @@
+require "flipper/adapters/http/client"
+
+RSpec.describe Flipper::Adapters::Http::Client do
+  describe "#initialize" do
+    it "requires url" do
+      expect { described_class.new }.to raise_error(KeyError, "key not found: :url")
+    end
+
+    it "sets default headers" do
+      client = described_class.new(url: "http://example.com")
+      expect(client.headers).to eq({
+        'content-type' => 'application/json',
+        'accept' => 'application/json',
+        'user-agent' => "Flipper HTTP Adapter v#{Flipper::VERSION}",
+      })
+    end
+
+    it "adds custom headers" do
+      client = described_class.new(url: "http://example.com", headers: {'custom-header' => 'value'})
+      expect(client.headers).to include('custom-header' => 'value')
+    end
+
+    it "overrides default headers with custom headers" do
+      client = described_class.new(url: "http://example.com", headers: {'content-type' => 'text/plain'})
+      expect(client.headers['content-type']).to eq('text/plain')
+    end
+  end
+
+  describe "#add_header" do
+    it "can add string header" do
+      client = described_class.new(url: "http://example.com")
+      client.add_header("key", "value")
+      expect(client.headers.fetch("key")).to eq("value")
+    end
+
+    it "standardizes key to lowercase" do
+      client = described_class.new(url: "http://example.com")
+      client.add_header("Content-Type", "value")
+      expect(client.headers.fetch("content-type")).to eq("value")
+    end
+
+    it "standardizes key to dashes" do
+      client = described_class.new(url: "http://example.com")
+      client.add_header(:content_type, "value")
+      expect(client.headers.fetch("content-type")).to eq("value")
+    end
+
+    it "can add symbol header" do
+      client = described_class.new(url: "http://example.com")
+      client.add_header(:key, "value")
+      expect(client.headers.fetch("key")).to eq("value")
+    end
+
+    it "overrides existing header" do
+      client = described_class.new(url: "http://example.com")
+      client.add_header("key", "value 1")
+      client.add_header("key", "value 2")
+      expect(client.headers.fetch("key")).to eq("value 2")
+    end
+  end
+end