detour 0.0.1 → 0.0.2

data/spec/lib/tasks/{detour_rake_spec.rb → detour_spec.rb}

@@ -12,151 +12,151 @@ end
 describe "detour:destroy" do
   include_context "rake"
 
-  let(:feature) { Detour::Feature.create(name: "foo") }
+  let(:feature) { create :feature }
 
   it "destroys the given feature" do
     Detour::Feature.should_receive(:find_by_name!).with(feature.name).and_return(feature)
     feature.should_receive(:destroy)
-    subject.invoke("foo")
+    subject.invoke(feature.name)
   end
 end
 
 describe "detour:activate" do
   include_context "rake"
 
-  let(:user) { User.create(name: "foo") }
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:user)    { create :user }
+  let(:feature) { create :feature }
 
   it "activates the feature for the record" do
-    Detour::Feature.should_receive(:add_record_to_feature).with(user, "foo")
-    subject.invoke("foo", "User", user.id.to_s)
+    Detour::Feature.should_receive(:add_record_to_feature).with(user, feature.name)
+    subject.invoke(feature.name, user.class.to_s, user.id.to_s)
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:add_record_to_feature).with(user, "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo", user.id.to_s) }.to_not raise_error
+    Detour::Feature.should_receive(:add_record_to_feature).with(user, feature.name)
+    Detour.config.default_flaggable_class_name = user.class.to_s
+    expect { subject.invoke(feature.name, user.id.to_s) }.to_not raise_error
   end
 end
 
 describe "detour:deactivate" do
   include_context "rake"
 
-  let(:user) { User.create(name: "foo") }
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:user)    { create :user }
+  let(:feature) { create :feature }
 
   it "deactivates the feature for the record" do
-    Detour::Feature.should_receive(:remove_record_from_feature).with(user, "foo")
-    subject.invoke("foo", "User", user.id.to_s)
+    Detour::Feature.should_receive(:remove_record_from_feature).with(user, feature.name)
+    subject.invoke(feature.name, user.class.to_s, user.id.to_s)
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:remove_record_from_feature).with(user, "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo", user.id.to_s) }.to_not raise_error
+    Detour::Feature.should_receive(:remove_record_from_feature).with(user, feature.name)
+    Detour.config.default_flaggable_class_name = user.class.to_s
+    expect { subject.invoke(feature.name, user.id.to_s) }.to_not raise_error
   end
 end
 
 describe "detour:opt_out" do
   include_context "rake"
 
-  let(:user) { User.create(name: "foo") }
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:user)    { create :user }
+  let(:feature) { create :feature }
 
   it "deactivates the feature for the record" do
-    Detour::Feature.should_receive(:opt_record_out_of_feature).with(user, "foo")
-    subject.invoke("foo", "User", user.id.to_s)
+    Detour::Feature.should_receive(:opt_record_out_of_feature).with(user, feature.name)
+    subject.invoke(feature.name, user.class.to_s, user.id.to_s)
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:opt_record_out_of_feature).with(user, "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo", user.id.to_s) }.to_not raise_error
+    Detour::Feature.should_receive(:opt_record_out_of_feature).with(user, feature.name)
+    Detour.config.default_flaggable_class_name = user.class.to_s
+    expect { subject.invoke(feature.name, user.id.to_s) }.to_not raise_error
   end
 end
 
 describe "detour:un_opt_out" do
   include_context "rake"
 
-  let(:user) { User.create(name: "foo") }
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:user)    { create :user }
+  let(:feature) { create :feature }
 
   it "deactivates the feature for the record" do
-    Detour::Feature.should_receive(:un_opt_record_out_of_feature).with(user, "foo")
-    subject.invoke("foo", "User", user.id.to_s)
+    Detour::Feature.should_receive(:un_opt_record_out_of_feature).with(user, feature.name)
+    subject.invoke(feature.name, user.class.to_s, user.id.to_s)
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:un_opt_record_out_of_feature).with(user, "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo", user.id.to_s) }.to_not raise_error
+    Detour::Feature.should_receive(:un_opt_record_out_of_feature).with(user, feature.name)
+    Detour.config.default_flaggable_class_name = user.class.to_s
+    expect { subject.invoke(feature.name, user.id.to_s) }.to_not raise_error
   end
 end
 
 describe "detour:activate_group" do
   include_context "rake"
 
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:feature) { create :feature }
 
   it "activates the feature for the group" do
-    Detour::Feature.should_receive(:add_group_to_feature).with("User", "admins", "foo")
-    subject.invoke("foo", "User", "admins")
+    Detour::Feature.should_receive(:add_group_to_feature).with("User", "admins", feature.name)
+    subject.invoke(feature.name, "User", "admins")
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:add_group_to_feature).with("User", "admins", "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo", "admins") }.to_not raise_error
+    Detour::Feature.should_receive(:add_group_to_feature).with("User", "admins", feature.name)
+    Detour.config.default_flaggable_class_name = "User"
+    expect { subject.invoke(feature.name, "admins") }.to_not raise_error
   end
 end
 
 describe "detour:deactivate_group" do
   include_context "rake"
 
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:feature) { create :feature }
 
   it "deactivates the feature for the group" do
-    Detour::Feature.should_receive(:remove_group_from_feature).with("User", "admins", "foo")
-    subject.invoke("foo", "User", "admins")
+    Detour::Feature.should_receive(:remove_group_from_feature).with("User", "admins", feature.name)
+    subject.invoke(feature.name, "User", "admins")
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:remove_group_from_feature).with("User", "admins", "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo", "admins") }.to_not raise_error
+    Detour::Feature.should_receive(:remove_group_from_feature).with("User", "admins", feature.name)
+    Detour.config.default_flaggable_class_name = "User"
+    expect { subject.invoke(feature.name, "admins") }.to_not raise_error
   end
 end
 
 describe "detour:activate_percentage" do
   include_context "rake"
 
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:feature) { create :feature }
 
   it "activates the feature for the percentage" do
-    Detour::Feature.should_receive(:add_percentage_to_feature).with("User", 50, "foo")
-    subject.invoke("foo", "User", "50")
+    Detour::Feature.should_receive(:add_percentage_to_feature).with("User", 50, feature.name)
+    subject.invoke(feature.name, "User", "50")
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:add_percentage_to_feature).with("User", 50, "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo", "50") }.to_not raise_error
+    Detour::Feature.should_receive(:add_percentage_to_feature).with("User", 50, feature.name)
+    Detour.config.default_flaggable_class_name = "User"
+    expect { subject.invoke(feature.name, "50") }.to_not raise_error
   end
 end
 
 describe "detour:deactivate_percentage" do
   include_context "rake"
 
-  let!(:feature) { Detour::Feature.create(name: "foo") }
+  let(:feature) { create :feature }
 
   it "deactivates the feature for the percentage" do
-    Detour::Feature.should_receive(:remove_percentage_from_feature).with("User", "foo")
-    subject.invoke("foo", "User")
+    Detour::Feature.should_receive(:remove_percentage_from_feature).with("User", feature.name)
+    subject.invoke(feature.name, "User")
   end
 
   it "does not require a class if defined_flaggable_class is set" do
-    Detour::Feature.should_receive(:remove_percentage_from_feature).with("User", "foo")
-    Detour::Feature.instance_variable_set "@default_flaggable_class_name", "User"
-    expect { subject.invoke("foo") }.to_not raise_error
+    Detour::Feature.should_receive(:remove_percentage_from_feature).with("User", feature.name)
+    Detour.config.default_flaggable_class_name = "User"
+    expect { subject.invoke(feature.name) }.to_not raise_error
   end
 end

data/spec/{lib/active_record/rollout → models/detour}/feature_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "fakefs/spec_helpers"
 
 describe Detour::Feature do
-  it { should have_many(:flaggable_flags) }
+  it { should have_many(:flag_in_flags) }
   it { should have_many(:group_flags) }
   it { should have_many(:percentage_flags) }
   it { should have_many(:opt_out_flags) }
@@ -11,13 +11,13 @@ describe Detour::Feature do
   it { should validate_uniqueness_of :name }
   it { should allow_mass_assignment_of :name }
 
-  describe ".all_with_lines" do
+  describe ".with_lines" do
     include FakeFS::SpecHelpers
 
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:feature) { create :feature, name: "foo" }
 
     before do
-      Detour::Feature.grep_dirs = ["/foo/**/*.rb"]
+      Detour.config.grep_dirs = ["/foo/**/*.rb"]
 
       FileUtils.mkdir("/foo")
 
@@ -45,30 +45,22 @@ describe Detour::Feature do
     end
 
     it "fetches lines for persisted features" do
-      persisted_feature = Detour::Feature.all_with_lines.detect { |f| f.name == feature.name }
+      persisted_feature = Detour::Feature.with_lines.detect { |f| f.name == feature.name }
       persisted_feature.lines.should eq %w[/foo/bar.rb#L1 /foo/bar.rb#L7 /foo/baz.rb#L1]
     end
 
     it "fetches lines for un-persisted features" do
-      unpersisted_feature = Detour::Feature.all_with_lines.detect { |f| f.name == "bar" }
+      unpersisted_feature = Detour::Feature.with_lines.detect { |f| f.name == "bar" }
       unpersisted_feature.lines.should eq %w[/foo/bar.rb#L4 /foo/baz.rb#L1 /foo/baz.rb#L3]
     end
   end
 
-  describe ".define_{klass}_group" do
-    let(:block) { Proc.new {} }
-    it "defines a group for the given class" do
-      Detour::Feature.should_receive(:define_group_for_class).with("User", :id_is_1)
-      Detour::Feature.define_user_group :id_is_1, block
-    end
-  end
-
   describe ".add_record_to_feature" do
-    let(:user) { User.create }
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:user)    { create :user }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.add_record_to_feature user, :foo
+      Detour::Feature.add_record_to_feature user, feature.name
     end
 
     it "creates a flag for the given instance and feature" do
@@ -77,12 +69,12 @@ describe Detour::Feature do
   end
 
   describe ".remove_record_from_feature" do
-    let(:user) { User.create }
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:user)    { create :user }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.add_record_to_feature user, :foo
-      Detour::Feature.remove_record_from_feature user, :foo
+      Detour::Feature.add_record_to_feature user, feature.name
+      Detour::Feature.remove_record_from_feature user, feature.name
     end
 
     it "creates a flag for the given instance and feature" do
@@ -91,41 +83,41 @@ describe Detour::Feature do
   end
 
   describe ".opt_record_out_of_feature" do
-    let(:user) { User.create }
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:user)    { create :user }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.add_percentage_to_feature "User", 100, "foo"
-      Detour::Feature.opt_record_out_of_feature user, "foo"
+      Detour::Feature.add_percentage_to_feature user.class.to_s, 100, feature.name
+      Detour::Feature.opt_record_out_of_feature user, feature.name
     end
 
     it "opts the record out of the feature" do
-      user.has_feature?("foo").should be_false
+      user.has_feature?(feature.name).should be_false
     end
   end
 
   describe ".un_opt_record_out_of_feature" do
-    let(:user) { User.create }
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:user)    { create :user }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.add_percentage_to_feature "User", 100, "foo"
-      Detour::Feature.opt_record_out_of_feature user, "foo"
-      Detour::Feature.un_opt_record_out_of_feature user, "foo"
+      Detour::Feature.add_percentage_to_feature user.class.to_s, 100, feature.name
+      Detour::Feature.opt_record_out_of_feature user, feature.name
+      Detour::Feature.un_opt_record_out_of_feature user, feature.name
     end
 
     it "opts the record out of the feature" do
-      user.has_feature?("foo").should be_true
+      user.has_feature?(feature.name).should be_true
     end
   end
 
   describe ".add_group_to_feature" do
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.define_user_group :bar do
+      Detour.config.define_user_group :bar do
       end
-      Detour::Feature.add_group_to_feature "User", :bar, "foo"
+      Detour::Feature.add_group_to_feature "User", :bar, feature.name
     end
 
     it "creates a flag for the given group and feature" do
@@ -134,13 +126,13 @@ describe Detour::Feature do
   end
 
   describe ".remove_group_from_feature" do
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.define_user_group :bar do
+      Detour.config.define_user_group :bar do
       end
-      Detour::Feature.add_group_to_feature "User", :bar, "foo"
-      Detour::Feature.remove_group_from_feature "User", :bar, "foo"
+      Detour::Feature.add_group_to_feature "User", :bar, feature.name
+      Detour::Feature.remove_group_from_feature "User", :bar, feature.name
     end
 
     it "destroys flags for the given group and feature" do
@@ -149,10 +141,10 @@ describe Detour::Feature do
   end
 
   describe ".add_percentage_to_feature" do
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.add_percentage_to_feature "User", 50, "foo"
+      Detour::Feature.add_percentage_to_feature "User", 50, feature.name
     end
 
     it "creates a flag for the given percentage and feature" do
@@ -161,11 +153,11 @@ describe Detour::Feature do
   end
 
   describe ".remove_percentage_from_feature" do
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.add_percentage_to_feature "User", 50, "foo"
-      Detour::Feature.remove_percentage_from_feature "User", "foo"
+      Detour::Feature.add_percentage_to_feature "User", 50, feature.name
+      Detour::Feature.remove_percentage_from_feature "User", feature.name
     end
 
     it "creates a flag for the given percentage and feature" do
@@ -173,20 +165,17 @@ describe Detour::Feature do
     end
   end
 
-  describe ".define_group_for_class" do
-    let(:block) { Proc.new {} }
-    before do
-      Detour::Feature.send :define_group_for_class, "User", "user_id_1", &block
-    end
+  describe "#to_s" do
+    let(:feature) { create :feature }
 
-    it "defines a group for the given class" do
-      Detour::Feature.defined_groups["User"].should eq({ "user_id_1" => block })
+    it "returns the name of the feature" do
+      feature.to_s.should eq feature.name
     end
   end
 
   describe "#match?" do
-    let(:user) { User.create }
-    let(:feature) { Detour::Feature.create(name: "foo") }
+    let(:user)    { create :user }
+    let(:feature) { create :feature }
 
     it "checks if the user is flagged individually" do
       feature.should_receive(:match_id?).with(user)
@@ -204,13 +193,50 @@ describe Detour::Feature do
     end
   end
 
+  describe "#flag_in_count_for" do
+    context "when a value does not exist" do
+      let(:feature) { create :feature }
+
+      it "returns 0" do
+        feature.flag_in_count_for("users").should eq 0
+      end
+    end
+
+    context "when a value exists" do
+      let(:feature) { create :feature, flag_in_counts: { "users" => 10 } }
+
+      it "returns the value" do
+        feature.flag_in_count_for("users").should eq 10
+      end
+    end
+  end
+
+  describe "#opt_out_count_for" do
+    context "when a value does not exist" do
+      let(:feature) { create :feature }
+
+      it "returns 0" do
+        feature.opt_out_count_for("users").should eq 0
+      end
+    end
+
+    context "when a value exists" do
+      let(:feature) { create :feature, opt_out_counts: { "users" => 10 } }
+
+      it "returns the value" do
+        feature.opt_out_count_for("users").should eq 10
+      end
+    end
+  end
+
+
   describe "#match_id?" do
-    let(:user) { User.create }
-    let(:user2) { User.create }
-    let!(:feature) { Detour::Feature.create!(name: "foo") }
+    let(:user)    { create :user }
+    let(:user2)   { create :user }
+    let(:feature) { create :feature }
 
     before do
-      Detour::Feature.add_record_to_feature user, :foo
+      Detour::Feature.add_record_to_feature user, feature.name
     end
 
     context "when the feature exists for the instance" do
@@ -227,9 +253,9 @@ describe Detour::Feature do
   end
 
   describe "#match_percentage?" do
-    let(:user) { User.create }
-    let(:feature) { Detour::Feature.create!(name: "foo") }
-    let!(:flag) { feature.percentage_flags.create(flaggable_type: "User", percentage: 50) }
+    let(:user)    { create :user }
+    let(:feature) { create :feature }
+    let!(:flag)   { create :percentage_flag, feature: feature, flaggable_type: user.class.to_s, percentage: 50 }
 
     context "when the user's ID matches `id % 10 < percentage / 10" do
       it "returns true" do
@@ -247,14 +273,14 @@ describe Detour::Feature do
   end
 
   describe "#match_groups?" do
-    let!(:user) { User.create(name: "foo") }
-    let!(:user2) { User.create(name: "bar") }
-    let!(:organization) { Organization.create(name: "foo") }
-    let(:feature) { Detour::Feature.create!(name: "baz") }
-    let!(:flag) { feature.group_flags.create(flaggable_type: "User", group_name: "foo_users") }
+    let(:user)    { create :user, name: "foo" }
+    let(:user2)   { create :user }
+    let(:widget)  { create :widget }
+    let(:feature) { create :feature }
+    let!(:flag)   { create :group_flag, feature: feature, flaggable_type: user.class.to_s, group_name: "foo_users" }
 
     before do
-      Detour::Feature.define_user_group "foo_users" do |user|
+      Detour.config.define_user_group "foo_users" do |user|
         user.name == "foo"
       end
     end
@@ -273,7 +299,7 @@ describe Detour::Feature do
 
     context "when the instance is not of the type of the block" do
       it "returns false" do
-        feature.match_groups?(organization).should be_false
+        feature.match_groups?(widget).should be_false
       end
     end
   end

data/spec/models/detour/flag_in_flag_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Detour::FlagInFlag do
+  it { should be_a Detour::Flag }
+  it { should belong_to :flaggable }
+  it { should validate_presence_of :flaggable }
+  it { should allow_mass_assignment_of :flaggable }
+
+  it "validates uniquness of feature_id on flaggable" do
+    user  = create :user
+    flag  = create :flag_in_flag, flaggable: user
+    flag2 = build  :flag_in_flag, flaggable: user, feature: flag.feature
+
+    flag2.should_not be_valid
+    flag2.errors.full_messages.should eq ["Feature has already been taken"]
+  end
+
+  describe "when creating" do
+    let(:flag) { create :flag_in_flag }
+
+    it "increments its feature's flag_in_count" do
+      flag.reload.feature.flag_in_count_for(flag.flaggable_type.tableize).should eq 1
+    end
+  end
+
+  describe "when destroying" do
+    let!(:flag)  { create  :flag_in_flag }
+    let!(:flag2) { create  :flag_in_flag, feature: flag.feature }
+
+    before do
+      flag2.destroy
+    end
+
+    it "decrements its feature's flag_in_count" do
+      flag.reload.feature.flag_in_count_for(flag.flaggable_type.tableize).should eq 1
+    end
+  end
+end

data/spec/{lib/active_record/rollout → models/detour}/flag_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Detour::Flag do
   it { should belong_to :feature }
-  it { should validate_presence_of :feature_id }
+  it { should validate_presence_of :feature }
   it { should validate_presence_of :flaggable_type }
   it { should allow_mass_assignment_of :flaggable_type }
 end

data/spec/models/detour/opt_out_flag_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Detour::OptOutFlag do
+  it { should be_a Detour::Flag }
+  it { should belong_to :flaggable }
+  it { should validate_presence_of :flaggable }
+  it { should allow_mass_assignment_of :flaggable }
+
+  it "validates uniquness of feature_id on flaggable" do
+    user  = create :user
+    flag  = create :opt_out_flag, flaggable: user
+    flag2 = build  :opt_out_flag, flaggable: user, feature: flag.feature
+
+    flag2.should_not be_valid
+    flag2.errors.full_messages.should eq ["Feature has already been taken"]
+  end
+
+  describe "when creating" do
+    let(:flag) { create :opt_out_flag }
+
+    it "increments its feature's opt_out_count" do
+      flag.reload.feature.opt_out_count_for(flag.flaggable_type.tableize).should eq 1
+    end
+  end
+
+  describe "when destroying" do
+    let!(:flag)  { create  :opt_out_flag }
+    let!(:flag2) { create  :opt_out_flag, feature: flag.feature }
+
+    before do
+      flag2.destroy
+    end
+
+    it "decrements its feature's opt_out_count" do
+      flag.reload.feature.opt_out_count_for(flag.flaggable_type.tableize).should eq 1
+    end
+  end
+end

data/spec/{lib/active_record/rollout → models/detour}/percentage_flag_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 describe Detour::PercentageFlag do
-  subject { Detour::PercentageFlag.new(feature_id: 1, flaggable_type: "User") }
+  subject { build :percentage_flag }
 
   it { should be_a Detour::Flag }
   it { should validate_numericality_of(:percentage).is_greater_than(0).is_less_than_or_equal_to(100) }