offs 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 205ff73781d83a027350f1de8da287e0a8fec834
-  data.tar.gz: 4f6e7f8bdd804461590bdbbd0b81b54f36748b08
+  metadata.gz: ef7d1cafac11c0b1e750c87fea4efc1a6ada9476
+  data.tar.gz: 3876047faae8388987ac0d1ed5ecbe62372a5c1a
 SHA512:
-  metadata.gz: 72aaffded2072d1316c5bb33b6c235d113e1737a7db79d52d643f6e6879d0f538b70f2b5f6ef65d5e431f2766f6b8f7a12f9fab75b0f28206cb0f4dd181d9305
-  data.tar.gz: a73eff40479677cc647c291c166b9ada2e79465da6b582673478abfa9957d60cc4f527504a538d14420474a3b200024833123242b68de906815bf0128a2ca548
+  metadata.gz: 895c580a906b1ed220d8a16a1f6244ba4d11a54f840d3b8f22b8e92c91b6d4cd3a5db2f9ac17517f58599a83e74beee0d45e0c1d2d0ff0bea1f7b5b07a72f941
+  data.tar.gz: 6ab68811b1910a87fc79fdd47f76daca0dac8104e76e0f01936b7cea736852bc55983ce744459a9c73f9729a51a4deec28a1b6f780f11eebfd885e0f6f968e77

data/lib/offs/exceptions.rb

@@ -0,0 +1,5 @@
+class OFFS
+  class FeatureDisabled < RuntimeError; end
+  class UndefinedFlagError < RuntimeError; end
+  class AlreadyInitializedError < StandardError; end
+end

data/lib/offs/flags.rb

@@ -1,54 +1,60 @@
-class OFFS
-  class Flags
-    UndefinedFlagError = Class.new(StandardError)
+require 'delegate'
+require 'offs/exceptions'
 
+class OFFS
+  class Flags < DelegateClass(Array)
     class << self
-      def instance
-        @instance ||= new
+      private :new
+      
+      def instance(*args)
+        unless @instance.nil? || args.empty?
+          raise AlreadyInitializedError
+        end
+        @instance ||= new(*args)
       end
 
-      def set(&block)
-        block.call(instance)
-        instance
+      def reset_instance!
+        @instance = nil
       end
     end
 
-    def flag(name, default)
-      env_var_name = name.to_s.upcase
-      feature_flags[name] = if ENV.has_key?(env_var_name)
-                              ENV[env_var_name].strip == '1'
-                            else
-                              default
-                            end
+    def initialize(*flags, value_sources: {})
+      self.value_sources = array_wrap(value_sources)
+      __setobj__(flags)
     end
 
-    def feature_flags
-      @feature_flags ||= {}
+    def validate!(flag)
+      return true if include?(flag)
+      raise UndefinedFlagError, "The #{flag} flag has not been defined."
     end
 
     def enabled?(flag)
-      status = feature_flags[flag]
-      if status.respond_to?(:call)
-        status.call
-      else
-        !!status
-      end
+      validate!(flag)
+      !!final_values[flag]
     end
 
-    def valid?(flag)
-      feature_flags.has_key?(flag)
+    private
+
+    attr_accessor :value_sources
+
+    def array_wrap(obj)
+      return [obj] unless obj.kind_of?(Array)
+      obj
     end
 
-    def validate!(flag)
-      if valid?(flag)
-        flag
-      else
-        raise UndefinedFlagError, "The #{flag} flag has not been defined."
-      end
+    def final_values
+      value_sources.reverse.reduce({}) { |final, source|
+        final.merge(sanitize(source))
+      }
     end
 
-    def to_a
-      feature_flags.keys
+    def sanitize(data_hash)
+      data_hash.reduce({}) { |result, k_v_pair|
+        key = k_v_pair.first.to_s.downcase.to_sym
+        value = [true, 'true', 1, '1', 'on'].include?(k_v_pair.last)
+        result[key] = value
+        result
+      }
     end
   end
 end

data/lib/offs/permutations.rb

@@ -1,23 +1,19 @@
 require 'delegate'
-require 'injectable_dependencies'
 
 class OFFS
   class Permutations < DelegateClass(Enumerator)
-    include InjectableDependencies
-
-    dependency(:flags) { Flags.instance }
-
-    def initialize(options={})
-      initialize_dependencies(options[:dependencies])
+    def initialize(flags: Flags.instance)
+      self.flags = flags
       __setobj__ create_permutations
     end
 
     private
 
+    attr_accessor :flags
+
     def create_permutations
-      keys = flags.to_a
-      permutations = [true,false].repeated_permutation(keys.size).map { |values|
-        keys.zip(values).inject({}) { |m, pair|
+      permutations = [true,false].repeated_permutation(flags.size).map { |values|
+        flags.zip(values).inject({}) { |m, pair|
           m[pair[0]] = pair[1]
           m
         }

data/lib/offs/version.rb

@@ -1,3 +1,3 @@
 class OFFS
-  VERSION = "1.4.0"
+  VERSION = "2.0.0"
 end

data/lib/offs.rb

@@ -1,42 +1,33 @@
 require "offs/version"
-require 'offs/flags'
-require 'injectable_dependencies'
+require "offs/flags"
+require 'offs/exceptions'
 
 class OFFS
-  include InjectableDependencies
-
-  class FeatureDisabled < RuntimeError; end
-
   class << self
-    def so_you_want_to(flag, &block)
-      new(flag).so_you_want_to(&block)
+    def so_you_want_to(flag, flag_status_checker: nil, &block)
+      new(flag, flag_status_checker: flag_status_checker).so_you_want_to(&block)
     end
 
-    def if_you_would_like_to(flag, &block)
-      so_you_want_to(flag) do |you|
+    def if_you_would_like_to(flag, flag_status_checker: nil, &block)
+      so_you_want_to(flag, flag_status_checker: flag_status_checker) do |you|
         you.would_like_to(&block)
       end
     end
 
-    def if_you_do_not_want_to(flag, &block)
-      so_you_want_to(flag) do |you|
+    def if_you_do_not_want_to(flag, flag_status_checker: nil, &block)
+      so_you_want_to(flag, flag_status_checker: flag_status_checker) do |you|
         you.may_still_need_to(&block)
       end
     end
 
-    def raise_error_unless_we(flag)
-      new(flag).raise_error_unless_we
-    end
-
-    def feature_flags
-      Flags.instance.to_a
+    def raise_error_unless_we(flag, flag_status_checker:)
+      new(flag, flag_status_checker: flag_status_checker) \
+        .raise_error_unless_we
     end
   end
 
-  dependency(:feature_flags) { Flags.instance }
-
-  def initialize(flag, options={})
-    initialize_dependencies options[:dependencies]
+  def initialize(flag, flag_status_checker: nil)
+    self.flag_status_checker = flag_status_checker || Flags.instance
     self.flag = flag
   end
 
@@ -64,18 +55,18 @@ class OFFS
   private
 
   attr_reader :flag
-  attr_accessor :result
+  attr_accessor :result, :flag_status_checker
 
-  def when_flag(bool, &block)
-    self.result = block.call if flag_status == bool
+  def flag=(new_flag)
+    flag_status_checker.validate!(new_flag)
+    @flag = new_flag
   end
 
-  def flag_status
-    feature_flags.enabled?(flag)
+  def when_flag(bool, &block)
+    self.result = block.call if flag_enabled? == bool
   end
-  alias_method :flag_enabled?, :flag_status
 
-  def flag=(new_flag)
-    @flag = feature_flags.validate!(new_flag)
+  def flag_enabled?
+    flag_status_checker.enabled?(flag)
   end
 end

data/offs.gemspec

@@ -21,8 +21,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "injectable_dependencies"
-
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"

data/spec/offs/flags_spec.rb

@@ -0,0 +1,156 @@
+require 'offs/flags'
+
+describe OFFS::Flags do
+  subject {
+    # Must use #send, because it is usually a Singleton, but we want seperate
+    # objects for testing.
+    described_class.send(:new, :use_feature_a, :use_feature_b, :use_feature_c,
+                         value_sources: value_sources)
+  }
+
+  let(:value_sources) {{}}
+
+  it 'acts like an Array of all defined flag names' do
+    expect(subject).to eq [:use_feature_a, :use_feature_b, :use_feature_c]
+  end
+
+  it 'provides singleton behavior' do
+    expect(described_class.instance).to be_kind_of(described_class)
+    expect(described_class.instance).to be described_class.instance
+  end
+
+  it 'allows flags and value_sources to be defined when the instance is ' \
+   + 'first created' do
+    described_class.reset_instance!
+    instance = described_class.instance(:foo, :bar, :baz)
+    expect(instance).to eq [:foo, :bar, :baz]
+  end
+
+  it 'raises an AlreadyInitializedError when #instance is called with ' \
+   + 'arguments on subsequent calls' do
+    described_class.reset_instance!
+    described_class.instance(:foo)
+    expect {
+      described_class.instance(:foo)
+    }.to raise_error(OFFS::AlreadyInitializedError)
+  end
+
+  context 'when a flag has not been defined' do
+    it 'raises an exception when asked to validate the flag' do
+      expect{
+        subject.validate!(:flag_that_is_not_defined)
+      }.to raise_error(OFFS::UndefinedFlagError,
+                       /flag_that_is_not_defined/)
+    end
+
+    it 'raises an exception when asked for the status of the flag' do
+      expect{
+        subject.enabled?(:flag_that_is_not_defined)
+      }.to raise_error(OFFS::UndefinedFlagError,
+                       /flag_that_is_not_defined/)
+    end
+  end
+
+  context 'when a flag has been defined' do
+    it 'returns true when asked to validate the flag' do
+      expect(subject.validate!(:use_feature_a)).to eq true
+    end
+
+    context 'when no value sources are defined' do
+      it 'assumes the flag is disabled' do
+        expect(subject.enabled?(:use_feature_a)).to eq false
+      end
+    end
+
+    context 'when one value source is defined' do
+      let(:value_sources) { [source_a] }
+
+      let(:source_a) {Hash.new}
+
+      context 'and the flag is set in the value source' do
+        shared_examples_for 'it determines flag status based on value source when' do |source_key|
+          let(:source_a) {{
+            source_key => true,
+          }}
+
+          it "has a value source with a key of #{source_key.inspect}" do
+            expect(subject.enabled?(:use_feature_a)).to eq true
+          end
+        end
+
+        it_behaves_like 'it determines flag status based on value source when',
+          :use_feature_a
+
+        it_behaves_like 'it determines flag status based on value source when',
+          'use_feature_a'
+
+        it_behaves_like 'it determines flag status based on value source when',
+          'USE_FEATURE_A'
+
+        shared_examples_for "it has a true value when" do |value|
+          it "the value source is set to #{value.inspect}" do
+            source_a[:use_feature_a] = value
+            expect(subject.enabled?(:use_feature_a)).to eq true
+          end
+        end
+
+        it_behaves_like 'it has a true value when', 'true'
+        it_behaves_like 'it has a true value when', '1'
+        it_behaves_like 'it has a true value when', 'on'
+        it_behaves_like 'it has a true value when', 1
+
+        shared_examples_for "it has a false value when" do |value|
+          it "the value source is set to #{value.inspect}" do
+            source_a[:use_feature_a] = value
+            expect(subject.enabled?(:use_feature_a)).to eq false
+          end
+        end
+
+        it_behaves_like 'it has a false value when', 'false'
+        it_behaves_like 'it has a false value when', '0'
+        it_behaves_like 'it has a false value when', 'off'
+        it_behaves_like 'it has a false value when', 0
+      end
+
+      context 'and the flag is not set in the value source' do
+        let(:source_a) {{
+          :use_feature_b => true,
+        }}
+
+        it 'assumes the flag is disabled' do
+          expect(subject.enabled?(:use_feature_a)).to eq false
+        end
+      end
+    end
+
+    context 'when multiple value sources are defined' do
+      let(:value_sources) { [source_c, source_b, source_a] }
+      let(:source_a) {{
+        :use_feature_a => true,
+        :use_feature_b => false,
+        :use_feature_c => true
+      }}
+
+      let(:source_b) {{
+        'USE_FEATURE_B' => true
+      }}
+
+      let(:source_c) {{
+        'use_feature_c' => false
+      }}
+
+      it 'determines whether the flag is enabled based on the first value ' \
+       + 'source in which the flag value is set' do
+        expect(subject.enabled?(:use_feature_a)).to eq true
+        expect(subject.enabled?(:use_feature_b)).to eq true
+        expect(subject.enabled?(:use_feature_c)).to eq false
+      end
+
+      it 'recalculates status if the value source changes state' do
+        expect(subject.enabled?(:use_feature_c)).to eq false
+        source_c[:use_feature_c] = true
+        expect(subject.enabled?(:use_feature_c)).to eq true
+      end
+    end
+  end
+end

data/spec/offs/permutations_spec.rb

@@ -2,13 +2,9 @@ require 'spec_helper'
 require 'offs/permutations'
 
 describe OFFS::Permutations do
-  subject { described_class.new(dependencies: dependencies) }
+  subject { described_class.new(flags: flags) }
 
-  let(:dependencies) {{
-    flags: flags
-  }}
-
-  let(:flags) { double(:flags, to_a: [:feature_a, :feature_b, :feature_c]) }
+  let(:flags) { [:feature_a, :feature_b, :feature_c] }
 
   let(:possible_permutations) {[
     { feature_a: true,  feature_b: true,  feature_c: true  },

data/spec/offs_spec.rb

@@ -5,28 +5,19 @@ describe OFFS do
     expect(described_class::VERSION).not_to be nil
   end
 
-  subject { described_class.new(flag, dependencies: dependencies) }
+  subject { described_class.new(flag, flag_status_checker: flag_status_checker) }
 
-  let(:flag) { :my_cool_new_feature }
+  let(:flag) { :use_my_new_feature }
 
-  let(:dependencies) {{
-    feature_flags: feature_flags
-  }}
-
-  let(:feature_flags) {
-    OFFS::Flags.set do |f|
-      f.flag :my_cool_new_feature, feature_status
-      f.flag :my_runtime_feature, ->{ feature_status }
-    end
-  }
+  let(:flag_status_checker) { double(:flag_status_checker, validate!: nil) }
 
   context 'when the specified feature flag is not defined' do
-    let(:feature_flags) { OFFS::Flags.new }
-
     it 'raises an error' do
-      expect{ subject.so_you_want_to {} }.to \
-        raise_error(OFFS::Flags::UndefinedFlagError,
-                    "The #{flag} flag has not been defined.")
+      allow(flag_status_checker).to receive(:validate!).with(flag) do
+        raise described_class::UndefinedFlagError, "Some message"
+      end
+      expect{ subject.would_like_to {} }.to \
+        raise_error(described_class::UndefinedFlagError, "Some message")
     end
   end
 
@@ -48,7 +39,12 @@ describe OFFS do
       end
     end
 
-    shared_examples_for 'the feature is enabled' do
+    context "and the feature is turned on by default" do
+      before(:each) do
+        allow(flag_status_checker).to receive(:enabled?).with(flag) \
+          .and_return(true)
+      end
+
       it 'executes the would_like_to block' do
         expect(would_like_to_blk).to receive(:call)
         do_it
@@ -66,7 +62,8 @@ describe OFFS do
 
       it 'will execute the block for if_you_would_like_to' do
         x = nil
-        OFFS.if_you_would_like_to(:my_cool_new_feature) do
+        OFFS.if_you_would_like_to(:use_my_new_feature,
+                                  flag_status_checker: flag_status_checker) do
           x = 1
         end
         expect(x).to eq 1
@@ -74,30 +71,26 @@ describe OFFS do
 
       it 'will not execute the block for if_you_do_not_want_to' do
         x = nil
-        OFFS.if_you_do_not_want_to(:my_cool_new_feature) do
+        OFFS.if_you_do_not_want_to(:use_my_new_feature,
+                                   flag_status_checker: flag_status_checker) do
           x = 1
         end
         expect(x).to be_nil
       end
 
       it 'noops for raise_error_unless_we' do
-        OFFS.raise_error_unless_we(:my_cool_new_feature)
+        OFFS.raise_error_unless_we(:use_my_new_feature,
+                                   flag_status_checker: flag_status_checker)
       end
     end
 
-    context "and the feature is turned on by default" do
-      let(:feature_status) { true }
-
-      it_behaves_like 'the feature is enabled'
-
-      context "and the feature status is a Proc" do
-        let(:flag) { :my_runtime_feature }
-
-        it_behaves_like 'the feature is enabled'
+    context "and the feature is turned off by default" do
+      before(:each) do
+        allow(flag_status_checker).to receive(:enabled?).with(flag) \
+          .and_return(false)
       end
-    end
 
-    shared_examples_for 'the feature is disabled' do
+
       it "executes the may_still_need_to block" do
         expect(may_still_need_to_blk).to receive(:call)
         do_it
@@ -115,7 +108,8 @@ describe OFFS do
 
       it 'will not execute the block for if_you_would_like_to' do
         x = nil
-        OFFS.if_you_would_like_to(:my_cool_new_feature) do
+        OFFS.if_you_would_like_to(:use_my_new_feature,
+                                  flag_status_checker: flag_status_checker) do
           x = 1
         end
         expect(x).to be_nil
@@ -123,27 +117,18 @@ describe OFFS do
 
       it 'will execute the block for if_you_do_not_want_to' do
         x = nil
-        OFFS.if_you_do_not_want_to(:my_cool_new_feature) do
+        OFFS.if_you_do_not_want_to(:use_my_new_feature,
+                                   flag_status_checker: flag_status_checker) do
           x = 1
         end
         expect(x).to eq 1
       end
 
       it 'raises an OFFS::FeatureDisabled error for raise_error_unless_we' do
-        expect { OFFS.raise_error_unless_we(:my_cool_new_feature) }.to \
-          raise_error(OFFS::FeatureDisabled, /my_cool_new_feature/)
-      end
-    end
-
-    context "and the feature is turned off by default" do
-      let(:feature_status) { false }
-
-      it_behaves_like 'the feature is disabled'
-
-      context "and the feature status is a Proc" do
-        let(:flag) { :my_runtime_feature }
-
-        it_behaves_like 'the feature is disabled'
+        expect {
+          OFFS.raise_error_unless_we(:use_my_new_feature,
+                                     flag_status_checker: flag_status_checker)
+        }.to raise_error(OFFS::FeatureDisabled, /use_my_new_feature/)
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,2 +1,10 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'offs'
+
+RSpec.configure do |config|
+  config.order = "random"
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end
+
+

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: offs
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - John Wilger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-19 00:00:00.000000000 Z
+date: 2015-03-31 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: injectable_dependencies
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -85,10 +71,12 @@ files:
 - README.md
 - Rakefile
 - lib/offs.rb
+- lib/offs/exceptions.rb
 - lib/offs/flags.rb
 - lib/offs/permutations.rb
 - lib/offs/version.rb
 - offs.gemspec
+- spec/offs/flags_spec.rb
 - spec/offs/permutations_spec.rb
 - spec/offs_spec.rb
 - spec/spec_helper.rb
@@ -117,6 +105,7 @@ signing_key:
 specification_version: 4
 summary: OFFS Feature Flagging System
 test_files:
+- spec/offs/flags_spec.rb
 - spec/offs/permutations_spec.rb
 - spec/offs_spec.rb
 - spec/spec_helper.rb