this_feature 0.3.0 → 0.5.2

data/docs/flipper.md

@@ -0,0 +1,41 @@
+# ThisFeature - Flipper Adapter
+
+## Installation
+
+```ruby
+gem 'this_feature-adapters-flipper
+```
+
+## Configuration
+
+```ruby
+# config/initializers/this_feature.rb
+require 'this_feature'
+require 'this_feature/adapters/flipper'
+
+ThisFeature.configure do |config|
+  adapter = ThisFeature::Adapters::Flipper.new
+  config.adapters = [adapter]
+  config.default_adapter = adapter
+end
+```
+
+An existing Flipper client can be optionally passed to the initializer:
+
+```
+ThisFeature::Adapters::Flipper.new(client: my_existing_client)
+```
+
+
+## API
+
+The Flipper adapter supports the public API of `ThisFeature`.
+
+The `context` argument is supported, but not `data`.
+
+Read the following notes as well:
+
+- **on?** / **off?**: Under the hood, calls `flipper_id` method on the `context`, if one was given.
+- **control?** / **present?**: Flipper doesn't have a concept of "control", so we just implement it as `!present?`
+
+It is possible to support `on!` and `off!` from Flipper but that's not implemented yet.

data/docs/memory.md

@@ -0,0 +1,88 @@
+# ThisFeature - Memory Adapter
+
+## Synopsis
+
+Under the hood, the memory adapter stores data in a dictionary like so:
+
+```json
+{
+  some_flag_name: {
+    global: false,
+    contexts: {
+      User1: true,
+      User2: false
+    }
+  }
+}
+```
+
+Since it doesn't require actual DB lookups, it's faster, and works well for use
+in test suites.
+
+## Installation
+
+This adapter is included with the core gem:
+
+```ruby
+gem 'this_feature
+```
+
+## Configuration
+
+```ruby
+# config/initializers/this_feature.rb
+require 'this_feature'
+require 'this_feature/adapters/memory'
+
+ThisFeature.configure do |config|
+  config.test_adapter = ThisFeature::Adapters::Memory.new
+  config.adapters = [config.test_adapter]
+  config.default_adapter = config.test_adapter
+end
+```
+
+The initializer takes an optional `context_key_method` argument. This is only relevant when using `context` - 
+it specifies a method name which should be called on the context object to determine its identity.
+For example:
+
+```ruby
+# Say you have this method which you want to use as the "identity"
+# of a context object (e.g. imagine this module is included onto User)
+module FeatureFlaggable
+  def this_feature_id
+    "#{self.class}-#{self.id}"
+  end
+end
+
+# Then you would refer to it like so in the initializer:
+ThisFeature::Adapters::Memory.new(context_key_method: :this_feature_id)
+```
+
+If this option is ommitted, then the context object uses its `self` as its "identity".
+
+**See below for example of how to use on! and off! from tests**
+
+## API
+
+The Memory adapter supports the public API of `ThisFeature`.
+
+The `context` argument is supported, but not `data`.
+
+Read the following notes as well:
+
+- **on?** / **off?**: If passed a `context` argument, uses the aformentioned logic
+(`context_key_method`) to determine how it's handled.
+
+- **control?** is not yet implemented
+
+We also support two additional methods here that aren't present on the main adapter yet:
+
+- **on!** / **off!**
+
+Usage example of these:
+
+```ruby
+# If you have configured the in-memory adapter as the default
+ThisFeature.test_adapter.on!(:flag_name, context: user) # with context
+ThisFeature.test_adapter.off!(:flag_name)               # without context
+```

data/docs/splitio.md

@@ -0,0 +1,35 @@
+# ThisFeature - Split Adapter
+
+## Installation
+
+```ruby
+gem 'this_feature-adapters-split-io
+```
+
+## Configuration
+
+```ruby
+# config/initializers/this_feature.rb
+require 'this_feature'
+require 'this_feature/adapters/split_io'
+
+ThisFeature.configure do |config|
+  adapter = ThisFeature::Adapters::SplitIo.new
+  config.adapters = [adapter]
+  config.default_adapter = adapter
+end
+```
+
+An existing Split client can be optionally passed to the initializer:
+
+```
+ThisFeature::Adapters::SplitIo.new(client: my_existing_client)
+```
+
+## API
+
+The SplitIo adapter supports the public API of `ThisFeature`.
+
+Both `context` and `data` are supported.
+
+`control` is a native Split feature, so we perform a query to Split to get this info.

data/docs/writing_an_adapter.md

@@ -0,0 +1,9 @@
+Look at [lib/this_feature/adapters/base.rb](../lib/this_feature/adapters/base.rb) to see the methods that your class should implement. 
+
+Make sure your class inherits from `ThisFeature::Adapters::Base` - this is a requirement. 
+
+You may define a custom `initialize` method - this isn't used by `this_feature` internals because we require an already-constructed instance to be passed into `ThisFeature.configure`. 
+
+For an example, look at one of the existing adapters: [lib/this_feature/adapters/](../lib/this_feature/adapters/)
+
+If you want to include your adapter in our README, just open up a PR.

data/lib/this_feature.rb

@@ -13,19 +13,19 @@ class ThisFeature
 
   def self.adapter_for(flag_name, context: nil, data: {})
     matching_adapter = adapters.find do |adapter|
-      adapter.present?(flag_name, context: context, data: data)
+      adapter.present?(flag_name)
     end
 
     matching_adapter || configuration.default_adapter
   end
 
-  # Configuration
-
   def self.configuration
     @configuration ||= Configuration.new
   end
 
   def self.configure
+    @configuration = Configuration.new
+
     yield(configuration)
 
     configuration.init
@@ -35,4 +35,7 @@ class ThisFeature
     configuration.adapters
   end
 
+  def self.test_adapter
+    configuration.test_adapter
+  end
 end

data/lib/this_feature/adapters/base.rb

@@ -1,34 +1,21 @@
 class ThisFeature
   module Adapters
     class Base
-
-      def self.setup
-        raise UnimplementedError.new(self, __method__)
-      end
-
-      def self.present?(flag_name)
-        raise UnimplementedError.new(self, __method__)
-      end
-
-      def self.on?(flag_name, context: nil, data: {})
-        raise UnimplementedError.new(self, __method__)
-      end
-
-      def self.off?(flag_name, context: nil, data: {})
+      def present?(flag_name)
         raise UnimplementedError.new(self, __method__)
       end
 
-      def self.on!(flag_name, context: nil, data: {})
+      def on?(flag_name, context: nil, data: {})
         raise UnimplementedError.new(self, __method__)
       end
 
-      def self.off!(flag_name, context: nil, data: {})
+      def off?(flag_name, context: nil, data: {})
         raise UnimplementedError.new(self, __method__)
       end
 
       # OPTIONAL method
       # check to see if a control is being used
-      def self.control?(flag_name, context: nil, data: {})
+      def control?(flag_name, context: nil, data: {})
         false
       end
     end

data/lib/this_feature/adapters/flipper.rb

@@ -4,48 +4,38 @@ require "flipper/adapters/active_record"
 class ThisFeature
   module Adapters
     class Flipper < Base
+      attr_reader :client
 
-      def self.setup(flipper = nil)
-        return @flipper = flipper unless flipper.nil?
-
-        @flipper = ::Flipper
-
-        ::Flipper.configure do |config|
-          config.default do
-            adapter = ::Flipper::Adapters::ActiveRecord.new
-            ::Flipper.new(adapter)
-          end
-        end
+      def initialize(client: nil)
+        @client = client || default_flipper_adapter
       end
 
-      def self.present?(flag_name)
-        flipper[flag_name].exist?
+      def present?(flag_name)
+        client[flag_name].exist?
       end
 
-      def self.on?(flag_name, context: nil, data: {})
-        return unless present?(flag_name)
-
-        flipper[flag_name].enabled?(*[context].compact)
+      def control?(flag_name, **kwargs)
+        !present?(flag_name)
       end
 
-      def self.off?(flag_name, context: nil, data: {})
-        on_result = on?(flag_name, context: context)
-
-        return if on_result.nil?
-
-        !on_result
+      def on?(flag_name, context: nil, data: {})
+        client[flag_name].enabled?(*[context].compact)
       end
 
-      def self.on!(flag_name, context: nil, data: {})
-        flipper[flag_name].enable(*[context].compact)
+      def off?(flag_name, context: nil, data: {})
+        !on?(flag_name, context: context)
       end
 
-      def self.off!(flag_name, context: nil, data: {})
-        flipper[flag_name].disable(*[context].compact)
-      end
+      private
 
-      def self.flipper
-        @flipper
+      def default_flipper_adapter
+        ::Flipper.configure do |config|
+          config.default do
+            adapter = ::Flipper::Adapters::ActiveRecord.new
+            ::Flipper.new(adapter)
+          end
+        end
+        ::Flipper
       end
     end
   end

data/lib/this_feature/adapters/memory.rb

@@ -2,20 +2,19 @@ class ThisFeature
   module Adapters
     class Memory < Base
 
-      def self.setup(context_id_method: :id)
-        @context_id_method = context_id_method
+      def initialize(context_key_method: nil)
+        @context_key_method = context_key_method
       end
 
-      def self.clear
+      def clear
         storage.clear
       end
 
-      def self.present?(flag_name)
+      def present?(flag_name)
         !storage[flag_name].nil?
       end
 
-      def self.on?(flag_name, context: nil, data: {})
-        # binding.pry
+      def on?(flag_name, context: nil, data: {})
         return unless present?(flag_name)
 
         flag_data = storage[flag_name]
@@ -25,10 +24,10 @@ class ThisFeature
 
         flag_data[:contexts] ||= {}
 
-        !!flag_data[:contexts][context.send(@context_id_method)]
+        !!flag_data[:contexts][context_key(context)]
       end
 
-      def self.off?(flag_name, context: nil, data: {})
+      def off?(flag_name, context: nil, data: {})
         on_result = on?(flag_name, context: context)
 
         return if on_result.nil?
@@ -36,27 +35,37 @@ class ThisFeature
         !on_result
       end
 
-      def self.on!(flag_name, context: nil, data: {})
+      def on!(flag_name, context: nil, data: {})
         storage[flag_name] ||= {}
 
         return storage[flag_name][:global] = true if context.nil?
 
         storage[flag_name][:contexts] ||= {}
-        storage[flag_name][:contexts][context.send(@context_id_method)] = true
+        storage[flag_name][:contexts][context_key(context)] = true
       end
 
-      def self.off!(flag_name, context: nil, data: {})
+      def off!(flag_name, context: nil, data: {})
         storage[flag_name] ||= {}
 
         return storage[flag_name][:global] = false if context.nil?
 
         storage[flag_name][:contexts] ||= {}
-        storage[flag_name][:contexts][context.send(@context_id_method)] = false
+        storage[flag_name][:contexts][context_key(context)] = false
       end
 
-      def self.storage
+      def storage
         @storage ||= {}
       end
+
+      private
+
+      attr_reader :context_key_method
+
+      def context_key(context)
+        return context if context_key_method.nil?
+
+        context.send(context_key_method)
+      end
     end
   end
 end

data/lib/this_feature/adapters/split_io.rb

@@ -0,0 +1,52 @@
+require 'splitclient-rb'
+
+class ThisFeature
+  module Adapters
+    class SplitIo < Base
+      # used as treatment key when none is given, it's required by split
+      UNDEFINED_KEY = 'undefined_key'
+
+      def initialize(client: nil)
+        @client = client || default_split_client
+
+        @client.block_until_ready
+      end
+
+      def present?(flag_name)
+        !control?(flag_name)
+      end
+
+      def control?(flag_name, context: UNDEFINED_KEY, data: {})
+        treatment(flag_name, context: context, data: data).include?('control')
+      end
+
+      def on?(flag_name, context: UNDEFINED_KEY, data: {})
+        treatment(flag_name, context: context, data: data).eql?('on')
+      end
+
+      def off?(flag_name, context: UNDEFINED_KEY, data: {})
+        treatment(flag_name, context: context, data: data).eql?('off')
+      end
+
+      private
+
+      attr_reader :client
+
+      def treatment(flag_name, context: UNDEFINED_KEY, data: {})
+        key = if context.nil?
+          UNDEFINED_KEY
+        elsif context.respond_to?(:to_s)
+          context.to_s
+        else
+          context
+        end
+
+        client.get_treatment(key, flag_name, data)
+      end
+
+      def default_split_client
+        SplitIoClient::SplitFactory.new(ENV.fetch('SPLIT_IO_AUTH_KEY')).client
+      end
+    end
+  end
+end