flipper 0.2.1 → 0.3.0

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - ree
+  - 1.9.3
+notifications:
+  email: false
+bundler_args: --without guard

data/Gemfile

@@ -7,7 +7,8 @@ group(:guard) do
   gem 'guard'
   gem 'guard-rspec'
   gem 'guard-bundler'
-  gem 'growl'
+  gem 'terminal-notifier-guard'
+  gem 'rb-fsevent'
 end
 
 group(:test) do

data/lib/flipper.rb

@@ -1,11 +1,3 @@
-require 'flipper/dsl'
-require 'flipper/errors'
-require 'flipper/feature'
-require 'flipper/gate'
-require 'flipper/registry'
-require 'flipper/toggle'
-require 'flipper/type'
-
 module Flipper
   def self.new(*args)
     DSL.new(*args)
@@ -31,3 +23,11 @@ module Flipper
     groups.get(name)
   end
 end
+
+require 'flipper/dsl'
+require 'flipper/errors'
+require 'flipper/feature'
+require 'flipper/gate'
+require 'flipper/registry'
+require 'flipper/toggle'
+require 'flipper/type'

data/lib/flipper/adapter.rb

@@ -1,5 +1,7 @@
 module Flipper
-  # Internal: Adapter wrapper that wraps vanilla adapter instances with local caching.
+  # Internal: Adapter wrapper that wraps vanilla adapter instances. Adds things
+  # like local caching and convenience methods for adding/reading features from
+  # the adapter.
   #
   # So what is this local cache crap?
   #
@@ -17,6 +19,8 @@ module Flipper
   # To see an example adapter that this would wrap, checkout the [memory
   # adapter included with flipper](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/memory.rb).
   class Adapter
+    FeaturesKey = 'features'
+
     # Internal: Wraps vanilla adapter instance for use internally in flipper.
     #
     # object - Either an instance of Flipper::Adapter or a vanilla adapter instance
@@ -65,35 +69,27 @@ module Flipper
     end
 
     def read(key)
-      if using_local_cache?
-        cache(key) { @adapter.read(key) }
-      else
-        @adapter.read(key)
-      end
+      perform_read(key) { @adapter.read(key) }
     end
 
     def write(key, value)
-      @adapter.write(key, value).tap { expire_local_cache(key) }
+      perform_update(key) { @adapter.write(key, value) }
     end
 
     def delete(key)
-      @adapter.delete(key).tap { expire_local_cache(key) }
+      perform_update(key) { @adapter.delete(key) }
     end
 
     def set_members(key)
-      if using_local_cache?
-        cache(key) { @adapter.set_members(key) }
-      else
-        @adapter.set_members(key)
-      end
+      perform_read(key) { @adapter.set_members(key) }
     end
 
     def set_add(key, value)
-      @adapter.set_add(key, value).tap { expire_local_cache(key) }
+      perform_update(key) { @adapter.set_add(key, value) }
     end
 
     def set_delete(key, value)
-      @adapter.set_delete(key, value).tap { expire_local_cache(key) }
+      perform_update(key) { @adapter.set_delete(key, value) }
     end
 
     def eql?(other)
@@ -101,14 +97,30 @@ module Flipper
     end
     alias :== :eql?
 
+    def features
+      set_members(FeaturesKey)
+    end
+
+    def feature_add(name)
+      set_add(FeaturesKey, name.to_s)
+    end
+
     private
 
-    def cache(key)
-      local_cache.fetch(key) { local_cache[key] = yield }
+    def perform_read(key)
+      if using_local_cache?
+        local_cache.fetch(key.to_s) { local_cache[key.to_s] = yield }
+      else
+        yield
+      end
     end
 
-    def expire_local_cache(key)
-      local_cache.delete(key) if using_local_cache?
+    def perform_update(key)
+      result = yield
+      if using_local_cache?
+        local_cache.delete(key.to_s)
+      end
+      result
     end
   end
 end

data/lib/flipper/adapters/memory.rb

@@ -8,27 +8,36 @@ module Flipper
       end
 
       def read(key)
-        @source[key]
+        @source[key.to_s]
       end
 
       def write(key, value)
-        @source[key] = value
+        @source[key.to_s] = value
       end
 
       def delete(key)
-        @source.delete(key)
+        @source.delete(key.to_s)
       end
 
       def set_add(key, value)
-        set_members(key).add(value)
+        ensure_set_initialized(key)
+        @source[key.to_s].add(value)
       end
 
       def set_delete(key, value)
-        set_members(key).delete(value)
+        ensure_set_initialized(key)
+        @source[key.to_s].delete(value)
       end
 
       def set_members(key)
-        @source[key] ||= Set.new
+        ensure_set_initialized(key)
+        @source[key.to_s]
+      end
+
+      private
+
+      def ensure_set_initialized(key)
+        @source[key.to_s] ||= Set.new
       end
     end
   end

data/lib/flipper/adapters/operation_logger.rb

@@ -0,0 +1,57 @@
+module Flipper
+  module Adapters
+    # Public: Adapter that wraps another adapter and stores the operations.
+    #
+    # Useful in tests to verify calls and such.
+    class OperationLogger
+      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)
+
+      def initialize(adapter)
+        @operations = []
+        @adapter = adapter
+      end
+
+      def read(key)
+        @operations << Read.new(key.to_s)
+        @adapter.read key
+      end
+
+      def write(key, value)
+        @operations << Write.new(key.to_s, value)
+        @adapter.write key, value
+      end
+
+      def delete(key)
+        @operations << Delete.new(key.to_s, nil)
+        @adapter.delete key
+      end
+
+      def set_add(key, value)
+        @operations << SetAdd.new(key.to_s, value)
+        @adapter.set_add key, value
+      end
+
+      def set_delete(key, value)
+        @operations << SetDelete.new(key.to_s, value)
+        @adapter.set_delete key, value
+      end
+
+      def set_members(key)
+        @operations << SetMembers.new(key.to_s)
+        @adapter.set_members key
+      end
+
+      # Public: Clears operation log
+      def reset
+        @operations.clear
+      end
+    end
+  end
+end

data/lib/flipper/dsl.rb

@@ -25,7 +25,7 @@ module Flipper
     end
 
     def feature(name)
-      features[name.to_sym] ||= Feature.new(name, @adapter)
+      memoized_features[name.to_sym] ||= Feature.new(name, @adapter)
     end
 
     alias :[] :feature
@@ -35,21 +35,27 @@ module Flipper
     end
 
     def actor(thing)
-      Flipper::Types::Actor.new(thing)
+      Types::Actor.new(thing)
     end
 
     def random(number)
-      Flipper::Types::PercentageOfRandom.new(number)
+      Types::PercentageOfRandom.new(number)
     end
+    alias :percentage_of_random :random
 
     def actors(number)
-      Flipper::Types::PercentageOfActors.new(number)
+      Types::PercentageOfActors.new(number)
+    end
+    alias :percentage_of_actors :actors
+
+    def features
+      adapter.features.map { |name| feature(name) }.to_set
     end
 
     private
 
-    def features
-      @features ||= {}
+    def memoized_features
+      @memoized_features ||= {}
     end
   end
 end

data/lib/flipper/feature.rb

@@ -30,13 +30,9 @@ module Flipper
       !enabled?(actor)
     end
 
-    private
-
-    def gate_for(thing)
-      gates.detect { |gate| gate.protects?(thing) } ||
-        raise(GateNotFound.new(thing))
-    end
-
+    # Internal: Gates to check to see if feature is enabled/disabled
+    #
+    # Returns an array of gates
     def gates
       @gates ||= [
         Gates::Boolean.new(self),
@@ -46,5 +42,20 @@ module Flipper
         Gates::PercentageOfRandom.new(self),
       ]
     end
+
+    # Internal: Returns gate that protects thing
+    #
+    # thing - The object for which you would like to find a gate
+    #
+    # Raises Flipper::GateNotFound if no gate found for thing
+    def gate_for(thing)
+      find_gate(thing) || raise(GateNotFound.new(thing))
+    end
+
+    private
+
+    def find_gate(thing)
+      gates.detect { |gate| gate.protects?(thing) }
+    end
   end
 end

data/lib/flipper/gate.rb

@@ -1,11 +1,10 @@
 require 'forwardable'
+require 'flipper/key'
 
 module Flipper
   class Gate
     extend Forwardable
 
-    Separator = '/'
-
     attr_reader :feature
 
     def_delegator :@feature, :adapter
@@ -14,12 +13,8 @@ module Flipper
       @feature = feature
     end
 
-    def key_prefix
-      @feature.name
-    end
-
     def key
-      "#{key_prefix}#{Separator}#{type_key}"
+      @key ||= Key.new(@feature.name, type_key)
     end
 
     def toggle_class

data/lib/flipper/gates/percentage_of_actors.rb

@@ -1,3 +1,5 @@
+require 'zlib'
+
 module Flipper
   module Gates
     class PercentageOfActors < Gate
@@ -13,7 +15,7 @@ module Flipper
         if percentage.nil?
           false
         else
-          actor.identifier % 100 < percentage
+          Zlib.crc32(actor.identifier.to_s) % 100 < percentage
         end
       end
 

data/lib/flipper/key.rb

@@ -0,0 +1,19 @@
+module Flipper
+  class Key
+    Separator = '/'
+
+    attr_reader :prefix, :suffix
+
+    def initialize(prefix, suffix)
+      @prefix, @suffix = prefix, suffix
+    end
+
+    def separator
+      Separator.dup
+    end
+
+    def to_s
+      "#{prefix}#{separator}#{suffix}"
+    end
+  end
+end

data/lib/flipper/registry.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Flipper
   class Registry
     include Enumerable

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -5,74 +5,69 @@ require 'set'
 # read_key(key)
 # write_key(key, value)
 shared_examples_for 'a flipper adapter' do
-  describe "#write" do
-    let(:separator)  { Flipper::Gate::Separator }
+  let(:key) { Flipper::Key.new(:foo, :bar) }
 
+  describe "#write" do
     it "sets key to value in store" do
-      subject.write('foo', true)
-      read_key('foo').should be_true
-    end
-
-    it "works with separator" do
-      subject.write("foo#{separator}bar", true)
-      read_key("foo#{separator}bar").should be_true
+      subject.write(key, true)
+      read_key(key).should be_true
     end
   end
 
   describe "#read" do
     it "returns nil if key not in store" do
-      subject.read('foo').should be_nil
+      subject.read(key).should be_nil
     end
 
     it "returns value if key in store" do
-      write_key 'foo', 'bar'
-      subject.read('foo').should eq('bar')
+      write_key key, 'bar'
+      subject.read(key).should eq('bar')
     end
   end
 
   describe "#delete" do
     it "deletes key" do
-      write_key 'foo', 'bar'
-      subject.delete('foo')
-      read_key('foo').should be_nil
+      write_key key, 'bar'
+      subject.delete(key)
+      read_key(key).should be_nil
     end
   end
 
   describe "#set_add" do
     it "adds value to store" do
-      subject.set_add('foo', 1)
-      read_key('foo').should eq(Set[1])
+      subject.set_add(key, 1)
+      read_key(key).should eq(Set[1])
     end
 
     it "does not add same value more than once" do
-      subject.set_add('foo', 1)
-      subject.set_add('foo', 1)
-      subject.set_add('foo', 1)
-      subject.set_add('foo', 2)
-      read_key('foo').should eq(Set[1, 2])
+      subject.set_add(key, 1)
+      subject.set_add(key, 1)
+      subject.set_add(key, 1)
+      subject.set_add(key, 2)
+      read_key(key).should eq(Set[1, 2])
     end
   end
 
   describe "#set_delete" do
     it "removes value from set if key in store" do
-      write_key 'foo', Set[1, 2]
-      subject.set_delete('foo', 1)
-      read_key('foo').should eq(Set[2])
+      write_key key, Set[1, 2]
+      subject.set_delete(key, 1)
+      read_key(key).should eq(Set[2])
     end
 
     it "works fine if key not in store" do
-      subject.set_delete('foo', 'bar')
+      subject.set_delete(key, 'bar')
     end
   end
 
   describe "#set_members" do
     it "defaults to empty set" do
-      subject.set_members('foo').should eq(Set.new)
+      subject.set_members(key).should eq(Set.new)
     end
 
     it "returns set if in store" do
-      write_key 'foo', Set[1, 2]
-      subject.set_members('foo').should eq(Set[1, 2])
+      write_key key, Set[1, 2]
+      subject.set_members(key).should eq(Set[1, 2])
     end
   end