flipper 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 843d4702915781ed5862b1e06ad68f1bbc70edab
-  data.tar.gz: b3709b9a9bddaee1e6847eca0401f4bbcfe09944
+  metadata.gz: ead277793aee2dece9038ca1cdd59ac0607a5cc4
+  data.tar.gz: c10127accd784df6b64e54442568e29bd4ddadde
 SHA512:
-  metadata.gz: 06713185ad986e260ab2e409f9b995267c938823c8f7a7193ce82e618a753849e813d3a34f5af3100aed44e79d5c2874b1acf9cef09fc588505ecc8f1cf59892
-  data.tar.gz: f1dab95196ab81477d3eb0e2c667fa36341763417582efc6181a40d5f64f60c24d118fd840a7bde4155b820301a6991e25975c8a88faa8ff4cb495e5946061e4
+  metadata.gz: 11dea621bb4989d05bf945de1c006e81029259e1996690aecc9327a879877f73d81813cb12c0f0afd47ecf53a93e6dfc235c6f370c9be0a149d0077f5ecf63c0
+  data.tar.gz: 55d930c0fb9031ed9470311805b613e831d610c70d0664338fa0a0e9f008785fa82302380f4dd0dbc3a37d8e019128343769faf5d8d20c4adbb3459370f6f04a

data/Changelog.md

@@ -1,3 +1,7 @@
+## 0.7.2
+
+* Add Flipper::UI.application_breadcrumb_href for setting breadcrumb back to original app from Flipper UI
+
 ## 0.7.1
 
 * Fix bug where features with names that match static file routes were incorrectly routing to the file action (https://github.com/jnunemaker/flipper/issues/80)

data/Gemfile

@@ -10,7 +10,7 @@ gem 'rake', '~> 10.4.2'
 gem 'metriks', '~> 0.9.9'
 gem 'shotgun', '~> 0.9'
 gem 'statsd-ruby', '~> 1.2.1'
-gem 'rspec', '~> 2.14'
+gem 'rspec', '~> 3.0'
 gem 'rack-test', '~> 0.6.3'
 gem 'activesupport', '~> 4.2.0'
 

data/docs/Adapters.md

@@ -8,7 +8,8 @@ I plan on supporting the adapters in the flipper repo. Other adapters are welcom
 * [Redis adapter](https://github.com/jnunemaker/flipper/blob/master/docs/redis)
 * [Cassanity adapter](https://github.com/jnunemaker/flipper-cassanity)
 * [Active Record 4 adapter](https://github.com/bgentry/flipper-activerecord)
-* [Active Record 3 adapter](https://github.com/jproudman/flipper-activerecord)
+* [Active Record 3 adapter](https://github.com/blueboxjesse/flipper-activerecord)
+* [Consul adapter](https://github.com/gdavison/flipper-consul)
 
 The basic API for an adapter is this:
 

data/examples/enabled_for_actor.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../example_setup', __FILE__)
+
+require 'flipper'
+require 'flipper/adapters/memory'
+
+# Some class that represents what will be trying to do something
+class User
+  attr_reader :id
+
+  def initialize(id, admin)
+    @id = id
+    @admin = admin
+  end
+
+  def admin?
+    @admin
+  end
+
+  # Must respond to flipper_id
+  alias_method :flipper_id, :id
+end
+
+user1 = User.new(1, true)
+user2 = User.new(2, false)
+
+# pick an adapter
+adapter = Flipper::Adapters::Memory.new
+
+# get a handy dsl instance
+flipper = Flipper.new(adapter)
+
+Flipper.register :admins do |actor|
+  actor.admin?
+end
+
+flipper[:search].enable
+flipper[:stats].enable_actor user1
+flipper[:pro_stats].enable_percentage_of_actors 50
+flipper[:tweets].enable_group :admins
+flipper[:posts].enable_actor user2
+
+pp flipper.features.select { |feature| feature.enabled?(user1) }.map(&:name)
+pp flipper.features.select { |feature| feature.enabled?(user2) }.map(&:name)

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -27,16 +27,16 @@ shared_examples_for 'a flipper adapter' do
   end
 
   it "has name that is a symbol" do
-    subject.name.should_not be_nil
-    subject.name.should be_instance_of(Symbol)
+    expect(subject.name).to_not be_nil
+    expect(subject.name).to be_instance_of(Symbol)
   end
 
   it "has included the flipper adapter module" do
-    subject.class.ancestors.should include(Flipper::Adapter)
+    expect(subject.class.ancestors).to include(Flipper::Adapter)
   end
 
   it "returns correct default values for the gates if none are enabled" do
-    subject.get(feature).should eq({
+    expect(subject.get(feature)).to eq({
       :boolean => nil,
       :groups => Set.new,
       :actors => Set.new,
@@ -46,28 +46,28 @@ 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 eq(true)
+    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
 
     result = subject.get(feature)
-    result[:boolean].should eq('true')
+    expect(result[:boolean]).to eq('true')
 
-    subject.disable(feature, boolean_gate, flipper.boolean(false)).should eq(true)
+    expect(subject.disable(feature, boolean_gate, flipper.boolean(false))).to eq(true)
 
     result = subject.get(feature)
-    result[:boolean].should eq(nil)
+    expect(result[:boolean]).to 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 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, time_gate, flipper.time(45)).should eq(true)
+    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
+    expect(subject.enable(feature, actor_gate, flipper.actor(actor_22))).to eq(true)
+    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
+    expect(subject.enable(feature, time_gate, flipper.time(45))).to eq(true)
 
-    subject.disable(feature, boolean_gate, flipper.boolean).should eq(true)
+    expect(subject.disable(feature, boolean_gate, flipper.boolean)).to eq(true)
 
-    subject.get(feature).should eq({
+    expect(subject.get(feature)).to eq({
       :boolean => nil,
       :groups => Set.new,
       :actors => Set.new,
@@ -77,117 +77,117 @@ 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 eq(true)
-    subject.enable(feature, group_gate, flipper.group(:early_access)).should eq(true)
+    expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
+    expect(subject.enable(feature, group_gate, flipper.group(:early_access))).to eq(true)
 
     result = subject.get(feature)
-    result[:groups].should eq(Set['admins', 'early_access'])
+    expect(result[:groups]).to eq(Set['admins', 'early_access'])
 
-    subject.disable(feature, group_gate, flipper.group(:early_access)).should eq(true)
+    expect(subject.disable(feature, group_gate, flipper.group(:early_access))).to eq(true)
     result = subject.get(feature)
-    result[:groups].should eq(Set['admins'])
+    expect(result[:groups]).to eq(Set['admins'])
 
-    subject.disable(feature, group_gate, flipper.group(:admins)).should eq(true)
+    expect(subject.disable(feature, group_gate, flipper.group(:admins))).to eq(true)
     result = subject.get(feature)
-    result[:groups].should eq(Set.new)
+    expect(result[:groups]).to eq(Set.new)
   end
 
   it "can enable, disable and get value for actor gate" do
     actor_22 = actor_class.new('22')
     actor_asdf = actor_class.new('asdf')
 
-    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should eq(true)
-    subject.enable(feature, actor_gate, flipper.actor(actor_asdf)).should eq(true)
+    expect(subject.enable(feature, actor_gate, flipper.actor(actor_22))).to eq(true)
+    expect(subject.enable(feature, actor_gate, flipper.actor(actor_asdf))).to eq(true)
 
     result = subject.get(feature)
-    result[:actors].should eq(Set['22', 'asdf'])
+    expect(result[:actors]).to eq(Set['22', 'asdf'])
 
-    subject.disable(feature, actor_gate, flipper.actor(actor_22)).should eq(true)
+    expect(subject.disable(feature, actor_gate, flipper.actor(actor_22))).to eq(true)
     result = subject.get(feature)
-    result[:actors].should eq(Set['asdf'])
+    expect(result[:actors]).to eq(Set['asdf'])
 
-    subject.disable(feature, actor_gate, flipper.actor(actor_asdf)).should eq(true)
+    expect(subject.disable(feature, actor_gate, flipper.actor(actor_asdf))).to eq(true)
     result = subject.get(feature)
-    result[:actors].should eq(Set.new)
+    expect(result[:actors]).to 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 eq(true)
+    expect(subject.enable(feature, actors_gate, flipper.actors(15))).to eq(true)
     result = subject.get(feature)
-    result[:percentage_of_actors].should eq('15')
+    expect(result[:percentage_of_actors]).to eq('15')
 
-    subject.disable(feature, actors_gate, flipper.actors(0)).should eq(true)
+    expect(subject.disable(feature, actors_gate, flipper.actors(0))).to eq(true)
     result = subject.get(feature)
-    result[:percentage_of_actors].should eq('0')
+    expect(result[:percentage_of_actors]).to eq('0')
   end
 
   it "can enable, disable and get value for percentage of time gate" do
-    subject.enable(feature, time_gate, flipper.time(10)).should eq(true)
+    expect(subject.enable(feature, time_gate, flipper.time(10))).to eq(true)
     result = subject.get(feature)
-    result[:percentage_of_time].should eq('10')
+    expect(result[:percentage_of_time]).to eq('10')
 
-    subject.disable(feature, time_gate, flipper.time(0)).should eq(true)
+    expect(subject.disable(feature, time_gate, flipper.time(0))).to eq(true)
     result = subject.get(feature)
-    result[:percentage_of_time].should eq('0')
+    expect(result[:percentage_of_time]).to eq('0')
   end
 
   it "converts boolean value to a string" do
-    subject.enable(feature, boolean_gate, flipper.boolean).should eq(true)
+    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
     result = subject.get(feature)
-    result[:boolean].should eq('true')
+    expect(result[:boolean]).to eq('true')
   end
 
   it "converts the actor value to a string" do
-    subject.enable(feature, actor_gate, flipper.actor(actor_class.new(22))).should eq(true)
+    expect(subject.enable(feature, actor_gate, flipper.actor(actor_class.new(22)))).to eq(true)
     result = subject.get(feature)
-    result[:actors].should eq(Set['22'])
+    expect(result[:actors]).to eq(Set['22'])
   end
 
   it "converts group value to a string" do
-    subject.enable(feature, group_gate, flipper.group(:admins)).should eq(true)
+    expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
     result = subject.get(feature)
-    result[:groups].should eq(Set['admins'])
+    expect(result[:groups]).to eq(Set['admins'])
   end
 
   it "converts percentage of time integer value to a string" do
-    subject.enable(feature, time_gate, flipper.time(10)).should eq(true)
+    expect(subject.enable(feature, time_gate, flipper.time(10))).to eq(true)
     result = subject.get(feature)
-    result[:percentage_of_time].should eq('10')
+    expect(result[:percentage_of_time]).to eq('10')
   end
 
   it "converts percentage of actors integer value to a string" do
-    subject.enable(feature, actors_gate, flipper.actors(10)).should eq(true)
+    expect(subject.enable(feature, actors_gate, flipper.actors(10))).to eq(true)
     result = subject.get(feature)
-    result[:percentage_of_actors].should eq('10')
+    expect(result[:percentage_of_actors]).to eq('10')
   end
 
   it "can add, remove and list known features" do
-    subject.features.should eq(Set.new)
+    expect(subject.features).to eq(Set.new)
 
-    subject.add(flipper[:stats]).should eq(true)
-    subject.features.should eq(Set['stats'])
+    expect(subject.add(flipper[:stats])).to eq(true)
+    expect(subject.features).to eq(Set['stats'])
 
-    subject.add(flipper[:search]).should eq(true)
-    subject.features.should eq(Set['stats', 'search'])
+    expect(subject.add(flipper[:search])).to eq(true)
+    expect(subject.features).to eq(Set['stats', 'search'])
 
-    subject.remove(flipper[:stats]).should eq(true)
-    subject.features.should eq(Set['search'])
+    expect(subject.remove(flipper[:stats])).to eq(true)
+    expect(subject.features).to eq(Set['search'])
 
-    subject.remove(flipper[:search]).should eq(true)
-    subject.features.should eq(Set.new)
+    expect(subject.remove(flipper[:search])).to eq(true)
+    expect(subject.features).to 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 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, time_gate, flipper.time(45)).should eq(true)
+    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
+    expect(subject.enable(feature, actor_gate, flipper.actor(actor_22))).to eq(true)
+    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
+    expect(subject.enable(feature, time_gate, flipper.time(45))).to eq(true)
 
-    subject.remove(feature).should eq(true)
+    expect(subject.remove(feature)).to eq(true)
 
-    subject.get(feature).should eq({
+    expect(subject.get(feature)).to eq({
       :boolean => nil,
       :groups => Set.new,
       :actors => Set.new,
@@ -198,15 +198,15 @@ 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 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, time_gate, flipper.time(45)).should eq(true)
+    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
+    expect(subject.enable(feature, actor_gate, flipper.actor(actor_22))).to eq(true)
+    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
+    expect(subject.enable(feature, time_gate, flipper.time(45))).to eq(true)
 
-    subject.clear(feature).should eq(true)
+    expect(subject.clear(feature)).to eq(true)
 
-    subject.get(feature).should eq({
+    expect(subject.get(feature)).to eq({
       :boolean => nil,
       :groups => Set.new,
       :actors => Set.new,
@@ -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 eq(true)
+    expect(subject.clear(flipper[:stats])).to eq(true)
   end
 end

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

data/spec/flipper/adapters/instrumented_spec.rb

@@ -4,7 +4,7 @@ require 'flipper/adapters/instrumented'
 require 'flipper/instrumenters/memory'
 require 'flipper/spec/shared_adapter_specs'
 
-describe Flipper::Adapters::Instrumented do
+RSpec.describe Flipper::Adapters::Instrumented do
   let(:instrumenter) { Flipper::Instrumenters::Memory.new }
   let(:adapter) { Flipper::Adapters::Memory.new }
   let(:flipper) { Flipper.new(adapter) }
@@ -24,12 +24,12 @@ describe Flipper::Adapters::Instrumented do
       result = subject.get(feature)
 
       event = instrumenter.events.last
-      event.should_not be_nil
-      event.name.should eq('adapter_operation.flipper')
-      event.payload[:operation].should eq(:get)
-      event.payload[:adapter_name].should eq(:memory)
-      event.payload[:feature_name].should eq(:stats)
-      event.payload[:result].should be(result)
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:get)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:feature_name]).to eq(:stats)
+      expect(event.payload[:result]).to be(result)
     end
   end
 
@@ -38,13 +38,13 @@ describe Flipper::Adapters::Instrumented do
       result = subject.enable(feature, gate, thing)
 
       event = instrumenter.events.last
-      event.should_not be_nil
-      event.name.should eq('adapter_operation.flipper')
-      event.payload[:operation].should eq(:enable)
-      event.payload[:adapter_name].should eq(:memory)
-      event.payload[:feature_name].should eq(:stats)
-      event.payload[:gate_name].should eq(:percentage_of_actors)
-      event.payload[:result].should be(result)
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:enable)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:feature_name]).to eq(:stats)
+      expect(event.payload[:gate_name]).to eq(:percentage_of_actors)
+      expect(event.payload[:result]).to be(result)
     end
   end
 
@@ -53,13 +53,13 @@ describe Flipper::Adapters::Instrumented do
       result = subject.disable(feature, gate, thing)
 
       event = instrumenter.events.last
-      event.should_not be_nil
-      event.name.should eq('adapter_operation.flipper')
-      event.payload[:operation].should eq(:disable)
-      event.payload[:adapter_name].should eq(:memory)
-      event.payload[:feature_name].should eq(:stats)
-      event.payload[:gate_name].should eq(:percentage_of_actors)
-      event.payload[:result].should be(result)
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:disable)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:feature_name]).to eq(:stats)
+      expect(event.payload[:gate_name]).to eq(:percentage_of_actors)
+      expect(event.payload[:result]).to be(result)
     end
   end
 
@@ -68,12 +68,12 @@ describe Flipper::Adapters::Instrumented do
       result = subject.add(feature)
 
       event = instrumenter.events.last
-      event.should_not be_nil
-      event.name.should eq('adapter_operation.flipper')
-      event.payload[:operation].should eq(:add)
-      event.payload[:adapter_name].should eq(:memory)
-      event.payload[:feature_name].should eq(:stats)
-      event.payload[:result].should be(result)
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:add)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:feature_name]).to eq(:stats)
+      expect(event.payload[:result]).to be(result)
     end
   end
 
@@ -82,12 +82,12 @@ describe Flipper::Adapters::Instrumented do
       result = subject.remove(feature)
 
       event = instrumenter.events.last
-      event.should_not be_nil
-      event.name.should eq('adapter_operation.flipper')
-      event.payload[:operation].should eq(:remove)
-      event.payload[:adapter_name].should eq(:memory)
-      event.payload[:feature_name].should eq(:stats)
-      event.payload[:result].should be(result)
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:remove)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:feature_name]).to eq(:stats)
+      expect(event.payload[:result]).to be(result)
     end
   end
 
@@ -96,12 +96,12 @@ describe Flipper::Adapters::Instrumented do
       result = subject.clear(feature)
 
       event = instrumenter.events.last
-      event.should_not be_nil
-      event.name.should eq('adapter_operation.flipper')
-      event.payload[:operation].should eq(:clear)
-      event.payload[:adapter_name].should eq(:memory)
-      event.payload[:feature_name].should eq(:stats)
-      event.payload[:result].should be(result)
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:clear)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:feature_name]).to eq(:stats)
+      expect(event.payload[:result]).to be(result)
     end
   end
 
@@ -110,11 +110,11 @@ describe Flipper::Adapters::Instrumented do
       result = subject.features
 
       event = instrumenter.events.last
-      event.should_not be_nil
-      event.name.should eq('adapter_operation.flipper')
-      event.payload[:operation].should eq(:features)
-      event.payload[:adapter_name].should eq(:memory)
-      event.payload[:result].should be(result)
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:features)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:result]).to be(result)
     end
   end
 end