flipper 0.1.0

data/examples/percentage_of_actors.rb

@@ -0,0 +1,35 @@
+require './example_setup'
+
+require 'flipper'
+require 'flipper/adapters/memory'
+
+adapter = Flipper::Adapters::Memory.new
+flipper = Flipper.new(adapter)
+stats = flipper[:stats]
+
+# Some class that represents what will be trying to do something
+class User
+  attr_reader :id
+
+  def initialize(id)
+    @id = id
+  end
+end
+
+pitt = User.new(1)
+clooney = User.new(10)
+
+puts "Stats for pitt: #{stats.enabled?(flipper.actor(pitt))}"
+puts "Stats for clooney: #{stats.enabled?(flipper.actor(clooney))}"
+
+puts "\nEnabling stats for 5 percent...\n\n"
+stats.enable(Flipper::Types::PercentageOfActors.new(5))
+
+puts "Stats for pitt: #{stats.enabled?(flipper.actor(pitt))}"
+puts "Stats for clooney: #{stats.enabled?(flipper.actor(clooney))}"
+
+puts "\nEnabling stats for 15 percent...\n\n"
+stats.enable(Flipper::Types::PercentageOfActors.new(15))
+
+puts "Stats for pitt: #{stats.enabled?(flipper.actor(pitt))}"
+puts "Stats for clooney: #{stats.enabled?(flipper.actor(clooney))}"

data/examples/percentage_of_random.rb

@@ -0,0 +1,33 @@
+require './example_setup'
+
+require 'flipper'
+require 'flipper/adapters/memory'
+
+adapter = Flipper::Adapters::Memory.new
+flipper = Flipper.new(adapter)
+logging = flipper[:logging]
+
+perform_test = lambda do |number|
+  logging.enable flipper.random(number)
+
+  total = 1_000
+  enabled = []
+  disabled = []
+
+  (1..total).each do |number|
+    if logging.enabled?
+      enabled << number
+    else
+      disabled << number
+    end
+  end
+
+  actual = (enabled.size / total.to_f * 100).round(2)
+
+  # puts "#{enabled.size} / #{total}"
+  puts "percentage: #{actual} vs #{number}"
+end
+
+[1, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 95, 99, 100].each do |number|
+  perform_test.call number
+end

data/flipper.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/flipper/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["John Nunemaker"]
+  gem.email         = ["nunemaker@gmail.com"]
+  gem.description   = %q{Feature flipper for any adapter}
+  gem.summary       = %q{Feature flipper for any adapter}
+  gem.homepage      = "http://jnunemaker.github.com/flipper"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "flipper"
+  gem.require_paths = ["lib"]
+  gem.version       = Flipper::VERSION
+end

data/lib/flipper.rb

@@ -0,0 +1,33 @@
+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)
+  end
+
+  def self.groups
+    @groups ||= Registry.new
+  end
+
+  def self.groups=(registry)
+    @groups = registry
+  end
+
+  def self.register(name, &block)
+    group = Types::Group.new(name, &block)
+    groups.add(group.name, group)
+    group
+  rescue Registry::DuplicateKey
+    raise DuplicateGroup, %Q{Group named "#{name}" is already registered}
+  end
+
+  def self.group(name)
+    groups.get(name)
+  end
+end

data/lib/flipper/adapters/memory.rb

@@ -0,0 +1,35 @@
+require 'set'
+
+module Flipper
+  module Adapters
+    class Memory
+      def initialize(source = nil)
+        @source = source || {}
+      end
+
+      def read(key)
+        @source[key]
+      end
+
+      def write(key, value)
+        @source[key] = value
+      end
+
+      def delete(key)
+        @source.delete(key)
+      end
+
+      def set_add(key, value)
+        set_members(key).add(value)
+      end
+
+      def set_delete(key, value)
+        set_members(key).delete(value)
+      end
+
+      def set_members(key)
+        @source[key] ||= Set.new
+      end
+    end
+  end
+end

data/lib/flipper/dsl.rb

@@ -0,0 +1,61 @@
+module Flipper
+  class DSL
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def enabled?(name, *args)
+      feature(name).enabled?(*args)
+    end
+
+    def disabled?(name, *args)
+      !enabled?(name, *args)
+    end
+
+    def enable(name, *args)
+      feature(name).enable(*args)
+    end
+
+    def disable(name, *args)
+      feature(name).disable(*args)
+    end
+
+    def feature(name)
+      features[name.to_sym] ||= Flipper::Feature.new(name, @adapter)
+    end
+
+    alias :[] :feature
+
+    def group(name)
+      Flipper.group(name)
+    end
+
+    def actor(actor_or_number)
+      raise ArgumentError, "actor cannot be nil" if actor_or_number.nil?
+
+      identifier = if actor_or_number.respond_to?(:identifier)
+        actor_or_number.identifier
+      elsif actor_or_number.respond_to?(:id)
+        actor_or_number.id
+      else
+        actor_or_number
+      end
+
+      Flipper::Types::Actor.new(identifier)
+    end
+
+    def random(number)
+      Flipper::Types::PercentageOfRandom.new(number)
+    end
+
+    def actors(number)
+      Flipper::Types::PercentageOfActors.new(number)
+    end
+
+    private
+
+    def features
+      @features ||= {}
+    end
+  end
+end

data/lib/flipper/errors.rb

@@ -0,0 +1,11 @@
+module Flipper
+  class Error < StandardError; end
+
+  class GateNotFound < Error
+    def initialize(thing)
+      super "Could not find gate for #{thing.inspect}"
+    end
+  end
+
+  class DuplicateGroup < Error; end
+end

data/lib/flipper/feature.rb

@@ -0,0 +1,49 @@
+require 'flipper/errors'
+require 'flipper/type'
+require 'flipper/toggle'
+require 'flipper/gate'
+
+module Flipper
+  class Feature
+    attr_reader :name
+    attr_reader :adapter
+
+    def initialize(name, adapter)
+      @name = name
+      @adapter = adapter
+    end
+
+    def enable(thing = Types::Boolean.new)
+      gate_for(thing).enable(thing)
+    end
+
+    def disable(thing = Types::Boolean.new)
+      gate_for(thing).disable(thing)
+    end
+
+    def enabled?(actor = nil)
+      !! catch(:short_circuit) { gates.detect { |gate| gate.open?(actor) } }
+    end
+
+    def disabled?(actor = nil)
+      !enabled?(actor)
+    end
+
+    private
+
+    def gate_for(thing)
+      gates.detect { |gate| gate.protects?(thing) } ||
+        raise(GateNotFound.new(thing))
+    end
+
+    def gates
+      @gates ||= [
+        Gates::Boolean.new(self),
+        Gates::Group.new(self),
+        Gates::Actor.new(self),
+        Gates::PercentageOfActors.new(self),
+        Gates::PercentageOfRandom.new(self),
+      ]
+    end
+  end
+end

data/lib/flipper/gate.rb

@@ -0,0 +1,55 @@
+require 'forwardable'
+
+module Flipper
+  class Gate
+    extend Forwardable
+
+    Separator = '/'
+
+    attr_reader :feature
+
+    def_delegator :@feature, :adapter
+
+    def initialize(feature)
+      @feature = feature
+    end
+
+    def key_prefix
+      @feature.name
+    end
+
+    def key
+      "#{key_prefix}#{Separator}#{type_key}"
+    end
+
+    def toggle_class
+      Toggles::Value
+    end
+
+    def toggle
+      @toggle ||= toggle_class.new(self)
+    end
+
+    def protects?(thing)
+      false
+    end
+
+    def match?(actor)
+      false
+    end
+
+    def enable(thing)
+      toggle.enable(thing)
+    end
+
+    def disable(thing)
+      toggle.disable(thing)
+    end
+  end
+end
+
+require 'flipper/gates/actor'
+require 'flipper/gates/boolean'
+require 'flipper/gates/group'
+require 'flipper/gates/percentage_of_actors'
+require 'flipper/gates/percentage_of_random'

data/lib/flipper/gates/actor.rb

@@ -0,0 +1,29 @@
+module Flipper
+  module Gates
+    class Actor < Gate
+      Key = :actors
+
+      def type_key
+        Key
+      end
+
+      def toggle_class
+        Toggles::Set
+      end
+
+      def open?(actor)
+        if actor && actor.respond_to?(:identifier)
+          identifiers.include?(actor.identifier)
+        end
+      end
+
+      def identifiers
+        toggle.value
+      end
+
+      def protects?(thing)
+        thing.is_a?(Flipper::Types::Actor)
+      end
+    end
+  end
+end

data/lib/flipper/gates/boolean.rb

@@ -0,0 +1,29 @@
+module Flipper
+  module Gates
+    class Boolean < Gate
+      Key = :boolean
+
+      def type_key
+        Key
+      end
+
+      def toggle_class
+        Toggles::Boolean
+      end
+
+      def open?(actor)
+        value = toggle.value
+
+        if value.nil?
+          false
+        else
+          throw :short_circuit, !!value
+        end
+      end
+
+      def protects?(thing)
+        thing.is_a?(Flipper::Types::Boolean)
+      end
+    end
+  end
+end

data/lib/flipper/gates/group.rb

@@ -0,0 +1,32 @@
+module Flipper
+  module Gates
+    class Group < Gate
+      Key = :groups
+
+      def type_key
+        Key
+      end
+
+      def toggle_class
+        Toggles::Set
+      end
+
+      def open?(actor)
+        return if actor.nil?
+        groups.any? { |group| group.match?(actor) }
+      end
+
+      def group_names
+        toggle.value
+      end
+
+      def groups
+        group_names.map { |name| Flipper.group(name) }.compact
+      end
+
+      def protects?(thing)
+        thing.is_a?(Flipper::Types::Group)
+      end
+    end
+  end
+end

data/lib/flipper/gates/percentage_of_actors.rb

@@ -0,0 +1,25 @@
+module Flipper
+  module Gates
+    class PercentageOfActors < Gate
+      Key = :perc_actors
+
+      def type_key
+        Key
+      end
+
+      def open?(actor)
+        percentage = toggle.value
+
+        if percentage.nil?
+          false
+        else
+          actor.identifier % 100 < percentage
+        end
+      end
+
+      def protects?(thing)
+        thing.is_a?(Flipper::Types::PercentageOfActors)
+      end
+    end
+  end
+end