flipper 0.1.0

data/lib/flipper/gates/percentage_of_random.rb

@@ -0,0 +1,25 @@
+module Flipper
+  module Gates
+    class PercentageOfRandom < Gate
+      Key = :perc_time
+
+      def type_key
+        Key
+      end
+
+      def open?(actor)
+        percentage = toggle.value
+
+        if percentage.nil?
+          false
+        else
+          rand < (percentage / 100.0)
+        end
+      end
+
+      def protects?(thing)
+        thing.is_a?(Flipper::Types::PercentageOfRandom)
+      end
+    end
+  end
+end

data/lib/flipper/registry.rb

@@ -0,0 +1,36 @@
+module Flipper
+  class Registry
+    class Error < StandardError; end
+    class DuplicateKey < Error; end
+    class MissingKey < Error; end
+
+    def initialize(source = {})
+      @mutex = Mutex.new
+      @source = source
+    end
+
+    def add(key, value)
+      @mutex.synchronize do
+        if @source[key]
+          raise DuplicateKey, "#{key} is already registered"
+        else
+          @source[key] = value
+        end
+      end
+    end
+
+    def get(key)
+      @mutex.synchronize do
+        @source[key]
+      end
+    end
+
+    def each(&block)
+      @mutex.synchronize { @source.dup }.each(&block)
+    end
+
+    def clear
+      @mutex.synchronize { @source.clear }
+    end
+  end
+end

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -0,0 +1,78 @@
+require 'set'
+
+# Requires the following methods
+# subject
+# read_key(key)
+# write_key(key, value)
+shared_examples_for 'a flipper adapter' do
+  describe "#write" do
+    let(:separator)  { Flipper::Gate::Separator }
+
+    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
+    end
+  end
+
+  describe "#read" do
+    it "returns nil if key not in store" do
+      subject.read('foo').should be_nil
+    end
+
+    it "returns value if key in store" do
+      write_key 'foo', 'bar'
+      subject.read('foo').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
+    end
+  end
+
+  describe "#set_add" do
+    it "adds value to store" do
+      subject.set_add('foo', 1)
+      read_key('foo').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])
+    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])
+    end
+
+    it "works fine if key not in store" do
+      subject.set_delete('foo', 'bar')
+    end
+  end
+
+  describe "#set_members" do
+    it "defaults to empty set" do
+      subject.set_members('foo').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])
+    end
+  end
+end

data/lib/flipper/toggle.rb

@@ -0,0 +1,31 @@
+require 'forwardable'
+
+module Flipper
+  class Toggle
+    extend Forwardable
+
+    attr_reader :gate
+
+    def_delegators :@gate, :key, :feature, :adapter
+
+    def initialize(gate)
+      @gate = gate
+    end
+
+    def enable(thing)
+      raise 'Not implemented'
+    end
+
+    def disable(thing)
+      raise 'Not implemented'
+    end
+
+    def value
+      raise 'Not implemented'
+    end
+  end
+end
+
+require 'flipper/toggles/boolean'
+require 'flipper/toggles/set'
+require 'flipper/toggles/value'

data/lib/flipper/toggles/boolean.rb

@@ -0,0 +1,22 @@
+module Flipper
+  module Toggles
+    class Boolean < Toggle
+      def enable(thing)
+        adapter.write key, thing.enabled_value
+      end
+
+      def disable(thing)
+        adapter.delete key
+
+        adapter.delete "#{gate.key_prefix}#{Gate::Separator}#{Gates::Actor::Key}"
+        adapter.delete "#{gate.key_prefix}#{Gate::Separator}#{Gates::Group::Key}"
+        adapter.delete "#{gate.key_prefix}#{Gate::Separator}#{Gates::PercentageOfActors::Key}"
+        adapter.delete "#{gate.key_prefix}#{Gate::Separator}#{Gates::PercentageOfRandom::Key}"
+      end
+
+      def value
+        adapter.read key
+      end
+    end
+  end
+end

data/lib/flipper/toggles/set.rb

@@ -0,0 +1,17 @@
+module Flipper
+  module Toggles
+    class Set < Toggle
+      def enable(thing)
+        adapter.set_add key, thing.enabled_value
+      end
+
+      def disable(thing)
+        adapter.set_delete key, thing.disabled_value
+      end
+
+      def value
+        adapter.set_members key
+      end
+    end
+  end
+end

data/lib/flipper/toggles/value.rb

@@ -0,0 +1,17 @@
+module Flipper
+  module Toggles
+    class Value < Toggle
+      def enable(thing)
+        adapter.write key, thing.enabled_value
+      end
+
+      def disable(thing)
+        adapter.write key, thing.disabled_value
+      end
+
+      def value
+        adapter.read key
+      end
+    end
+  end
+end

data/lib/flipper/type.rb

@@ -0,0 +1,18 @@
+module Flipper
+  class Type
+    def enabled_value
+      raise 'Not implemented'
+    end
+
+    def disabled_value
+      raise 'Not implemented'
+    end
+  end
+end
+
+require 'flipper/types/actor'
+require 'flipper/types/boolean'
+require 'flipper/types/group'
+require 'flipper/types/percentage'
+require 'flipper/types/percentage_of_actors'
+require 'flipper/types/percentage_of_random'

data/lib/flipper/types/actor.rb

@@ -0,0 +1,17 @@
+module Flipper
+  module Types
+    class Actor < Type
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier.to_i
+      end
+
+      def enabled_value
+        @identifier
+      end
+
+      alias_method :disabled_value, :enabled_value
+    end
+  end
+end

data/lib/flipper/types/boolean.rb

@@ -0,0 +1,13 @@
+module Flipper
+  module Types
+    class Boolean < Type
+      def enabled_value
+        true
+      end
+
+      def disabled_value
+        false
+      end
+    end
+  end
+end

data/lib/flipper/types/group.rb

@@ -0,0 +1,22 @@
+module Flipper
+  module Types
+    class Group < Type
+      attr_reader :name
+
+      def initialize(name, &block)
+        @name = name.to_sym
+        @block = block
+      end
+
+      def match?(*args)
+        @block.call(*args) == true
+      end
+
+      def enabled_value
+        @name
+      end
+
+      alias_method :disabled_value, :enabled_value
+    end
+  end
+end

data/lib/flipper/types/percentage.rb

@@ -0,0 +1,19 @@
+module Flipper
+  module Types
+    class Percentage < Type
+      attr_reader :value
+
+      def initialize(value)
+        @value = value.to_i
+      end
+
+      def enabled_value
+        value
+      end
+
+      def disabled_value
+        0
+      end
+    end
+  end
+end

data/lib/flipper/types/percentage_of_actors.rb

@@ -0,0 +1,6 @@
+module Flipper
+  module Types
+    class PercentageOfActors < Percentage
+    end
+  end
+end

data/lib/flipper/types/percentage_of_random.rb

@@ -0,0 +1,6 @@
+module Flipper
+  module Types
+    class PercentageOfRandom < Percentage
+    end
+  end
+end

data/lib/flipper/version.rb

@@ -0,0 +1,3 @@
+module Flipper
+  VERSION = "0.1.0"
+end

data/spec/flipper/adapters/memory_spec.rb

@@ -0,0 +1,19 @@
+require 'helper'
+require 'flipper/adapters/memory'
+require 'flipper/spec/shared_adapter_specs'
+
+describe Flipper::Adapters::Memory do
+  let(:source) { {} }
+
+  subject { Flipper::Adapters::Memory.new(source) }
+
+  def read_key(key)
+    source[key]
+  end
+
+  def write_key(key, value)
+    source[key] = value
+  end
+
+  it_should_behave_like 'a flipper adapter'
+end

data/spec/flipper/dsl_spec.rb

@@ -0,0 +1,185 @@
+require 'helper'
+require 'flipper/dsl'
+
+describe Flipper::DSL do
+  subject { Flipper::DSL.new(adapter) }
+
+  let(:source)  { {} }
+  let(:adapter) { Flipper::Adapters::Memory.new(source) }
+
+  let(:admins_feature) { feature(:admins) }
+
+  def feature(name)
+    Flipper::Feature.new(name, adapter)
+  end
+
+  describe "#enabled?" do
+    before do
+      subject.stub(:feature => admins_feature)
+    end
+
+    it "passes arguments to feature enabled check and returns result" do
+      admins_feature.should_receive(:enabled?).with(:foo).and_return(true)
+      subject.should_receive(:feature).with(:stats).and_return(admins_feature)
+      subject.enabled?(:stats, :foo).should be_true
+    end
+  end
+
+  describe "#disabled?" do
+    it "passes all args to enabled? and returns the opposite" do
+      subject.should_receive(:enabled?).with(:stats, :foo).and_return(true)
+      subject.disabled?(:stats, :foo).should be_false
+    end
+  end
+
+  describe "#enable" do
+    before do
+      subject.stub(:feature => admins_feature)
+    end
+
+    it "calls enable for feature with arguments" do
+      admins_feature.should_receive(:enable).with(:foo)
+      subject.should_receive(:feature).with(:stats).and_return(admins_feature)
+      subject.enable :stats, :foo
+    end
+  end
+
+  describe "#disable" do
+    before do
+      subject.stub(:feature => admins_feature)
+    end
+
+    it "calls disable for feature with arguments" do
+      admins_feature.should_receive(:disable).with(:foo)
+      subject.should_receive(:feature).with(:stats).and_return(admins_feature)
+      subject.disable :stats, :foo
+    end
+  end
+
+  describe "#feature" do
+    before do
+      @result = subject.feature(:stats)
+    end
+
+    it "returns instance of feature with correct name and adapter" do
+      @result.should be_instance_of(Flipper::Feature)
+      @result.name.should eq(:stats)
+      @result.adapter.should eq(adapter)
+    end
+
+    it "memoizes the feature" do
+      subject.feature(:stats).should equal(@result)
+    end
+  end
+
+  describe "#[]" do
+    before do
+      @result = subject[:stats]
+    end
+
+    it "returns instance of feature with correct name and adapter" do
+      @result.should be_instance_of(Flipper::Feature)
+      @result.name.should eq(:stats)
+      @result.adapter.should eq(adapter)
+    end
+
+    it "memoizes the feature" do
+      subject[:stats].should equal(@result)
+    end
+  end
+
+  describe "#group" do
+    context "for registered group" do
+      before do
+        @group = Flipper.register(:admins) { }
+      end
+
+      it "returns group" do
+        subject.group(:admins).should eq(@group)
+      end
+
+      it "always returns same instance for same name" do
+        subject.group(:admins).should equal(subject.group(:admins))
+      end
+    end
+
+    context "for unregistered group" do
+      it "returns nil" do
+        subject.group(:admins).should be_nil
+      end
+    end
+  end
+
+  describe "#actor" do
+    context "for something that responds to id" do
+      it "returns actor instance with identifier set to id" do
+        user = Struct.new(:id).new(23)
+        actor = subject.actor(user)
+        actor.should be_instance_of(Flipper::Types::Actor)
+        actor.identifier.should eq(23)
+      end
+    end
+
+    context "for something that responds to identifier" do
+      it "returns actor instance with identifier set to id" do
+        user = Struct.new(:identifier).new(45)
+        actor = subject.actor(user)
+        actor.should be_instance_of(Flipper::Types::Actor)
+        actor.identifier.should eq(45)
+      end
+    end
+
+    context "for something that responds to identifier and id" do
+      it "returns actor instance with identifier set to identifier" do
+        user = Struct.new(:id, :identifier).new(1, 50)
+        actor = subject.actor(user)
+        actor.should be_instance_of(Flipper::Types::Actor)
+        actor.identifier.should eq(50)
+      end
+    end
+
+    context "for a number" do
+      it "returns actor instance with identifer set to number" do
+        actor = subject.actor(33)
+        actor.should be_instance_of(Flipper::Types::Actor)
+        actor.identifier.should eq(33)
+      end
+    end
+
+    context "for nil" do
+      it "raises error" do
+        expect {
+          subject.actor(nil)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#random" do
+    before do
+      @result = subject.random(5)
+    end
+
+    it "returns percentage of random" do
+      @result.should be_instance_of(Flipper::Types::PercentageOfRandom)
+    end
+
+    it "sets value" do
+      @result.value.should eq(5)
+    end
+  end
+
+  describe "#actors" do
+    before do
+      @result = subject.actors(17)
+    end
+
+    it "returns percentage of actors" do
+      @result.should be_instance_of(Flipper::Types::PercentageOfActors)
+    end
+
+    it "sets value" do
+      @result.value.should eq(17)
+    end
+  end
+end