flag 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aa905390895050cd8a589c4c97f36cc1b3d8a8b9
+  data.tar.gz: 360389f7f12e04b64b009bc4ba63cad0b0d40481
+SHA512:
+  metadata.gz: 839277859db6982e7fb3833642a79ff49f83c0764a50390021648b6319bea6746fd60bed4b965d55450fdceee9a481075bac5f6f35588fecb937430a860a3d1a
+  data.tar.gz: 16fdbe22d8fa51324ec895b2db0d20cf83e2ea12395b91cb782b34e4ce11fd89a42aea67ee18ba49e1bd28a92006a938ceff14a47f0232976acfe41dba87ee90

data/README.md

@@ -0,0 +1,72 @@
+# Flag
+
+Simple feature flags for any app
+
+## Install
+
+```
+gem install flag
+```
+
+## Initialize
+
+`Flag` uses `Redic.new` if no other conenction is supplied
+
+```ruby
+Flag.store = Redic.new(ENV["OTHER_REDIS"]) # <3 Redic
+```
+
+## Basic usage
+
+```ruby
+if Flag(:new_design).on?
+  # Shiny new design
+else
+  # Marquee and blink everywhere
+end
+```
+
+## Enable/Check feature flags
+
+### Ids
+
+```ruby
+Flag(:new_buttons).on!  # Enabled for everyone
+Flag(:new_buttons).off! # Disabled for everyone
+
+Flag(:new_buttons).on!(1) # Enabled for id 1
+Flag(:new_buttons).on?(1) #=> true
+
+Flag(:new_buttons).on!("AnyRandomIdentification") # Use what you want as an id
+Flag(:new_buttons).on?("AnyRandomIdentification") #=> true
+```
+
+### Groups
+
+```ruby
+Flag.group[:staff] = lambda { |id| User.find(id).staff? }
+
+Flag(:new_scary_feature).on!(:staff)  # This will run a block to check if it's valid
+Flag(:new_scary_feature).on?(user.id) #=> true
+```
+
+### Percentages
+
+```ruby
+Flag(:testing).on!("33%")
+```
+
+## Info
+
+```ruby
+Flag.enabled  # Shows you an array of the currently activated features
+              #=> [:landing_page]
+
+Flag.features # All the features, even the off ones
+
+Flag.groups # The currently defined groups
+            #=> [:staff, :beta_testers]
+
+Flag(:holidays).activated # A hash with info on who has this feature active
+                          #=> {:percentage => 100, :users => ["1"], :groups => [:staff] }
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require "rake/testtask"
+
+Rake::TestTask.new("spec") do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => [:test]
+task :all     => [:test, :bench]
+task :test    => [:spec]

data/SPEC.md

@@ -0,0 +1,16 @@
+``ruby
+if Flag(:experiment).on?
+end
+
+Flag(:experiment).on!
+Flag(:experiment).off!
+
+Flag(:experiment).on!("30%")
+Flag(:experiment).on!(user.id)
+Flag(:experiment).on!(:group)
+
+Flag(:experiment).on?(user.id)
+Flag(:experiment).on?(:group)
+
+Flag.group[:group] = lambda { |id| id % 2 }
+```

data/flag.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name              = "flag"
+  s.version           = "0.0.1"
+  s.summary           = "Simple feature flags"
+  s.description       = "Feature flags for the humans and the coders"
+  s.authors           = ["elcuervo"]
+  s.licenses          = ["MIT", "HUGWARE"]
+  s.email             = ["yo@brunoaguirre.com"]
+  s.homepage          = "http://github.com/elcuervo/flag"
+  s.files             = `git ls-files`.split("\n")
+  s.test_files        = `git ls-files test`.split("\n")
+
+  s.add_dependency("redic", "~> 0.0.8")
+
+  s.add_development_dependency("minitest",        "~> 5.3.0")
+  s.add_development_dependency("minitest-given",  "~> 3.0.0")
+end

data/lib/flag.rb

@@ -0,0 +1,139 @@
+require "zlib"
+require "redic"
+
+module Flag
+  FEATURES = "_flag:features".freeze
+
+  Members = Struct.new(:name) do
+    USERS  = "users".freeze
+    GROUPS = "groups".freeze
+
+    def <<(item)
+      if item.to_s.end_with?("%")
+        Flag.store.call("HSET", Flag::FEATURES, name, item[0...-1])
+      else
+        Flag.store.call("SADD", subkey(item), item)
+      end
+    end
+
+    def key
+      "#{Flag::FEATURES}:#{name}"
+    end
+
+    def actived
+      { percentage: percentage.to_i, users: users, groups: groups }
+    end
+
+    def groups; members_for(GROUPS).map(&:to_sym) end
+    def users;  members_for(USERS) end
+
+    def include?(item)
+      return percentage == item[0...-1].to_i if item.to_s.end_with?("%")
+      return true if Zlib.crc32(item.to_s) % 100 < percentage
+
+      Flag.store.call("SISMEMBER", subkey(item), item).to_i == 1
+    end
+
+    def reset
+      [USERS, GROUPS].each { |k| Flag.store.call("DEL", "#{key}:#{k}") }
+    end
+
+    private
+
+    def members_for(type)
+      Flag.store.call("SMEMBERS", "#{key}:#{type}") || []
+    end
+
+    def percentage
+      Flag.store.call("HGET", Flag::FEATURES, name).to_i
+    end
+
+    def subkey(item)
+      "#{key}:#{subgroup(item)}"
+    end
+
+    def subgroup(item)
+      case item
+      when Integer, Fixnum, String then USERS
+      when Symbol then GROUPS
+      end
+    end
+  end
+
+  class Feature
+    attr_accessor :active
+    attr_reader   :name
+
+    def initialize(name)
+      @name = name
+      @members = Members.new(name)
+    end
+
+    def reset;   @members.reset   end
+    def key;     @members.key     end
+    def actived; @members.actived end
+
+    def off?; !active? end
+
+    def on?(what = false)
+      return active? if !what
+      return true    if @members.include?(what)
+
+      case what
+      when Integer, Fixnum, String
+        @members.groups.any? { |g| Flag.group[g].call(what) }
+      else
+        false
+      end
+    end
+
+    def off!
+      Flag.store.call("HSET", Flag::FEATURES, name, 0)
+    end
+
+    def on!(what = false)
+      if what
+        @members << what
+      else
+        Flag.store.call("HSET", Flag::FEATURES, name, 100)
+      end
+    end
+
+    private
+
+    def active?
+      Flag.store.call("HGET", FEATURES, name).to_i == 100
+    end
+  end
+
+  class << self
+    attr_accessor :store
+
+    def flush
+      @_group = nil
+      features.each { |_, f| f.reset }
+      self.store.call("DEL", FEATURES)
+    end
+
+    def enabled
+      features.select { |k, v| k if v.on? }.keys
+    end
+
+    def store; @store  ||= Redic.new end
+    def group; @_group ||= Hash.new { |h, k| h[k] = lambda { |id| } } end
+
+    def groups; group.keys end
+
+    def features
+      @_features ||= Hash.new { |h, k| h[k] = Feature.new(k) }
+
+      self.store.call("HGETALL", FEATURES).each_slice(2) do |slice|
+        @_features[slice.first.to_sym]
+      end
+
+      @_features
+    end
+  end
+end
+
+def Flag(feature); Flag.features[feature] end

data/test/flag_test.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+describe Flag do
+  after { Flag.flush }
+
+  context "features" do
+
+    context "empty" do
+      Given(:features) { Flag.enabled }
+      Then { features == [] }
+    end
+
+    context "having one" do
+      Given { Flag(:test).on! }
+      Then  { Flag.enabled == [:test] }
+    end
+
+    context "turning them off" do
+      Given { Flag(:test).on! }
+      When  { Flag(:test).off! }
+      When  { Flag(:test2).on! }
+
+      Then  { Flag.enabled  == [:test2] }
+      And   { Flag.features.keys == [:test, :test2] }
+    end
+
+  end
+
+  context "groups" do
+    Given do
+      Flag.group[:staff] = lambda { |id| id > 1 }
+    end
+
+    context "adding groups" do
+      When(:groups) { Flag.groups }
+      Then { groups == [:staff] }
+    end
+
+    context "testing if feature is actived for a group" do
+      Given { Flag(:test).on!(:staff) }
+      When(:feature) { Flag(:test).on?(:staff) }
+      Then { feature == true }
+    end
+
+    context "trying to check for an empty group" do
+      Given { Flag(:test).on!(:bogus) }
+      When(:feature) { Flag(:test).on?(1) }
+      Then { feature == false }
+    end
+
+    context "testing if a user beloging to a group get stuff activated" do
+      Given { Flag(:test).on!(:staff) }
+
+      Then { Flag(:test).on?(1) == false }
+      And  { Flag(:test).on?(2) == true }
+      And  { Flag(:test).on?(3) == true }
+    end
+  end
+
+  context "users" do
+    context "enabled only for a user" do
+      When { Flag(:test).on!(1) }
+
+      Then { Flag(:test).on?(1) == true }
+      And  { Flag(:test).on?(2) == false }
+    end
+
+    context "with non numeric users" do
+      When { Flag(:test).on!("ImARandomUUID") }
+      Then { Flag(:test).on?("ImARandomUUID") == true }
+    end
+  end
+
+  context "keys" do
+    Given(:feature) { Flag(:test_the_key) }
+    Then { feature.key == "_flag:features:test_the_key" }
+  end
+
+  context "percentage" do
+    Given { Flag(:test).on!("50%") }
+
+    Then { Flag(:test).on?(1) == false }
+    And  { Flag(:test).on?(2) == true }
+    And  { Flag(:test).on?("49%") == false }
+    And  { Flag(:test).on?("50%") == true }
+  end
+
+  context "get feature info" do
+    Given { Flag(:test).on!("50%") }
+    Given { Flag(:test).on!("25") }
+    Given { Flag(:test).on!("UUID") }
+    Given { Flag(:test).on!(:staff) }
+
+    Then { Flag(:test).actived.is_a?(Hash) }
+    And  { Flag(:test).actived[:percentage] == 50 }
+    And  { Flag(:test).actived[:users] == ["25", "UUID"] }
+    And  { Flag(:test).actived[:groups] == [:staff] }
+  end
+end

data/test/spec_helper.rb

@@ -0,0 +1,7 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require "minitest/autorun"
+require "minitest/spec"
+require "minitest/pride"
+require "minitest/given"
+require "flag"

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: flag
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- elcuervo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.3.0
+- !ruby/object:Gem::Dependency
+  name: minitest-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Feature flags for the humans and the coders
+email:
+- yo@brunoaguirre.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- SPEC.md
+- flag.gemspec
+- lib/flag.rb
+- test/flag_test.rb
+- test/spec_helper.rb
+homepage: http://github.com/elcuervo/flag
+licenses:
+- MIT
+- HUGWARE
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Simple feature flags
+test_files:
+- test/flag_test.rb
+- test/spec_helper.rb