flipflop 2.4.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d991f9cd5e93e4a837c0e6835da5ae2339498bf74a26fc6e21cee4503793ca6
-  data.tar.gz: 943ba8e6ea38bf2afbc45454890f8111a3b9029383018e5ddf3a76f8faac0732
+  metadata.gz: 5d280de2ff4eb5a0d3437866c2f6d08e6069564183d670cb437cc7741e7eeac3
+  data.tar.gz: e16c3770910db3cfc4a442e2094acf44426651f0456235992f8ea0166e53e6d9
 SHA512:
-  metadata.gz: a81cbf3b37f9d91ec310bc971eec5c06b2d4b0581bd42191366503782bb8d95ef6b51fef33588bd28ec571a57ebc03f51cd1c5f9514ac8151f1a855e4072e085
-  data.tar.gz: 30a184287b36b7a346cc72fb0bf4f2ed4cb59083461f3859d70d1ec9908c37b3c1b65e54dc3536ed472fed85f94465ea191c6d4eeb7b049679b4056cb3585b05
+  metadata.gz: b2ab3024b4106125d0f67a6333c5d2fc6b6e32d744e3fca9775894e9291cca0e2ecb3b74d6343598fc91c44cf0077b7496e79dade91fa27ce6418bb7fb3a534a
+  data.tar.gz: 6c55c846ba7759fa595485283a8d7d5eeaeb919e238a5752310b8bbfb6915f486cf4f750ab96acef3ec94da4295dab144fd6673e5802a0b26d4b3481d16654ba

data/.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 cache: bundler
 rvm:
 - 2.5.0
-- 2.4.2
+- 2.4.4
 - 2.3.5
 - jruby-9.1.13.0
 - ruby-head
@@ -18,16 +18,12 @@ env:
 - RAILS_VERSION=5.0 RAILS_API_ONLY=1
 matrix:
   include:
-  - rvm: 2.3.5
-    env: RAILS_VERSION=4.2
   - rvm: 2.2.8
     env: RAILS_VERSION=4.2
   - rvm: 2.1.10
     env: RAILS_VERSION=4.2
   - rvm: 2.0.0
     env: RAILS_VERSION=4.2
-  - rvm: 2.3.5
-    env: RAILS_VERSION=4.1
   - rvm: 2.2.8
     env: RAILS_VERSION=4.1
   - rvm: 2.1.10
@@ -35,6 +31,10 @@ matrix:
   - rvm: 2.0.0
     env: RAILS_VERSION=4.1
   exclude:
+  - rvm: 2.4.4
+    env: RAILS_VERSION=master
+  - rvm: 2.4.4
+    env: RAILS_VERSION=master RAILS_API_ONLY=1
   - rvm: 2.3.5
     env: RAILS_VERSION=master
   - rvm: 2.3.5
@@ -52,4 +52,4 @@ deploy:
   on:
     tags: true
     repo: voormedia/flipflop
-    ruby: 2.3.5
+    ruby: 2.5.0

data/CHANGES.md

@@ -1,3 +1,18 @@
+## 2.7.0
+
+* Removing .css extension from render partial and adding it to html handler to correctly render the erb file.
+  * Fixes Rails 6 & 7 deprecation: `Render file with extension is deprecated`
+  * Ruby 3.x compatible (Credits: https://github.com/voormedia/flipflop/pull/36)
+
+## 2.6.0
+
+* Failure to load strategies in test environments will result in a warning instead of an error. This should aid in running Rake tasks.
+
+## 2.5.0
+
+* Add Sequel strategy. ActiveRecord/Sequel can be used side by side.
+* Rails 6 compatibility.
+
 ## 2.4.0
 
 * Add location of feature definition.

data/Gemfile

@@ -13,7 +13,16 @@ group :test do
   gem "bootstrap", "= 4.0.0.alpha6", require: false
 
   gem "fakeredis", require: false
-  gem "sqlite3", ">= 1.3", platform: :ruby
+
+  if version == "master" || version >= "6"
+    gem "sqlite3", "~> 1.4.0", platform: :ruby
+  else
+    gem "sqlite3", "~> 1.3.6", platform: :ruby
+  end
+  if version >= "5.2" || Gem::Version.new(RUBY_VERSION) > Gem::Version.new("2.4.4")
+    gem 'sassc-rails'
+  end
+
   gem "activerecord-jdbcsqlite3-adapter", platform: :jruby,
     github: "jruby/activerecord-jdbc-adapter"
 

data/LICENSE

@@ -1,7 +1,7 @@
 The MIT License
 
 Copyright (c) 2011-2013 Learnable Pty Ltd
-Copyright (c) 2016-2017 Voormedia
+Copyright (c) 2016-2019 Voormedia
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -4,11 +4,14 @@
 
 **Flipflop** provides a declarative, layered way of enabling and disabling
 application functionality at run-time. It is originally based on
-[Flip](https://github.com/pda/flip). Compared to the original gem **Flipflop** has:
+[Flip](https://github.com/pda/flip). **Flipflop** has the following features:
+* simple configuration
+* ease of use for developers
 * an improved dashboard
+* manage features via console (using rake tasks)
 * thread safety
 * better database performance due to per-request caching, enabled by default
-* more strategies (Redis, query strings, sessions, custom code)
+* more strategies (Sequel, Redis, query strings, sessions, custom code)
 * more strategy options (cookie options, strategy names and descriptions, custom database models)
 * the ability to use the same strategy twice, with different options
 * configuration in a fixed location (`config/features.rb`) that is usable even if you don't use the database strategy
@@ -21,7 +24,7 @@ application functionality at run-time. It is originally based on
 You can configure strategy layers that will evaluate if a feature is currently
 enabled or disabled. Available strategies are:
 * a per-feature default setting
-* database (with Active Record or Redis), to flipflop features site-wide for all users
+* database (with Active Record, Sequel, or Redis), to flipflop features site-wide for all users
 * cookie or session, to flipflop features for single users
 * query string parameters, to flipflop features occasionally (in development mode for example)
 * custom strategy code
@@ -30,6 +33,19 @@ Flipflop has a dashboard interface that's easy to understand and use.
 
 [<img src="https://raw.githubusercontent.com/voormedia/flipflop/screenshots/dashboard.png" alt="Dashboard">](https://raw.githubusercontent.com/voormedia/flipflop/screenshots/dashboard.png)
 
+If you prefer, you can use the included rake tasks to enable or disable features.
+
+```
+rake flipflop:features                    # Shows features table
+rake flipflop:turn_on[feature,strategy]   # Enables a feature with the specified strategy
+rake flipflop:turn_off[feature,strategy]  # Disables a feature with the specified strategy
+rake flipflop:clear[feature,strategy]     # Clears a feature with the specified strategy
+```
+
+## Rails requirements
+
+This gem requires Rails 4, 5, 6 or 7. Using an ORM layer is entirely optional.
+
 ## Installation
 
 Add the gem to your `Gemfile`:
@@ -58,7 +74,7 @@ Features and strategies are declared in `config/features.rb`:
 Flipflop.configure do
   # Strategies will be used in the order listed here.
   strategy :cookie
-  strategy :active_record
+  strategy :active_record # or :sequel, :redis
   strategy :default
 
   # Basic feature declaration:
@@ -86,8 +102,8 @@ Feature definitions support these options:
 ## Strategies
 
 The following strategies are provided:
-* `:active_record` – Save feature settings in the database.
-    * `:class` – Provide the feature model. `Flipflop::Feature` by default (which uses the table `flipflop_features`). Honors `default_scope` when features are resolved or switched on/off.
+* `:active_record`/`:sequel` – Save feature settings in the database.
+    * `:class` – Provide the feature model. `Flipflop::Feature` by default (which is defined automatically and uses the table `flipflop_features`). The `ActiveRecord` version honors `default_scope` when features are resolved or switched on/off.
 * `:cookie` – Save feature settings in browser cookies for the current user.
     * `:prefix` – String prefix for all cookie names. Defaults to no prefix.
     * `:path` – The path for which the cookies apply. Defaults to the root of the application.

data/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/app/controllers/flipflop/features_controller.rb

@@ -25,7 +25,12 @@ module Flipflop
         @strategies = @feature_set.strategies.reject(&:hidden?)
         @grouped_features = @feature_set.features.group_by(&:group)
 
-        @application_name = Rails.application.class.parent_name.underscore.titleize
+        app_class = Rails.application.class
+        application_name = app_class.respond_to?(:module_parent_name) ?
+          app_class.module_parent_name :
+          app_class.parent_name
+
+        @application_name = application_name.underscore.titleize
       end
 
       def grouped?

data/app/views/layouts/flipflop.html.erb

@@ -2,7 +2,7 @@
 <html>
   <head>
     <title><%= yield :title -%></title>
-    <style><%= render partial: "flipflop/stylesheets/flipflop.css" %></style>
+    <style><%= render partial: "flipflop/stylesheets/flipflop" %></style>
   </head>
   <body><%= yield -%></body>
 </html>

data/flipflop.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
   s.license  = "MIT"
 
   s.add_dependency("activesupport", ">= 4.0")
+  s.add_dependency('terminal-table', '>= 1.8')
   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) }

data/lib/flipflop/configurable.rb

@@ -32,6 +32,12 @@ module Flipflop
       end
 
       FeatureSet.current.use(strategy)
+    rescue StandardError => err
+      if FeatureSet.current.raise_strategy_errors
+        raise err
+      else
+        warn "WARNING: Unable to load Flipflop strategy #{strategy}: #{err}"
+      end
     end
   end
 end

data/lib/flipflop/engine.rb

@@ -14,6 +14,12 @@ module Flipflop
 
     config.flipflop = ActiveSupport::OrderedOptions.new
 
+    initializer "flipflop.config" do |app|
+      raise_errors = config.flipflop.raise_strategy_errors
+      raise_errors = (ENV["RACK_ENV"] || ENV["RAILS_ENV"]) != "test" if raise_errors.nil?
+      FeatureSet.current.raise_strategy_errors = raise_errors
+    end
+
     initializer "flipflop.features_path" do |app|
       FeatureLoader.current.append(app)
     end
@@ -37,8 +43,13 @@ module Flipflop
 
     initializer "flipflop.request_interceptor" do |app|
       interceptor = Strategies::AbstractStrategy::RequestInterceptor
-      ActionController::Base.send(:include, interceptor)
-      ActionController::API.send(:include, interceptor) if defined?(ActionController::API)
+      ActiveSupport.on_load(:action_controller_base) do
+        ActionController::Base.send(:include, interceptor)
+      end
+
+      ActiveSupport.on_load(:action_controller_api) do
+        ActionController::API.send(:include, interceptor)
+      end
     end
 
     def run_tasks_blocks(app)
@@ -49,9 +60,9 @@ module Flipflop
 
     private
 
-    def to_prepare
+    def to_prepare(&block)
       klass = defined?(ActiveSupport::Reloader) ? ActiveSupport::Reloader : ActionDispatch::Reloader
-      klass.to_prepare(&Proc.new)
+      klass.to_prepare(&block)
     end
   end
 end

data/lib/flipflop/facade.rb

@@ -1,3 +1,5 @@
+require "forwardable"
+
 module Flipflop
   module Facade
     extend Forwardable

data/lib/flipflop/feature_set.rb

@@ -28,15 +28,17 @@ module Flipflop
       private :new
     end
 
+    attr_accessor :raise_strategy_errors
+
     def initialize
       @features = {}
       @strategies = {}
     end
 
-    def configure
+    def configure(&block)
       Module.new do
         extend Configurable
-        instance_exec(&Proc.new)
+        instance_exec(&block)
       end
       self
     end

data/lib/flipflop/strategies/active_record_strategy.rb

@@ -5,10 +5,17 @@ module Flipflop
         def default_description
           "Stores features in database. Applies to all users."
         end
+
+        def define_feature_class
+          return Flipflop::Feature if defined?(Flipflop::Feature)
+
+          model = Class.new(ActiveRecord::Base)
+          Flipflop.const_set(:Feature, model)
+        end
       end
 
       def initialize(**options)
-        @class = options.delete(:class) || ::Flipflop::Feature
+        @class = options.delete(:class) || self.class.define_feature_class
         if !@class.kind_of?(Class)
           @class = ActiveSupport::Inflector.constantize(@class.to_s)
         end

data/lib/flipflop/strategies/sequel_strategy.rb

@@ -0,0 +1,57 @@
+module Flipflop
+  module Strategies
+    class SequelStrategy < AbstractStrategy
+      class << self
+        def default_description
+          "Stores features in database. Applies to all users."
+        end
+
+        def define_feature_class
+          return Flipflop::Feature if defined?(Flipflop::Feature)
+
+          model = Class.new(Sequel::Model(:flipflop_features))
+          model.plugin(:timestamps, force: true, update_on_create: true)
+          model.raise_on_save_failure = true
+
+          Flipflop.const_set(:Feature, model)
+        end
+      end
+
+      def initialize(**options)
+        @class = options.delete(:class) || self.class.define_feature_class
+        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).try(:enabled?)
+      end
+
+      def switch!(feature, enabled)
+        record = find_or_new(feature)
+        record.enabled = enabled
+        record.save
+      end
+
+      def clear!(feature)
+        find(feature).try(:destroy)
+      end
+
+      protected
+
+      def find_or_new(feature)
+        find(feature) || @class.new(key: feature.to_s)
+      end
+
+      def find(feature)
+        @class.where(key: feature.to_s).first
+      end
+    end
+  end
+end

data/lib/flipflop/version.rb

@@ -1,3 +1,3 @@
 module Flipflop
-  VERSION = "2.4.0"
+  VERSION = "2.7.0"
 end

data/lib/flipflop.rb

@@ -22,6 +22,7 @@ require "flipflop/strategies/lambda_strategy"
 require "flipflop/strategies/query_string_strategy"
 require "flipflop/strategies/redis_strategy"
 require "flipflop/strategies/session_strategy"
+require "flipflop/strategies/sequel_strategy"
 require "flipflop/strategies/test_strategy"
 
 require "flipflop/engine" if defined?(Rails)

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

@@ -6,8 +6,10 @@ Flipflop.configure do
 
   # Other strategies:
   #
-  # strategy :query_string
+  # strategy :sequel
   # strategy :redis
+  #
+  # strategy :query_string
   # strategy :session
   #
   # strategy :my_strategy do |feature|

data/lib/generators/flipflop/install/install_generator.rb

@@ -24,6 +24,10 @@ class Flipflop::InstallGenerator < Rails::Generators::Base
 # Before filter for Flipflop dashboard. Replace with a lambda or method name
 # defined in ApplicationController to implement access control.
 config.flipflop.dashboard_access_filter = #{access_filter}
+
+# By default, when set to `nil`, strategy loading errors are suppressed in test
+# mode. Set to `true` to always raise errors, or `false` to always warn.
+config.flipflop.raise_strategy_errors = nil
 RUBY
   end
 

data/lib/tasks/flipflop.rake

@@ -0,0 +1,31 @@
+require_relative 'support/methods'
+
+namespace :flipflop do
+  # Encapsulates support methods to prevent name collision with global
+  # rake namespace
+  m = Object.new
+  m.extend Flipflop::Rake::SupportMethods
+
+  desc 'Enables a feature with the specified strategy.'
+  task :turn_on, %i[feature strategy] => :environment do |_task, args|
+    m.switch_feature! args[:feature], args[:strategy], true
+    puts "Feature :#{args[:feature]} enabled!"
+  end
+
+  desc 'Disables a feature with the specified strategy.'
+  task :turn_off, %i[feature strategy] => :environment do |_task, args|
+    m.switch_feature! args[:feature], args[:strategy], false
+    puts "Feature :#{args[:feature]} disabled!"
+  end
+
+  desc 'Clears a feature with the specified strategy.'
+  task :clear, %i[feature strategy] => :environment do |_task, args|
+    m.clear_feature! args[:feature], args[:strategy]
+    puts "Feature :#{args[:feature]} cleared!"
+  end
+
+  desc 'Shows features table'
+  task features: :environment do
+    puts m.build_features_table
+  end
+end

data/lib/tasks/support/methods.rb

@@ -0,0 +1,71 @@
+require 'terminal-table'
+
+module Flipflop
+  module Rake
+    module SupportMethods
+      def status_label(enabled)
+        enabled.nil? ? '' : (enabled ? 'ON' : 'OFF')
+      end
+
+      def switch_feature!(feature_name, strategy_name, value)
+        feature = find_feature_by_name(feature_name)
+        strategy = find_strategy_by_name(strategy_name)
+
+        if strategy.switchable?
+          strategy.switch!(feature.key, value)
+        else
+          raise "The :#{strategy_name} strategy doesn't support switching."
+        end
+      end
+
+      def clear_feature!(feature_name, strategy_name)
+        feature = find_feature_by_name(feature_name)
+        strategy = find_strategy_by_name(strategy_name)
+
+        strategy.clear!(feature.key)
+      end
+
+      def build_features_table
+        table_class.new(headings: table_header, rows: table_rows)
+      end
+
+      protected
+
+      def features
+        Flipflop.feature_set.features
+      end
+
+      def strategies
+        Flipflop.feature_set.strategies
+      end
+
+      def find_feature_by_name(name)
+        features.find { |f| f.name == name } || raise("Feature :#{name} is not defined.")
+      end
+
+      def find_strategy_by_name(name)
+        strategies.find { |s| s.name == name } || raise("Strategy :#{name} is not available.")
+      end
+
+      def table_header
+        %w[feature description] + strategies.map(&:name)
+      end
+
+      def table_class
+        Terminal::Table
+      end
+
+      def table_rows
+        features.inject([]) do |array, feature|
+          array << build_row_for(feature)
+        end
+      end
+
+      def build_row_for(feature)
+        strategies.inject([feature.name, feature.description]) do |row, strategy|
+          row << status_label(strategy.enabled?(feature.key))
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -31,6 +31,20 @@ def create_request
   request
 end
 
+def capture_stdout
+  stdout, $stdout = $stdout, StringIO.new
+  yield rescue nil
+  stdout, $stdout = $stdout, stdout
+  stdout.string
+end
+
+def capture_stderr
+  stderr, $stderr = $stderr, StringIO.new
+  yield rescue nil
+  stderr, $stderr = $stderr, stderr
+  stderr.string
+end
+
 def reload_constant(name)
   ActiveSupport::Dependencies.remove_constant(name.to_s)
   path = ActiveSupport::Dependencies.search_for_file(name.to_s.underscore).sub!(/\.rb\z/, "")
@@ -100,7 +114,11 @@ class TestApp
       quiet: true,
       api: ENV["RAILS_API_ONLY"].to_i.nonzero?,
       skip_active_job: true,
+      skip_active_storage: true,
+      skip_action_cable: true,
+      skip_bootsnap: true,
       skip_bundle: true,
+      skip_puma: true,
       skip_gemfile: true,
       skip_git: true,
       skip_javascript: true,
@@ -128,11 +146,26 @@ class TestApp
     require "rails"
     require "flipflop/engine"
 
+    ActiveSupport::Dependencies.autoloaded_constants.clear
     load File.expand_path("../../#{path}/config/application.rb", __FILE__)
     load File.expand_path("../../#{path}/config/environments/test.rb", __FILE__)
     Rails.application.config.cache_classes = false
     Rails.application.config.action_view.raise_on_missing_translations = true
     Rails.application.config.i18n.enforce_available_locales = false
+    Rails.application.config.autoloader = :classic # Disable Zeitwerk in Rails 6+
+
+    # Avoid Rails 6+ deprecation warning
+    if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter) &&
+      ActiveRecord::ConnectionAdapters::SQLite3Adapter.respond_to?(:represent_boolean_as_integer=) &&
+      Rails.application.config.active_record.sqlite3.nil?
+      Rails.application.config.active_record.sqlite3 = ActiveSupport::OrderedOptions.new
+    end
+
+    # Avoid Rails 6+ deprecation warning
+    if defined?(ActionView::Railtie::NULL_OPTION)
+      Rails.application.config.action_view.finalize_compiled_template_methods = ActionView::Railtie::NULL_OPTION
+    end
+
     Rails.application.initialize!
 
     I18n.locale = :en
@@ -143,18 +176,20 @@ class TestApp
   def migrate!
     ActiveRecord::Base.establish_connection
 
-    silence_stdout { ActiveRecord::Tasks::DatabaseTasks.create_current }
+    capture_stdout { ActiveRecord::Tasks::DatabaseTasks.create_current }
     ActiveRecord::Migration.verbose = false
 
     if defined?(ActiveRecord::Migrator.migrate)
       ActiveRecord::Migrator.migrate(Rails.application.paths["db/migrate"].to_a)
+    elsif ActiveRecord::Base.connection.respond_to?(:schema_migration)
+      ActiveRecord::MigrationContext.new(Rails.application.paths["db/migrate"], ActiveRecord::Base.connection.schema_migration).migrate
     else
-      # Rails 5.2+
       ActiveRecord::MigrationContext.new(Rails.application.paths["db/migrate"]).migrate
     end
   end
 
   def unload!
+    ENV["RAILS_ENV"] = nil
     Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
     Flipflop::FeatureLoader.instance_variable_set(:@current, nil)
 
@@ -173,12 +208,6 @@ class TestApp
 
   private
 
-  def silence_stdout
-    stdout, $stdout = $stdout, StringIO.new
-    yield rescue nil
-    $stdout = stdout
-  end
-
   def path
     "tmp/" + name
   end

data/test/unit/configurable_test.rb

@@ -1,5 +1,12 @@
 require File.expand_path("../../test_helper", __FILE__)
 
+class FailingStrategy < Flipflop::Strategies::AbstractStrategy
+  def initialize(*)
+    raise "Oops"
+  end
+end
+
+
 describe Flipflop::Configurable do
   subject do
     Flipflop::FeatureSet.current.send(:initialize)
@@ -100,5 +107,20 @@ describe Flipflop::Configurable do
       assert_equal ["awesome"],
         Flipflop::FeatureSet.current.strategies.map(&:description)
     end
+
+    it "should raise error when strategy fails to load if unsuppressed" do
+      subject
+      Flipflop::FeatureSet.current.raise_strategy_errors = true
+      assert_raises "Oops" do
+        subject.strategy(FailingStrategy)
+      end
+    end
+
+    it "should not raise error when strategy fails to load if suppressed" do
+      subject
+      Flipflop::FeatureSet.current.raise_strategy_errors = false
+      assert_equal "WARNING: Unable to load Flipflop strategy FailingStrategy: Oops\n",
+        capture_stderr { subject.strategy(FailingStrategy) }
+    end
   end
 end

data/test/unit/strategies/active_record_strategy_test.rb

@@ -6,7 +6,7 @@ class ResultSet
   end
 
   def first_or_initialize
-    @results.first or My::Feature.new(@key, false)
+    @results.first or MyAr::Feature.new(@key, false)
   end
 
   def first
@@ -14,7 +14,7 @@ class ResultSet
   end
 end
 
-module My
+module MyAr
   class Feature < Struct.new(:key, :enabled)
     class << self
       attr_accessor :results
@@ -27,11 +27,11 @@ module My
     alias_method :enabled?, :enabled
 
     def destroy
-      My::Feature.results[key] = ResultSet.new(key)
+      MyAr::Feature.results[key] = ResultSet.new(key)
     end
 
     def save!
-      My::Feature.results[key] = ResultSet.new(key, [self])
+      MyAr::Feature.results[key] = ResultSet.new(key, [self])
     end
   end
 end
@@ -39,7 +39,7 @@ end
 describe Flipflop::Strategies::ActiveRecordStrategy do
   describe "with defaults" do
     subject do
-      Flipflop::Strategies::ActiveRecordStrategy.new(class: My::Feature).freeze
+      Flipflop::Strategies::ActiveRecordStrategy.new(class: MyAr::Feature).freeze
     end
 
     it "should have default name" do
@@ -65,8 +65,8 @@ describe Flipflop::Strategies::ActiveRecordStrategy do
 
     describe "with enabled feature" do
       before do
-        My::Feature.results = {
-          one: ResultSet.new(:one, [My::Feature.new(:one, true)]),
+        MyAr::Feature.results = {
+          one: ResultSet.new(:one, [MyAr::Feature.new(:one, true)]),
         }
       end
 
@@ -87,8 +87,8 @@ describe Flipflop::Strategies::ActiveRecordStrategy do
 
     describe "with disabled feature" do
       before do
-        My::Feature.results = {
-          two: ResultSet.new(:two, [My::Feature.new(:two, false)]),
+        MyAr::Feature.results = {
+          two: ResultSet.new(:two, [MyAr::Feature.new(:two, false)]),
         }
       end
 
@@ -109,7 +109,7 @@ describe Flipflop::Strategies::ActiveRecordStrategy do
 
     describe "with unsaved feature" do
       before do
-        My::Feature.results = {
+        MyAr::Feature.results = {
           three: ResultSet.new(:three),
         }
       end
@@ -127,12 +127,12 @@ describe Flipflop::Strategies::ActiveRecordStrategy do
 
   describe "with string class name" do
     subject do
-      Flipflop::Strategies::ActiveRecordStrategy.new(class: "My::Feature").freeze
+      Flipflop::Strategies::ActiveRecordStrategy.new(class: "MyAr::Feature").freeze
     end
 
     before do
-      My::Feature.results = {
-        one: ResultSet.new(:one, [My::Feature.new(:one, true)]),
+      MyAr::Feature.results = {
+        one: ResultSet.new(:one, [MyAr::Feature.new(:one, true)]),
       }
     end
 
@@ -144,12 +144,12 @@ describe Flipflop::Strategies::ActiveRecordStrategy do
 
   describe "with symbol class name" do
     subject do
-      Flipflop::Strategies::ActiveRecordStrategy.new(class: :"My::Feature").freeze
+      Flipflop::Strategies::ActiveRecordStrategy.new(class: :"MyAr::Feature").freeze
     end
 
     before do
-      My::Feature.results = {
-        one: ResultSet.new(:one, [My::Feature.new(:one, true)]),
+      MyAr::Feature.results = {
+        one: ResultSet.new(:one, [MyAr::Feature.new(:one, true)]),
       }
     end
 

data/test/unit/strategies/cookie_strategy_test.rb

@@ -112,7 +112,7 @@ describe Flipflop::Strategies::CookieStrategy do
         subject.switch!(:one, true)
         subject.clear!(:one)
         subject.send(:request).cookie_jar.write(headers = {})
-        assert_equal "my_cookie_one=; domain=.example.com; path=/foo; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000; HttpOnly",
+        assert_equal "my_cookie_one=; domain=.example.com; path=/foo; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 GMT; HttpOnly",
           headers["Set-Cookie"]
       end
     end

data/test/unit/strategies/sequel_strategy_test.rb

@@ -0,0 +1,165 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class ResultSet
+  def initialize(key, results = [])
+    @key, @results = key, results
+  end
+
+  def first
+    @results.first
+  end
+end
+
+module MySq
+  class Feature < Struct.new(:key, :enabled)
+    class << self
+      attr_accessor :results
+
+      def where(conditions)
+        results[conditions[:key].to_sym]
+      end
+    end
+
+    alias_method :enabled?, :enabled
+
+    def initialize(key, value = false)
+      if key.kind_of?(Hash)
+        key.each { |k, v| self[k] = v.to_sym }
+      else
+        super
+      end
+    end
+
+    def destroy
+      MySq::Feature.results[key] = ResultSet.new(key)
+    end
+
+    def save
+      MySq::Feature.results[key] = ResultSet.new(key, [self])
+    end
+  end
+end
+
+describe Flipflop::Strategies::SequelStrategy do
+  describe "with defaults" do
+    subject do
+      Flipflop::Strategies::SequelStrategy.new(class: MySq::Feature).freeze
+    end
+
+    it "should have default name" do
+      assert_equal "sequel", subject.name
+    end
+
+    it "should have title derived from name" do
+      assert_equal "Sequel", subject.title
+    end
+
+    it "should have default description" do
+      assert_equal "Stores features in database. Applies to all users.",
+        subject.description
+    end
+
+    it "should be switchable" do
+      assert_equal true, subject.switchable?
+    end
+
+    it "should have unique key" do
+      assert_match /^\w+$/, subject.key
+    end
+
+    describe "with enabled feature" do
+      before do
+        MySq::Feature.results = {
+          one: ResultSet.new(:one, [MySq::Feature.new(:one, true)]),
+        }
+      end
+
+      it "should have feature enabled" do
+        assert_equal true, subject.enabled?(:one)
+      end
+
+      it "should be able to switch feature off" do
+        subject.switch!(:one, false)
+        assert_equal false, subject.enabled?(:one)
+      end
+
+      it "should be able to clear feature" do
+        subject.clear!(:one)
+        assert_nil subject.enabled?(:one)
+      end
+    end
+
+    describe "with disabled feature" do
+      before do
+        MySq::Feature.results = {
+          two: ResultSet.new(:two, [MySq::Feature.new(:two, false)]),
+        }
+      end
+
+      it "should not have feature enabled" do
+        assert_equal false, subject.enabled?(:two)
+      end
+
+      it "should be able to switch feature on" do
+        subject.switch!(:two, true)
+        assert_equal true, subject.enabled?(:two)
+      end
+
+      it "should be able to clear feature" do
+        subject.clear!(:two)
+        assert_nil subject.enabled?(:two)
+      end
+    end
+
+    describe "with unsaved feature" do
+      before do
+        MySq::Feature.results = {
+          three: ResultSet.new(:three),
+        }
+      end
+
+      it "should not know feature" do
+        assert_nil subject.enabled?(:three)
+      end
+
+      it "should be able to switch feature on" do
+        subject.switch!(:three, true)
+        assert_equal true, subject.enabled?(:three)
+      end
+    end
+  end
+
+  describe "with string class name" do
+    subject do
+      Flipflop::Strategies::SequelStrategy.new(class: "MySq::Feature").freeze
+    end
+
+    before do
+      MySq::Feature.results = {
+        one: ResultSet.new(:one, [MySq::Feature.new(:one, true)]),
+      }
+    end
+
+    it "should be able to switch feature off" do
+      subject.switch!(:one, false)
+      assert_equal false, subject.enabled?(:one)
+    end
+  end
+
+  describe "with symbol class name" do
+    subject do
+      Flipflop::Strategies::SequelStrategy.new(class: :"MySq::Feature").freeze
+    end
+
+    before do
+      MySq::Feature.results = {
+        one: ResultSet.new(:one, [MySq::Feature.new(:one, true)]),
+      }
+    end
+
+    it "should be able to switch feature off" do
+      subject.switch!(:one, false)
+      assert_equal false, subject.enabled?(:one)
+    end
+  end
+end

data/test/unit/tasks/support/methods_test.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../../../../test_helper', __FILE__)
+require File.expand_path('../../../../../lib/tasks/support/methods', __FILE__)
+
+describe Flipflop::Rake::SupportMethods do
+  subject do
+    object = Object.new
+    object.extend Flipflop::Rake::SupportMethods
+  end
+
+  describe '#status_label' do
+    it 'returns the "enabled" label when its argument is "true"' do
+      assert_equal 'ON', subject.status_label(true)
+    end
+
+    it 'returns the "disabled" label when its argument is "false"' do
+      assert_equal 'OFF', subject.status_label(false)
+    end
+
+    it 'returns the "unset" label when its argument is "nil"' do
+      assert_equal '', subject.status_label(nil)
+    end
+  end
+
+  def with_feature_and_strategy(strategy = 'Test')
+    # Stubs finder methods to avoid going into FeatureSet code.
+    feature = Flipflop::FeatureDefinition.new(:world_domination)
+    subject.stub :find_feature_by_name, feature do
+      classname = "#{strategy}Strategy"
+      strategy = Flipflop::Strategies.const_get(classname).new(name: strategy)
+      subject.stub :find_strategy_by_name, strategy do
+        yield(strategy, feature) if block_given?
+      end
+    end
+  end
+
+  describe '#switch_feature!' do
+    it 'enables a feature using a strategy' do
+      with_feature_and_strategy do |strategy, feature|
+        subject.switch_feature! 'world_domination', 'test', true
+        assert_equal true, strategy.enabled?(feature.key)
+      end
+    end
+
+    it 'disables a feature using a strategy' do
+      with_feature_and_strategy do |strategy, feature|
+        subject.switch_feature! 'world_domination', 'test', false
+        assert_equal false, strategy.enabled?(feature.key)
+      end
+    end
+
+    describe 'when the strategy is not switchable' do
+      it 'raises an error' do
+        with_feature_and_strategy 'Lambda' do |strategy, feature|
+          -> { subject.switch_feature!('world_domination', 'lambda', true) }.must_raise
+        end
+      end
+    end
+  end
+
+  describe '#clear_feature!' do
+    it 'clears a feature using a strategy' do
+      with_feature_and_strategy do |strategy, feature|
+        subject.clear_feature! 'world_domination', 'test'
+        assert_nil strategy.enabled?(feature.key)
+      end
+    end
+  end
+end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: flipflop
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Paul Annesley
 - Rolf Timmermans
 - Jippe Holwerda
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-04-26 00:00:00.000000000 Z
+date: 2022-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -26,6 +26,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
 description: Declarative API for specifying features, switchable in declaration, database
   and cookies.
 email:
@@ -43,11 +57,11 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/assets/config/manifest.js
 - app/controllers/flipflop/features_controller.rb
 - app/controllers/flipflop/strategies_controller.rb
-- app/models/flipflop/feature.rb
 - app/views/flipflop/features/index.html.erb
-- app/views/flipflop/stylesheets/_flipflop.css
+- app/views/flipflop/stylesheets/_flipflop.html.erb
 - app/views/layouts/flipflop.html.erb
 - config/features.rb
 - config/locales/en.yml
@@ -70,6 +84,7 @@ files:
 - lib/flipflop/strategies/options_hasher.rb
 - lib/flipflop/strategies/query_string_strategy.rb
 - lib/flipflop/strategies/redis_strategy.rb
+- lib/flipflop/strategies/sequel_strategy.rb
 - lib/flipflop/strategies/session_strategy.rb
 - lib/flipflop/strategies/test_strategy.rb
 - lib/flipflop/version.rb
@@ -82,6 +97,8 @@ files:
 - lib/generators/flipflop/migration/templates/create_features.rb
 - lib/generators/flipflop/routes/USAGE
 - lib/generators/flipflop/routes/routes_generator.rb
+- lib/tasks/flipflop.rake
+- lib/tasks/support/methods.rb
 - src/stylesheets/_flipflop.scss
 - test/integration/app_test.rb
 - test/integration/dashboard_test.rb
@@ -105,14 +122,16 @@ files:
 - test/unit/strategies/options_hasher_test.rb
 - test/unit/strategies/query_string_strategy_test.rb
 - test/unit/strategies/redis_strategy_test.rb
+- test/unit/strategies/sequel_strategy_test.rb
 - test/unit/strategies/session_strategy_test.rb
 - test/unit/strategies/test_strategy_test.rb
 - test/unit/strategies_controller_test.rb
+- test/unit/tasks/support/methods_test.rb
 homepage: https://github.com/voormedia/flipflop
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -127,9 +146,35 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: A feature flipflopper for Rails web applications.
-test_files: []
+test_files:
+- test/integration/app_test.rb
+- test/integration/dashboard_test.rb
+- test/templates/nl.yml
+- test/templates/test_app_features.rb
+- test/templates/test_engine.rb
+- test/templates/test_engine_features.rb
+- test/test_helper.rb
+- test/unit/configurable_test.rb
+- test/unit/feature_cache_test.rb
+- test/unit/feature_definition_test.rb
+- test/unit/feature_set_test.rb
+- test/unit/flipflop_test.rb
+- test/unit/group_definition_test.rb
+- test/unit/strategies/abstract_strategy_request_test.rb
+- test/unit/strategies/abstract_strategy_test.rb
+- test/unit/strategies/active_record_strategy_test.rb
+- test/unit/strategies/cookie_strategy_test.rb
+- test/unit/strategies/default_strategy_test.rb
+- test/unit/strategies/lambda_strategy_test.rb
+- test/unit/strategies/options_hasher_test.rb
+- test/unit/strategies/query_string_strategy_test.rb
+- test/unit/strategies/redis_strategy_test.rb
+- test/unit/strategies/sequel_strategy_test.rb
+- test/unit/strategies/session_strategy_test.rb
+- test/unit/strategies/test_strategy_test.rb
+- test/unit/strategies_controller_test.rb
+- test/unit/tasks/support/methods_test.rb

data/app/models/flipflop/feature.rb

@@ -1,4 +0,0 @@
-if defined?(ActiveRecord)
-  class Flipflop::Feature < ActiveRecord::Base
-  end
-end