flipper 0.6.1 → 0.6.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 443602b7b9c4e35349dcf1a0f78da58839d7ce63
+  data.tar.gz: beba70f2d2cadf459ac88a90bddb723e3ccefcef
+SHA512:
+  metadata.gz: 5635c48d957d327148478fb2d5b2e1995d902be5c8f9eb80be4bf6d8465c1a8add294a67c53657716680ae5b597b777af0a998dfaf96d17a3ef62d91bc76e486
+  data.tar.gz: 60d23d5b7a1795828e3fbfd513b593360ab19e4cd6318b4ec6eb6850ab4da9c1dc2c2d4291b5a75e66cdbd458781af1dbc2ba60bf4296f606630e61341d26193

data/Gemfile

@@ -6,7 +6,7 @@ gem 'metriks', :require => false
 gem 'statsd-ruby', :require => false
 gem 'rspec'
 gem 'rack-test'
-gem 'activesupport', :require => false
+gem 'activesupport', '< 4.0.0', :require => false
 
 group(:guard) do
   gem 'guard'

data/lib/flipper.rb

@@ -16,7 +16,7 @@ module Flipper
   #
   # Examples
   #
-  #   Flipper.registry(:admins) { |thing|
+  #   Flipper.register(:admins) { |thing|
   #     thing.respond_to?(:admin?) && thing.admin?
   #   }
   #
@@ -37,6 +37,13 @@ module Flipper
     groups.clear
   end
 
+  # Public: Check if a group exists
+  #
+  # Returns boolean
+  def self.group_exists?(name)
+    self.groups.key?(name)
+  end
+
   # Internal: Fetches a group by name.
   #
   # name - The Symbol name of the group.

data/lib/flipper/feature.rb

@@ -8,7 +8,7 @@ module Flipper
     # Private: The name of instrumentation events.
     InstrumentationName = "feature_operation.#{InstrumentationNamespace}"
 
-    # Internal: The name of the feature.
+    # Public: The name of the feature.
     attr_reader :name
 
     # Internal: Name converted to value safe for adapter.

data/lib/flipper/instrumentation/statsd_subscriber.rb

@@ -1,5 +1,5 @@
 # Note: You should never need to require this file directly if you are using
-# ActiveSupport::Notifications. Instead, you should require the metriks file
+# ActiveSupport::Notifications. Instead, you should require the statsd file
 # that lives in the same directory as this file. The benefit is that it
 # subscribes to the correct events and does everything for your.
 require 'flipper/instrumentation/subscriber'

data/lib/flipper/registry.rb

@@ -45,7 +45,6 @@ module Flipper
 
     def get(key)
       key = key.to_sym
-
       @mutex.synchronize {
         @source.fetch(key) {
           raise KeyNotFound.new(key)
@@ -53,6 +52,13 @@ module Flipper
       }
     end
 
+    def key?(key)
+      key = key.to_sym
+      @mutex.synchronize {
+        @source.has_key?(key)
+      }
+    end
+
     def each(&block)
       @mutex.synchronize { @source.dup }.each(&block)
     end

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -46,26 +46,26 @@ shared_examples_for 'a flipper adapter' do
   end
 
   it "can enable, disable and get value for boolean gate" do
-    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
+    subject.enable(feature, boolean_gate, flipper.boolean).should eq(true)
 
     result = subject.get(feature)
     result[:boolean].should eq('true')
 
-    subject.disable(feature, boolean_gate, flipper.boolean(false)).should be_true
+    subject.disable(feature, boolean_gate, flipper.boolean(false)).should eq(true)
 
     result = subject.get(feature)
-    result[:boolean].should be_nil
+    result[:boolean].should eq(nil)
   end
 
   it "fully disables all enabled things when boolean gate disabled" do
     actor_22 = actor_class.new('22')
-    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
-    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
-    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should be_true
-    subject.enable(feature, actors_gate, flipper.actors(25)).should be_true
-    subject.enable(feature, random_gate, flipper.random(45)).should be_true
+    subject.enable(feature, boolean_gate, flipper.boolean).should eq(true)
+    subject.enable(feature, group_gate, flipper.group(:admins)).should eq(true)
+    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should eq(true)
+    subject.enable(feature, actors_gate, flipper.actors(25)).should eq(true)
+    subject.enable(feature, random_gate, flipper.random(45)).should eq(true)
 
-    subject.disable(feature, boolean_gate, flipper.boolean).should be_true
+    subject.disable(feature, boolean_gate, flipper.boolean).should eq(true)
 
     subject.get(feature).should eq({
       :boolean => nil,
@@ -77,17 +77,17 @@ shared_examples_for 'a flipper adapter' do
   end
 
   it "can enable, disable and get value for group gate" do
-    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
-    subject.enable(feature, group_gate, flipper.group(:early_access)).should be_true
+    subject.enable(feature, group_gate, flipper.group(:admins)).should eq(true)
+    subject.enable(feature, group_gate, flipper.group(:early_access)).should eq(true)
 
     result = subject.get(feature)
     result[:groups].should eq(Set['admins', 'early_access'])
 
-    subject.disable(feature, group_gate, flipper.group(:early_access)).should be_true
+    subject.disable(feature, group_gate, flipper.group(:early_access)).should eq(true)
     result = subject.get(feature)
     result[:groups].should eq(Set['admins'])
 
-    subject.disable(feature, group_gate, flipper.group(:admins)).should be_true
+    subject.disable(feature, group_gate, flipper.group(:admins)).should eq(true)
     result = subject.get(feature)
     result[:groups].should eq(Set.new)
   end
@@ -96,67 +96,67 @@ shared_examples_for 'a flipper adapter' do
     actor_22 = actor_class.new('22')
     actor_asdf = actor_class.new('asdf')
 
-    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should be_true
-    subject.enable(feature, actor_gate, flipper.actor(actor_asdf)).should be_true
+    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should eq(true)
+    subject.enable(feature, actor_gate, flipper.actor(actor_asdf)).should eq(true)
 
     result = subject.get(feature)
     result[:actors].should eq(Set['22', 'asdf'])
 
-    subject.disable(feature, actor_gate, flipper.actor(actor_22)).should be_true
+    subject.disable(feature, actor_gate, flipper.actor(actor_22)).should eq(true)
     result = subject.get(feature)
     result[:actors].should eq(Set['asdf'])
 
-    subject.disable(feature, actor_gate, flipper.actor(actor_asdf)).should be_true
+    subject.disable(feature, actor_gate, flipper.actor(actor_asdf)).should eq(true)
     result = subject.get(feature)
     result[:actors].should eq(Set.new)
   end
 
   it "can enable, disable and get value for percentage of actors gate" do
-    subject.enable(feature, actors_gate, flipper.actors(15)).should be_true
+    subject.enable(feature, actors_gate, flipper.actors(15)).should eq(true)
     result = subject.get(feature)
     result[:percentage_of_actors].should eq('15')
 
-    subject.disable(feature, actors_gate, flipper.actors(0)).should be_true
+    subject.disable(feature, actors_gate, flipper.actors(0)).should eq(true)
     result = subject.get(feature)
     result[:percentage_of_actors].should eq('0')
   end
 
   it "can enable, disable and get value for percentage of random gate" do
-    subject.enable(feature, random_gate, flipper.random(10)).should be_true
+    subject.enable(feature, random_gate, flipper.random(10)).should eq(true)
     result = subject.get(feature)
     result[:percentage_of_random].should eq('10')
 
-    subject.disable(feature, random_gate, flipper.random(0)).should be_true
+    subject.disable(feature, random_gate, flipper.random(0)).should eq(true)
     result = subject.get(feature)
     result[:percentage_of_random].should eq('0')
   end
 
   it "converts boolean value to a string" do
-    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
+    subject.enable(feature, boolean_gate, flipper.boolean).should eq(true)
     result = subject.get(feature)
     result[:boolean].should eq('true')
   end
 
   it "converts the actor value to a string" do
-    subject.enable(feature, actor_gate, flipper.actor(actor_class.new(22))).should be_true
+    subject.enable(feature, actor_gate, flipper.actor(actor_class.new(22))).should eq(true)
     result = subject.get(feature)
     result[:actors].should eq(Set['22'])
   end
 
   it "converts group value to a string" do
-    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
+    subject.enable(feature, group_gate, flipper.group(:admins)).should eq(true)
     result = subject.get(feature)
     result[:groups].should eq(Set['admins'])
   end
 
   it "converts percentage of random integer value to a string" do
-    subject.enable(feature, random_gate, flipper.random(10)).should be_true
+    subject.enable(feature, random_gate, flipper.random(10)).should eq(true)
     result = subject.get(feature)
     result[:percentage_of_random].should eq('10')
   end
 
   it "converts percentage of actors integer value to a string" do
-    subject.enable(feature, actors_gate, flipper.actors(10)).should be_true
+    subject.enable(feature, actors_gate, flipper.actors(10)).should eq(true)
     result = subject.get(feature)
     result[:percentage_of_actors].should eq('10')
   end
@@ -164,28 +164,28 @@ shared_examples_for 'a flipper adapter' do
   it "can add, remove and list known features" do
     subject.features.should eq(Set.new)
 
-    subject.add(flipper[:stats]).should be_true
+    subject.add(flipper[:stats]).should eq(true)
     subject.features.should eq(Set['stats'])
 
-    subject.add(flipper[:search]).should be_true
+    subject.add(flipper[:search]).should eq(true)
     subject.features.should eq(Set['stats', 'search'])
 
-    subject.remove(flipper[:stats]).should be_true
+    subject.remove(flipper[:stats]).should eq(true)
     subject.features.should eq(Set['search'])
 
-    subject.remove(flipper[:search]).should be_true
+    subject.remove(flipper[:search]).should eq(true)
     subject.features.should eq(Set.new)
   end
 
   it "clears all the gate values for the feature on remove" do
     actor_22 = actor_class.new('22')
-    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
-    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
-    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should be_true
-    subject.enable(feature, actors_gate, flipper.actors(25)).should be_true
-    subject.enable(feature, random_gate, flipper.random(45)).should be_true
+    subject.enable(feature, boolean_gate, flipper.boolean).should eq(true)
+    subject.enable(feature, group_gate, flipper.group(:admins)).should eq(true)
+    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should eq(true)
+    subject.enable(feature, actors_gate, flipper.actors(25)).should eq(true)
+    subject.enable(feature, random_gate, flipper.random(45)).should eq(true)
 
-    subject.remove(feature).should be_true
+    subject.remove(feature).should eq(true)
 
     subject.get(feature).should eq({
       :boolean => nil,
@@ -198,13 +198,13 @@ shared_examples_for 'a flipper adapter' do
 
   it "can clear all the gate values for a feature" do
     actor_22 = actor_class.new('22')
-    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
-    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
-    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should be_true
-    subject.enable(feature, actors_gate, flipper.actors(25)).should be_true
-    subject.enable(feature, random_gate, flipper.random(45)).should be_true
+    subject.enable(feature, boolean_gate, flipper.boolean).should eq(true)
+    subject.enable(feature, group_gate, flipper.group(:admins)).should eq(true)
+    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should eq(true)
+    subject.enable(feature, actors_gate, flipper.actors(25)).should eq(true)
+    subject.enable(feature, random_gate, flipper.random(45)).should eq(true)
 
-    subject.clear(feature).should be_true
+    subject.clear(feature).any?.should eq(true)
 
     subject.get(feature).should eq({
       :boolean => nil,
@@ -216,6 +216,6 @@ shared_examples_for 'a flipper adapter' do
   end
 
   it "does not complain clearing a feature that does not exist in adapter" do
-    subject.clear(flipper[:stats]).should be_true
+    subject.clear(flipper[:stats]).any?.should eq(true)
   end
 end

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

data/spec/flipper/adapters/memoizable_spec.rb

@@ -21,10 +21,10 @@ describe Flipper::Adapters::Memoizable do
   describe "#memoize=" do
     it "sets value" do
       subject.memoize = true
-      subject.memoizing?.should be_true
+      subject.memoizing?.should eq(true)
 
       subject.memoize = false
-      subject.memoizing?.should be_false
+      subject.memoizing?.should eq(false)
     end
 
     it "clears the local cache" do
@@ -37,12 +37,12 @@ describe Flipper::Adapters::Memoizable do
   describe "#memoizing?" do
     it "returns true if enabled" do
       subject.memoize = true
-      subject.memoizing?.should be_true
+      subject.memoizing?.should eq(true)
     end
 
     it "returns false if disabled" do
       subject.memoize = false
-      subject.memoizing?.should be_false
+      subject.memoizing?.should eq(false)
     end
   end
 

data/spec/flipper/feature_spec.rb

@@ -142,7 +142,7 @@ describe Flipper::Feature do
       event.payload[:feature_name].should eq(:search)
       event.payload[:operation].should eq(:enabled?)
       event.payload[:thing].should eq(thing)
-      event.payload[:result].should be_false
+      event.payload[:result].should eq(false)
     end
   end
 

data/spec/flipper/gates/boolean_spec.rb

@@ -26,37 +26,37 @@ describe Flipper::Gates::Boolean do
   describe "#enabled?" do
     context "for true value" do
       it "returns true" do
-        subject.enabled?(true).should be_true
+        subject.enabled?(true).should eq(true)
       end
     end
 
     context "for false value" do
       it "returns false" do
-        subject.enabled?(false).should be_false
+        subject.enabled?(false).should eq(false)
       end
     end
 
     context "for nil value" do
       it "returns false" do
-        subject.enabled?(nil).should be_false
+        subject.enabled?(nil).should eq(false)
       end
     end
 
     context "for empty string value" do
       it "returns false" do
-        subject.enabled?('').should be_false
+        subject.enabled?('').should eq(false)
       end
     end
 
     context "for the string true value" do
       it "returns true" do
-        subject.enabled?('true').should be_true
+        subject.enabled?('true').should eq(true)
       end
     end
 
     context "for the string false value" do
       it "returns false" do
-        subject.enabled?('false').should be_false
+        subject.enabled?('false').should eq(false)
       end
     end
   end
@@ -64,37 +64,37 @@ describe Flipper::Gates::Boolean do
   describe "#open?" do
     context "for true value" do
       it "returns true" do
-        subject.open?(Object.new, true).should be_true
+        subject.open?(Object.new, true).should eq(true)
       end
     end
 
     context "for false value" do
       it "returns false" do
-        subject.open?(Object.new, false).should be_false
+        subject.open?(Object.new, false).should eq(false)
       end
     end
 
     context "for nil value" do
       it "returns false" do
-        subject.open?(Object.new, nil).should be_false
+        subject.open?(Object.new, nil).should eq(false)
       end
     end
 
     context "for string true value" do
       it "returns true" do
-        subject.open?(Object.new, 'true').should be_true
+        subject.open?(Object.new, 'true').should eq(true)
       end
     end
 
     context "for string false value" do
       it "returns false" do
-        subject.open?(Object.new, 'false').should be_false
+        subject.open?(Object.new, 'false').should eq(false)
       end
     end
 
     context "for an empty string value" do
       it "returns false" do
-        subject.open?(Object.new, '').should be_false
+        subject.open?(Object.new, '').should eq(false)
       end
     end
   end

data/spec/flipper/gates/group_spec.rb

@@ -50,7 +50,7 @@ describe Flipper::Gates::Group do
 
       it "ignores group" do
         thing = Struct.new(:flipper_id).new('5')
-        subject.open?(thing, Set[:newbs, :staff]).should be_true
+        subject.open?(thing, Set[:newbs, :staff]).should eq(true)
       end
     end
 

data/spec/flipper/gates/percentage_of_random_spec.rb

@@ -24,7 +24,7 @@ describe Flipper::Gates::PercentageOfRandom do
       event.payload[:feature_name].should eq(:search)
 
       # random so don't test value
-      event.payload.key?(:result).should be_true
+      event.payload.key?(:result).should eq(true)
       event.payload[:result].should_not be_nil
     end
   end

data/spec/flipper/instrumenters/noop_spec.rb

@@ -7,7 +7,7 @@ describe Flipper::Instrumenters::Noop do
       it "yields block" do
         yielded = false
         described_class.instrument(:foo) { yielded = true }
-        yielded.should be_true
+        yielded.should eq(true)
       end
     end
 
@@ -15,7 +15,7 @@ describe Flipper::Instrumenters::Noop do
       it "yields block" do
         yielded = false
         described_class.instrument(:foo, {:pay => :load}) { yielded = true }
-        yielded.should be_true
+        yielded.should eq(true)
       end
     end
   end

data/spec/flipper/middleware/memoizer_spec.rb

@@ -27,7 +27,7 @@ describe Flipper::Middleware::Memoizer do
       }
       middleware = described_class.new app, flipper
       middleware.call({})
-      called.should be_true
+      called.should eq(true)
     end
 
     it "disables local cache after body close" do
@@ -35,9 +35,9 @@ describe Flipper::Middleware::Memoizer do
       middleware = described_class.new app, flipper
       body = middleware.call({}).last
 
-      flipper.adapter.memoizing?.should be_true
+      flipper.adapter.memoizing?.should eq(true)
       body.close
-      flipper.adapter.memoizing?.should be_false
+      flipper.adapter.memoizing?.should eq(false)
     end
 
     it "clears local cache after body close" do

data/spec/flipper/registry_spec.rb

@@ -52,6 +52,20 @@ describe Flipper::Registry do
     end
   end
 
+  describe "#key?" do
+    before do
+      source[:admins] = "admins"
+    end
+
+    it "returns true if the key exists" do
+      subject.key?(:admins).should eq true
+    end
+
+    it "returns false if the key does not exists" do
+      subject.key?(:unknown_key).should eq false
+    end
+  end
+
   describe "#each" do
     before do
       source[:admins] = 'admins'

data/spec/flipper/types/actor_spec.rb

@@ -25,12 +25,12 @@ describe Flipper::Types::Actor do
     it "returns true if actor" do
       thing = thing_class.new('1')
       actor = described_class.new(thing)
-      described_class.wrappable?(actor).should be_true
+      described_class.wrappable?(actor).should eq(true)
     end
 
     it "returns true if responds to id" do
       thing = thing_class.new(10)
-      described_class.wrappable?(thing).should be_true
+      described_class.wrappable?(thing).should eq(true)
     end
   end
 
@@ -80,26 +80,26 @@ describe Flipper::Types::Actor do
   it "proxies everything to thing" do
     thing = thing_class.new(10)
     actor = described_class.new(thing)
-    actor.admin?.should be_true
+    actor.admin?.should eq(true)
   end
 
   describe "#respond_to?" do
     it "returns true if responds to method" do
       thing = thing_class.new('1')
       actor = described_class.new(thing)
-      actor.respond_to?(:value).should be_true
+      actor.respond_to?(:value).should eq(true)
     end
 
     it "returns true if thing responds to method" do
       thing = thing_class.new(10)
       actor = described_class.new(thing)
-      actor.respond_to?(:admin?).should be_true
+      actor.respond_to?(:admin?).should eq(true)
     end
 
     it "returns false if does not respond to method and thing does not respond to method" do
       thing = thing_class.new(10)
       actor = described_class.new(thing)
-      actor.respond_to?(:frankenstein).should be_false
+      actor.respond_to?(:frankenstein).should eq(false)
     end
   end
 end

data/spec/flipper/types/group_spec.rb

@@ -22,11 +22,11 @@ describe Flipper::Types::Group do
     let(:non_admin_actor) { double('Actor', :admin? => false) }
 
     it "returns true if block matches" do
-      subject.match?(admin_actor).should be_true
+      subject.match?(admin_actor).should eq(true)
     end
 
     it "returns false if block does not match" do
-      subject.match?(non_admin_actor).should be_false
+      subject.match?(non_admin_actor).should eq(false)
     end
   end
 end

data/spec/flipper/types/percentage_spec.rb

@@ -9,19 +9,19 @@ describe Flipper::Types::Percentage do
 
   describe "#eql?" do
     it "returns true for same class and value" do
-      subject.eql?(described_class.new(subject.value)).should be_true
+      subject.eql?(described_class.new(subject.value)).should eq(true)
     end
 
     it "returns false for different value" do
-      subject.eql?(described_class.new(subject.value + 1)).should be_false
+      subject.eql?(described_class.new(subject.value + 1)).should eq(false)
     end
 
     it "returns false for different class" do
-      subject.eql?(Object.new).should be_false
+      subject.eql?(Object.new).should eq(false)
     end
 
     it "is aliased to ==" do
-      (subject == described_class.new(subject.value)).should be_true
+      (subject == described_class.new(subject.value)).should eq(true)
     end
   end
 end

data/spec/flipper_spec.rb

@@ -8,6 +8,17 @@ describe Flipper do
     end
   end
 
+  describe ".group_exists" do
+    it "returns true if the group is already created" do
+      group = Flipper.register('admins') { |actor| actor.admin? }
+      Flipper.group_exists?(:admins).should eq(true)
+    end
+
+    it "returns false when the group is not yet registered" do
+      Flipper.group_exists?(:non_existing).should eq(false)
+    end
+  end
+
   describe ".groups" do
     it "returns a registry instance" do
       Flipper.groups.should be_instance_of(Flipper::Registry)

data/spec/integration_spec.rb

@@ -35,11 +35,11 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "enables feature for all" do
-        feature.enabled?.should be_true
+        feature.enabled?.should eq(true)
       end
 
       it "adds feature to set of features" do
@@ -53,27 +53,27 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "enables feature for non flipper thing in group" do
-        feature.enabled?(admin_thing).should be_true
+        feature.enabled?(admin_thing).should eq(true)
       end
 
       it "does not enable feature for non flipper thing in other group" do
-        feature.enabled?(dev_thing).should be_false
+        feature.enabled?(dev_thing).should eq(false)
       end
 
       it "enables feature for flipper actor in group" do
-        feature.enabled?(flipper.actor(admin_thing)).should be_true
+        feature.enabled?(flipper.actor(admin_thing)).should eq(true)
       end
 
       it "does not enable for flipper actor not in group" do
-        feature.enabled?(flipper.actor(dev_thing)).should be_false
+        feature.enabled?(flipper.actor(dev_thing)).should eq(false)
       end
 
       it "does not enable feature for all" do
-        feature.enabled?.should be_false
+        feature.enabled?.should eq(false)
       end
 
       it "adds feature to set of features" do
@@ -87,15 +87,15 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "enables feature for actor" do
-        feature.enabled?(pitt).should be_true
+        feature.enabled?(pitt).should eq(true)
       end
 
       it "does not enable feature for other actors" do
-        feature.enabled?(clooney).should be_false
+        feature.enabled?(clooney).should eq(false)
       end
 
       it "adds feature to set of features" do
@@ -109,7 +109,7 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "enables feature for actor within percentage" do
@@ -133,17 +133,17 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "enables feature for time within percentage" do
         @gate.stub(:rand => 0.04)
-        feature.enabled?.should be_true
+        feature.enabled?.should eq(true)
       end
 
       it "does not enable feature for time not within percentage" do
         @gate.stub(:rand => 0.10)
-        feature.enabled?.should be_false
+        feature.enabled?.should eq(false)
       end
 
       it "adds feature to set of features" do
@@ -176,19 +176,19 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should be_truthy
       end
 
       it "disables feature" do
-        feature.enabled?.should be_false
+        feature.enabled?.should eq(false)
       end
 
       it "disables for individual actor" do
-        feature.enabled?(pitt).should be_false
+        feature.enabled?(pitt).should eq(false)
       end
 
       it "disables actor in group" do
-        feature.enabled?(admin_thing).should be_false
+        feature.enabled?(admin_thing).should eq(false)
       end
 
       it "disables actor in percentage of actors" do
@@ -201,7 +201,7 @@ describe Flipper do
       end
 
       it "disables percentage of random" do
-        feature.enabled?(pitt).should be_false
+        feature.enabled?(pitt).should eq(false)
       end
 
       it "adds feature to set of features" do
@@ -217,23 +217,23 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "disables the feature for non flipper thing in the group" do
-        feature.enabled?(admin_thing).should be_false
+        feature.enabled?(admin_thing).should eq(false)
       end
 
       it "does not disable feature for non flipper thing in other groups" do
-        feature.enabled?(dev_thing).should be_true
+        feature.enabled?(dev_thing).should eq(true)
       end
 
       it "disables feature for flipper actor in group" do
-        feature.enabled?(flipper.actor(admin_thing)).should be_false
+        feature.enabled?(flipper.actor(admin_thing)).should eq(false)
       end
 
       it "does not disable feature for flipper actor in other groups" do
-        feature.enabled?(flipper.actor(dev_thing)).should be_true
+        feature.enabled?(flipper.actor(dev_thing)).should eq(true)
       end
 
       it "adds feature to set of features" do
@@ -249,15 +249,15 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "disables feature for actor" do
-        feature.enabled?(pitt).should be_false
+        feature.enabled?(pitt).should eq(false)
       end
 
       it "does not disable feature for other actors" do
-        feature.enabled?(clooney).should be_true
+        feature.enabled?(clooney).should eq(true)
       end
 
       it "adds feature to set of features" do
@@ -271,7 +271,7 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "disables feature" do
@@ -295,17 +295,17 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be_true
+        @result.should eq(true)
       end
 
       it "disables feature for time within percentage" do
         @gate.stub(:rand => 0.04)
-        feature.enabled?.should be_false
+        feature.enabled?.should eq(false)
       end
 
       it "disables feature for time not within percentage" do
         @gate.stub(:rand => 0.10)
-        feature.enabled?.should be_false
+        feature.enabled?.should eq(false)
       end
 
       it "adds feature to set of features" do
@@ -326,7 +326,7 @@ describe Flipper do
   describe "#enabled?" do
     context "with no arguments" do
       it "defaults to false" do
-        feature.enabled?.should be_false
+        feature.enabled?.should eq(false)
       end
     end
 
@@ -336,7 +336,7 @@ describe Flipper do
       end
 
       it "returns true" do
-        feature.enabled?.should be_true
+        feature.enabled?.should eq(true)
       end
     end
 
@@ -346,15 +346,15 @@ describe Flipper do
       end
 
       it "returns true" do
-        feature.enabled?(flipper.actor(admin_thing)).should be_true
-        feature.enabled?(admin_thing).should be_true
+        feature.enabled?(flipper.actor(admin_thing)).should eq(true)
+        feature.enabled?(admin_thing).should eq(true)
       end
     end
 
     context "for actor in disabled group" do
       it "returns false" do
-        feature.enabled?(flipper.actor(dev_thing)).should be_false
-        feature.enabled?(dev_thing).should be_false
+        feature.enabled?(flipper.actor(dev_thing)).should eq(false)
+        feature.enabled?(dev_thing).should eq(false)
       end
     end
 
@@ -364,18 +364,18 @@ describe Flipper do
       end
 
       it "returns true" do
-        feature.enabled?(pitt).should be_true
+        feature.enabled?(pitt).should eq(true)
       end
     end
 
     context "for not enabled actor" do
       it "returns false" do
-        feature.enabled?(clooney).should be_false
+        feature.enabled?(clooney).should eq(false)
       end
 
       it "returns true if boolean enabled" do
         feature.enable
-        feature.enabled?(clooney).should be_true
+        feature.enabled?(clooney).should eq(true)
       end
     end
 
@@ -389,10 +389,10 @@ describe Flipper do
       end
 
       it "returns true" do
-        feature.enabled?.should be_true
-        feature.enabled?(nil).should be_true
-        feature.enabled?(pitt).should be_true
-        feature.enabled?(admin_thing).should be_true
+        feature.enabled?.should eq(true)
+        feature.enabled?(nil).should eq(true)
+        feature.enabled?(pitt).should eq(true)
+        feature.enabled?(admin_thing).should eq(true)
       end
     end
 
@@ -406,18 +406,18 @@ describe Flipper do
       end
 
       it "returns false" do
-        feature.enabled?.should be_false
-        feature.enabled?(nil).should be_false
-        feature.enabled?(pitt).should be_false
-        feature.enabled?(admin_thing).should be_false
+        feature.enabled?.should eq(false)
+        feature.enabled?(nil).should eq(false)
+        feature.enabled?(pitt).should eq(false)
+        feature.enabled?(admin_thing).should eq(false)
       end
 
       it "returns true if boolean enabled" do
         feature.enable
-        feature.enabled?.should be_true
-        feature.enabled?(nil).should be_true
-        feature.enabled?(pitt).should be_true
-        feature.enabled?(admin_thing).should be_true
+        feature.enabled?.should eq(true)
+        feature.enabled?(nil).should eq(true)
+        feature.enabled?(pitt).should eq(true)
+        feature.enabled?(admin_thing).should eq(true)
       end
     end
 
@@ -427,17 +427,17 @@ describe Flipper do
       end
 
       it "returns true if in enabled group" do
-        feature.enabled?(admin_thing).should be_true
+        feature.enabled?(admin_thing).should eq(true)
       end
 
       it "returns false if not in enabled group" do
-        feature.enabled?(dev_thing).should be_false
+        feature.enabled?(dev_thing).should eq(false)
       end
 
       it "returns true if boolean enabled" do
         feature.enable
-        feature.enabled?(admin_thing).should be_true
-        feature.enabled?(dev_thing).should be_true
+        feature.enabled?(admin_thing).should eq(true)
+        feature.enabled?(dev_thing).should eq(true)
       end
     end
   end
@@ -451,11 +451,11 @@ describe Flipper do
     end
 
     it "enables feature for object in enabled group" do
-      feature.enabled?(admin_thing).should be_true
+      feature.enabled?(admin_thing).should eq(true)
     end
 
     it "does not enable feature for object in not enabled group" do
-      feature.enabled?(dev_thing).should be_false
+      feature.enabled?(dev_thing).should eq(false)
     end
   end
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flipper
 version: !ruby/object:Gem::Version
-  version: 0.6.1
-  prerelease: 
+  version: 0.6.2
 platform: ruby
 authors:
 - John Nunemaker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-27 00:00:00.000000000 Z
+date: 2014-10-07 00:00:00.000000000 Z
 dependencies: []
 description: Feature flipper for any adapter
 email:
@@ -18,9 +17,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Changelog.md
 - Gemfile
 - Guardfile
@@ -103,33 +102,26 @@ files:
 - spec/support/fake_udp_socket.rb
 homepage: http://jnunemaker.github.com/flipper
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2625440176401499604
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2625440176401499604
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Feature flipper for any adapter
 test_files:
 - spec/flipper/adapters/instrumented_spec.rb