flipper 1.0.0 → 1.3.6

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,
     }

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/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