flipflop 2.2.1 → 2.3.0

data/config/locales/en.yml

@@ -0,0 +1,34 @@
+en:
+  flipflop:
+    title: "%{application} Features"
+    feature: "Feature"
+    description: "Description"
+
+    feature_states:
+      enabled: "on"
+      disabled: "off"
+
+    clear: "clear"
+
+    # You can optionally translate the names of the chosen features, feature
+    # groups and strategies:
+
+    groups:
+      default: "Other features"
+
+    # groups:
+    #   design_improvements: "Design improvements"
+
+    # features:
+    #   world_domination: "World domination"
+    #   world_domination_description: "Take over the world!"
+
+    # strategies:
+    #   cookie: "Cookie"
+    #   active_record: "Active record"
+    #   default: "Default"
+    #   lambda: "Lambda"
+    #   query_string: "Query string"
+    #   redis: "Redis"
+    #   session: "Session"
+    #   test: "Test"

data/flipflop.gemspec

@@ -14,12 +14,7 @@ Gem::Specification.new do |s|
   s.license  = "MIT"
 
   s.add_dependency("activesupport", ">= 4.0")
-if ENV["CONTINUOUS_INTEGRATION"]
-  s.files         = `git ls-files`.split("\n").map { |f| f.sub(".scss", ".css") }
-else
-  s.add_dependency("bootstrap", "= 4.0.0.alpha3")
   s.files         = `git ls-files`.split("\n")
-end
   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"]

data/lib/flipflop/configurable.rb

@@ -1,6 +1,16 @@
 module Flipflop
   module Configurable
+    attr_accessor :current_group
+
+    def group(group)
+      self.current_group = GroupDefinition.new(group)
+      yield
+    ensure
+      self.current_group = nil
+    end
+
     def feature(feature, **options)
+      options = options.merge(group: current_group)
       feature = FeatureDefinition.new(feature, **options)
       FeatureSet.current.add(feature)
     end

data/lib/flipflop/engine.rb

@@ -4,23 +4,24 @@ module Flipflop
 
     isolate_namespace Flipflop
 
+    # The following middleware needs to be inserted for this engine, because it
+    # may not be available in Rails API only apps.
+    middleware.use Rack::MethodOverride
+    middleware.use ActionDispatch::Cookies
+
     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")
+      FeatureLoader.current.append(app)
     end
 
-    initializer "flipflop.features_reloader" do |app|
-      app.reloaders.push(reloader = feature_reloader(app))
+    initializer "flipflop.features_loader" do |app|
+      app.reloaders.push(FeatureLoader.current)
       to_prepare do
-        reloader.execute
+        FeatureLoader.current.execute
       end
     end
 
@@ -37,6 +38,7 @@ 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)
     end
 
     def run_tasks_blocks(app)
@@ -47,13 +49,6 @@ module Flipflop
 
     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)

data/lib/flipflop/feature_definition.rb

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

data/lib/flipflop/feature_loader.rb

@@ -0,0 +1,40 @@
+module Flipflop
+  class FeatureLoader
+    @@lock = Monitor.new
+
+    class << self
+      def current
+        @current or @@lock.synchronize { @current ||= new }
+      end
+
+      private :new
+    end
+
+    extend Forwardable
+    delegate [:execute, :updated?] => :checker
+
+    def initialize
+      @paths = []
+    end
+
+    def append(engine)
+      @paths.concat(engine.paths.add("config/features.rb".freeze).existent)
+    end
+
+    private
+
+    def checker
+      @checker or @@lock.synchronize do
+        @checker ||= ActiveSupport::FileUpdateChecker.new(@paths) { reload! }
+      end
+    end
+
+    def reload!
+      @@lock.synchronize do
+        Flipflop::FeatureSet.current.replace do
+          @paths.each { |path| Kernel.load(path) }
+        end
+      end
+    end
+  end
+end

data/lib/flipflop/feature_set.rb

@@ -28,21 +28,19 @@ module Flipflop
     end
 
     def configure
-      @@lock.synchronize do
-        initialize
-        Module.new do
-          extend Configurable
-          instance_exec(&Proc.new)
-        end
-        @features.freeze
-        @strategies.freeze
+      Module.new do
+        extend Configurable
+        instance_exec(&Proc.new)
       end
       self
     end
 
-    def reset!
+    def replace
       @@lock.synchronize do
         initialize
+        yield if block_given?
+        @features.freeze
+        @strategies.freeze
       end
       self
     end

data/lib/flipflop/group_definition.rb

@@ -0,0 +1,11 @@
+module Flipflop
+  class GroupDefinition
+    attr_reader :key, :name, :title
+
+    def initialize(key)
+      @key = key
+      @name = @key.to_s.freeze
+      @title = @name.humanize.freeze
+    end
+  end
+end

data/lib/flipflop/strategies/abstract_strategy.rb

@@ -35,7 +35,7 @@ module Flipflop
         end
       end
 
-      attr_reader :key, :name, :description
+      attr_reader :key, :name, :title, :description
 
       def initialize(**options)
         # Generate key before setting instance that should be excluded from
@@ -43,6 +43,7 @@ module Flipflop
         @key = OptionsHasher.new(self).generate
 
         @name = (options.delete(:name) || self.class.default_name).freeze
+        @title = @name.humanize.freeze
         @description = (options.delete(:description) || self.class.default_description).freeze
         @hidden = !!options.delete(:hidden) || false
 

data/lib/flipflop/version.rb

@@ -1,3 +1,3 @@
 module Flipflop
-  VERSION = "2.2.1"
+  VERSION = "2.3.0"
 end

data/lib/flipflop.rb

@@ -8,7 +8,9 @@ require "flipflop/configurable"
 require "flipflop/facade"
 require "flipflop/feature_cache"
 require "flipflop/feature_definition"
+require "flipflop/feature_loader"
 require "flipflop/feature_set"
+require "flipflop/group_definition"
 
 require "flipflop/strategies/abstract_strategy"
 require "flipflop/strategies/options_hasher"

data/lib/test_engine/config/features.rb

@@ -0,0 +1,3 @@
+Flipflop.configure do
+  feature :engine_feature
+end

data/lib/test_engine/test_engine.rb

@@ -0,0 +1,7 @@
+class TestEngine < Rails::Engine
+  config.root = "lib/test_engine"
+
+  initializer "features" do
+    Flipflop::FeatureLoader.current.append(self)
+  end
+end

data/src/stylesheets/_flipflop.scss

@@ -0,0 +1,160 @@
+$enable-transitions: true;
+$grid-gutter-width-base: 0;
+
+@import "bootstrap/variables";
+@import "bootstrap/mixins";
+@import "bootstrap/normalize";
+@import "bootstrap/print";
+
+@import "bootstrap/reboot";
+@import "bootstrap/type";
+@import "bootstrap/tables";
+@import "bootstrap/buttons";
+
+@import "bootstrap/button-group";
+@import "bootstrap/badge";
+
+@import "bootstrap/utilities/spacing";
+
+section.flipflop {
+  @include make-container(); /* @extend .container-fluid; */
+  margin: 5rem 0 0;
+
+  h1 {
+    padding: 0 1.4rem;
+  }
+
+  table {
+    @extend .table;
+
+    td:first-child {
+      padding-left: 1.5rem;
+    }
+
+    td:last-child {
+      padding-right: 1.5rem;
+    }
+
+    thead {
+      @extend .thead-inverse;
+
+      tr {
+        th {
+          position: relative;
+          cursor: default;
+
+          &[data-tooltip]:before, &[data-tooltip]:after {
+            @include transition(all 0.2s ease-out);
+            transform: translateY(0.2rem) translateZ(0);
+            opacity: 0;
+
+            display: block;
+            position: absolute;
+          }
+
+          &[data-tooltip]:before {
+            content: attr(data-tooltip);
+            width: 98%;
+            left: 0;
+            bottom: 3.75rem;
+            margin: 0;
+            padding: 0.5rem 0.75rem;
+            background: $gray;
+            border-radius: 0.2rem;
+            font-size: 0.875rem;
+            font-weight: normal;
+            pointer-events: none;
+          }
+
+          &[data-tooltip]:after {
+            content: " ";
+            width: 0;
+            height: 0;
+            left: 1rem;
+            bottom: 3.25rem;
+            border-left: solid transparent 0.5rem;
+            border-right: solid transparent 0.5rem;
+            border-top: solid $gray 0.5rem;
+          }
+
+          &:hover {
+            &[data-tooltip]:before, &[data-tooltip]:after {
+              transform: translateY(0) translateZ(0);
+              opacity: 1;
+            }
+          }
+        }
+      }
+    }
+
+    tbody {
+      tr {
+        td.status {
+          width: 2.2rem;
+          font-size: 1.1rem;
+
+          span.enabled, span.disabled {
+            width: 2rem;
+            @extend .badge;
+            @extend .badge-pill;
+            span {
+              width: auto;
+              text-align: center;
+              margin: 0 -2rem;
+            }
+          }
+
+          span.enabled { @extend .badge-success; }
+          span.disabled { @extend .badge-default; }
+        }
+
+        td.name {
+          min-width: 12rem;
+          padding-top: 0.9rem;
+          font-weight: bold;
+        }
+
+        td.description {
+          min-width: 12rem;
+          padding-top: 0.9rem;
+        }
+
+        td.toggle {
+          min-width: 10rem;
+
+          div.toolbar {
+            @extend .btn-toolbar;
+            margin-left: 0;
+
+            div.group {
+              @extend .mr-2;
+              @extend .btn-group;
+              @extend .btn-group-sm;
+
+              button {
+                @extend .btn;
+                @extend .btn-sm;
+                cursor: pointer;
+                &.active { @extend .btn-primary; }
+                &:not(.active) { @extend .btn-secondary; }
+              }
+            }
+          }
+        }
+
+        &.group {
+          background-color: $table-bg-accent;
+
+          td {
+            h2 {
+              margin: 0;
+              line-height: inherit;
+              font-size: 1.4rem;
+              font-weight: bold;
+            }
+          }
+        }
+      }
+    }
+  }
+}

data/test/integration/app_test.rb

@@ -1,36 +1,65 @@
 require File.expand_path("../../test_helper", __FILE__)
 
 describe Flipflop do
-  before do
-    @app = TestApp.new
-  end
+  describe "without engine" do
+    before do
+      @app = TestApp.new
+    end
 
-  subject do
-    @app
-  end
+    after do
+      @app.unload!
+    end
 
-  after do
-    Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
-  end
+    subject do
+      @app
+    end
 
-  describe "middleware" do
-    it "should include cache middleware" do
-      middlewares = Rails.application.middleware.map(&:klass)
-      assert_includes middlewares, Flipflop::FeatureCache::Middleware
+    describe "middleware" do
+      it "should include cache middleware" do
+        middlewares = Rails.application.middleware.map(&:klass)
+        assert_includes middlewares, Flipflop::FeatureCache::Middleware
+      end
+    end
+
+    describe "module" do
+      before do
+        Flipflop::FeatureSet.current.instance_variable_set(:@features, {})
+        Module.new do
+          extend Flipflop::Configurable
+          feature :world_domination
+        end
+      end
+
+      it "should allow querying for app features" do
+        assert_equal false, Flipflop.world_domination?
+      end
     end
   end
 
-  describe "module" do
+  describe "with engine" do
     before do
-      Flipflop::FeatureSet.current.instance_variable_set(:@features, {})
-      Module.new do
-        extend Flipflop::Configurable
-        feature :world_domination
-      end
+      @app = TestApp.new([
+        TestFeaturesGenerator,
+        TestEngineGenerator,
+      ])
+    end
+
+    after do
+      @app.unload!
     end
 
-    it "should allow querying for features" do
-      assert_equal false, Flipflop.world_domination?
+    subject do
+      @app
+    end
+
+    describe "module" do
+      it "should allow querying for app features" do
+        assert_equal false, Flipflop.application_feature?
+      end
+
+      it "should allow querying for engine features" do
+        assert_equal false, Flipflop.engine_feature?
+      end
     end
   end
 end