flipper 0.4.0 → 0.5.0

data/lib/flipper/adapters/memoizable.rb

@@ -0,0 +1,88 @@
+require 'flipper/adapters/decorator'
+
+module Flipper
+  module Adapters
+    class Memoizable < Decorator
+      FeaturesKey = :flipper_features
+
+      # Internal
+      def self.cache
+        Thread.current[:flipper_memoize_cache] ||= {}
+      end
+
+      # Internal
+      def self.memoizing?
+        !!Thread.current[:flipper_memoize]
+      end
+
+      # Internal
+      def self.memoize=(value)
+        cache.clear
+        Thread.current[:flipper_memoize] = value
+      end
+
+      # Public
+      def initialize(adapter)
+        super(adapter)
+      end
+
+      # Public
+      def get(feature)
+        if memoizing?
+          cache.fetch(feature) { cache[feature] = super }
+        else
+          super
+        end
+      end
+
+      # Public
+      def enable(feature, gate, thing)
+        result = super
+        cache.delete(feature) if memoizing?
+        result
+      end
+
+      # Public
+      def disable(feature, gate, thing)
+        result = super
+        cache.delete(feature) if memoizing?
+        result
+      end
+
+      # Public
+      def features
+        if memoizing?
+          cache.fetch(FeaturesKey) {
+            cache[FeaturesKey] = super
+          }
+        else
+          super
+        end
+      end
+
+      # Public
+      def add(feature)
+        result = super
+        cache.delete(FeaturesKey) if memoizing?
+        result
+      end
+
+      # Internal
+      def cache
+        self.class.cache
+      end
+
+      # Internal: Turns local caching on/off.
+      #
+      # value - The Boolean that decides if local caching is on.
+      def memoize=(value)
+        self.class.memoize = value
+      end
+
+      # Internal: Returns true for using local cache, false for not.
+      def memoizing?
+        self.class.memoizing?
+      end
+    end
+  end
+end

data/lib/flipper/adapters/memory.rb

@@ -3,46 +3,128 @@ require 'set'
 module Flipper
   module Adapters
     class Memory
+      include Flipper::Adapter
+
+      FeaturesKey = :flipper_features
+
+      # Public: The name of the adapter.
+      attr_reader :name
+
       # Public
       def initialize(source = nil)
         @source = source || {}
+        @name = :memory
+      end
+
+      # Public
+      def get(feature)
+        result = {}
+
+        feature.gates.each do |gate|
+          result[gate.key] = case gate.data_type
+          when :boolean, :integer
+            read key(feature, gate)
+          when :set
+            set_members key(feature, gate)
+          else
+            raise "#{gate} is not supported by this adapter yet"
+          end
+        end
+
+        result
       end
 
       # Public
+      def enable(feature, gate, thing)
+        case gate.data_type
+        when :boolean, :integer
+          write key(feature, gate), thing.value.to_s
+        when :set
+          set_add key(feature, gate), thing.value.to_s
+        else
+          raise "#{gate} is not supported by this adapter yet"
+        end
+
+        true
+      end
+
+      # Public
+      def disable(feature, gate, thing)
+        case gate.data_type
+        when :boolean
+          feature.gates.each do |gate|
+            delete key(feature, gate)
+          end
+        when :integer
+          write key(feature, gate), thing.value.to_s
+        when :set
+          set_delete key(feature, gate), thing.value.to_s
+        else
+          raise "#{gate} is not supported by this adapter yet"
+        end
+
+        true
+      end
+
+      # Public: Adds a feature to the set of known features.
+      def add(feature)
+        features.add(feature.name.to_s)
+
+        true
+      end
+
+      # Public: The set of known features.
+      def features
+        set_members(FeaturesKey)
+      end
+
+      def inspect
+        attributes = [
+          "name=:memory",
+          "source=#{@source.inspect}",
+        ]
+        "#<#{self.class.name}:#{object_id} #{attributes.join(', ')}>"
+      end
+
+      # private
+      def key(feature, gate)
+        "#{feature.key}/#{gate.key}"
+      end
+
+      # Private
       def read(key)
         @source[key.to_s]
       end
 
-      # Public
+      # Private
       def write(key, value)
         @source[key.to_s] = value.to_s
       end
 
-      # Public
+      # Private
       def delete(key)
         @source.delete(key.to_s)
       end
 
-      # Public
+      # Private
       def set_add(key, value)
         ensure_set_initialized(key)
         @source[key.to_s].add(value.to_s)
       end
 
-      # Public
+      # Private
       def set_delete(key, value)
         ensure_set_initialized(key)
         @source[key.to_s].delete(value.to_s)
       end
 
-      # Public
+      # Private
       def set_members(key)
         ensure_set_initialized(key)
         @source[key.to_s]
       end
 
-      private
-
+      # Private
       def ensure_set_initialized(key)
         @source[key.to_s] ||= Set.new
       end

data/lib/flipper/adapters/operation_logger.rb

@@ -1,61 +1,47 @@
+require 'flipper/adapters/decorator'
+
 module Flipper
   module Adapters
     # Public: Adapter that wraps another adapter and stores the operations.
     #
-    # Useful in tests to verify calls and such.
-    class OperationLogger
+    # Useful in tests to verify calls and such. Never use outside of testing.
+    class OperationLogger < Decorator
+      Operation = Struct.new(:type, :args)
+
+      OperationTypes = [
+        :get,
+        :add,
+        :enable,
+        :disable,
+        :features
+      ]
+
+      # Internal: An array of the operations that have happened.
       attr_reader :operations
 
-      Read      = Struct.new(:key)
-      Write     = Struct.new(:key, :value)
-      Delete    = Struct.new(:key)
-      SetAdd    = Struct.new(:key, :value)
-      SetDelete = Struct.new(:key, :value)
-      SetMember = Struct.new(:key)
-
-      # Public
-      def initialize(adapter)
-        @operations = []
-        @adapter = adapter
-      end
-
-      # Public
-      def read(key)
-        @operations << Read.new(key.to_s)
-        @adapter.read key
-      end
-
       # Public
-      def write(key, value)
-        @operations << Write.new(key.to_s, value)
-        @adapter.write key, value
+      def initialize(adapter, operations = nil)
+        super(adapter)
+        @operations = operations || []
       end
 
-      # Public
-      def delete(key)
-        @operations << Delete.new(key.to_s, nil)
-        @adapter.delete key
-      end
-
-      # Public
-      def set_add(key, value)
-        @operations << SetAdd.new(key.to_s, value)
-        @adapter.set_add key, value
+      OperationTypes.each do |type|
+        class_eval <<-EOE
+          def #{type}(*args)
+            @operations << Operation.new(:#{type}, args)
+            super
+          end
+        EOE
       end
 
-      # Public
-      def set_delete(key, value)
-        @operations << SetDelete.new(key.to_s, value)
-        @adapter.set_delete key, value
-      end
-
-      # Public
-      def set_members(key)
-        @operations << SetMembers.new(key.to_s)
-        @adapter.set_members key
+      # Public: Count the number of times a certain operation happened.
+      def count(type)
+        @operations.select { |operation|
+          operation.type == type
+        }.size
       end
 
-      # Public: Clears operation log
+      # Public: Resets the operation log to empty
       def reset
         @operations.clear
       end

data/lib/flipper/decorator.rb

@@ -0,0 +1,6 @@
+require 'delegate'
+
+module Flipper
+  class Decorator < SimpleDelegator
+  end
+end

data/lib/flipper/dsl.rb

@@ -1,4 +1,5 @@
-require 'flipper/adapter'
+require 'flipper/adapters/instrumented'
+require 'flipper/adapters/memoizable'
 require 'flipper/instrumenters/noop'
 
 module Flipper
@@ -16,7 +17,13 @@ module Flipper
     #           :instrumenter - What should be used to instrument all the things.
     def initialize(adapter, options = {})
       @instrumenter = options.fetch(:instrumenter, Flipper::Instrumenters::Noop)
-      @adapter = Adapter.wrap(adapter, :instrumenter => @instrumenter)
+
+      instrumented = Flipper::Adapters::Instrumented.new(adapter, {
+        :instrumenter => @instrumenter,
+      })
+      memoized = Flipper::Adapters::Memoizable.new(instrumented)
+      @adapter = memoized
+
       @memoized_features = {}
     end
 
@@ -56,6 +63,10 @@ module Flipper
     #
     # Returns an instance of Flipper::Feature.
     def feature(name)
+      if !name.is_a?(String) && !name.is_a?(Symbol)
+        raise ArgumentError, "#{name} must be a String or Symbol"
+      end
+
       @memoized_features[name.to_sym] ||= Feature.new(name, @adapter, {
         :instrumenter => instrumenter,
       })
@@ -68,6 +79,22 @@ module Flipper
     # Returns an instance of Flipper::Feature.
     alias_method :[], :feature
 
+    # Public: Shortcut for getting a boolean type instance.
+    #
+    # value - The true or false value for the boolean.
+    #
+    # Returns a Flipper::Types::Boolean instance.
+    def boolean(value = true)
+      Types::Boolean.new(value)
+    end
+
+    # Public: Event shorter shortcut for getting a boolean type instance.
+    #
+    # value - The true or false value for the boolean.
+    #
+    # Returns a Flipper::Types::Boolean instance.
+    alias_method :bool, :boolean
+
     # Public: Access a flipper group by name.
     #
     # name - The String or Symbol name of the feature.

data/lib/flipper/feature.rb

@@ -1,7 +1,5 @@
-require 'flipper/adapter'
 require 'flipper/errors'
 require 'flipper/type'
-require 'flipper/toggle'
 require 'flipper/gate'
 require 'flipper/instrumenters/noop'
 
@@ -13,6 +11,9 @@ module Flipper
     # Internal: The name of the feature.
     attr_reader :name
 
+    # Internal: Name converted to value safe for adapter.
+    attr_reader :key
+
     # Private: The adapter this feature should use.
     attr_reader :adapter
 
@@ -29,29 +30,36 @@ module Flipper
     #
     def initialize(name, adapter, options = {})
       @name = name
+      @key = name.to_s
       @instrumenter = options.fetch(:instrumenter, Flipper::Instrumenters::Noop)
-      @adapter = Adapter.wrap(adapter, :instrumenter => @instrumenter)
+      @adapter = adapter
     end
 
     # Public: Enable this feature for something.
     #
     # Returns the result of Flipper::Gate#enable.
-    def enable(thing = Types::Boolean.new)
+    def enable(thing = Types::Boolean.new(true))
       instrument(:enable, thing) { |payload|
+        adapter.add self
+
         gate = gate_for(thing)
         payload[:gate_name] = gate.name
-        gate.enable(thing)
+
+        adapter.enable self, gate, gate.wrap(thing)
       }
     end
 
     # Public: Disable this feature for something.
     #
     # Returns the result of Flipper::Gate#disable.
-    def disable(thing = Types::Boolean.new)
+    def disable(thing = Types::Boolean.new(false))
       instrument(:disable, thing) { |payload|
+        adapter.add self
+
         gate = gate_for(thing)
         payload[:gate_name] = gate.name
-        gate.disable(thing)
+
+        adapter.disable self, gate, gate.wrap(thing)
       }
     end
 
@@ -60,7 +68,11 @@ module Flipper
     # Returns true if enabled, false if not.
     def enabled?(thing = nil)
       instrument(:enabled?, thing) { |payload|
-        gate = gates.detect { |gate| gate.open?(thing) }
+        gate_values = adapter.get(self)
+
+        gate = gates.detect { |gate|
+          gate.open?(thing, gate_values[gate.key])
+        }
 
         if gate.nil?
           false
@@ -71,19 +83,71 @@ module Flipper
       }
     end
 
+    # Public
+    def state
+      gate_values = adapter.get(self)
+      boolean_value = gate_values[:boolean]
+
+      if boolean_gate.enabled?(boolean_value)
+        :on
+      elsif conditional_gates(gate_values).any?
+        :conditional
+      else
+        :off
+      end
+    end
+
+    # Public
+    def description
+      gate_values = adapter.get(self)
+      boolean_value = gate_values[:boolean]
+      conditional_gates = conditional_gates(gate_values)
+
+      if boolean_gate.enabled?(boolean_value)
+        boolean_gate.description(boolean_value).capitalize
+      elsif conditional_gates.any?
+        fragments = conditional_gates.map { |gate|
+          value = gate_values[gate.key]
+          gate.description(value)
+        }
+
+        "Enabled for #{fragments.join(', ')}"
+      else
+        boolean_gate.description(boolean_value).capitalize
+      end
+    end
+
+    # Public: Pretty string version for debugging.
+    def inspect
+      attributes = [
+        "name=#{name.inspect}",
+        "state=#{state.inspect}",
+        "description=#{description.inspect}",
+        "adapter=#{adapter.name.inspect}",
+      ]
+      "#<#{self.class.name}:#{object_id} #{attributes.join(', ')}>"
+    end
+
     # Internal: Gates to check to see if feature is enabled/disabled
     #
     # Returns an array of gates
     def gates
       @gates ||= [
-        Gates::Boolean.new(self, :instrumenter => @instrumenter),
-        Gates::Group.new(self, :instrumenter => @instrumenter),
-        Gates::Actor.new(self, :instrumenter => @instrumenter),
-        Gates::PercentageOfActors.new(self, :instrumenter => @instrumenter),
-        Gates::PercentageOfRandom.new(self, :instrumenter => @instrumenter),
+        Gates::Boolean.new(@name, :instrumenter => @instrumenter),
+        Gates::Group.new(@name, :instrumenter => @instrumenter),
+        Gates::Actor.new(@name, :instrumenter => @instrumenter),
+        Gates::PercentageOfActors.new(@name, :instrumenter => @instrumenter),
+        Gates::PercentageOfRandom.new(@name, :instrumenter => @instrumenter),
       ]
     end
 
+    # Internal: Finds a gate by name.
+    #
+    # Returns a Flipper::Gate if found, nil if not.
+    def gate(name)
+      gates.detect { |gate| gate.name == name.to_sym }
+    end
+
     # Internal: Find the gate that protects a thing.
     #
     # thing - The object for which you would like to find a gate
@@ -95,42 +159,9 @@ module Flipper
         raise(GateNotFound.new(thing))
     end
 
-    # Public: Pretty string version for debugging.
-    def inspect
-      attributes = [
-        "name=#{name.inspect}",
-        "state=#{state.inspect}",
-        "adapter=#{adapter.name.inspect}",
-      ]
-      "#<#{self.class.name}:#{object_id} #{attributes.join(', ')}>"
-    end
-
-    # Public
-    def state
-      if boolean_gate.enabled?
-        :on
-      elsif conditional_gates.any?
-        :conditional
-      else
-        :off
-      end
-    end
-
-    # Public
-    def description
-      if boolean_gate.enabled?
-        boolean_gate.description.capitalize
-      elsif conditional_gates.any?
-        fragments = conditional_gates.map(&:description)
-        "Enabled for #{fragments.join(', ')}"
-      else
-        boolean_gate.description.capitalize
-      end
-    end
-
     # Private
     def boolean_gate
-      @boolean_gate ||= gates.detect { |gate| gate.name == :boolean }
+      @boolean_gate ||= gate(:boolean)
     end
 
     # Private
@@ -139,8 +170,11 @@ module Flipper
     end
 
     # Private
-    def conditional_gates
-      @conditional_gates ||= non_boolean_gates.select { |gate| gate.enabled? }
+    def conditional_gates(gate_values)
+      @conditional_gates ||= non_boolean_gates.select { |gate|
+        value = gate_values[gate.key]
+        gate.enabled?(value)
+      }
     end
 
     # Private