flipper 0.21.0.rc1 → 0.21.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04567e721e7189ed3a5a28c91833caa438e89c8dc412708c1d5487ebcf43e09e
-  data.tar.gz: c31948ae275a36a986352ae8d53e858d63e67590a1cae3831013530446008608
+  metadata.gz: 1cdc35a74141977ee7aa3f92a8ddba338f9e268aee9ae9ed709c2f9c391cac8a
+  data.tar.gz: f4f387595c12a6219dea6f0451e5c47c2e12cfb3d830fd602f3e648e23a2d0ab
 SHA512:
-  metadata.gz: 30e3b27356e2a24948cb4136c59be5a7a0d0b21631102999affa01c3e969dc037e6ff524df3da4ffc0c39ecd8ffbbb1798bda4593fca21f33aeebefb0236caff
-  data.tar.gz: 7cb046ca418ff31219b9d786cd22c0f81de6c37c9efc38a718e9ddcf2c97027de0d1a351ddeeae1a24adf1db081dcb364e0751f4d2881ef126e2a98ff0212b63
+  metadata.gz: 314fe25d0dfd891c038c8296ab3f07dfe539fbbbd33bbf1e9fec93267048f8f979025d0166f1b81ee629aee1b06d19ae891ab6bce45ca74039b82ff4978a747a
+  data.tar.gz: 515e5b5a19e9394a50fab5c6d0bd93b55e9f7c05c49ab8d1c88b6d9ff838aa5b0e2e57980e25e668cda71659cefdcdb1ee3f282eb03b08e9769bdc37c236400f

data/Changelog.md

@@ -7,6 +7,41 @@
 * Added cloud recommendation to flipper-ui. Can be disabled with `Flipper::UI.configure { |config| config.cloud_recommendation = false }`. Just want to raise awareness that more is available if people want it (https://github.com/jnunemaker/flipper/pull/504)
 * Added default `flipper_id` implementation via `Flipper::Identifier` and automatically included it in ActiveRecord and Sequel models (https://github.com/jnunemaker/flipper/pull/505)
 * Deprecate superflous sync_method setting (https://github.com/jnunemaker/flipper/pull/511)
+* Flipper is now pre-configured when used with Rails. By default, it will [memoize and preload all features for each request](docs/Optimization.md#memoization). (https://github.com/jnunemaker/flipper/pull/506)
+
+### Upgrading
+
+You should be able to upgrade to 0.21 without any breaking changes. However, if you want to simplify your setup, you can remove some configuration that is now handled automatically:
+
+1. Adapters are configured when on require, so unless you are using caching or other customizations, you can remove adapter configuration.
+
+    ```diff
+    # config/initializers/flipper.rb
+    - Flipper.configure do |config|
+    -   config.default { Flipper.new(Flipper::Adapters::ActiveRecord.new) }
+    - end
+    ```
+
+2. `Flipper::Middleware::Memoizer` will be enabled by default.
+
+    ```diff
+    # config/initializers/flipper.rb
+    - Rails.configuration.middleware.use Flipper::Middleware::Memoizer,
+    -   preload: [:stats, :search, :some_feature]
+    + Rails.application.configure do
+    +   # Uncomment to configure which features to preload on all requests
+    +   # config.flipper.preload = [:stats, :search, :some_feature]
+    + end
+    ```
+
+3. `#flipper_id`, which is used to enable features for specific actors, is now defined by [Flipper::Identifier](lib/flipper/identifier.rb) on all ActiveRecord and Sequel models. You can remove your implementation if it is in the form of `ModelName;id`.
+
+4. When using `flipper-cloud`, The `Flipper::Cloud.app` webhook receiver is now mounted at `/_flipper` by default.
+
+    ```diff
+    # config/routes.rb
+    - mount Flipper::Cloud.app, at: "/_flipper"
+    ```
 
 ## 0.20.4
 
@@ -14,6 +49,7 @@
 
 * Allow actors and time gates to deal with decimal percentages (https://github.com/jnunemaker/flipper/pull/492)
 * Change Flipper::Cloud::Middleware to receive webhooks at / in addition to /webhooks.
+* Add `write_through` option to ActiveSupportCacheStore adapter to support write-through caching (https://github.com/jnunemaker/flipper/pull/512)
 
 ## 0.20.3
 

data/README.md

@@ -21,7 +21,7 @@ Add this line to your application's Gemfile:
 
 You'll also want to pick a storage [adapter](#adapters), for example:
 
-    gem 'flipper-active_record'`
+    gem 'flipper-active_record'
 
 And then execute:
 

data/docs/Adapters.md

@@ -4,18 +4,17 @@ I plan on supporting the adapters in the flipper repo. Other adapters are welcom
 
 ## Officially Supported
 
-* [ActiveRecord adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_record) - Rails 3, 4, 5, and 6.
-* [ActiveSupportCacheStore adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_support_cache_store) - ActiveSupport::Cache::Store
-* [Cassanity adapter](https://github.com/jnunemaker/flipper-cassanity)
-* [Http adapter](https://github.com/jnunemaker/flipper/blob/master/docs/http)
-* [memory adapter](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/memory.rb) – great for tests
-* [Moneta adapter](https://github.com/jnunemaker/flipper/blob/master/docs/moneta)
+* [ActiveRecord adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_record) - Rails 5 and 6.
+* [Sequel adapter](https://github.com/jnunemaker/flipper/blob/master/docs/sequel)
+* [Redis adapter](https://github.com/jnunemaker/flipper/blob/master/docs/redis)
 * [Mongo adapter](https://github.com/jnunemaker/flipper/blob/master/docs/mongo)
 * [PStore adapter](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/pstore.rb) – great for when a local file is enough
-* [read-only adapter](https://github.com/jnunemaker/flipper/blob/master/docs/read-only)
-* [Redis adapter](https://github.com/jnunemaker/flipper/blob/master/docs/redis)
-* [Rollout adapter](rollout/README.md)
-* [Sequel adapter](https://github.com/jnunemaker/flipper/blob/master/docs/sequel)
+* [Http adapter](https://github.com/jnunemaker/flipper/blob/master/docs/http) - great for using with `Flipper::Api`
+* [Moneta adapter](https://github.com/jnunemaker/flipper/blob/master/docs/moneta) - great for a variety of data stores
+* [ActiveSupportCacheStore adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_support_cache_store) - great for Rails caching
+* [Memory adapter](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/memory.rb) – great for tests
+* [Read-only adapter](https://github.com/jnunemaker/flipper/blob/master/docs/read-only) - great for preventing writes from production console
+* [Rollout adapter](rollout/README.md) - great for switching from rollout to flipper
 
 ## Community Supported
 

data/docs/Caveats.md

@@ -1,4 +1,4 @@
 # Caveats
 
-1. The [individual actor gate](https://github.com/jnunemaker/flipper/blob/master/docs/Gates.md#2-individual-actor) is typically not designed for hundreds or thousands of actors to be enabled. This is an explicit choice to make it easier to batch load data from the adapters instead of performing individual checks for actors over and over. If you need to enable something for more than 20 individual people, I would recommend using a [group](https://github.com/jnunemaker/flipper/blob/master/docs/Gates.md#5-group).
-2. The disable method exists only to clear something that is enabled. If the thing you are disabling is not enabled, the disable is pointless. This means that if you enable one group an actor is in and disable another group, the feature will be enabled for the actor. ([related issue](https://github.com/jnunemaker/flipper/issues/71))
+1. The [individual actor gate](https://github.com/jnunemaker/flipper/blob/master/docs/Gates.md#2-individual-actor) is typically not designed for hundreds or thousands of actors to be enabled. This is an explicit choice to make it easier to batch load data from the adapters instead of performing individual checks for actors over and over. If you need to enable something for more than 100 individual actors, I would recommend using a [group](https://github.com/jnunemaker/flipper/blob/master/docs/Gates.md#5-group).
+2. The `disable` method exists only to clear something that is enabled. If the thing you are disabling is not enabled, the disable is pointless. This means that if you enable one group an actor is in and disable another group, the feature will be enabled for the actor. ([related issue](https://github.com/jnunemaker/flipper/issues/71))

data/docs/Optimization.md

@@ -1,52 +1,63 @@
 # Optimization
 
-## Memoizing Middleware
+## Memoization
 
-One optimization that flipper provides is a memoizing middleware. The memoizing middleware ensures that you only make one adapter call per feature per request. This means if you check the same feature over and over, it will only make one Mongo, Redis, or whatever call per feature for the length of the request.
+By default, Flipper will preload and memoize all features to ensure one adapter call per request. This means no matter how many times you check features, Flipper will only make one network request to Postgres, MySQL, Redis, Mongo or whatever adapter you are using for the length of the request.
 
-You can use the middleware like so for Rails:
+### Preloading
+
+Flipper will preload all features before each request by default, which is recommended if you have a limited number of features (< 100?) and they are used on most requests. If you have a lot of features, but only a few are used on most requests, you may want to customize preloading:
 
 ```ruby
-# setup default instance (perhaps in config/initializers/flipper.rb)
-Flipper.configure do |config|
-  config.default do
-    Flipper.new(...)
-  end
+# config/initializers/flipper.rb
+Rails.application.configure do
+  # Load specific features that are used on most requests
+  config.flipper.preload = [:stats, :search, :some_feature]
+
+  # Or completely disable preloading
+  config.flipper.preload = false
 end
+```
+
+Features that are not preloaded are still memoized, ensuring one adapter call per feature during a request.
+
+### Skip memoization
+
+Prevent preloading and memoization on specific requests by setting `memoize` to a proc that evaluates to false.
 
-# This assumes you setup a default flipper instance using configure.
-Rails.configuration.middleware.use Flipper::Middleware::Memoizer
+```ruby
+# config/initializers/flipper.rb
+Rails.application.configure do
+  config.flipper.memoize = ->(request) { !request.path.start_with?("/assets") }
+end
 ```
 
-**Note**: Be sure that the middleware is high enough up in your stack that all feature checks are wrapped.
+### Disable memoization
 
-**Also Note**: If you haven't setup a default instance, you can pass the instance to `SetupEnv` as `Memoizer` uses whatever is setup in the `env`:
+To disable memoization entirely:
 
 ```ruby
-Rails.configuration.middleware.use Flipper::Middleware::SetupEnv, -> { Flipper.new(...) }
-Rails.configuration.middleware.use Flipper::Middleware::Memoizer
+Rails.application.configure do
+  config.flipper.memoize = false
+end
 ```
 
-### Options
-
-The Memoizer middleware also supports a few options. Use either `preload` or `preload_all`, not both.
-
-* **`:preload`** - An `Array` of feature names (`Symbol`) to preload for every request. Useful if you have features that are used on every endpoint. `preload` uses `Adapter#get_multi` to attempt to load the features in one network call instead of N+1 network calls.
-    ```ruby
-    Rails.configuration.middleware.use Flipper::Middleware::Memoizer,
-      preload: [:stats, :search, :some_feature]
-    ```
-* **`:preload_all`** - A Boolean value (default: false) of whether or not all features should be preloaded. Using this results in a `preload_all` call with the result of `Adapter#get_all`. Any subsequent feature checks will be memoized and perform no network calls. I wouldn't recommend using this unless you have few features (< 100?) and nearly all of them are used on every request.
-    ```ruby
-    Rails.configuration.middleware.use Flipper::Middleware::Memoizer,
-      preload_all: true
-    ```
-* **`:unless`** - A block that prevents preloading and memoization if it evaluates to true.
-    ```ruby
-    # skip preloading and memoizing if path starts with /assets
-    Rails.configuration.middleware.use Flipper::Middleware::Memoizer,
-      unless: ->(request) { request.path.start_with?("/assets") }
-    ```
+### Advanced
+
+Memoization is implemented as a Rack middleware, which can be used manually in any Ruby app:
+
+```ruby
+use Flipper::Middleware::Memoizer,
+  preload: true,
+  unless: ->(request) { request.path.start_with?("/assets") }
+```
+
+**Also Note**: If you need to customize the instance of Flipper used by the memoizer, you can pass the instance to `SetupEnv`:
+
+```ruby
+use Flipper::Middleware::SetupEnv, -> { Flipper.new(...) }
+use Flipper::Middleware::Memoizer
+```
 
 ## Cache Adapters
 
@@ -61,11 +72,15 @@ https://github.com/petergoldstein/dalli
 Example using the Dalli cache adapter with the Memory adapter and a TTL of 600 seconds:
 
 ```ruby
-dalli_client = Dalli::Client.new('localhost:11211')
-memory_adapter = Flipper::Adapters::Memory.new
-adapter = Flipper::Adapters::Dalli.new(memory_adapter, dalli_client, 600)
-flipper = Flipper.new(adapter)
+Flipper.configure do |config|
+  config.adapter do
+    dalli = Dalli::Client.new('localhost:11211')
+    adapter = Flipper::Adapters::Memory.new
+    Flipper::Adapters::Dalli.new(adapter, dalli, 600)
+  end
+end
 ```
+
 ### RedisCache
 
 Applications using [Redis](https://redis.io/) via the [redis-rb](https://github.com/redis/redis-rb) client can take advantage of the RedisCache adapter.
@@ -75,12 +90,15 @@ Initialize `RedisCache`  with a flipper [adapter](https://github.com/jnunemaker/
 Example using the RedisCache adapter with the Memory adapter and a TTL of 4800 seconds:
 
 ```ruby
-  require 'flipper/adapters/redis_cache'
+require 'flipper/adapters/redis_cache'
 
-  redis = Redis.new(url: ENV['REDIS_URL'])
-  memory_adapter = Flipper::Adapters::Memory.new
-  adapter = Flipper::Adapters::RedisCache.new(memory_adapter, redis, 4800)
-  flipper = Flipper.new(adapter)
+Flipper.configure do |config|
+  config.adapter do
+    redis = Redis.new(url: ENV['REDIS_URL'])
+    memory_adapter = Flipper::Adapters::Memory.new
+    Flipper::Adapters::RedisCache.new(memory_adapter, redis, 4800)
+  end
+end
 ```
 
 ### ActiveSupportCacheStore
@@ -105,10 +123,15 @@ Example using the ActiveSupportCacheStore adapter with ActiveSupport's [MemorySt
 require 'active_support/cache'
 require 'flipper/adapters/active_support_cache_store'
 
-memory_adapter = Flipper::Adapters::Memory.new
-cache = ActiveSupport::Cache::MemoryStore.new
-adapter = Flipper::Adapters::ActiveSupportCacheStore.new(memory_adapter, cache, expires_in: 5.minutes)
-flipper = Flipper.new(adapter)
+Flipper.configure do |config|
+  config.adapter do
+    Flipper::Adapters::ActiveSupportCacheStore.new(
+      Flipper::Adapters::Memory.new,
+      ActiveSupport::Cache::MemoryStore.new # Or Rails.cache,
+      expires_in: 5.minutes
+    )
+  end
+end
 ```
 
 Setting `expires_in` is optional and will set an expiration time on Flipper cache keys.  If specified, all flipper keys will use this `expires_in` over the `expires_in` passed to your ActiveSupport cache constructor.

data/docs/http/README.md

@@ -8,17 +8,18 @@ Initialize the HTTP adapter with a configuration Hash.
 ```ruby
 require 'flipper/adapters/http'
 
-configuration = {
-  url: 'http://app.com/mount-point', # required
-  headers: { 'X-Custom-Header' => 'foo' },
-  basic_auth_username: 'user123',
-  basic_auth_password: 'password123'
-  read_timeout: 5,
-  open_timeout: 2,
-}
-
-adapter = Flipper::Adapters::Http.new(configuration)
-flipper = Flipper.new(adapter)
+Flipper.configure do |config|
+  config.adapter do
+    Flipper::Adapters::Http.new({
+      url: 'http://app.com/mount-point', # required
+      headers: { 'X-Custom-Header' => 'foo' },
+      basic_auth_username: 'user123',
+      basic_auth_password: 'password123'
+      read_timeout: 5,
+      open_timeout: 2,
+    })
+  end
+end
 ```
 
 **Required keys**:

data/docs/read-only/README.md

@@ -5,17 +5,20 @@ A [read-only](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adap
 Use this adapter to wrap another adapter and raise an exception for any writes.
 
 Any attempted write raises `Flipper::Adapters::ReadOnly::WriteAttempted`  with message  `'write attempted while in read only mode'`
+
 ## Usage
+
 ```ruby
 # example wrapping memory adapter
 require 'flipper/adapters/read_only'
 
-memory_adapter = Flipper::Adapters::Memory.new
-read_only_adapter = Flipper::Adapters::ReadOnly.new(memory_adapter)
-
-flipper = Flipper.new(read_only_adapter)
+Flipper.configure do |config|
+  config.adapter do
+    Flipper::Adapters::ReadOnly.new(Flipper::Adapters::Memory.new)
+  end
+end
 
 # Enabling a feature
-> flipper[:dashboard_panel].enable
+> Flipper[:dashboard_panel].enable
 => Flipper::Adapters::ReadOnly::WriteAttempted: write attempted while in read only mode
 ```

data/examples/configuring_default.rb

@@ -3,9 +3,7 @@ require 'flipper'
 
 # sets up default adapter so Flipper works like Flipper::DSL
 Flipper.configure do |config|
-  config.default do
-    Flipper.new Flipper::Adapters::Memory.new
-  end
+  config.adapter { Flipper::Adapters::Memory.new }
 end
 
 puts Flipper.enabled?(:search) # => false

data/examples/memoizing.rb

@@ -4,12 +4,9 @@ require 'flipper/adapters/operation_logger'
 require 'flipper/instrumentation/log_subscriber'
 
 Flipper.configure do |config|
-  config.default do
+  config.adapter do
     # pick an adapter, this uses memory, any will do
-    adapter = Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
-
-    # pass adapter to handy DSL instance
-    Flipper.new(adapter)
+    Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
   end
 end
 

data/lib/flipper.rb

@@ -16,7 +16,7 @@ module Flipper
   # Public: Configure flipper.
   #
   #   Flipper.configure do |config|
-  #     config.default { ... }
+  #     config.adapter { ... }
   #   end
   #
   # Yields Flipper::Configuration instance.
@@ -164,3 +164,5 @@ require 'flipper/types/percentage'
 require 'flipper/types/percentage_of_actors'
 require 'flipper/types/percentage_of_time'
 require 'flipper/typecast'
+
+require "flipper/railtie" if defined?(Rails::Railtie)

data/lib/flipper/adapters/pstore.rb

@@ -216,3 +216,7 @@ module Flipper
     end
   end
 end
+
+Flipper.configure do |config|
+  config.adapter { Flipper::Adapters::PStore.new }
+end

data/lib/flipper/configuration.rb

@@ -1,7 +1,33 @@
 module Flipper
   class Configuration
-    def initialize
-      @default = -> { Flipper.new(Flipper::Adapters::Memory.new) }
+    def initialize(options = {})
+      @default = -> { Flipper.new(adapter) }
+      @adapter = -> { Flipper::Adapters::Memory.new }
+    end
+
+    # The default adapter to use.
+    #
+    # Pass a block to assign the adapter, and invoke without a block to
+    # return the configured adapter instance.
+    #
+    #   Flipper.configure do |config|
+    #     config.adapter # => instance of default Memory adapter
+    #
+    #     # Configure it to use the ActiveRecord adapter
+    #     config.adapter do
+    #       require "flipper-active_record"
+    #       Flipper::Adapters::ActiveRecord.new
+    #     end
+    #
+    #     config.adapter # => instance of ActiveRecord adapter
+    #  end
+    #
+    def adapter(&block)
+      if block_given?
+        @adapter = block
+      else
+        @adapter.call
+      end
     end
 
     # Controls the default instance for flipper. When used with a block it

data/lib/flipper/middleware/memoizer.rb

@@ -8,8 +8,7 @@ module Flipper
       #
       # app - The app this middleware is included in.
       # opts - The Hash of options.
-      #        :preload_all - Boolean of whether or not to preload all features.
-      #        :preload - Array of Symbol feature names to preload.
+      #        :preload - Boolean to preload all features or Array of Symbol feature names to preload.
       #
       # Examples
       #
@@ -26,6 +25,11 @@ module Flipper
           raise 'Flipper::Middleware::Memoizer no longer initializes with a flipper instance or block. Read more at: https://git.io/vSo31.'
         end
 
+        if opts[:preload_all]
+          warn "Flipper::Middleware::Memoizer: `preload_all` is deprecated, use `preload: true`"
+          opts[:preload] = true
+        end
+
         @app = app
         @opts = opts
         @env_key = opts.fetch(:env_key, 'flipper')
@@ -34,39 +38,50 @@ module Flipper
       def call(env)
         request = Rack::Request.new(env)
 
-        if skip_memoize?(request)
-          @app.call(env)
-        else
+        if memoize?(request)
           memoized_call(env)
+        else
+          @app.call(env)
         end
       end
 
       private
 
-      def skip_memoize?(request)
-        @opts[:unless] && @opts[:unless].call(request)
+      def memoize?(request)
+        if @opts[:if]
+          @opts[:if].call(request)
+        elsif @opts[:unless]
+          !@opts[:unless].call(request)
+        else
+          true
+        end
       end
 
       def memoized_call(env)
         reset_on_body_close = false
         flipper = env.fetch(@env_key) { Flipper }
-        original = flipper.memoizing?
-        flipper.memoize = true
 
-        flipper.preload_all if @opts[:preload_all]
+        # Already memoizing. This instance does not need to do anything.
+        if flipper.memoizing?
+          warn "Flipper::Middleware::Memoizer appears to be running twice. Read how to resolve this at https://github.com/jnunemaker/flipper/pull/523"
+          return @app.call(env)
+        end
+
+        flipper.memoize = true
 
-        if (preload = @opts[:preload])
-          flipper.preload(preload)
+        case @opts[:preload]
+        when true then flipper.preload_all
+        when Array then flipper.preload(@opts[:preload])
         end
 
         response = @app.call(env)
         response[2] = Rack::BodyProxy.new(response[2]) do
-          flipper.memoize = original
+          flipper.memoize = false
         end
         reset_on_body_close = true
         response
       ensure
-        flipper.memoize = original if flipper && !reset_on_body_close
+        flipper.memoize = false if flipper && !reset_on_body_close
       end
     end
   end

data/lib/flipper/railtie.rb

@@ -0,0 +1,38 @@
+module Flipper
+  class Railtie < Rails::Railtie
+    config.before_configuration do
+      config.flipper = ActiveSupport::OrderedOptions.new.update(
+        env_key: "flipper",
+        memoize: true,
+        preload: true,
+        instrumenter: ActiveSupport::Notifications
+      )
+    end
+
+    initializer "flipper.default", before: :load_config_initializers do |app|
+      Flipper.configure do |config|
+        config.default do
+          Flipper.new(config.adapter, instrumenter: app.config.flipper.instrumenter)
+        end
+      end
+    end
+
+    initializer "flipper.memoizer", after: :load_config_initializers do |app|
+      config = app.config.flipper
+
+      if config.memoize
+        app.middleware.use Flipper::Middleware::Memoizer, {
+          env_key: config.env_key,
+          preload: config.preload,
+          if: config.memoize.respond_to?(:call) ? config.memoize : nil
+        }
+      end
+    end
+
+    initializer "flipper.identifier" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Base.include Flipper::Identifier
+      end
+    end
+  end
+end

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = '0.21.0.rc1'.freeze
+  VERSION = '0.21.0.rc2'.freeze
 end

data/spec/flipper/configuration_spec.rb

@@ -2,10 +2,25 @@ require 'helper'
 require 'flipper/configuration'
 
 RSpec.describe Flipper::Configuration do
+  describe '#adapter' do
+    it 'returns instance using Memory adapter' do
+      expect(subject.adapter).to be_a(Flipper::Adapters::Memory)
+    end
+
+    it 'can be set' do
+      instance = Flipper::Adapters::Memory.new
+      expect(subject.adapter).not_to be(instance)
+      subject.adapter { instance }
+      expect(subject.adapter).to be(instance)
+      # All adapters are wrapped in Memoizable
+      expect(subject.default.adapter.adapter).to be(instance)
+    end
+  end
+
   describe '#default' do
     it 'returns instance using Memory adapter' do
       expect(subject.default).to be_a(Flipper::DSL)
-      # All adapter are wrapped in Memoizable
+      # All adapters are wrapped in Memoizable
       expect(subject.default.adapter.adapter).to be_a(Flipper::Adapters::Memory)
     end
 

data/spec/flipper/middleware/memoizer_spec.rb

@@ -15,10 +15,6 @@ RSpec.describe Flipper::Middleware::Memoizer do
   let(:flipper) { Flipper.new(adapter) }
   let(:env) { { 'flipper' => flipper } }
 
-  after do
-    flipper.memoize = nil
-  end
-
   it 'raises if initialized with app and flipper instance' do
     expect do
       described_class.new(app, flipper)
@@ -103,14 +99,14 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
   end
 
-  context 'with preload_all' do
+  context 'with preload: true' do
     let(:app) do
       # ensure scoped for builder block, annoying...
       instance = flipper
       middleware = described_class
 
       Rack::Builder.new do
-        use middleware, preload_all: true
+        use middleware, preload: true
 
         map '/' do
           run ->(_env) { [200, {}, []] }
@@ -139,7 +135,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
         [200, {}, []]
       end
 
-      middleware = described_class.new(app, preload_all: true)
+      middleware = described_class.new(app, preload: true)
       middleware.call(env)
 
       expect(adapter.operations.size).to be(1)
@@ -156,7 +152,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
         [200, {}, []]
       end
 
-      middleware = described_class.new(app, preload_all: true)
+      middleware = described_class.new(app, preload: true)
       middleware.call(env)
 
       expect(adapter.count(:get)).to be(1)
@@ -222,6 +218,44 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
   end
 
+  context 'with multiple instances' do
+    let(:app) do
+      # ensure scoped for builder block, annoying...
+      instance = flipper
+      middleware = described_class
+
+      Rack::Builder.new do
+        use middleware, preload: %i(stats)
+        # Second instance should be a noop
+        use middleware, preload: true
+
+        map '/' do
+          run ->(_env) { [200, {}, []] }
+        end
+
+        map '/fail' do
+          run ->(_env) { raise 'FAIL!' }
+        end
+      end.to_app
+    end
+
+    def get(uri, params = {}, env = {}, &block)
+      silence { super(uri, params, env, &block) }
+    end
+
+    include_examples 'flipper middleware'
+
+    it 'does not call preload in second instance' do
+      expect(flipper).not_to receive(:preload_all)
+
+      output = get '/', {}, 'flipper' => flipper
+
+      expect(output).to match(/Flipper::Middleware::Memoizer appears to be running twice/)
+      expect(adapter.count(:get_multi)).to be(1)
+      expect(adapter.last(:get_multi).args).to eq([[flipper[:stats]]])
+    end
+  end
+
   context 'when an app raises an exception' do
     it 'resets memoize' do
       begin
@@ -259,10 +293,9 @@ RSpec.describe Flipper::Middleware::Memoizer do
   context 'with Flipper setup in env' do
     it 'caches getting a feature for duration of request' do
       Flipper.configure do |config|
-        config.default do
+        config.adapter do
           memory = Flipper::Adapters::Memory.new
-          logged_adapter = Flipper::Adapters::OperationLogger.new(memory)
-          Flipper.new(logged_adapter)
+          Flipper::Adapters::OperationLogger.new(memory)
         end
       end
       Flipper.enable(:stats)
@@ -308,14 +341,16 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
   end
 
-  context 'with preload_all and unless option' do
+  context 'with preload:true' do
+    let(:options) { {preload: true} }
+
     let(:app) do
       # ensure scoped for builder block, annoying...
       middleware = described_class
+      opts = options
 
       Rack::Builder.new do
-        use middleware, preload_all: true,
-                        unless: ->(request) { request.path.start_with?("/assets") }
+        use middleware, opts
 
         map '/' do
           run ->(_env) { [200, {}, []] }
@@ -327,18 +362,53 @@ RSpec.describe Flipper::Middleware::Memoizer do
       end.to_app
     end
 
-    it 'does NOT preload_all if request matches unless block' do
-      expect(flipper).to receive(:preload_all).never
-      get '/assets/foo.png', {}, 'flipper' => flipper
+
+    context 'and unless option' do
+      before do
+        options[:unless] = ->(request) { request.path.start_with?("/assets") }
+      end
+
+      it 'does NOT preload if request matches unless block' do
+        expect(flipper).to receive(:preload_all).never
+        get '/assets/foo.png', {}, 'flipper' => flipper
+      end
+
+      it 'does preload if request does NOT match unless block' do
+        expect(flipper).to receive(:preload_all).once
+        get '/some/other/path', {}, 'flipper' => flipper
+      end
     end
 
-    it 'does preload_all if request does NOT match unless block' do
-      expect(flipper).to receive(:preload_all).once
-      get '/some/other/path', {}, 'flipper' => flipper
+    context 'and if option' do
+      before do
+        options[:if] = ->(request) { !request.path.start_with?("/assets") }
+      end
+
+      it 'does NOT preload if request does not match if block' do
+        expect(flipper).to receive(:preload_all).never
+        get '/assets/foo.png', {}, 'flipper' => flipper
+      end
+
+      it 'does preload if request matches if block' do
+        expect(flipper).to receive(:preload_all).once
+        get '/some/other/path', {}, 'flipper' => flipper
+      end
     end
   end
 
-  context 'with preload_all and caching adapter' do
+  context 'with preload:true and caching adapter' do
+    let(:app) do
+      app = lambda do |_env|
+        flipper[:stats].enabled?
+        flipper[:stats].enabled?
+        flipper[:shiny].enabled?
+        flipper[:shiny].enabled?
+        [200, {}, []]
+      end
+
+      described_class.new(app, preload: true)
+    end
+
     it 'eagerly caches known features for duration of request' do
       memory = Flipper::Adapters::Memory.new
       logged_memory = Flipper::Adapters::OperationLogger.new(memory)
@@ -355,25 +425,15 @@ RSpec.describe Flipper::Middleware::Memoizer do
       logged_memory.reset
       logged_cached.reset
 
-      app = lambda do |_env|
-        flipper[:stats].enabled?
-        flipper[:stats].enabled?
-        flipper[:shiny].enabled?
-        flipper[:shiny].enabled?
-        [200, {}, []]
-      end
-
-      middleware = described_class.new(app, preload_all: true)
-
-      middleware.call('flipper' => flipper)
+      get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(1)
       expect(logged_memory.count(:get_all)).to be(1)
 
-      middleware.call('flipper' => flipper)
+      get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(2)
       expect(logged_memory.count(:get_all)).to be(1)
 
-      middleware.call('flipper' => flipper)
+      get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(3)
       expect(logged_memory.count(:get_all)).to be(1)
     end

data/spec/flipper/railtie_spec.rb

@@ -0,0 +1,69 @@
+require 'helper'
+require 'rails'
+require 'flipper/railtie'
+
+RSpec.describe Flipper::Railtie do
+  let(:application) do
+    app = Class.new(Rails::Application).new(
+      railties: [Flipper::Railtie],
+      ordered_railties: [Flipper::Railtie]
+    )
+    app.config.eager_load = false
+    app.config.logger = ActiveSupport::Logger.new($stdout)
+    app.run_load_hooks!
+  end
+
+  before do
+    Rails.application = nil
+  end
+
+  subject do
+    application.initialize!
+    application
+  end
+
+  describe 'initializers' do
+    it 'sets defaults' do
+      expect(application.config.flipper.env_key).to eq("flipper")
+      expect(application.config.flipper.memoize).to be(true)
+      expect(application.config.flipper.preload).to be(true)
+    end
+
+    it "configures instrumentor on default instance" do
+      subject
+
+      expect(Flipper.instance.instrumenter).to eq(ActiveSupport::Notifications)
+    end
+
+    it 'uses Memoizer middleware if config.memoize = true' do
+      expect(subject.middleware.last).to eq(Flipper::Middleware::Memoizer)
+    end
+
+    it 'does not use Memoizer middleware if config.memoize = false' do
+      # load but don't initialize
+      application.config.flipper.memoize = false
+
+      expect(subject.middleware.last).not_to eq(Flipper::Middleware::Memoizer)
+    end
+
+    it 'passes config to memoizer' do
+      # load but don't initialize
+      application.config.flipper.update(
+        env_key: 'my_flipper',
+        preload: [:stats, :search]
+      )
+
+      expect(Flipper::Middleware::Memoizer).to receive(:new).with(application.routes,
+        env_key: 'my_flipper', preload: [:stats, :search], if: nil
+      )
+
+      subject # initialize
+    end
+
+    it "defines #flipper_id on AR::Base" do
+      subject
+      require 'active_record'
+      expect(ActiveRecord::Base.ancestors).to include(Flipper::Identifier)
+    end
+  end
+end

data/spec/support/spec_helpers.rb

@@ -61,6 +61,23 @@ module SpecHelpers
   def with_modified_env(options, &block)
     ClimateControl.modify(options, &block)
   end
+
+  def silence
+    # Store the original stderr and stdout in order to restore them later
+    original_stderr = $stderr
+    original_stdout = $stdout
+
+    # Redirect stderr and stdout
+    output = $stderr = $stdout = StringIO.new
+
+    yield
+
+    $stderr = original_stderr
+    $stdout = original_stdout
+
+    # Return output
+    output.string
+  end
 end
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flipper
 version: !ruby/object:Gem::Version
-  version: 0.21.0.rc1
+  version: 0.21.0.rc2
 platform: ruby
 authors:
 - John Nunemaker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-01 00:00:00.000000000 Z
+date: 2021-05-08 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -92,6 +92,7 @@ files:
 - lib/flipper/metadata.rb
 - lib/flipper/middleware/memoizer.rb
 - lib/flipper/middleware/setup_env.rb
+- lib/flipper/railtie.rb
 - lib/flipper/registry.rb
 - lib/flipper/spec/shared_adapter_specs.rb
 - lib/flipper/test/shared_adapter_test.rb
@@ -137,6 +138,7 @@ files:
 - spec/flipper/instrumenters/noop_spec.rb
 - spec/flipper/middleware/memoizer_spec.rb
 - spec/flipper/middleware/setup_env_spec.rb
+- spec/flipper/railtie_spec.rb
 - spec/flipper/registry_spec.rb
 - spec/flipper/typecast_spec.rb
 - spec/flipper/types/actor_spec.rb
@@ -213,6 +215,7 @@ test_files:
 - spec/flipper/instrumenters/noop_spec.rb
 - spec/flipper/middleware/memoizer_spec.rb
 - spec/flipper/middleware/setup_env_spec.rb
+- spec/flipper/railtie_spec.rb
 - spec/flipper/registry_spec.rb
 - spec/flipper/typecast_spec.rb
 - spec/flipper/types/actor_spec.rb