flipper 0.20.2 → 0.21.0

data/lib/flipper/errors.rb

@@ -16,9 +16,8 @@ module Flipper
   # use it.
   class DefaultNotSet < Flipper::Error
     def initialize(message = nil)
-      default = "Default flipper instance not configured. See " \
-                "Flipper.configure for how to configure the default instance."
-      super(message || default)
+      warn "Flipper::DefaultNotSet is deprecated and will be removed in 1.0"
+      super
     end
   end
 

data/lib/flipper/identifier.rb

@@ -0,0 +1,17 @@
+module Flipper
+  # A default implementation of `#flipper_id` for actors.
+  #
+  #   class User < Struct.new(:id)
+  #     include Flipper::Identifier
+  #   end
+  #
+  #   user = User.new(99)
+  #   Flipper.enable :thing, user
+  #   Flipper.enabled? :thing, user #=> true
+  #
+  module Identifier
+    def flipper_id
+      "#{self.class.name};#{id}"
+    end
+  end
+end

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.20.2'.freeze
+  VERSION = '0.21.0'.freeze
 end

data/spec/flipper/adapters/memory_spec.rb

@@ -2,7 +2,27 @@ require 'helper'
 require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::Memory do
-  subject { described_class.new }
+  let(:source) { {} }
+  subject { described_class.new(source) }
 
   it_should_behave_like 'a flipper adapter'
+
+  it "can initialize from big hash" do
+    flipper = Flipper.new(subject)
+    flipper.enable :subscriptions
+    flipper.disable :search
+    flipper.enable_percentage_of_actors :pro_deal, 20
+    flipper.enable_percentage_of_time :logging, 30
+    flipper.enable_actor :following, Flipper::Actor.new('1')
+    flipper.enable_actor :following, Flipper::Actor.new('3')
+    flipper.enable_group :following, Flipper::Types::Group.new(:staff)
+
+    expect(source).to eq({
+      "subscriptions" => subject.default_config.merge(boolean: "true"),
+      "search" => subject.default_config,
+      "logging" => subject.default_config.merge(:percentage_of_time => "30"),
+      "pro_deal" => subject.default_config.merge(:percentage_of_actors => "20"),
+      "following" => subject.default_config.merge(actors: Set["1", "3"], groups: Set["staff"]),
+    })
+  end
 end

data/spec/flipper/configuration_spec.rb

@@ -2,13 +2,31 @@ 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 'raises if default not configured' do
-      expect { subject.default }.to raise_error(Flipper::DefaultNotSet)
+    it 'returns instance using Memory adapter' do
+      expect(subject.default).to be_a(Flipper::DSL)
+      # All adapters are wrapped in Memoizable
+      expect(subject.default.adapter.adapter).to be_a(Flipper::Adapters::Memory)
     end
 
     it 'can be set default' do
       instance = Flipper.new(Flipper::Adapters::Memory.new)
+      expect(subject.default).not_to be(instance)
       subject.default { instance }
       expect(subject.default).to be(instance)
     end

data/spec/flipper/identifier_spec.rb

@@ -0,0 +1,14 @@
+require 'helper'
+require 'flipper/identifier'
+
+RSpec.describe Flipper::Identifier do
+  describe '#flipper_id' do
+    class User < Struct.new(:id)
+      include Flipper::Identifier
+    end
+
+    it 'uses class name and id' do
+      expect(User.new(5).flipper_id).to eq('User;5')
+    end
+  end
+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,22 +362,57 @@ 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)
-      cache = ActiveSupport::Cache::DalliStore.new(ENV['MEMCACHED_URL'])
+      cache = ActiveSupport::Cache::MemoryStore.new
       cache.clear
       cached = Flipper::Adapters::ActiveSupportCacheStore.new(logged_memory, cache, expires_in: 10)
       logged_cached = Flipper::Adapters::OperationLogger.new(cached)
@@ -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