flipper 0.4.0 → 0.5.0

data/lib/flipper/gate.rb

@@ -1,5 +1,4 @@
 require 'forwardable'
-require 'flipper/key'
 require 'flipper/instrumenters/noop'
 
 module Flipper
@@ -10,16 +9,14 @@ module Flipper
     InstrumentationName = "gate_operation.#{InstrumentationNamespace}"
 
     # Private
-    attr_reader :feature
+    attr_reader :feature_name
 
     # Private: What is used to instrument all the things.
     attr_reader :instrumenter
 
-    def_delegator :@feature, :adapter
-
     # Public
-    def initialize(feature, options = {})
-      @feature = feature
+    def initialize(feature_name, options = {})
+      @feature_name = feature_name
       @instrumenter = options.fetch(:instrumenter, Flipper::Instrumenters::Noop)
     end
 
@@ -28,26 +25,29 @@ module Flipper
       raise 'Not implemented'
     end
 
-    # Private: The piece of the adapter key that is unique to the gate class.
-    # Implemented in subclass.
+    # Private: Name converted to value safe for adapter. Implemented in subclass.
     def key
       raise 'Not implemented'
     end
 
-    # Internal: The key where details about this gate can be retrieved from the
-    # adapter.
-    def adapter_key
-      @key ||= Key.new(@feature.name, key)
+    def data_type
+      raise 'Not implemented'
+    end
+
+    def enable(thing)
+      raise 'Not implemented'
+    end
+
+    def disable(thing)
+      raise 'Not implemented'
     end
 
-    # Internal: The toggle class to use for this gate.
-    def toggle_class
-      Toggles::Value
+    def enabled?(value)
+      raise 'Not implemented'
     end
 
-    # Internal: The toggle to use to enable/disable this gate.
-    def toggle
-      @toggle ||= toggle_class.new(self)
+    def description(value)
+      raise 'Not implemented'
     end
 
     # Internal: Check if a gate is open for a thing. Implemented in subclass.
@@ -64,33 +64,16 @@ module Flipper
       false
     end
 
-    # Internal: Enable this gate for a thing.
-    #
-    # Returns the result of Flipper::Toggle#enable.
-    def enable(thing)
-      toggle.enable(thing)
-    end
-
-    # Internal: Disable this gate for a thing.
-    #
-    # Returns the result of Flipper::Toggle#disable.
-    def disable(thing)
-      toggle.disable(thing)
-    end
-
-    def enabled?
-      toggle.enabled?
+    # Internal: Allows gate to wrap thing using one of the supported flipper
+    # types so adapters always get something that responds to value.
+    def wrap(thing)
+      thing
     end
 
     # Public: Pretty string version for debugging.
     def inspect
       attributes = [
-        "feature=#{feature.name.inspect}",
-        "description=#{description.inspect}",
-        "adapter=#{adapter.name.inspect}",
-        "adapter_key=#{adapter_key.inspect}",
-        "toggle_class=#{toggle_class.inspect}",
-        "toggle_value=#{toggle.value.inspect}",
+        "feature_name=#{feature_name.inspect}",
       ]
       "#<#{self.class.name}:#{object_id} #{attributes.join(', ')}>"
     end
@@ -101,7 +84,7 @@ module Flipper
         :thing => thing,
         :operation => operation,
         :gate_name => name,
-        :feature_name => @feature.name,
+        :feature_name => @feature_name,
       }
 
       @instrumenter.instrument(InstrumentationName, payload) {

data/lib/flipper/gates/actor.rb

@@ -6,27 +6,39 @@ module Flipper
         :actor
       end
 
-      # Internal: The piece of the adapter key that is unique to the gate class.
+      # Internal: Name converted to value safe for adapter.
       def key
         :actors
       end
 
-      # Internal: The toggle class used to enable/disable the gate for a thing.
-      def toggle_class
-        Toggles::Set
+      def data_type
+        :set
+      end
+
+      def description(value)
+        if enabled?(value)
+          actor_ids = value.to_a.sort.map { |id| id.inspect }
+          "actors (#{actor_ids.join(', ')})"
+        else
+          'disabled'
+        end
+      end
+
+      def enabled?(value)
+        !value.nil? && !value.empty?
       end
 
       # Internal: Checks if the gate is open for a thing.
       #
       # Returns true if gate open for thing, false if not.
-      def open?(thing)
+      def open?(thing, value)
         instrument(:open?, thing) { |payload|
           if thing.nil?
             false
           else
-            if Types::Actor.wrappable?(thing)
-              actor = Types::Actor.wrap(thing)
-              enabled_actor_ids = toggle.value
+            if protects?(thing)
+              actor = wrap(thing)
+              enabled_actor_ids = value
               enabled_actor_ids.include?(actor.value)
             else
               false
@@ -35,24 +47,12 @@ module Flipper
         }
       end
 
-      def protects?(thing)
-        Types::Actor.wrappable?(thing)
-      end
-
-      def enable(thing)
-        super Types::Actor.wrap(thing)
+      def wrap(thing)
+        Types::Actor.wrap(thing)
       end
 
-      def disable(thing)
-        super Types::Actor.wrap(thing)
-      end
-
-      def description
-        if enabled?
-          "actors (#{toggle.value.to_a.sort.join(', ')})"
-        else
-          'disabled'
-        end
+      def protects?(thing)
+        Types::Actor.wrappable?(thing)
       end
     end
   end

data/lib/flipper/gates/boolean.rb

@@ -1,39 +1,52 @@
 module Flipper
   module Gates
     class Boolean < Gate
+      TruthMap = {
+        true    => true,
+        false   => false,
+        'true'  => true,
+        'false' => false,
+      }
+
       # Internal: The name of the gate. Used for instrumentation, etc.
       def name
         :boolean
       end
 
-      # Internal: The piece of the adapter key that is unique to the gate class.
+      # Internal: Name converted to value safe for adapter.
       def key
         :boolean
       end
 
-      # Internal: The toggle class used to enable/disable the gate for a thing.
-      def toggle_class
-        Toggles::Boolean
+      def data_type
+        :boolean
+      end
+
+      def description(value)
+        if enabled?(value)
+          'Enabled'
+        else
+          'Disabled'
+        end
+      end
+
+      def enabled?(value)
+        !!TruthMap[value]
       end
 
       # Internal: Checks if the gate is open for a thing.
       #
-      # Returns true if gate open for thing, false if not.
-      def open?(thing)
-        instrument(:open?, thing) { |payload| toggle.value }
+      # Returns true if explicitly set to true, false if explicitly set to false
+      # or nil if not explicitly set.
+      def open?(thing, value)
+        instrument(:open?, thing) { |payload|
+          !!TruthMap[value]
+        }
       end
 
       def protects?(thing)
         thing.is_a?(Flipper::Types::Boolean)
       end
-
-      def description
-        if enabled?
-          'Enabled'
-        else
-          'Disabled'
-        end
-      end
     end
   end
 end

data/lib/flipper/gates/group.rb

@@ -6,25 +6,44 @@ module Flipper
         :group
       end
 
-      # Internal: The piece of the adapter key that is unique to the gate class.
+      # Internal: Name converted to value safe for adapter.
       def key
         :groups
       end
 
-      # Internal: The toggle class used to enable/disable the gate for a thing.
-      def toggle_class
-        Toggles::Set
+      def data_type
+        :set
+      end
+
+      def description(value)
+        if enabled?(value)
+          group_names = value.to_a.sort.map { |name| name.to_sym.inspect }
+          "groups (#{group_names.join(', ')})"
+        else
+          'disabled'
+        end
+      end
+
+      def enabled?(value)
+        !value.nil? && !value.empty?
       end
 
       # Internal: Checks if the gate is open for a thing.
       #
       # Returns true if gate open for thing, false if not.
-      def open?(thing)
+      def open?(thing, value)
         instrument(:open?, thing) { |payload|
           if thing.nil?
             false
           else
-            enabled_groups.any? { |group| group.match?(thing) }
+            value.any? { |name|
+              begin
+                group = Flipper.group(name)
+                group.match?(thing)
+              rescue GroupNotRegistered
+                false
+              end
+            }
           end
         }
       end
@@ -32,34 +51,6 @@ module Flipper
       def protects?(thing)
         thing.is_a?(Flipper::Types::Group)
       end
-
-      def description
-        if enabled?
-          "groups (#{toggle.value.to_a.sort.join(', ')})"
-        else
-          'disabled'
-        end
-      end
-
-      # Private: Get all the enabled groups for this gate.
-      #
-      # Returns an Array of Flipper::Types::Group instances.
-      def enabled_groups
-        enabled_group_names.map { |name|
-          begin
-            Flipper.group(name)
-          rescue GroupNotRegistered
-            nil
-          end
-        }.compact
-      end
-
-      # Private: Get all the names of enabled groups.
-      #
-      # Returns a Set of the enabled group names.
-      def enabled_group_names
-        toggle.value
-      end
     end
   end
 end

data/lib/flipper/gates/percentage_of_actors.rb

@@ -8,21 +8,37 @@ module Flipper
         :percentage_of_actors
       end
 
-      # Internal: The piece of the adapter key that is unique to the gate class.
+      # Internal: Name converted to value safe for adapter.
       def key
-        :perc_actors
+        :percentage_of_actors
+      end
+
+      def data_type
+        :integer
+      end
+
+      def description(value)
+        if enabled?(value)
+          "#{value}% of actors"
+        else
+          'disabled'
+        end
+      end
+
+      def enabled?(value)
+        !value.nil? && value.to_i > 0
       end
 
       # Internal: Checks if the gate is open for a thing.
       #
       # Returns true if gate open for thing, false if not.
-      def open?(thing)
+      def open?(thing, value)
         instrument(:open?, thing) { |payload|
-          percentage = toggle.value.to_i
+          percentage = value.to_i
 
           if Types::Actor.wrappable?(thing)
             actor = Types::Actor.wrap(thing)
-            key = "#{@feature.name}#{actor.value}"
+            key = "#{@feature_name}#{actor.value}"
             Zlib.crc32(key) % 100 < percentage
           else
             false
@@ -33,14 +49,6 @@ module Flipper
       def protects?(thing)
         thing.is_a?(Flipper::Types::PercentageOfActors)
       end
-
-      def description
-        if enabled?
-          "#{toggle.value}% of actors"
-        else
-          'disabled'
-        end
-      end
     end
   end
 end

data/lib/flipper/gates/percentage_of_random.rb

@@ -6,17 +6,33 @@ module Flipper
         :percentage_of_random
       end
 
-      # Internal: The piece of the adapter key that is unique to the gate class.
+      # Internal: Name converted to value safe for adapter.
       def key
-        :perc_time
+        :percentage_of_random
+      end
+
+      def data_type
+        :integer
+      end
+
+      def description(value)
+        if enabled?(value)
+          "#{value}% of the time"
+        else
+          'disabled'
+        end
+      end
+
+      def enabled?(value)
+        !value.nil? && value.to_i > 0
       end
 
       # Internal: Checks if the gate is open for a thing.
       #
       # Returns true if gate open for thing, false if not.
-      def open?(thing)
+      def open?(thing, value)
         instrument(:open?, thing) { |payload|
-          percentage = toggle.value.to_i
+          percentage = value.to_i
 
           rand < (percentage / 100.0)
         }
@@ -25,14 +41,6 @@ module Flipper
       def protects?(thing)
         thing.is_a?(Flipper::Types::PercentageOfRandom)
       end
-
-      def description
-        if enabled?
-          "#{toggle.value}% of the time"
-        else
-          'disabled'
-        end
-      end
     end
   end
 end