flipper 0.20.2 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df90e63870767caa4d32363658e4515d0822a1453cc3a5325d7dbf932c326b59
-  data.tar.gz: 125256e9cdee5bd0e2bfe065203140eb7fa015cac56043711c7eb45bd5421aa8
+  metadata.gz: 25b07936734df32fbd0331822a97059e76ee9919db287e1073c15b338afc5924
+  data.tar.gz: 221fbb5002318b366d022365b7597f23094d2b50215e9545d3e1c2435faa03ec
 SHA512:
-  metadata.gz: 9598a0a2f62b5c160a8a7c81b50ed9d2bd06f6e70898037c8321f9060780875347552b66919c62b5deb40647f734efa6bef1382b0e9fb1caefe2c8f4b5eaec01
-  data.tar.gz: 8bb413f54398cf90e9aafc7feba144a2e15343e8a75e28ca197d52505ae4771659b3fc7bfafec899388e71c76832859396d86fa52438ba22327f6b6522ade3a5
+  metadata.gz: 4529f945a2c71a3c776940cc091e48280e5088e080c203d478aca91e94e52855d4b5c912bae8aad2b7ca95248f42cabf62599a67f307fc98c34faf46c6361bf1
+  data.tar.gz: 3fed3febaf673456551dea59b13b01777f9f59f9ee267424547b495b4d7f06a7cc5c50521431ef29260585c01f93e05f2c1c30c4e55d5833cfb1cb40fccfb7c3

data/.github/workflows/ci.yml

@@ -1,5 +1,8 @@
 name: CI
-on: [push, pull_request]
+on:
+  push:
+    branches: [master]
+  pull_request:
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -19,6 +22,7 @@ jobs:
       RAILS_VERSION: 6.0.0
       SQLITE3_VERSION: 1.4.1
       REDIS_URL: redis://localhost:6379/0
+      CI: true
     steps:
       - name: Setup memcached
         uses: KeisukeYamashita/memcached-actions@v1
@@ -47,3 +51,7 @@ jobs:
         run: bundle install --jobs 4 --retry 3
       - name: Run Rake
         run: bundle exec rake
+      - name: Run Examples
+        env:
+          FLIPPER_CLOUD_TOKEN: ${{ secrets.FLIPPER_CLOUD_TOKEN }}
+        run: script/examples

data/Changelog.md

@@ -1,3 +1,62 @@
+## 0.21.0
+
+### Additions/Changes
+
+* Default to using memory adapter (https://github.com/jnunemaker/flipper/pull/501)
+* Adapters now configured on require when possible (https://github.com/jnunemaker/flipper/pull/502)
+* Added cloud recommendation to flipper-ui. Can be disabled with `Flipper::UI.configure { |config| config.cloud_recommendation = false }`. Just want to raise awareness that more is available if people want it (https://github.com/jnunemaker/flipper/pull/504)
+* Added default `flipper_id` implementation via `Flipper::Identifier` and automatically included it in ActiveRecord and Sequel models (https://github.com/jnunemaker/flipper/pull/505)
+* Deprecate superflous sync_method setting (https://github.com/jnunemaker/flipper/pull/511)
+* Flipper is now pre-configured when used with Rails. By default, it will [memoize and preload all features for each request](docs/Optimization.md#memoization). (https://github.com/jnunemaker/flipper/pull/506)
+
+### Upgrading
+
+You should be able to upgrade to 0.21 without any breaking changes. However, if you want to simplify your setup, you can remove some configuration that is now handled automatically:
+
+1. Adapters are configured when on require, so unless you are using caching or other customizations, you can remove adapter configuration.
+
+    ```diff
+    # config/initializers/flipper.rb
+    - Flipper.configure do |config|
+    -   config.default { Flipper.new(Flipper::Adapters::ActiveRecord.new) }
+    - end
+    ```
+
+2. `Flipper::Middleware::Memoizer` will be enabled by default.
+
+    ```diff
+    # config/initializers/flipper.rb
+    - Rails.configuration.middleware.use Flipper::Middleware::Memoizer,
+    -   preload: [:stats, :search, :some_feature]
+    + Rails.application.configure do
+    +   # Uncomment to configure which features to preload on all requests
+    +   # config.flipper.preload = [:stats, :search, :some_feature]
+    + end
+    ```
+
+3. `#flipper_id`, which is used to enable features for specific actors, is now defined by [Flipper::Identifier](lib/flipper/identifier.rb) on all ActiveRecord and Sequel models. You can remove your implementation if it is in the form of `ModelName;id`.
+
+4. When using `flipper-cloud`, The `Flipper::Cloud.app` webhook receiver is now mounted at `/_flipper` by default.
+
+    ```diff
+    # config/routes.rb
+    - mount Flipper::Cloud.app, at: "/_flipper"
+    ```
+
+## 0.20.4
+
+### Additions/Changes
+
+* Allow actors and time gates to deal with decimal percentages (https://github.com/jnunemaker/flipper/pull/492)
+* Change Flipper::Cloud::Middleware to receive webhooks at / in addition to /webhooks.
+* Add `write_through` option to ActiveSupportCacheStore adapter to support write-through caching (https://github.com/jnunemaker/flipper/pull/512)
+
+## 0.20.3
+
+### Additions/Changes
+
+* Changed the internal structure of how the memory adapter stores things.
+
 ## 0.20.2
 
 ### Additions/Changes

data/Gemfile

@@ -18,6 +18,7 @@ gem 'minitest', '~> 5.8'
 gem 'minitest-documentation'
 gem 'webmock', '~> 3.0'
 gem 'climate_control'
+gem 'redis-namespace'
 
 group(:guard) do
   gem 'guard', '~> 2.15'

data/README.md

@@ -1,23 +1,17 @@
-<pre>
-                                   __
-                               _.-~  )
-                    _..--~~~~,'   ,-/     _
-                 .-'. . . .'   ,-','    ,' )
-               ,'. . . _   ,--~,-'__..-'  ,'
-             ,'. . .  (@)' ---~~~~      ,'
-            /. . . . '~~             ,-'
-           /. . . . .             ,-'
-          ; . . . .  - .        ,'
-         : . . . .       _     /
-        . . . . .          `-.:
-       . . . ./  - .          )
-      .  . . |  _____..---.._/ _____
-~---~~~~----~~~~             ~~
-</pre>
-
-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.
+[![Flipper Mark](docs/images/banner.jpg)](https://www.flippercloud.io)
+
+# Flipper
+
+> Beautiful, performant feature flags for Ruby.
+
+Flipper gives you control over who has access to features in your app.
+
+* Enable or disable features for everyone, specific actors, groups of actors, a percentage of actors, or a percentage of time.
+* Configure your feature flags from the console or a web UI.
+* Regardless of what data store you are using, Flipper can performantly store your feature flags.
+* Use [Flipper Cloud](#flipper-cloud) to cascade features from multiple environments, share settings with your team, control permissions, keep an audit history, and rollback.
+
+Control your software &mdash; don't let it control you.
 
 ## Installation
 
@@ -25,6 +19,10 @@ Add this line to your application's Gemfile:
 
     gem 'flipper'
 
+You'll also want to pick a storage [adapter](#adapters), for example:
+
+    gem 'flipper-active_record'
+
 And then execute:
 
     $ bundle
@@ -33,50 +31,108 @@ Or install it yourself with:
 
     $ gem install flipper
 
-## Examples
+## Getting Started
 
-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, ...)`).
+Use `Flipper#enabled?` in your app to check if a feature is enabled.
 
 ```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)
+if Flipper.enabled? :search, current_user
   puts 'Search away!'
 else
   puts 'No search for you!'
 end
+```
 
-puts 'Enabling Search...'
-Flipper.enable(:search)
+All features are disabled by default, so you'll need to explicitly enable them.
 
-# check if search is enabled
-if Flipper.enabled?(:search)
-  puts 'Search away!'
-else
-  puts 'No search for you!'
+#### Enable a feature for everyone
+
+```ruby
+Flipper.enable :search
+```
+
+#### Enable a feature for a specific actor
+
+```ruby
+Flipper.enable_actor :search, current_user
+```
+
+#### Enable a feature for a group of actors
+
+First tell Flipper about your groups:
+
+```ruby
+# config/initializers/flipper.rb
+Flipper.register(:admin) do |actor|
+  actor.respond_to?(:admin?) && actor.admin?
 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.
+Then enable the feature for that group:
+
+```ruby
+Flipper.enable_group :search, :admin
+```
+
+#### Enable a feature for a percentage of actors
+
+```ruby
+Flipper.enable_percentage_of_actors :search, 2
+```
+
+
+Read more about enabling and disabling features with [Gates](docs/Gates.md). Check out the [examples directory](examples/) for more, and take a peek at the [DSL](lib/flipper/dsl.rb) and [Feature](lib/flipper/feature.rb) classes for code/docs.
+
+## Adapters
+
+Flipper is built on adapters for maximum flexibility. Regardless of what data store you are using, Flipper can performantly store data in it.
+
+Pick one of our [supported adapters](docs/Adapters.md#officially-supported) and follow the installation instructions:
+
+* [Active Record](docs/active_record/README.md)
+* [Sequel](docs/sequel/README.md)
+* [Redis](docs/redis/README.md)
+* [Mongo](docs/mongo/README.md)
+* [Moneta](docs/moneta/README.md)
+* [Rollout](docs/rollout/README.md)
+
+Or [roll your own](docs/Adapters.md#roll-your-own). We even provide automatic (rspec and minitest) tests for you, so you know you've built your custom adapter correctly.
+
+Read more about [Adapters](docs/Adapters.md).
+
+## Flipper UI
+
+If you prefer a web UI to an IRB console, you can setup the [Flipper UI](docs/ui/README.md).
+
+It's simple and pretty.
+
+![Flipper UI Screenshot](docs/ui/images/feature.png)
+
+
+
+## Flipper Cloud
+
+Or, (even better than OSS + UI) use [Flipper Cloud](https://www.flippercloud.io) which comes with:
+
+* **everything in one place** &mdash; no need to bounce around from different application UIs or IRB consoles.
+* **permissions** &mdash; grant access to everyone in your organization or lockdown each project to particular people.
+* **multiple environments** &mdash; production, staging, enterprise, by continent, whatever you need.
+* **personal environments** &mdash; no more rake scripts or manual enable/disable to get your laptop to look like production. Every developer gets a personal environment that inherits from production that they can override as they please ([read more](https://www.johnnunemaker.com/flipper-cloud-environments/)).
+* **no maintenance** &mdash; we'll keep the lights on for you. We also have handy webhooks for keeping your app in sync with Cloud, so **our availability won't affect yours**. All your feature flag reads are local to your app.
+* **audit history** &mdash; every feature change and who made it.
+* **rollbacks** &mdash; enable or disable a feature accidentally? No problem. You can roll back to any point in the audit history with a single click.
+
+[![Flipper Cloud Screenshot](docs/images/flipper_cloud.png)](https://www.flippercloud.io)
+
+Cloud is super simple to integrate with Rails ([demo app](https://github.com/fewerandfaster/flipper-rails-demo)), Sinatra or any other framework.
+
+## Advanced
 
-## Docs
+A few miscellaneous docs with more info for the hungry.
 
-* [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

data/docs/Adapters.md

@@ -4,17 +4,17 @@ I plan on supporting the adapters in the flipper repo. Other adapters are welcom
 
 ## Officially Supported
 
-* [ActiveRecord adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_record) - Rails 3, 4, 5, and 6.
-* [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)
+* [ActiveRecord adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_record) - Rails 5 and 6.
+* [Sequel adapter](https://github.com/jnunemaker/flipper/blob/master/docs/sequel)
+* [Redis adapter](https://github.com/jnunemaker/flipper/blob/master/docs/redis)
 * [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)
+* [Http adapter](https://github.com/jnunemaker/flipper/blob/master/docs/http) - great for using with `Flipper::Api`
+* [Moneta adapter](https://github.com/jnunemaker/flipper/blob/master/docs/moneta) - great for a variety of data stores
+* [ActiveSupportCacheStore adapter](https://github.com/jnunemaker/flipper/blob/master/docs/active_support_cache_store) - great for Rails caching
+* [Memory adapter](https://github.com/jnunemaker/flipper/blob/master/lib/flipper/adapters/memory.rb) – great for tests
+* [Read-only adapter](https://github.com/jnunemaker/flipper/blob/master/docs/read-only) - great for preventing writes from production console
+* [Rollout adapter](rollout/README.md) - great for switching from rollout to flipper
 
 ## Community Supported
 

data/docs/Caveats.md

@@ -1,4 +1,4 @@
 # 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))
+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 100 individual actors, 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))

data/docs/Gates.md

@@ -7,76 +7,82 @@ Out of the box several types of enabling are supported. They are checked in this
 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
+Flipper.enable :stats # turn on
+Flipper.disable :stats # turn off
+Flipper.enabled? :stats # 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`.
+Turn feature on for individual thing. Think enable feature for someone to test or for a buddy.
 
 ```ruby
-flipper = Flipper.new(adapter)
+Flipper.enable_actor :stats, user
+Flipper.enabled? :stats, user # true
 
-flipper[:stats].enable user
-flipper[:stats].enabled? user # true
-
-flipper[:stats].disable user
-flipper[:stats].enabled? user # false
+Flipper.disable_actor :stats, user
+Flipper.enabled? :stats, 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
-```
+Flipper.enable_actor :search, organization
+Flipper.enabled? :search, organization
 
-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.
+# you can also save a reference to a specific feature
+feature = Flipper[:search]
+
+feature.enable_actor user
+feature.enabled? user # true
+feature.disable_actor user
+```
 
-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:
+The only requirement for an individual actor is that it must have a unique `flipper_id`. Include the `Flipper::Identifier` module for a default implementation which combines the class name and `id` (e.g. `User;6`).
 
 ```ruby
-class User
-  def flipper_id
-    "User;#{id}"
-  end
+class User < Struct.new(:id)
+  include Flipper::Identifier
 end
 
-class Group
+User.new(5).flipper_id # => "User;5"
+```
+
+You can also define your own implementation:
+
+```
+class Organization < Struct.new(:uuid)
   def flipper_id
-    "Group;#{id}"
+    uuid
   end
 end
+
+Organization.new("DEB3D850-39FB-444B-A1E9-404A990FDBE0").flipper_id
+# => "DEB3D850-39FB-444B-A1E9-404A990FDBE0"
 ```
 
+Just make sure each type of object has a unique `flipper_id`.
+
 ## 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
+Flipper.enable :stats, Flipper.actors(10)
+# or
+Flipper.enable_percentage_of_actors :stats, 10
 
 # 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
+Flipper.enabled? :stats, 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
+Flipper.disable_percentage_of_actors :search # sets to 0
+# or
+Flipper.disable :stats, Flipper.actors(0)
+
+# you can also save a reference to a specific feature
+feature = Flipper[:search]
+feature.enable_percentage_of_actors 10
+feature.enabled? user
+feature.disable_percentage_of_actors # sets to 0
 ```
 
 ## 4. Percentage of Time
@@ -84,22 +90,20 @@ flipper[:search].disable_percentage_of_actors # sets to 0
 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 "search" 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
+Flipper.enable_percentage_of_time :logging, 5
+
+Flipper.enabled? :logging # this will return true 5% of the time.
+
+Flipper.disable_percentage_of_time :logging # sets to 0
+
+# you can also save a reference to a specific feature
+feature = Flipper[:search]
+feature.enable_percentage_of_time, 5
+feature.enabled?
+feature.disable_percentage_of_time
 ```
 
 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.
@@ -114,52 +118,48 @@ 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
+Flipper.enable_group :stats, :admins # This registers a stats feature and turns it on for admins (which is anything that returns true from the registered block).
+Flipper.disable_group :stats, :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
+Flipper.enabled? :stats, 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
+# you can also use shortcut methods. This also registers a stats feature and turns it on for admins.
+feature = Flipper[:search]
+feature.enable_group :admins
+feature.enabled? person
+feature.disable_group :admins
 ```
 
 Here's a quick explanation of the above code block:
 
-```
+```ruby
 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. The `actor` is an instance of the `Flipper::Types::Actor` that wraps the thing being checked against and `actor.thing` is the original object being checked. 
+- 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. The `actor` is an instance of the `Flipper::Types::Actor` that wraps the thing being checked against and `actor.thing` is the original object being checked.
 
-```
-flipper[:stats].enable flipper.group(:admins)
+```ruby
+Flipper.enable_group :stats, :admins
 ```
 
 - The above enables the stats feature to any object that returns true from the `:admins` proc.
 
-```
+```ruby
 person = Person.find(params[:id])
-flipper[:stats].enabled? person # check if person is enabled, returns true if person.admin? is true
+Flipper.enabled? :stats, 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.
+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)
+```ruby
+if Flipper.enabled? :stats, some_admin
   # do thing...
 else
   # do not do thing