flipflop 2.0.0

data/flipflop.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "flipflop/version"
+
+Gem::Specification.new do |s|
+  s.name        = "flipflop"
+  s.version     = Flipflop::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Paul Annesley", "Rolf Timmermans", "Jippe Holwerda"]
+  s.email       = ["paul@annesley.cc", "rolftimmermans@voormedia.com", "jippeholwerda@voormedia.com"]
+  s.homepage    = "https://github.com/voormedia/flipflop"
+  s.summary     = %q{A feature flipflopper for Rails web applications.}
+  s.description = %q{Declarative API for specifying features, switchable in declaration, database and cookies.}
+  s.license  = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("activesupport", ">= 4.0")
+  s.add_dependency("bootstrap", "~> 4.0.0.alpha3")
+end

data/lib/flipflop/configurable.rb

@@ -0,0 +1,27 @@
+module Flipflop
+  module Configurable
+    def feature(feature, **options)
+      feature = FeatureDefinition.new(feature, **options)
+      FeatureSet.current.add(feature)
+    end
+
+    def strategy(strategy = nil, **options)
+      if block_given?
+        options[:name] = strategy.to_s
+        options[:lambda] = Proc.new
+        strategy = Strategies::LambdaStrategy
+      end
+
+      if strategy.kind_of?(Symbol)
+        name = ActiveSupport::Inflector.camelize(strategy) + "Strategy"
+        strategy = Strategies.const_get(name)
+      end
+
+      if strategy.kind_of?(Class)
+        strategy = strategy.new(**options)
+      end
+
+      FeatureSet.current.use(strategy)
+    end
+  end
+end

data/lib/flipflop/engine.rb

@@ -0,0 +1,58 @@
+module Flipflop
+  class Engine < ::Rails::Engine
+    isolate_namespace Flipflop
+
+    config.app_middleware.insert_after ActionDispatch::Callbacks,
+      FeatureCache::Middleware
+
+    config.flipflop = ActiveSupport::OrderedOptions.new
+
+    initializer "flipflop.assets" do |app|
+      config.assets.precompile += ["flipflop.css"]
+    end
+
+    initializer "flipflop.features_path" do |app|
+      app.paths.add("config/features.rb")
+    end
+
+    initializer "flipflop.features_reloader" do |app|
+      app.reloaders.push(reloader = feature_reloader(app))
+      to_prepare do
+        reloader.execute
+      end
+    end
+
+    initializer "flipflop.dashboard", after: "flipflop.features_reloader" do |app|
+      if actions = config.flipflop.dashboard_access_filter
+        to_prepare do
+          Flipflop::FeaturesController.before_action(*actions)
+          Flipflop::StrategiesController.before_action(*actions)
+        end
+      else
+        unless defined?(Rails::Generators) or defined?(Rake)
+          warn("WARNING: You have not set `config.flipflop.dashboard_access_filter`; " +
+               "the Flipflop dashboard is now always public!")
+        end
+      end
+    end
+
+    initializer "flipflop.request_interceptor" do |app|
+      interceptor = Strategies::AbstractStrategy::RequestInterceptor
+      ActionController::Base.send(:include, interceptor)
+    end
+
+    private
+
+    def feature_reloader(app)
+      features = app.paths["config/features.rb"].existent
+      ActiveSupport::FileUpdateChecker.new(features) do
+        features.each { |path| load(path) }
+      end
+    end
+
+    def to_prepare
+      klass = defined?(ActiveSupport::Reloader) ? ActiveSupport::Reloader : ActionDispatch::Reloader
+      klass.to_prepare(&Proc.new)
+    end
+  end
+end

data/lib/flipflop/facade.rb

@@ -0,0 +1,23 @@
+module Flipflop
+  module Facade
+    extend Forwardable
+    delegate [:configure, :enabled?] => :feature_set
+    alias_method :on?, :enabled?
+
+    def feature_set
+      FeatureSet.current
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      method[-1] == "?"
+    end
+
+    def method_missing(method, *args)
+      if method[-1] == "?"
+        FeatureSet.current.enabled?(method[0..-2].to_sym)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/flipflop/feature_cache.rb

@@ -0,0 +1,64 @@
+module Flipflop
+  class FeatureCache
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) if FeatureCache.current.enabled?
+
+        FeatureCache.current.enable!
+        response = @app.call(env)
+        response[2] = Rack::BodyProxy.new(response[2]) do
+          FeatureCache.current.disable!
+        end
+        response
+      rescue Exception => err
+        FeatureCache.current.disable!
+        raise err
+      end
+    end
+
+    class << self
+      def current
+        Thread.current.thread_variable_get(:flipflop_cache) or
+        Thread.current.thread_variable_set(:flipflop_cache, new)
+      end
+
+      private :new
+    end
+
+    def initialize
+      @enabled = false
+      @cache = {}
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def clear!
+      @cache.clear
+    end
+
+    def enable!
+      @enabled = true
+    end
+
+    def disable!
+      @enabled = false
+      @cache.clear
+    end
+
+    def fetch(key)
+      if @enabled
+        @cache.fetch(key) do
+          @cache[key] = yield
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/flipflop/feature_definition.rb

@@ -0,0 +1,15 @@
+module Flipflop
+  class FeatureDefinition
+    attr_reader :key, :default, :description
+
+    def initialize(key, **options)
+      @key = key
+      @default = !!options.delete(:default) || false
+      @description = options.delete(:description) || key.to_s.humanize + "."
+    end
+
+    def name
+      key.to_s
+    end
+  end
+end

data/lib/flipflop/feature_set.rb

@@ -0,0 +1,99 @@
+module Flipflop
+  class FeatureError < StandardError
+    def initialize(feature, error)
+      super("Feature '#{feature}' #{error}.")
+    end
+  end
+
+  class StrategyError < StandardError
+    def initialize(strategy, error)
+      super("Strategy '#{strategy}' #{error}.")
+    end
+  end
+
+  class FeatureSet
+    @@lock = Monitor.new
+
+    class << self
+      def current
+        @current or @@lock.synchronize { @current ||= new }
+      end
+
+      private :new
+    end
+
+    def initialize
+      @features = {}
+      @strategies = {}
+    end
+
+    def configure
+      @@lock.synchronize do
+        initialize
+        Module.new do
+          extend Configurable
+          instance_exec(&Proc.new)
+        end
+        @features.freeze
+        @strategies.freeze
+      end
+      self
+    end
+
+    def reset!
+      @@lock.synchronize do
+        initialize
+      end
+      self
+    end
+
+    def test!(strategy = Strategies::TestStrategy.new)
+      @@lock.synchronize do
+        @strategies = { strategy.key => strategy.freeze }.freeze
+      end
+      strategy
+    end
+
+    def add(feature)
+      @@lock.synchronize do
+        @features[feature.key] = feature.freeze
+      end
+    end
+
+    def use(strategy)
+      @@lock.synchronize do
+        @strategies[strategy.key] = strategy.freeze
+      end
+    end
+
+    def enabled?(feature)
+      FeatureCache.current.fetch(feature) do
+        result = @strategies.each_value.inject(nil) do |status, strategy|
+          break status unless status.nil?
+          strategy.enabled?(feature)
+        end
+        result.nil? ? feature(feature).default : result
+      end
+    end
+
+    def feature(feature)
+      @features.fetch(feature) do
+        raise FeatureError.new(feature, "unknown")
+      end
+    end
+
+    def features
+      @features.values
+    end
+
+    def strategy(strategy)
+      @strategies.fetch(strategy) do
+        raise StrategyError.new(strategy, "unknown")
+      end
+    end
+
+    def strategies
+      @strategies.values
+    end
+  end
+end

data/lib/flipflop/strategies/abstract_strategy.rb

@@ -0,0 +1,103 @@
+module Flipflop
+  module Strategies
+    class AbstractStrategy
+      module RequestInterceptor
+        class << self
+          def request
+            Thread.current.thread_variable_get(:flipflop_request)
+          end
+
+          def request=(request)
+            Thread.current.thread_variable_set(:flipflop_request, request)
+          end
+        end
+
+        extend ActiveSupport::Concern
+
+        included do
+          before_action do
+            RequestInterceptor.request = request
+          end
+
+          after_action do
+            RequestInterceptor.request = nil
+          end
+        end
+      end
+
+      class << self
+        def default_name
+          return "anonymous" unless name
+          name.split("::").last.gsub(/Strategy$/, "").underscore
+        end
+
+        def default_description
+        end
+      end
+
+      attr_reader :name, :description
+
+      def initialize(**options)
+        @name = (options.delete(:name) || self.class.default_name).freeze
+        @description = (options.delete(:description) || self.class.default_description).freeze
+        @hidden = !!options.delete(:hidden) || false
+        if options.any?
+          raise StrategyError.new(name, "did not understand option #{options.keys.map(&:inspect) * ', '}")
+        end
+      end
+
+      def hidden?
+        @hidden
+      end
+
+      def key
+        # TODO: Object ID changes if the feature definitions are reloaded. Maybe
+        # we can use the index instead?
+        object_id.to_s
+      end
+
+      # Return true iff this strategy is able to switch features on/off.
+      # Return false otherwise.
+      def switchable?
+        false
+      end
+
+      # Return true iff the given feature symbol is explicitly enabled.
+      # Return false iff the given feature symbol is explicitly disabled.
+      # Return nil iff the given feature symbol is unknown by this strategy.
+      def enabled?(feature)
+        raise NotImplementedError
+      end
+
+      # Enable/disable (true/false) the given feature symbol explicitly.
+      def switch!(feature, enabled)
+        raise NotImplementedError
+      end
+
+      # Remove the feature symbol from this strategy. It should no longer be
+      # recognized afterwards: enabled?(feature) will return nil.
+      def clear!(feature)
+        raise NotImplementedError
+      end
+
+      # Optional. Remove all features, so that no feature is known.
+      def reset!
+        raise NotImplementedError
+      end
+
+      protected
+
+      # Returns the request. Raises if no request is available, for example if
+      # the strategy was used outside of a request context.
+      def request
+        RequestInterceptor.request or
+          raise StrategyError.new(name, "required request, but was used outside request context")
+      end
+
+      # Returns true iff a request is available.
+      def request?
+        !RequestInterceptor.request.nil?
+      end
+    end
+  end
+end

data/lib/flipflop/strategies/active_record_strategy.rb

@@ -0,0 +1,43 @@
+module Flipflop
+  module Strategies
+    class ActiveRecordStrategy < AbstractStrategy
+      class << self
+        def default_description
+          "Stores features in database. Applies to all users."
+        end
+      end
+
+      def initialize(**options)
+        @class = options.delete(:class) || "Flipflop::Feature"
+        if !@class.kind_of?(Class)
+          @class = ActiveSupport::Inflector.constantize(@class.to_s)
+        end
+        super(**options)
+      end
+
+      def switchable?
+        true
+      end
+
+      def enabled?(feature)
+        find(feature).first.try(:enabled?)
+      end
+
+      def switch!(feature, enabled)
+        record = find(feature).first_or_initialize
+        record.enabled = enabled
+        record.save!
+      end
+
+      def clear!(feature)
+        find(feature).first.try(:destroy)
+      end
+
+      protected
+
+      def find(feature)
+        @class.where(key: feature.to_s)
+      end
+    end
+  end
+end

data/lib/flipflop/strategies/cookie_strategy.rb

@@ -0,0 +1,44 @@
+module Flipflop
+  module Strategies
+    class CookieStrategy < AbstractStrategy
+      class << self
+        def default_description
+          "Stores features in a browser cookie. Applies to current user."
+        end
+      end
+
+      def initialize(**options)
+        # TODO: Support :expires as a runtime-evaluated option?
+        @options = options.extract!(:path, :domain, :secure, :httponly).freeze
+        super(**options)
+      end
+
+      def switchable?
+        request?
+      end
+
+      def enabled?(feature)
+        return unless request?
+        return unless request.cookie_jar.has_key?(cookie_name(feature))
+        cookie = request.cookie_jar[cookie_name(feature)]
+        cookie_value = cookie.is_a?(Hash) ? cookie["value"] : cookie
+        cookie_value === "1"
+      end
+
+      def switch!(feature, enabled)
+        value = @options.merge(value: enabled ? "1" : "0")
+        request.cookie_jar[cookie_name(feature)] = value
+      end
+
+      def clear!(feature)
+        request.cookie_jar.delete(cookie_name(feature), **@options)
+      end
+
+      protected
+
+      def cookie_name(feature)
+        :"flipflop_#{feature}"
+      end
+    end
+  end
+end

data/lib/flipflop/strategies/default_strategy.rb

@@ -0,0 +1,15 @@
+module Flipflop
+  module Strategies
+    class DefaultStrategy < AbstractStrategy
+      class << self
+        def default_description
+          "Uses feature default status."
+        end
+      end
+
+      def enabled?(feature)
+        FeatureSet.current.feature(feature).default
+      end
+    end
+  end
+end

data/lib/flipflop/strategies/lambda_strategy.rb

@@ -0,0 +1,25 @@
+module Flipflop
+  module Strategies
+    class LambdaStrategy < AbstractStrategy
+      class << self
+        def default_description
+          "Resolves feature settings with custom code."
+        end
+      end
+
+      def initialize(**options)
+        @lambda = (options.delete(:lambda) || ->(*) { }).freeze
+        super(**options)
+        if @lambda.arity.abs != 1
+          raise StrategyError.new(name, "has lambda with arity #{@lambda.arity}, expected 1 or -1")
+        end
+      end
+
+      def enabled?(feature)
+        result = instance_exec(feature, &@lambda)
+        return result if result.nil? or result == !!result
+        raise StrategyError.new(name, "returned invalid result #{result.inspect} for feature '#{feature}'")
+      end
+    end
+  end
+end

data/lib/flipflop/strategies/query_string_strategy.rb

@@ -0,0 +1,17 @@
+module Flipflop
+  module Strategies
+    class QueryStringStrategy < AbstractStrategy
+      class << self
+        def default_description
+          "Interprets query string parameters as features."
+        end
+      end
+
+      def enabled?(feature)
+        return unless request?
+        return unless request.params.has_key?(feature)
+        request.params[feature].to_s != "0"
+      end
+    end
+  end
+end

data/lib/flipflop/strategies/session_strategy.rb

@@ -0,0 +1,29 @@
+module Flipflop
+  module Strategies
+    class SessionStrategy < AbstractStrategy
+      class << self
+        def default_description
+          "Stores features in the user session. Applies to current user."
+        end
+      end
+
+      def switchable?
+        request?
+      end
+
+      def enabled?(feature)
+        return unless request?
+        return unless request.session.has_key?(feature)
+        request.session[feature]
+      end
+
+      def switch!(feature, enabled)
+        request.session[feature] = enabled
+      end
+
+      def clear!(feature)
+        request.session.delete(feature)
+      end
+    end
+  end
+end

data/lib/flipflop/strategies/test_strategy.rb

@@ -0,0 +1,40 @@
+module Flipflop
+  module Strategies
+    class TestStrategy < AbstractStrategy
+      @@lock = Mutex.new
+
+      def initialize(**options)
+        @features = {}
+        super(**options)
+      end
+
+      def switchable?
+        true
+      end
+
+      def enabled?(feature)
+        @@lock.synchronize do
+          @features[feature]
+        end
+      end
+
+      def switch!(feature, enabled)
+        @@lock.synchronize do
+          @features[feature] = enabled
+        end
+      end
+
+      def clear!(feature)
+        @@lock.synchronize do
+          @features.delete(feature)
+        end
+      end
+
+      def reset!
+        @@lock.synchronize do
+          @features.clear
+        end
+      end
+    end
+  end
+end

data/lib/flipflop/version.rb

@@ -0,0 +1,3 @@
+module Flipflop
+  VERSION = "2.0.0"
+end

data/lib/flipflop.rb

@@ -0,0 +1,26 @@
+require "active_support/concern"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/try"
+require "active_support/inflector"
+
+require "flipflop/configurable"
+require "flipflop/facade"
+require "flipflop/feature_cache"
+require "flipflop/feature_definition"
+require "flipflop/feature_set"
+
+require "flipflop/strategies/abstract_strategy"
+require "flipflop/strategies/active_record_strategy"
+require "flipflop/strategies/cookie_strategy"
+require "flipflop/strategies/default_strategy"
+require "flipflop/strategies/lambda_strategy"
+require "flipflop/strategies/query_string_strategy"
+require "flipflop/strategies/session_strategy"
+require "flipflop/strategies/test_strategy"
+
+require "flipflop/engine" if defined?(Rails)
+
+module Flipflop
+  extend Facade
+end

data/lib/generators/flipflop/features/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a Flipflop features configuration file for your application.
+
+Example:
+    rails generate flipflop:features
+
+    This will create:
+        config/features.rb

data/lib/generators/flipflop/features/features_generator.rb

@@ -0,0 +1,7 @@
+class Flipflop::FeaturesGenerator < Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+
+  def copy_features_file
+    copy_file "features.rb", "config/features.rb"
+  end
+end