featurer 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9df68ddc8f5f914b1893afb7156d3a88d8b24697
-  data.tar.gz: cb25475d7fb0d5e2ea0cdf697c26c9744d9197ce
+  metadata.gz: b841a0cb7f4bdda8b8484436e69c086ed3c356e8
+  data.tar.gz: b3cef4ae265b6de20e91b174923e676afaaa2dbf
 SHA512:
-  metadata.gz: 85061688766dc09e391bfb439dcc945517a85bbc3e9711c9064c6ba530b999451df0ff3d6cf32e624e9c4eaced4c1c0b54c559abe2152ea0d5f9a3f648feb0d2
-  data.tar.gz: 504147f604eb16472905c1c05c66ecb040841390a3c30d592d4b6df913c7cd6a77f59b26b0f2499bb22f711140797d23811a0b9b260559a3c57eaea707c25be3
+  metadata.gz: 77548e6ba64d74da3a3f94a309084469e9fe6fffdd9f1b4bdae38aa632bbc589f872de9bd66ccffe1be7e1d74dbdbc0c7a326b5305dba4da6a8ca713393db89f
+  data.tar.gz: 8ea8674ab337fbb44b1eccdd95da7d5cde70d22a251c871569143ad21834da0ea77b657d930d1d5dc3b27668ed7b83aca74bdb98dd54237d044ac4c9c6fd90d1

data/.gitignore

@@ -11,4 +11,6 @@
 *.so
 *.o
 *.a
+.byebug_history
 mkmf.log
+vendor/bundle

data/.hound.yml

@@ -0,0 +1,2 @@
+ruby:
+  config_file: .rubocop.yml

data/.rspec

@@ -1,3 +1,4 @@
 --colour
 --require ./spec/support/fast_feedback_formatter
 --format documentation FastFeedbackFormatter
+--order random

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 2.1
+
+Style/Documentation:
+  Enabled: false
+
+LineLength:
+  Max: 120

data/.ruby-version

@@ -1 +1 @@
-2.1.1
+2.3.1

data/.travis.yml

@@ -1,11 +1,9 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - 2.1.1
-  - 2.1.2
-  - 2.1.3
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
 services:
   - redis-server
 bundler_args: --without debug

data/Gemfile

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in featurer.gemspec
 gemspec
 
 group :development do
-  gem 'rubocop', '~> 0.26'
-  gem 'guard', '~> 2.6'
-  gem 'guard-rspec', '~> 4.3'
+  gem 'rubocop', '~> 0.47.1'
+end
+
+group :test do
+  gem 'fakeredis', '~> 0.5.0'
 end
 
 group :debug do
-  gem 'pry', '~> 0.10'
-  gem 'pry-debugger', '~> 0.2'
+  gem 'pry', '~> 0.10.4'
+  gem 'pry-byebug', '~> 3.4.2'
 end

data/Guardfile

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 

data/Rakefile

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'bundler/gem_tasks'
 
 require 'rspec/core/rake_task'
@@ -6,4 +7,4 @@ RSpec::Core::RakeTask.new(:spec) do |task|
   task.rspec_opts = ['--color', '--format', 'documentation']
 end
 
-task :default => :spec
+task default: :spec

data/app/helpers/featurer_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module FeaturerHelper
+  def featurer_head_tag(value)
+    render partial: 'featurer/head_tag', locals: { value: value }
+  end
+end

data/app/views/featurer/_head_tag.html.erb

@@ -0,0 +1,8 @@
+<script>
+  var Featurer = {
+    enabledFeatures: <%= Featurer.enabled_features(value).to_json.html_safe %>,
+    isEnabled: function(feature_name) {
+      return this.enabledFeatures.indexOf(feature_name) != -1
+    }
+  };
+</script>

data/featurer.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'featurer/version'
@@ -8,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.version       = Featurer::VERSION
   spec.authors       = ['Alejandro El Informatico']
   spec.email         = ['aeinformatico@gmail.com']
-  spec.summary       = %q{Easy feature flag for your project}
-  spec.description   = %q{Easy feature flag for your project shipped with Redis support}
+  spec.summary       = 'Easy feature flag for your project'
+  spec.description   = 'Easy feature flag for your project shipped with Redis support'
   spec.homepage      = 'https://github.com/ainformatico/featurer'
   spec.license       = 'MIT'
 

data/lib/featurer/adapter.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Featurer
   class Adapter
     attr_reader :config
@@ -10,20 +11,55 @@ module Featurer
       @config = config
     end
 
-    def delete(feature)
-      fail 'implement a delete method'
+    # Attaches a new matching value to the given feature.
+    # If the feature doesn't exist, the adapter should create it automatically.
+    # Feature matching_values must be matched in the order they were added.
+    #
+    # @param _feature the name of the feature as will be used when questioning if the feature is #on?
+    # @param _matching_value the value that will be used to match when calling #on?. Valid values are:
+    # =>                     - true: it will match any value (ie: the feature enabled globally)
+    # =>                     - false: the feature is disabled globally
+    # =>                     - regular expression: matched when calling #on?, if regular expression is passed
+    # =>                     - other types: matched literally when calling #on?, based on the #to_s representation
+    def add(_feature, _matching_value)
+      raise NotImplementedError
     end
 
-    def key(name)
-      fail 'implement a key method'
+    # Completely removes a feature from the system.
+    # If the feature doesn't exist, the adapter should not fail.
+    def delete(_feature)
+      raise NotImplementedError
     end
 
-    def on?(feature, user_id = nil)
-      fail 'implement a on? method'
+    # Returns true if the feature has a matching value attached wich matches the given value.
+    #
+    # @param _feature the feature name, as provided when calling #add or #register
+    # @param _value the value that will be used when matching against the stored matching_value for the given feature
+    # @return a Boolean that depends on the _value provided
+    # =>      - true if _value is nil and the _feature has a matching_value of true
+    # =>      - true if _value is an integer and the _feature has that exact integer attached as a matching_value
+    # =>      - true if _value is a string and the _feature has a matching_value which is a regexp that matches _value
+    # =>      - true if _value is any other type and the _feature has a matching_value which has the same exact #to_s
+    # =>        representation
+    # =>      - false in any other case
+    def on?(_feature, _value = true)
+      raise NotImplementedError
     end
 
-    def register(name, value = true)
-      fail 'implement a register? method'
+    # Returns an array with all the enabled features that match the given value (or just the global ones if no value is
+    # provided)
+    #
+    # @param _value the value that will be used when matching against the stored matching_values
+    def enabled_features(_value = true)
+      raise NotImplementedError
+    end
+
+    # First deletes the given _feature and then creates it again with only the provided _matching_value attached.
+    #
+    # @param _feature the feature to register
+    # @param _matching_value the new matching_value for the feature that replaces any existing matching_value on it
+    def register(_feature, _matching_value = true)
+      raise NotImplementedError
     end
   end
 end

data/lib/featurer/adapter_manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Featurer
   class AdapterManager
     class << self
@@ -20,9 +21,9 @@ module Featurer
 
       def extract_name(klass)
         klass.name
-          .downcase[/(?:\w+$)/] # get only class name
-          .sub('adapter', '') # remove adapter prefix
-          .to_sym
+             .downcase[/(?:\w+$)/] # get only class name
+             .sub('adapter', '') # remove adapter prefix
+             .to_sym
       end
     end
   end

data/lib/featurer/adapter_proxy.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Featurer
   class AdapterProxy
     attr_reader :adapter

data/lib/featurer/adapters/redis.rb

@@ -1,35 +1,53 @@
+# frozen_string_literal: true
 require 'redis'
 
 module Featurer
   class RedisAdapter < Adapter
     def prepare
-      @redis = ::Redis.new({
-        host: @config[:host],
-        port: @config[:port],
-        db: @config[:db]
-      })
-    end
-
-    def delete(feature)
-      delete_key(feature)
+      @redis = @config[:client] || ::Redis.new(host: @config[:host],
+                                               port: @config[:port],
+                                               db: @config[:db])
     end
 
     def add(feature, value)
       save_set(feature, value)
     end
 
+    def delete(feature)
+      delete_key(feature)
+    end
+
     def on?(feature, value = true)
       fetch_from_set(feature, value)
+    rescue => e
+      @config[:logger].warn e
+      false
+    end
+
+    def enabled_features(value = true)
+      all_features.select { |feature| on?(feature, value) }
+    rescue => e
+      @config[:logger].warn e
+      []
     end
 
     def off(feature, value)
       remove_from_set(feature, value)
     end
 
-    def register(name, value = true)
+    def register(feature, value = true)
       # ensure old data is wiped
-      delete(name)
-      save_set(name, value)
+      delete(feature)
+      save_set(feature, value)
+    end
+
+    def feature_list
+      full_feature_names.map do |full_feature_name|
+        {
+          name: short_feature_name(full_feature_name),
+          matching_values: @redis.smembers(full_feature_name)
+        }
+      end
     end
 
     private
@@ -46,12 +64,38 @@ module Featurer
       @redis.sadd key(name), value
     end
 
-    def fetch_from_set(name, id)
-      @redis.sismember(key(name), id)
+    def fetch_from_set(name, value)
+      matching_values = @redis.smembers(key(name))
+
+      matching_values.each do |matching_value|
+        return true if matching_value == 'true' # Globally enabled feature
+
+        if value.is_a?(String) && matching_value =~ /\(\?-mix:.+\)/ # Regexp matching
+          return true if Regexp.new(matching_value).match(value)
+        elsif matching_value == value.to_s # By exact value
+          return true
+        end
+      end
+
+      false
     end
 
     def remove_from_set(name, id)
       @redis.srem(key(name), id)
     end
+
+    def all_features
+      full_feature_names.map do |key|
+        short_feature_name(key)
+      end
+    end
+
+    def full_feature_names
+      @redis.keys("#{@config[:prefix]}:feature:*")
+    end
+
+    def short_feature_name(full_feature_name)
+      full_feature_name.split("#{@config[:prefix]}:feature:").last.to_sym
+    end
   end
 end

data/lib/featurer/facade.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+require 'logger'
+
 module Featurer
   module Facade
-    attr_accessor :adapter
+    attr_accessor :adapter, :logger
 
     def configure(config)
+      @logger = config[:logger] ||= Logger.new(STDOUT)
       @adapter = AdapterProxy.new(config).adapter
     end
 

data/lib/featurer/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Featurer
-  VERSION = '0.0.4'
+  VERSION = '0.1.0'.freeze
 end

data/lib/featurer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'featurer/adapter_proxy'
 require 'featurer/adapter_manager'
 require 'featurer/adapter'
@@ -7,4 +8,12 @@ require 'featurer/version'
 
 module Featurer
   extend Facade
+
+  if const_defined?(:Rails)
+    class Engine < ::Rails::Engine
+      initializer 'featurer:init_adapter' do
+        Featurer.init! unless Featurer.adapter
+      end
+    end
+  end
 end

data/spec/lib/featurer/adapter_manager_spec.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Featurer::AdapterManager do
-
   describe 'registered adapters' do
     it 'checks the default adapter' do
       expect(Featurer::AdapterManager.adapters).to include(redis: Featurer::RedisAdapter)

data/spec/lib/featurer/adapter_proxy_spec.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Featurer::AdapterProxy do
-
   describe 'default adapter' do
     it 'creates the default adapter' do
       proxy = Featurer::AdapterProxy.new
@@ -9,11 +9,11 @@ describe Featurer::AdapterProxy do
     end
 
     it 'creates a new adapter' do
-      class TestAdapter < Featurer::Adapter
+      class ProxyAdapter < Featurer::Adapter
       end
 
-      proxy = Featurer::AdapterProxy.new(adapter: :test)
-      expect(proxy.adapter).to be_an(TestAdapter)
+      proxy = Featurer::AdapterProxy.new(adapter: :proxy)
+      expect(proxy.adapter).to be_an(ProxyAdapter)
     end
   end
 end

data/spec/lib/featurer/adapter_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+describe Featurer::Adapter do
+  describe '#add' do
+    it 'raises an error' do
+      expect { subject.add(:feature, :matching_value) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#delete' do
+    it 'raises an error' do
+      expect { subject.delete(:feature) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#on?' do
+    it 'raises an error' do
+      expect { subject.on?(:feature, :value) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#register' do
+    it 'raises an error' do
+      expect { subject.register(:feature, :matching_value) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/lib/featurer/adapters/redis_spec.rb

@@ -1,14 +1,78 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Featurer::RedisAdapter do
-  it 'should create the connection' do
-    expect_any_instance_of(Featurer::RedisAdapter).to receive(:prepare)
-      .and_call_original
+  let(:redis_handler) { Featurer.adapter.instance_variable_get(:@redis) }
 
-    Featurer.init
-    redis_handler = Featurer.adapter.instance_variable_get(:@redis)
+  before { Featurer.init! }
 
+  it 'creates the connection' do
     expect(redis_handler).to be_an(Redis)
     expect(redis_handler.ping).to eq('PONG')
   end
+
+  describe '#on?' do
+    context 'when there is an exception' do
+      let(:exception) { StandardError.new }
+      let(:logger) { double(Logger) }
+
+      before do
+        subject.instance_variable_set :@config, logger: logger
+
+        expect(logger).to receive(:warn)
+        expect(subject).to receive(:fetch_from_set).and_raise(exception)
+      end
+
+      it "doesn't propagate the exception, just logs it" do
+        expect(subject.on?(:feature)).to be(false)
+      end
+    end
+  end
+
+  describe '#enabled_features' do
+    context 'when there is an exception' do
+      let(:exception) { StandardError.new }
+      let(:logger) { double(Logger) }
+
+      before do
+        subject.instance_variable_set :@config, logger: logger
+
+        expect(logger).to receive(:warn)
+        expect(subject).to receive(:all_features).and_raise(exception)
+      end
+
+      it "doesn't propagate the exception, just logs it" do
+        expect(subject.enabled_features(:feature)).to eq([])
+      end
+    end
+  end
+
+  describe '#prepare' do
+    subject { described_class.new(config).prepare }
+
+    context 'a preconfigured client is provided' do
+      let(:client) { double(Redis) }
+      let(:config) { { client: client } }
+
+      it 'sets the given client as the adapter client' do
+        expect(subject).to eq(client)
+      end
+    end
+
+    context 'the connection details are provided' do
+      let(:config) do
+        {
+          host: 'the_host',
+          port: 3425,
+          db: 89
+        }
+      end
+
+      it 'creates a new redis client with the given settings' do
+        expect(subject.client.host).to eq(config[:host])
+        expect(subject.client.port).to eq(config[:port])
+        expect(subject.client.db).to eq(config[:db])
+      end
+    end
+  end
 end

data/spec/lib/featurer/facade_spec.rb

@@ -1,20 +1,52 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Featurer::Facade do
   describe 'configuration' do
-    it 'should use default options' do
+    it 'uses default options' do
       Featurer.init!
+
       expect(Featurer.adapter.config).to include(adapter: :redis)
     end
 
-    it 'should configure the adapter' do
-      options = {
-        adapter: :redis,
-        prefix: :custom,
-        host: '192.168.1.1'
-      }
-      Featurer.configure(options)
-      expect(Featurer.adapter.config).to include(options)
+    context 'when providing a configuration' do
+      let(:new_config) do
+        {
+          adapter: :redis,
+          prefix: :custom,
+          host: '192.168.1.1'
+        }
+      end
+
+      it 'configures the adapter' do
+        Featurer.configure(new_config)
+
+        expect(Featurer.adapter.config).to include(new_config)
+      end
+    end
+
+    describe 'supports passing a custom logger in the config' do
+      let(:logger) { double(Logger) }
+
+      context 'no logger is passed in the config' do
+        before do
+          expect(Logger).to receive(:new).with(STDOUT).and_return(logger)
+        end
+
+        it 'sets a default logger' do
+          Featurer.configure({})
+
+          expect(Featurer.logger).to eq(logger)
+        end
+      end
+
+      context 'a logger is passed in the config' do
+        it 'sets a default logger' do
+          Featurer.configure(logger: logger)
+
+          expect(Featurer.logger).to eq(logger)
+        end
+      end
     end
   end
 
@@ -25,23 +57,23 @@ describe Featurer::Facade do
     end
 
     describe '#init' do
-      it 'should reset the adapter' do
+      it 'resets the adapter' do
         Featurer.configure(adapter: :nil)
         Featurer.init!
 
         expect(Featurer.config).to include(adapter: :redis)
       end
 
-      it 'should not reset the adapter' do
+      it "doesn't reset the adapter" do
         Featurer.configure(adapter: :nil, prefix: :custom)
         Featurer.init
 
-        expect(Featurer.config).to eq(adapter: :nil, prefix: :custom)
+        expect(Featurer.config).to include(adapter: :nil, prefix: :custom)
       end
     end
 
     describe '#reset' do
-      it 'should reset the adapter' do
+      it 'resets the adapter' do
         Featurer.configure(adapter: :nil)
         Featurer.reset
 
@@ -49,4 +81,10 @@ describe Featurer::Facade do
       end
     end
   end
+
+  describe 'calling methods not defined in the adapter' do
+    it 'produces an error' do
+      expect { Featurer.this_is_clearly_not_a_valid_method_ok }.to raise_error(NoMethodError)
+    end
+  end
 end

data/spec/lib/featurer_spec.rb

@@ -1,104 +1,174 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Featurer do
-  describe 'feature flag is defined' do
-    after(:each) { Featurer.delete(:feature) }
+  before { Featurer.init! }
 
+  let(:user_id) { 1 }
+
+  describe '#enabled_features' do
+    before do
+      Featurer.register(:feature_1)
+      Featurer.register(:feature_2, [user_id])
+      Featurer.register(:feature_3, [user_id + 1, /client_123/])
+      Featurer.register(:feature_4, /^admin_/)
+    end
+
+    it 'returns all enabled features' do
+      expect(Featurer.enabled_features.to_set).to eq([:feature_1].to_set)
+      expect(Featurer.enabled_features(user_id).to_set).to eq([:feature_1, :feature_2].to_set)
+      expect(Featurer.enabled_features('admin_client_123').to_set).to eq([:feature_1, :feature_3, :feature_4].to_set)
+    end
+  end
+
+  context 'globally enabled feature' do
     before do
-      Featurer.init!
+      Featurer.register :feature, true
+    end
+
+    it 'matches on an integer' do
+      expect(Featurer.on?(:feature, 1)).to be
+    end
+
+    it 'matches on a boolean' do
+      expect(Featurer.on?(:feature, true)).to be
+    end
+
+    it 'matches on a string' do
+      expect(Featurer.on?(:feature, 'admin_client_123')).to be
+    end
+  end
+
+  context 'feature matching_value is a list of integers' do
+    it 'returns true because user is in the list' do
+      Featurer.register :feature, [user_id]
+
+      expect(Featurer.on?(:feature, user_id)).to be
+    end
+
+    it 'defines the user twice and returns true' do
+      Featurer.register :feature, [user_id]
+      Featurer.register :feature, [user_id]
+
+      expect(Featurer.on?(:feature, user_id)).to be
+    end
+
+    it 'returns false because user is not in the list' do
+      Featurer.register :feature, [user_id + 1]
+
+      expect(Featurer.on?(:feature, user_id)).to_not be
+    end
+
+    it 'gives priority to global features' do
+      Featurer.register :feature, [user_id]
+      Featurer.register :feature, true
+
+      expect(Featurer.on?(:feature)).to be
+      expect(Featurer.on?(:feature, user_id + 1)).to be
     end
 
-    let(:user_id) { 1 }
+    it 'removes a single user from the feature' do
+      Featurer.register :feature, [user_id, user_id + 1]
+      Featurer.off :feature, user_id
 
-    describe 'per user' do
-      it 'returns true because user is in the list' do
-        Featurer.register :feature, [user_id]
-        expect(Featurer.on?(:feature, user_id)).to be
-      end
+      expect(Featurer.on?(:feature, user_id)).to_not be
+      expect(Featurer.on?(:feature, user_id + 1)).to be
+    end
 
-      it 'defines the user twice and returns true' do
-        Featurer.register :feature, [user_id]
-        Featurer.register :feature, [user_id]
-        expect(Featurer.on?(:feature, user_id)).to be
-      end
+    it 'removes multiple users from the feature' do
+      Featurer.register :feature, [user_id, user_id + 1]
+      Featurer.off :feature, [user_id, user_id + 1]
 
-      it 'returns false because user is not in the list' do
-        Featurer.register :feature, [user_id + 1]
-        expect(Featurer.on?(:feature, user_id)).to_not be
-      end
+      expect(Featurer.on?(:feature, user_id)).to_not be
+      expect(Featurer.on?(:feature, user_id + 1)).to_not be
+    end
 
-      it 'converts a per user feature into a global one' do
-        Featurer.register :feature, [user_id]
-        Featurer.register :feature, true
+    it 'adds a user to a non-existing feature' do
+      Featurer.add :feature, user_id
 
-        expect(Featurer.on?(:feature)).to be
-        expect(Featurer.on?(:feature, user_id)).to_not be
-      end
+      expect(Featurer.on?(:feature, user_id)).to be
+    end
 
-      it 'should remove a single user from the feature' do
-        Featurer.register :feature, [user_id, user_id + 1]
-        Featurer.off :feature, user_id
+    it 'adds a single user to a existing feature' do
+      Featurer.register :feature, [user_id]
+      Featurer.add :feature, user_id + 1
 
-        expect(Featurer.on?(:feature, user_id)).to_not be
-        expect(Featurer.on?(:feature, user_id + 1)).to be
-      end
+      expect(Featurer.on?(:feature, user_id)).to be
+      expect(Featurer.on?(:feature, user_id + 1)).to be
+    end
 
-      it 'should remove a multiple users from the feature' do
-        Featurer.register :feature, [user_id, user_id + 1]
+    it 'adda multiple users to a feature' do
+      Featurer.register :feature, [user_id]
+      Featurer.add :feature, [user_id + 1, user_id + 2]
 
-        Featurer.off :feature, [user_id, user_id + 1]
-        expect(Featurer.on?(:feature, user_id)).to_not be
-        expect(Featurer.on?(:feature, user_id + 1)).to_not be
-      end
+      expect(Featurer.on?(:feature, user_id)).to be
+      expect(Featurer.on?(:feature, user_id + 1)).to be
+      expect(Featurer.on?(:feature, user_id + 2)).to be
+    end
 
-      it 'should add a user to a non-existing feature' do
-        Featurer.add :feature, user_id
+    it "doesn't match a string" do
+      Featurer.register :feature, [user_id]
 
-        expect(Featurer.on?(:feature, user_id)).to be
-      end
+      expect(Featurer.on?(:feature, user_id.to_s))
+    end
+  end
 
-      it 'should add a single user to a feature' do
-        Featurer.register :feature, [user_id]
-        Featurer.add :feature, user_id + 1
+  context 'feature matching_value is a regular expressions' do
+    it 'matches a matching string' do
+      Featurer.register :feature, [/^admin_/]
 
-        expect(Featurer.on?(:feature, user_id)).to be
-        expect(Featurer.on?(:feature, user_id + 1)).to be
-      end
+      expect(Featurer.on?(:feature, 'admin_1234')).to be(true)
+    end
 
-      it 'should add multiple users to a feature' do
-        Featurer.register :feature, [user_id]
-        Featurer.add :feature, [user_id + 1, user_id + 2]
+    it "doesn't match a non-matching string" do
+      Featurer.register :feature, [/^admin_/]
 
-        expect(Featurer.on?(:feature, user_id)).to be
-        expect(Featurer.on?(:feature, user_id + 1)).to be
-        expect(Featurer.on?(:feature, user_id + 2)).to be
-      end
+      expect(Featurer.on?(:feature, '_admin_1234')).to be(false)
     end
+  end
 
-    describe 'global' do
-      it 'returns true because the feature is enabled(default)' do
-        Featurer.register :feature
-        expect(Featurer.on?(:feature)).to be
-      end
+  context 'feature matching_value is a Boolean' do
+    it 'returns true because the feature is enabled(default)' do
+      Featurer.register :feature
+      expect(Featurer.on?(:feature)).to be
+    end
 
-      it 'returns true because the feature is enabled(manually)' do
-        Featurer.register :feature, true
-        expect(Featurer.on?(:feature)).to be
-      end
+    it 'returns true because the feature is enabled(manually)' do
+      Featurer.register :feature, true
+      expect(Featurer.on?(:feature)).to be
+    end
 
-      it 'returns false because the feature is disabled' do
-        Featurer.register :feature, false
-        expect(Featurer.on?(:feature)).to_not be
-      end
+    it 'returns false because the feature is disabled' do
+      Featurer.register :feature, false
+      expect(Featurer.on?(:feature)).to_not be
+    end
 
-      it 'converts a global feature into a per user one' do
-        Featurer.register :feature, true
-        Featurer.register :feature, [user_id]
+    it 'converts a global feature into a per user one' do
+      Featurer.register :feature, true
+      Featurer.register :feature, [user_id]
 
-        expect(Featurer.on?(:feature, user_id)).to be
-        expect(Featurer.on?(:feature)).to_not be
-      end
+      expect(Featurer.on?(:feature, user_id)).to be
+      expect(Featurer.on?(:feature)).to_not be
     end
   end
 
+  context 'feature matching_value is a String' do
+    let(:value) { 'this is the value' }
+
+    before do
+      Featurer.register :feature, value
+    end
+
+    it 'matches on the exact value of the string' do
+      expect(Featurer.on?(:feature, value)).to be
+    end
+
+    it "doesn't match partially" do
+      expect(Featurer.on?(:feature, value[0..-3])).to_not be
+    end
+
+    it "doesn't match on an empty string" do
+      expect(Featurer.on?(:feature, '')).to_not be
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'fakeredis/rspec'
+
 require 'featurer'
 
 # Requires supporting ruby files with custom matchers and macros, etc,

data/spec/support/fast_feedback_formatter.rb

@@ -1,12 +1,17 @@
-require "rspec/core/formatters/progress_formatter"
+# frozen_string_literal: true
+require 'rspec/core/formatters/progress_formatter'
 
 class FastFeedbackFormatter < RSpec::Core::Formatters::ProgressFormatter
   def example_failed(example)
     super(example)
 
-    example_group = example.metadata[:example_group]
+    print_formatted_example(example.metadata[:example_group])
+  end
+
+  private
 
-    output.puts ""
+  def print_formatted_example(example_group)
+    output.puts ''
     output.puts red("#{example_group[:file_path]}:#{example_group[:line_number]}")
     output.puts red(example.execution_result[:exception].to_s.strip)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: featurer
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Alejandro El Informatico
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-26 00:00:00.000000000 Z
+date: 2017-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -74,7 +74,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".hound.yml"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
 - Gemfile
@@ -82,6 +84,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/helpers/featurer_helper.rb
+- app/views/featurer/_head_tag.html.erb
 - featurer.gemspec
 - lib/featurer.rb
 - lib/featurer/adapter.rb
@@ -92,6 +96,7 @@ files:
 - lib/featurer/version.rb
 - spec/lib/featurer/adapter_manager_spec.rb
 - spec/lib/featurer/adapter_proxy_spec.rb
+- spec/lib/featurer/adapter_spec.rb
 - spec/lib/featurer/adapters/redis_spec.rb
 - spec/lib/featurer/facade_spec.rb
 - spec/lib/featurer_spec.rb
@@ -117,13 +122,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Easy feature flag for your project
 test_files:
 - spec/lib/featurer/adapter_manager_spec.rb
 - spec/lib/featurer/adapter_proxy_spec.rb
+- spec/lib/featurer/adapter_spec.rb
 - spec/lib/featurer/adapters/redis_spec.rb
 - spec/lib/featurer/facade_spec.rb
 - spec/lib/featurer_spec.rb