__
_.-~ )
_..--~~~~,' ,-/ _
.-'. . . .' ,-',' ,' )
,'. . . _ ,--~,-'__..-' ,'
,'. . . (@)' ---~~~~ ,'
/. . . . '~~ ,-'
/. . . . . ,-'
; . . . . - . ,'
: . . . . _ /
. . . . . `-.:
. . . ./ - . )
. . . | _____..---.._/ _____
~---~~~~----~~~~ ~~
Feature flipping is the act of enabling or disabling features or parts of your application, ideally without re-deploying or changing anything in your code base.
The goal of this gem is to make turning features on or off so easy that everyone does it. Whatever your data store, throughput, or experience, feature flipping should be easy and have minimal impact on your application.
## Installation
Add this line to your application's Gemfile:
gem 'flipper'
And then execute:
$ bundle
Or install it yourself with:
$ gem install flipper
## Examples
The goal of the API for flipper was to have everything revolve around features and what ways they can be enabled. Start with top level and dig into a feature, then dig in further and enable that feature for a given type of access, as opposed to thinking about how the feature will be accessed first (ie: `stats.enable` vs `activate_group(:stats, ...)`).
```ruby
require 'flipper'
Flipper.configure do |config|
config.default do
# pick an adapter, this uses memory, any will do
adapter = Flipper::Adapters::Memory.new
# pass adapter to handy DSL instance
Flipper.new(adapter)
end
end
# check if search is enabled
if Flipper.enabled?(:search)
puts 'Search away!'
else
puts 'No search for you!'
end
puts 'Enabling Search...'
Flipper.enable(:search)
# check if search is enabled
if Flipper.enabled?(:search)
puts 'Search away!'
else
puts 'No search for you!'
end
```
Of course there are more [examples for you to peruse](examples/). You could also check out the [DSL](lib/flipper/dsl.rb) and [Feature](lib/flipper/feature.rb) classes for code/docs.
## Docs
* [Gates](docs/Gates.md) - Boolean, Groups, Actors, % of Actors, and % of Time
* [Adapters](docs/Adapters.md) - Mongo, Redis, Cassandra, Active Record...
* [Instrumentation](docs/Instrumentation.md) - ActiveSupport::Notifications and Statsd
* [Optimization](docs/Optimization.md) - Memoization middleware and Cache adapters
* [Web Interface](docs/ui/README.md) - Point and click...
* [API](docs/api/README.md) - HTTP API interface
* [Caveats](docs/Caveats.md) - Flipper beware! (see what I did there)
* [Docker-Compose](docs/DockerCompose.md) - Using docker-compose in contributing
## Contributing
1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Run the tests (`bundle exec rake`)
4. Commit your changes (`git commit -am 'Added some feature'`)
5. Push to the branch (`git push origin my-new-feature`)
6. Create new Pull Request
## Releasing
1. Update the version to be whatever it should be and commit.
2. `script/release`
3. Profit.
## Brought To You By
| pic | @mention | area |
|---|---|---|
|  | [@jnunemaker](https://github.com/jnunemaker) | most things |
|  | [@alexwheeler](https://github.com/alexwheeler) | api |
|  | [@thetimbanks](https://github.com/thetimbanks) | ui |
|  | [@lazebny](https://github.com/lazebny) | docker |
flipper-0.17.1/Rakefile 0000664 0000000 0000000 00000002542 13537027355 0014723 0 ustar 00root root 0000000 0000000 #!/usr/bin/env rake
$LOAD_PATH.push File.expand_path('../lib', __FILE__)
require 'rake/testtask'
require 'rubocop/rake_task'
require 'flipper/version'
# gem install pkg/*.gem
# gem uninstall flipper flipper-ui flipper-redis
desc 'Build gem into the pkg directory'
task :build do
FileUtils.rm_rf('pkg')
Dir['*.gemspec'].each do |gemspec|
system "gem build #{gemspec}"
end
FileUtils.mkdir_p('pkg')
FileUtils.mv(Dir['*.gem'], 'pkg')
end
desc 'Tags version, pushes to remote, and pushes gem'
task release: :build do
sh 'git', 'tag', "v#{Flipper::VERSION}"
sh 'git push origin master'
sh "git push origin v#{Flipper::VERSION}"
sh 'ls pkg/*.gem | xargs -n 1 gem push'
end
require 'rspec/core/rake_task'
RSpec::Core::RakeTask.new(:spec) do |t|
t.rspec_opts = %w(--color --format documentation)
end
namespace :spec do
desc 'Run specs for UI queue'
RSpec::Core::RakeTask.new(:ui) do |t|
t.rspec_opts = %w(--color)
t.pattern = ['spec/flipper/ui/**/*_spec.rb', 'spec/flipper/ui_spec.rb']
end
end
Rake::TestTask.new do |t|
t.libs = %w(lib test)
t.pattern = 'test/**/*_test.rb'
t.options = '--documentation'
t.warning = false
end
Rake::TestTask.new(:test_rails) do |t|
t.libs = %w(lib test_rails)
t.pattern = 'test_rails/**/*_test.rb'
t.warning = false
end
RuboCop::RakeTask.new
task default: [:spec, :test, :test_rails, :rubocop]
flipper-0.17.1/docker-compose.yml 0000664 0000000 0000000 00000001242 13537027355 0016707 0 ustar 00root root 0000000 0000000 # postgres:
# container_name: flipper_postgres
# image: postgres:9.4
redis:
container_name: flipper_redis
image: redis:2.8
mongo:
container_name: flipper_mongo
image: mongo:3.3
memcached:
container_name: flipper_memcached
image: memcached:1.4.33
app:
container_name: flipper_app
build: .
dockerfile: Dockerfile
volumes:
- .:/srv/app
volumes_from:
- bundle_cache
links:
# - postgres
- redis
- mongo
- memcached
environment:
- REDIS_URL=redis://redis:6379
- MONGODB_HOST=mongo
- MEMCACHED_URL=memcached:11211
bundle_cache:
container_name: flipper_bundle_cache
image: busybox
volumes:
- /bundle_cache
flipper-0.17.1/docs/ 0000775 0000000 0000000 00000000000 13537027355 0014203 5 ustar 00root root 0000000 0000000 flipper-0.17.1/docs/Adapters.md 0000664 0000000 0000000 00000012422 13537027355 0016271 0 ustar 00root root 0000000 0000000 # Adapters
I plan on supporting the adapters in the flipper repo. Other adapters are welcome, so please let me know if you create one.
## Officially Supported
* [ActiveRecord adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_record) - Rails 3, 4, and 5.
* [ActiveSupportCacheStore adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_support_cache_store) - ActiveSupport::Cache::Store
* [Cassanity adapter](https://github.com/jnunemaker/flipper-cassanity)
* [Http adapter](https://github.com/jnunemaker/flipper/blob/master/docs/http)
* [memory adapter](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/memory.rb) – great for tests
* [Moneta adapter](https://github.com/jnunemaker/flipper/blob/master/docs/moneta)
* [Mongo adapter](https://github.com/jnunemaker/flipper/blob/master/docs/mongo)
* [PStore adapter](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/pstore.rb) – great for when a local file is enough
* [read-only adapter](https://github.com/jnunemaker/flipper/blob/master/docs/read-only)
* [Redis adapter](https://github.com/jnunemaker/flipper/blob/master/docs/redis)
* [Sequel adapter](https://github.com/jnunemaker/flipper/blob/master/docs/sequel)
## Community Supported
* [Active Record 3 adapter](https://github.com/blueboxjesse/flipper-activerecord)
* [Consul adapter](https://github.com/gdavison/flipper-consul)
## Roll Your Own
The basic API for an adapter is this:
* `features` - Get the set of known features.
* `add(feature)` - Add a feature to the set of known features.
* `remove(feature)` - Remove a feature from the set of known features.
* `clear(feature)` - Clear all gate values for a feature.
* `get(feature)` - Get all gate values for a feature.
* `enable(feature, gate, thing)` - Enable a gate for a thing.
* `disable(feature, gate, thing)` - Disable a gate for a thing.
* `get_multi(features)` - Get all gate values for several features at once. Implementation is optional. If none provided, default implementation performs N+1 `get` calls where N is the number of elements in the features parameter.
* `get_all` - Get all gate values for all features at once. Implementation is optional. If none provided, default implementation performs two calls, one to `features` to get the names of all features and one to `get_multi` with the feature names from the first call.
If you would like to make your own adapter, there are shared adapter specs (RSpec) and tests (MiniTest) that you can use to verify that you have everything working correctly.
### RSpec
For example, here is what the in-memory adapter spec looks like:
`spec/flipper/adapters/memory_spec.rb`
```ruby
require 'helper'
# The shared specs are included with the flipper gem so you can use them in
# separate adapter specific gems.
require 'flipper/spec/shared_adapter_specs'
describe Flipper::Adapters::Memory do
# an instance of the new adapter you are trying to create
subject { described_class.new }
# include the shared specs that the subject must pass
it_should_behave_like 'a flipper adapter'
end
```
### MiniTest
Here is what an in-memory adapter MiniTest looks like:
`test/adapters/memory_test.rb`
```ruby
require 'test_helper'
class MemoryTest < MiniTest::Test
prepend SharedAdapterTests
def setup
# Any code here will run before each test
@adapter = Flipper::Adapters::Memory.new
end
def teardown
# Any code here will run after each test
end
end
```
1. Create a file under `test/adapters` that inherits from MiniTest::Test.
2. `prepend SharedAdapterTests`.
3. Initialize an instance variable `@adapter` referencing an instance of the adapter.
4. Add any code to run before each test in a `setup` method and any code to run after each test in a `teardown` method.
A good place to start when creating your own adapter is to copy one of the adapters mentioned above and replace the client specific code with whatever client you are attempting to adapt.
I would also recommend setting `fail_fast = true` in your RSpec configuration as that will just give you one failure at a time to work through. It is also handy to have the shared adapter spec file open.
## Swapping Adapters
If you find yourself using one adapter and would like to swap to another, you can do that! Flipper adapters support importing another adapter's data. This will wipe the adapter you are wanting to swap to, if it isn't already clean, so please be careful.
```ruby
# Say you are using redis...
redis_adapter = Flipper::Adapters::Redis.new(Redis.new)
redis_flipper = Flipper.new(redis_adapter)
# And redis has some stuff enabled...
redis_flipper.enable(:search)
redis_flipper.enable_percentage_of_time(:verbose_logging, 5)
redis_flipper.enable_percentage_of_actors(:new_feature, 5)
redis_flipper.enable_actor(:issues, Flipper::Actor.new('1'))
redis_flipper.enable_actor(:issues, Flipper::Actor.new('2'))
redis_flipper.enable_group(:request_tracing, :staff)
# And you would like to switch to active record...
ar_adapter = Flipper::Adapters::ActiveRecord.new
ar_flipper = Flipper.new(ar_adapter)
# NOTE: This wipes active record clean and copies features/gates from redis into active record.
ar_flipper.import(redis_flipper)
# active record is now identical to redis.
ar_flipper.features.each do |feature|
pp feature: feature.key, values: feature.gate_values
end
```
flipper-0.17.1/docs/Caveats.md 0000664 0000000 0000000 00000001536 13537027355 0016120 0 ustar 00root root 0000000 0000000 # Caveats
1. The [individual actor gate](https://github.com/jnunemaker/flipper/blob/master/docs/Gates.md#2-individual-actor) is typically not designed for hundreds or thousands of actors to be enabled. This is an explicit choice to make it easier to batch load data from the adapters instead of performing individual checks for actors over and over. If you need to enable something for more than 20 individual people, I would recommend using a [group](https://github.com/jnunemaker/flipper/blob/master/docs/Gates.md#5-group).
2. The disable method exists only to clear something that is enabled. If the thing you are disabling is not enabled, the disable is pointless. This means that if you enable one group an actor is in and disable another group, the feature will be enabled for the actor. ([related issue](https://github.com/jnunemaker/flipper/issues/71))
flipper-0.17.1/docs/DockerCompose.md 0000664 0000000 0000000 00000001433 13537027355 0017263 0 ustar 00root root 0000000 0000000 # Docker Compose for contributors
This gem includes different adapters which require specific tools instaled
on local machine. With docker this could be achieved inside container and
new contributor could start working on code with a minumum efforts.
## Steps:
1. Install Docker Compose https://docs.docker.com/compose/install
1. Build the app container `docker-compose build`
1. Install gems `docker-compose run --rm app bundle install`
1. Run specs `docker-compose run --rm app bundle exec rspec`
1. Run tests `docker-compose run --rm app bundle exec rake test`
1. Clear and check files with Rubocop `docker-compose run --rm app bundle exec rubocop -D`
1. Optional: log in to container an using a `bash` shell for running specs
```sh
docker-compose run --rm app bash
bundle exec rspec
```
flipper-0.17.1/docs/Gates.md 0000664 0000000 0000000 00000014206 13537027355 0015573 0 ustar 00root root 0000000 0000000 # Gates
Out of the box several types of enabling are supported. They are checked in this order:
## 1. Boolean
All on or all off. Think top level things like `:stats`, `:search`, `:logging`, etc. Also, an easy way to release a new feature as once a feature is boolean enabled it is on for every situation.
```ruby
flipper = Flipper.new(adapter)
flipper[:stats].enable # turn on
flipper[:stats].disable # turn off
flipper[:stats].enabled? # check
```
## 2. Individual Actor
Turn feature on for individual thing. Think enable feature for someone to test or for a buddy. The only requirement for an individual actor is that it must respond to `flipper_id`.
```ruby
flipper = Flipper.new(adapter)
flipper[:stats].enable user
flipper[:stats].enabled? user # true
flipper[:stats].disable user
flipper[:stats].enabled? user # false
# you can enable anything, does not need to be user or person
flipper[:search].enable group
flipper[:search].enabled? group
# you can also use shortcut methods
flipper.enable_actor :search, user
flipper.disable_actor :search, user
flipper[:search].enable_actor user
flipper[:search].disable_actor user
```
The key is to make sure you do not enable two different types of objects for the same feature. Imagine that user has a `flipper_id` of 6 and group has a `flipper_id` of 6. Enabling search for user would automatically enable it for group, as they both have a `flipper_id` of 6.
The one exception to this rule is if you have globally unique `flipper_ids`, such as UUIDs. If your `flipper_ids` are unique globally in your entire system, enabling two different types should be safe. Another way around this is to prefix the `flipper_id` with the class name like this:
```ruby
class User
def flipper_id
"User;#{id}"
end
end
class Group
def flipper_id
"Group;#{id}"
end
end
```
## 3. Percentage of Actors
Turn this on for a percentage of actors (think user, member, account, group, whatever). Consistently on or off for this user as long as percentage increases. Think slow rollout of a new feature to a percentage of things.
```ruby
flipper = Flipper.new(adapter)
# returns a percentage of actors instance set to 10
percentage = flipper.actors(10)
# turn stats on for 10 percent of users in the system
flipper[:stats].enable percentage
# checks if actor's flipper_id is in the enabled percentage by hashing
# user.flipper_id.to_s to ensure enabled distribution is smooth
flipper[:stats].enabled? user
# you can also use shortcut methods
flipper.enable_percentage_of_actors :search, 10
flipper.disable_percentage_of_actors :search # sets to 0
flipper[:search].enable_percentage_of_actors 10
flipper[:search].disable_percentage_of_actors # sets to 0
```
## 4. Percentage of Time
Turn this on for a percentage of time. Think load testing new features behind the scenes and such.
```ruby
flipper = Flipper.new(adapter)
# get percentage of time instance set to 5
percentage = flipper.time(5)
# Register a feature called logging and turn it on for 5 percent of the time.
# This could be on during one request and off the next
# could even be on first time in request and off second time
flipper[:logging].enable percentage
flipper[:logging].enabled? # this will return true 5% of the time.
# you can also use shortcut methods
flipper.enable_percentage_of_time :search, 5 # registers a feature called "enable_percentage_of_time" and enables it 5% of the time
flipper.disable_percentage_of_time :search # sets to 0
flipper[:search].enable_percentage_of_time 5
flipper[:search].disable_percentage_of_time # sets to 0
```
Timeness is not a good idea for enabling new features in the UI. Most of the time you want a feature on or off for a user, but there are definitely times when I have found percentage of time to be very useful.
## 5. Group
Turn on feature based on the return value of block. Super flexible way to turn on a feature for multiple things (users, people, accounts, etc.) as long as the thing returns true when passed to the block.
```ruby
# this registers a group
Flipper.register(:admins) do |actor|
actor.respond_to?(:admin?) && actor.admin?
end
flipper = Flipper.new(adapter)
flipper[:stats].enable flipper.group(:admins) # This registers a stats feature and turns it on for admins (which is anything that returns true from the registered block).
flipper[:stats].disable flipper.group(:admins) # turn off the stats feature for admins
person = Person.find(params[:id])
flipper[:stats].enabled? person # check if enabled, returns true if person.admin? is true
# you can also use shortcut methods. This also registers a stats feature and turns it on for admins.
flipper.enable_group :stats, :admins
person = Person.find(params[:id])
flipper[:stats].enabled? person # same as above. check if enabled, returns true if person.admin? is true
flipper.disable_group :stats, :admins
flipper[:stats].enable_group :admins
flipper[:stats].disable_group :admins
```
Here's a quick explanation of the above code block:
```
Flipper.register(:admins) do |actor|
actor.respond_to?(:admin?) && actor.admin?
end
```
- The above first registers a group called `admins` which essentially saves a [Proc](http://www.eriktrautman.com/posts/ruby-explained-blocks-procs-and-lambdas-aka-closures) to be called later.
```
flipper[:stats].enable flipper.group(:admins)
```
- The above enables the stats feature to any object that returns true from the `:admins` proc.
```
person = Person.find(params[:id])
flipper[:stats].enabled? person # check if person is enabled, returns true if person.admin? is true
```
When the `person` object is passed to the `enabled?` method, it is then passed into the proc. If the proc returns true, the entire statement returns true and so `flipper[:stats].enabled? person` returns true. Whatever logic follows this conditional check is then executed.
There is no requirement that the thing yielded to the block be a user model or whatever. It can be anything you want, therefore it is a good idea to check that the thing passed into the group block actually responds to what you are trying to do in the `register` proc.
In your application code, you can do something like this now:
```
if flipper[:stats].enabled?(some_admin)
# do thing...
else
# do not do thing
end
```
flipper-0.17.1/docs/Instrumentation.md 0000664 0000000 0000000 00000001643 13537027355 0017734 0 ustar 00root root 0000000 0000000 # Instrumentation
Flipper comes with automatic instrumentation. By default these work with ActiveSupport::Notifications, but only require the pieces of ActiveSupport that are needed and only do so if you actually attempt to require the instrumentation files listed below.
To use the log subscriber:
```ruby
# Gemfile
gem "activesupport"
# config/initializers/flipper.rb (or wherever you want it)
require "flipper/instrumentation/log_subscriber"
```
To use the statsd instrumentation:
```ruby
# Gemfile
gem "activesupport"
gem "statsd-ruby"
# config/initializers/flipper.rb (or wherever you want it)
require "flipper/instrumentation/statsd"
Flipper::Instrumentation::StatsdSubscriber.client = Statsd.new # or whatever your statsd instance is
```
You can also do whatever you want with the instrumented events. Check out [this example](https://github.com/jnunemaker/flipper/blob/master/examples/instrumentation.rb) for more.
flipper-0.17.1/docs/Optimization.md 0000664 0000000 0000000 00000011542 13537027355 0017216 0 ustar 00root root 0000000 0000000 # Optimization
## Memoizing Middleware
One optimization that flipper provides is a memoizing middleware. The memoizing middleware ensures that you only make one adapter call per feature per request. This means if you check the same feature over and over, it will only make one Mongo, Redis, or whatever call per feature for the length of the request.
You can use the middleware like so for Rails:
```ruby
# setup default instance (perhaps in config/initializer/flipper.rb)
Flipper.configure do |config|
config.default do
Flipper.new(...)
end
end
# This assumes you setup a default flipper instance using configure.
config.middleware.use Flipper::Middleware::Memoizer
```
**Note**: Be sure that the middleware is high enough up in your stack that all feature checks are wrapped.
**Also Note**: If you haven't setup a default instance, you can pass the instance to `SetupEnv` as `Memoizer` uses whatever is setup in the `env`:
```ruby
config.middleware.use Flipper::Middleware::SetupEnv, -> { Flipper.new(...) }
config.middleware.use Flipper::Middleware::Memoizer
```
### Options
The Memoizer middleware also supports a few options. Use either `preload` or `preload_all`, not both.
* **`:preload`** - An `Array` of feature names (`Symbol`) to preload for every request. Useful if you have features that are used on every endpoint. `preload` uses `Adapter#get_multi` to attempt to load the features in one network call instead of N+1 network calls.
```ruby
config.middleware.use Flipper::Middleware::Memoizer,
preload: [:stats, :search, :some_feature]
```
* **`:preload_all`** - A Boolean value (default: false) of whether or not all features should be preloaded. Using this results in a `preload_all` call with the result of `Adapter#get_all`. Any subsequent feature checks will be memoized and perform no network calls. I wouldn't recommend using this unless you have few features (< 100?) and nearly all of them are used on every request.
```ruby
config.middleware.use Flipper::Middleware::Memoizer,
preload_all: true
```
* **`:unless`** - A block that prevents preloading and memoization if it evaluates to true.
```ruby
# skip preloading and memoizing if path starts with /assets
config.middleware.use Flipper::Middleware::Memoizer,
unless: ->(request) { request.path.start_with?("/assets") }
```
## Cache Adapters
Cache adapters allow you to cache adapter calls for longer than a single request and should be used alongside the memoization middleware to add another caching layer.
### Dalli
> Dalli is a high performance pure Ruby client for accessing memcached servers.
https://github.com/petergoldstein/dalli
Example using the Dalli cache adapter with the Memory adapter and a TTL of 600 seconds:
```ruby
dalli_client = Dalli::Client.new('localhost:11211')
memory_adapter = Flipper::Adapters::Memory.new
adapter = Flipper::Adapters::Dalli.new(memory_adapter, dalli_client, 600)
flipper = Flipper.new(adapter)
```
### RedisCache
Applications using [Redis](https://redis.io/) via the [redis-rb](https://github.com/redis/redis-rb) client can take advantage of the RedisCache adapter.
Initialize `RedisCache` with a flipper [adapter](https://github.com/jnunemaker/flipper/blob/master/docs/Adapters.md), a Redis client instance, and an optional TTL in seconds. TTL defaults to 3600 seconds.
Example using the RedisCache adapter with the Memory adapter and a TTL of 4800 seconds:
```ruby
require 'flipper/adapters/redis_cache'
redis = Redis.new(url: ENV['REDIS_URL'])
memory_adapter = Flipper::Adapters::Memory.new
adapter = Flipper::Adapters::RedisCache.new(memory_adapter, redis, 4800)
flipper = Flipper.new(adapter)
```
### ActiveSupportCacheStore
Rails applications can cache Flipper calls in any [ActiveSupport::Cache::Store](http://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html) implementation.
Add this line to your application's Gemfile:
gem 'flipper-active_support_cache_store'
And then execute:
$ bundle
Or install it yourself with:
$ gem install flipper-active_support_cache_store
Example using the ActiveSupportCacheStore adapter with ActiveSupport's [MemoryStore](http://api.rubyonrails.org/classes/ActiveSupport/Cache/MemoryStore.html), Flipper's [Memory adapter](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/memory.rb), and a TTL of 5 minutes.
```ruby
require 'active_support/cache'
require 'flipper/adapters/active_support_cache_store'
memory_adapter = Flipper::Adapters::Memory.new
cache = ActiveSupport::Cache::MemoryStore.new
adapter = Flipper::Adapters::ActiveSupportCacheStore.new(memory_adapter, cache, expires_in: 5.minutes)
flipper = Flipper.new(adapter)
```
Setting `expires_in` is optional and will set an expiration time on Flipper cache keys. If specified, all flipper keys will use this `expires_in` over the `expires_in` passed to your ActiveSupport cache constructor.
flipper-0.17.1/docs/active_record/ 0000775 0000000 0000000 00000000000 13537027355 0017014 5 ustar 00root root 0000000 0000000 flipper-0.17.1/docs/active_record/README.md 0000664 0000000 0000000 00000011002 13537027355 0020265 0 ustar 00root root 0000000 0000000 # Flipper ActiveRecord
An ActiveRecord adapter for [Flipper](https://github.com/jnunemaker/flipper).
Supported Active Record versions:
* 4.2.x
* 5.0.x
* 6.0.x
## Installation
Add this line to your application's Gemfile:
gem 'flipper-active_record'
And then execute:
$ bundle
Or install it yourself with:
$ gem install flipper-active_record
## Usage
For your convenience a migration generator is provided to create the necessary migrations for using the active record adapter. By default this generates a migration that will create two database tables - flipper_features and flipper_gates.
$ rails g flipper:active_record
Once you have created and executed the migration, you can use the active record adapter like so:
```ruby
require 'flipper/adapters/active_record'
adapter = Flipper::Adapters::ActiveRecord.new
flipper = Flipper.new(adapter)
# profit...
```
## Internals
Each feature is stored as a row in a features table. Each gate is stored as a row in a gates table, related to the feature by the feature's key.
```ruby
require 'flipper/adapters/active_record'
adapter = Flipper::Adapters::ActiveRecord.new
flipper = Flipper.new(adapter)
# Register a few groups.
Flipper.register(:admins) { |thing| thing.admin? }
Flipper.register(:early_access) { |thing| thing.early_access? }
# Create a user class that has flipper_id instance method.
User = Struct.new(:flipper_id)
flipper[:stats].enable
flipper[:stats].enable_group :admins
flipper[:stats].enable_group :early_access
flipper[:stats].enable_actor User.new('25')
flipper[:stats].enable_actor User.new('90')
flipper[:stats].enable_actor User.new('180')
flipper[:stats].enable_percentage_of_time 15
flipper[:stats].enable_percentage_of_actors 45
flipper[:search].enable
puts 'all rows in features table'
pp Flipper::Adapters::ActiveRecord::Feature.all
# [#