flippant 0.6.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8c259d40ca6b2cbd3305d2ab5a1c2ba425794886
-  data.tar.gz: 913b5c2043ae9b6c6c2ecea20666f0c82e3dc444
+SHA256:
+  metadata.gz: eb2f65a02966b9232561570498e893b0905ca3685b6e826b79376d7ede5c76d5
+  data.tar.gz: e6c8c1487f5ef80b0f467305076c36aca091fbcd38d1953fe4e03de6ea8dcb87
 SHA512:
-  metadata.gz: 627e7caa8606d1d7b002f513553be1a5e0bea1647ae35d111ccc71962b496fb2b0f0b93669233fe67e97e283321a41dbb54f03d545a09b35c3e8fd9adc1041ce
-  data.tar.gz: 919ce1da13ee2f5e7353eb0f96b892aea75bf006b148cb125e0cbbed25ffec8c421a3658df4a9766a8210f741037a4f71744d6447cdd5ee9a16160546f508aa0
+  metadata.gz: afc9ead23ec2566f9750802e73c6895a8ac99aa75b7f6bd9295b7c48d0aecd5b3d839eacf83ed30637c09a8f1c2cff34c0e82623a3edd3d2b0d7892de0093bc8
+  data.tar.gz: dcb7abfe21f01a19d900c3933ec43d5b62a6a2be34f6c054b6ed6abc0ed9f8aa82567306730e52500fb86fba05b5d18e0ae83754cf433c96d8110c63b47748c3

data/.rubocop.yml

@@ -4,12 +4,26 @@ AllCops:
     - "vendor/**/*"
   TargetRubyVersion: 2.3
 
+Layout/IndentArray:
+  Enabled: false
+
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+  EnforcedStyleForEmptyBraces: no_space
+
 Metrics/AbcSize:
   Max: 20
 
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+
 Metrics/ClassLength:
   Max: 200
 
+Metrics/LineLength:
+  Max: 96
+
 Metrics/MethodLength:
   Max: 20
 
@@ -40,14 +54,3 @@ Style/PercentLiteralDelimiters:
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
-
-Style/SpaceInsideHashLiteralBraces:
-  EnforcedStyle: no_space
-  EnforcedStyleForEmptyBraces: no_space
-
-Style/IndentArray:
-  Enabled: false
-
-Metrics/BlockLength:
-  Exclude:
-    - "spec/**/*"

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.5.0

data/.travis.yml

@@ -1,7 +1,13 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.3.0
-before_install: gem install bundler -v 1.13.6
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
 services:
+  - postgresql
   - redis-server
+before_script:
+  - psql -c "CREATE DATABASE flippant_test;" -U postgres
+addons:
+  postgresql: "9.6"

data/CHANGELOG.md

@@ -1,4 +1,30 @@
-## v0.6.0 - 2017-08-08
+## v0.9.0 2018-03-20
+
+### Enhancements
+
+* [Flippant] - Add a new Postgres adatper, backed by PG and ActiveRecord pools.
+* [Flippant] - Add `setup` to facilitate adapter setup (i.e. Postgres).
+* [Flippant] - Modify `enable` and `disable` to prevent duplicate values and
+  operate atomically without a transaction.
+* [Flippant] - Add `dump/1` and `load/1` functions for backups and portability.
+
+### Changes
+
+* [Flippant::Adapter] - Values are no longer guaranteed to be sorted. Some
+  adapters guarantee sorting, but race conditions prevent it in the Postgres
+  adapter, so it is no longer guaranteed.
+
+## v0.6.0 2017-08-08
+
+### Enhancements
+
+* [Flippant] - Merge additional values when enabling features. This prevents
+  clobbering existing values in "last write wins" situations.
+* [Flippant] - Support enabling or disabling of individual values. This makes it
+  possible to remove a single value from a group's rules.
+* [Flippant] - Add `rename/2` for renaming existing features.
+* [Flippant] - Add `exists?/1` for checking whether a feature exists at all,
+  and `exists?/2` for checking whether a feature exists for a particular group.
 
 ### Changes
 
@@ -7,12 +33,12 @@
   exist. This forces an order of defining groups before enabling features, but
   it will prevent trying to register groups that don't exist or with typos.
 
-## v0.5.1 - 2017-01-26
+## v0.5.1 2017-01-26
 
 ### Changes
 
 * [Flippant::Adapter::Redis] - Constructor uses keyword arguments.
 
-## v0.5.0 - 2017-01-24
+## v0.5.0 2017-01-24
 
 * Initial release, largely ported from sorentwo/flippant, the Elixir version.

data/README.md

@@ -1,41 +1,186 @@
 # Flippant
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/flippant`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Fast feature toggling for ruby applications, backed by Redis.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'flippant-rb'
+gem 'flippant'
 ```
 
-And then execute:
+## Usage
+
+Flippant composes three constructs to determine whether a feature is enabled:
 
-    $ bundle
+* Actors - An actor can be any value, but typically it is a `User` or
+  some other object representing a user.
+* Groups - Groups are used to identify and qualify actors. For example,
+  "everybody", "nobody", "admins", "staff", "testers" could all be groups names.
+* Rules - Rules represent individual features which are evaluated against actors
+  and groups. For example, "search", "analytics", "super-secret-feature" could
+  all be rule names.
 
-Or install it yourself as:
+Group names may be either strings or symbols.
 
-    $ gem install flippant-rb
+Let's walk through setting up a few example groups and rules. You'll want to
+establish groups at startup, as they aren't likely to change (and defining
+functions from a web interface isn't wise).
 
-## Usage
+### Groups
 
-TODO: Write usage instructions here
+First, a group that nobody can belong to. This is useful for disabling a feature
+without deleting it:
+
+```ruby
+Flippant.register("nobody", ->(actor, _) { false })
+```
 
-## Development
+Now the opposite, a group that everybody can belong to:
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```ruby
+Flippant.register("everybody", ->(actor, _) { true })
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To be more exclusive and define staff-only features we need a "staff" group:
 
-## Contributing
+```ruby
+Flippant.register("staff", ->(actor, _) { actor.staff? })
+```
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/flippant-rb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Lastly, we'll roll out a feature out to a percentage of the actors:
 
+```ruby
+Flippant.register("adopters", ->(actor, buckets) { buckets.include?(actor.id % 10) })
+```
 
-## License
+To tidy up a bit, we can define the registered group detection functions in a separate module.
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+```ruby
+module FeatureGroups
+  def self.premium_subscriber?(actor, _)
+    actor.premium_subscriber?
+  end
+
+  def self.allowed_user?(actor, allowed_ids)
+    allowed_ids.include?(actor.id)
+  end
+end
+
+Flippant.register("premium_subscriber", &FeatureGroups.method(:premium_subscriber?))
+Flippant.register("allowed_user", &FeatureGroups.method(:allowed_user?))
+```
+
+
+With some core groups defined we now can set up some rules.
+
+### Rules
+
+Rules are comprised of a name, a group, and an optional set of values. Starting
+with a simple example that builds on the groups we have already created, we'll
+enable the "search" feature:
+
+```ruby
+# Any staff can use the "search" feature
+Flippant.enable("search", "staff")
+
+# 30% of "adopters" can use the "search" feature as well
+Flippant.enable("search", "adopters", [0, 1, 2])
+```
+
+Because rules are only built of binaries and simple data they can be defined or
+refined at runtime. In fact, this is a crucial part of feature toggling. With a
+web interface rules can be added, removed, or modified.
+
+```ruby
+# Turn search off for adopters
+Flippant.disable("search", "adopters")
+
+# On second thought, enable it again for 10%
+Flippant.enable("search", "adopters", [3])
+```
+
+With a set of groups and rules defined we can check whether a feature is
+enabled for a particular actor:
+
+```ruby
+class User
+  attr_accessor :id, :is_staff
+
+  def initialize(id, is_staff)
+    @id = id
+    @is_staff = is_staff
+  end
+
+  def staff?
+    @is_staff
+  end
+end
+
+staff_user = User.new(1, true)
+early_user = User.new(2, false)
+later_user = User.new(3, false)
+
+Flippant.enabled?("search", staff_user) #=> true, staff
+Flippant.enabled?("search", early_user) #=> false, not an adopter
+Flippant.enabled?("search", later_user) #=> true, is an adopter
+```
+
+If an actor qualifies for multiple groups and *any* of the rules evaluate to
+true that feature will be enabled for them. Think of the "nobody" and
+"everybody" groups that were defined earlier:
+
+```ruby
+Flippant.enable("search", "everybody")
+Flippant.enable("search", "nobody")
+
+Flippant.enabled?("search", User.new) #=> true
+```
+
+## Breakdown
+
+Evaluating rules requires a round trip to the database. Clearly, with a lot of
+rules it is inefficient to evaluate each one individually. There is a function
+to help with this exact scenario:
+
+```ruby
+Flippant.enable("search", "staff")
+Flippant.enable("delete", "everybody")
+Flippant.enable("invite", "nobody")
+
+user = User.new(1, true)
+Flippant.breakdown(user) #=> {
+  "search" => true,
+  "delete" => true,
+  "invite" => false
+}
+```
+
+The breakdown is a simple hash of string keys to boolean values. This is
+extremely handy for single page applications where you can serialize the
+breakdown on boot or send it back from an endpoint as JSON.
+
+## Configuration
+
+Both Redis and Memory adapters are available for Flippant's registry storage. Memory
+is the default.
+
+The Memory adapter behaves identically to the Redis adapter, but will clear out
+its registry whenever the application is reloaded, so it may be especially useful
+in testing.
+
+You may want to change this to Redis in production by overriding the `adapter` setting.
+
+```ruby
+# In Rails, for instance, add this to `config/initializers/flippant.rb`:
+Flippant.adapter = if Rails.env.test?
+                     Flippant::Adapter::Memory.new
+                   else
+                     Flippant::Adapter::Redis.new
+                   end
+```
+
+## License
 
+MIT License, see [LICENSE.txt](LICENSE.txt) for details.

data/benchmarks/adapters.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "flippant"
+require "active_record"
+
+ActiveRecord::Base.establish_connection("postgres:///flippant_test")
+
+memory = Flippant::Adapter::Memory.new
+postgres = Flippant::Adapter::Postgres.new
+redis = Flippant::Adapter::Redis.new
+
+memory_enabled = lambda do
+  Flippant.adapter = memory unless Flippant.adapter == memory
+
+  Flippant.enabled?("search", nil)
+end
+
+postgres_enabled = lambda do
+  Flippant.adapter = postgres unless Flippant.adapter == postgres
+
+  Flippant.enabled?("search", nil)
+end
+
+redis_enabled = lambda do
+  Flippant.adapter = redis unless Flippant.adapter == redis
+
+  Flippant.enabled?("search", nil)
+end
+
+Flippant.configure do |config|
+  config.adapter = Flippant::Adapter::Postgres.new
+end
+
+Flippant.register("everybody", ->(_, _) { true })
+Flippant.enable("search", "everybody")
+
+Benchmark.ips do |x|
+  x.report "memory:enabled?", &memory_enabled
+  x.report "postgres:enabled?", &postgres_enabled
+  x.report "redis:enabled?", &redis_enabled
+  x.compare!
+end

data/flippant.gemspec

@@ -1,19 +1,17 @@
-# coding: utf-8
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "flippant/version"
 
 Gem::Specification.new do |spec|
-  spec.name        = "flippant"
-  spec.version     = Flippant::VERSION
-  spec.authors     = ["Parker Selbert"]
-  spec.email       = ["parker@sorentwo.com"]
+  spec.name = "flippant"
+  spec.version = Flippant::VERSION
+  spec.authors = ["Parker Selbert"]
+  spec.email = ["parker@sorentwo.com"]
 
-  spec.summary     = "Fast feature toggling for applications"
+  spec.summary = "Fast feature toggling for applications"
   spec.description = "Fast feature toggling for applications"
-  spec.homepage    = "https://github.com/sorentwo/flippant-rb"
-  spec.license     = "MIT"
+  spec.homepage = "https://github.com/sorentwo/flippant-rb"
+  spec.license = "MIT"
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^spec/})
@@ -22,9 +20,12 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "activerecord", "~> 5.1"
+  spec.add_development_dependency "benchmark-ips"
   spec.add_development_dependency "bundler"
+  spec.add_development_dependency "pg", "~> 1.0"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 3.2"
-  spec.add_development_dependency "redis", "~> 3.3"
-  spec.add_development_dependency "rubocop", "~> 0.47"
+  spec.add_development_dependency "redis", "~> 4.0"
+  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "rubocop", "~> 0.52"
 end

data/lib/flippant/adapters/memory.rb

@@ -1,36 +1,42 @@
 # frozen_string_literal: true
 
+require "monitor"
+
 module Flippant
   module Adapter
     class Memory
-      attr_reader :table
+      attr_reader :monitor, :table
 
       def initialize
+        @monitor = Monitor.new
+
         clear
       end
 
-      def add(feature)
-        table[normalize(feature)] ||= {}
+      def setup
+        true
       end
 
-      def remove(feature)
-        table.delete(feature)
+      def add(feature)
+        table[feature] ||= {}
       end
 
-      def enable(feature, group, values = [])
-        fkey = normalize(feature)
-        gkey = group.to_s
+      def breakdown(actor = nil)
+        return table if actor.nil?
 
-        Mutex.new.synchronize do
-          table[fkey][gkey] ||= []
-          table[fkey][gkey] = (table[fkey][gkey] | values).sort
+        table.each_with_object({}) do |(feature, _), memo|
+          memo[feature] = enabled?(feature, actor)
         end
       end
 
+      def clear
+        @table = Hash.new { |hash, key| hash[key] = {} }
+      end
+
       def disable(feature, group, values = [])
-        rules = table[normalize(feature)]
+        rules = table[feature]
 
-        Mutex.new.synchronize do
+        monitor.synchronize do
           if values.any?
             remove_values(rules, group, values)
           else
@@ -39,24 +45,25 @@ module Flippant
         end
       end
 
-      def rename(old_feature, new_feature)
-        old_feature = normalize(old_feature)
-        new_feature = normalize(new_feature)
+      def enable(feature, group, values = [])
+        fkey = feature
+        gkey = group.to_s
 
-        table[new_feature] = table.delete(old_feature)
+        monitor.synchronize do
+          table[fkey][gkey] ||= []
+          table[fkey][gkey] = (table[fkey][gkey] | values).sort
+        end
       end
 
       def enabled?(feature, actor, registered = Flippant.registered)
-        table[normalize(feature)].any? do |group, values|
+        table[feature].any? do |group, values|
           if (block = registered[group.to_s])
             block.call(actor, values)
           end
         end
       end
 
-      def exists?(feature, group = nil)
-        feature = normalize(feature)
-
+      def exists?(feature, group)
         if group.nil?
           table.key?(feature)
         else
@@ -74,24 +81,29 @@ module Flippant
         end
       end
 
-      def breakdown(actor = nil)
-        return table if actor.nil?
-
-        table.each_with_object({}) do |(feature, _), memo|
-          memo[feature] = enabled?(feature, actor)
+      def load(loaded)
+        monitor.synchronize do
+          loaded.each do |feature, rules|
+            rules.each do |group, values|
+              table[feature][group] = values
+            end
+          end
         end
       end
 
-      def clear
-        @table = Hash.new { |hash, key| hash[key] = {} }
+      def remove(feature)
+        table.delete(feature)
       end
 
-      private
+      def rename(old_feature, new_feature)
+        old_feature = old_feature
+        new_feature = new_feature
 
-      def normalize(feature)
-        feature.to_s.downcase.strip
+        table[new_feature] = table.delete(old_feature)
       end
 
+      private
+
       def remove_group(rules, to_remove)
         rules.reject! { |(group, _)| group == to_remove.to_s }
       end

data/lib/flippant/adapters/postgres.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "pg"
+
+module Flippant
+  module Adapter
+    class Postgres
+      DEFAULT_TABLE = "flippant_features"
+
+      attr_reader :pool, :table
+
+      def initialize(pool: ActiveRecord::Base.connection_pool, table: DEFAULT_TABLE)
+        @pool = pool
+        @table = table
+      end
+
+      def add(feature)
+        exec("INSERT INTO #{table} (name) VALUES ($1) ON CONFLICT (name) DO NOTHING", [feature])
+      end
+
+      def breakdown(actor = :all)
+        result = exec("SELECT jsonb_object_agg(name, rules) FROM #{table}")
+        object = JSON.parse(result.values.flatten.first || "{}")
+
+        object.each_with_object({}) do |(fkey, rules), memo|
+          memo[fkey] = actor == :all ? rules : Rules.enabled_for_actor?(rules, actor)
+        end
+      end
+
+      def clear
+        exec("TRUNCATE #{table} RESTART IDENTITY")
+      end
+
+      def disable(feature, group, values)
+        if values.empty?
+          exec("UPDATE #{table} SET rules = rules - $1 WHERE name = $2", [group, feature])
+        else
+          command = <<~SQL
+            UPDATE #{table} SET rules = jsonb_set(rules, $1, array_to_json(
+              ARRAY(
+                SELECT UNNEST(ARRAY(SELECT jsonb_array_elements(COALESCE(rules#>$1, '[]'::jsonb))))
+                EXCEPT
+                SELECT UNNEST(ARRAY(SELECT jsonb_array_elements($2)))
+              )
+            )::jsonb)
+            WHERE name = $3
+          SQL
+
+          exec(command, [encode_array([group]), encode_json(values), feature])
+        end
+      end
+
+      def enable(feature, group, values)
+        command = <<~SQL
+          INSERT INTO #{table} AS t (name, rules) VALUES ($1, $2)
+          ON CONFLICT (name) DO UPDATE
+          SET rules = jsonb_set(t.rules, $3, array_to_json(
+            ARRAY(
+              SELECT DISTINCT(UNNEST(ARRAY(
+                SELECT jsonb_array_elements(COALESCE(t.rules#>$3, '[]'::jsonb))
+              ) || $4))
+            )
+          )::jsonb)
+        SQL
+
+        exec(command, [feature,
+                       encode_json(group => values),
+                       encode_array([group]),
+                       encode_array(values)])
+      end
+
+      def enabled?(feature, actor)
+        result = exec("SELECT rules FROM #{table} WHERE name = $1", [feature])
+        object = JSON.parse(result.values.flatten.first || "[]")
+
+        Rules.enabled_for_actor?(object, actor)
+      end
+
+      def exists?(feature, group = nil)
+        result =
+          if group.nil?
+            exec("SELECT EXISTS (SELECT 1 FROM #{table} WHERE name = $1)",
+                 [feature])
+          else
+            exec("SELECT EXISTS (SELECT 1 FROM #{table} WHERE name = $1 " \
+                 "AND rules ? $2)",
+                 [feature, group])
+          end
+
+        result.values.first == [true]
+      end
+
+      def features(group = :all)
+        result =
+          if group == :all
+            exec("SELECT name FROM #{table} ORDER BY name ASC")
+          else
+            exec("SELECT name FROM #{table} WHERE rules ? $1 ORDER BY name ASC", [group])
+          end
+
+        result.values.flatten
+      end
+
+      def load(loaded)
+        transaction do |client|
+          loaded.each do |feature, rules|
+            client.exec_params(
+              "INSERT INTO #{table} AS t (name, rules) VALUES ($1, $2)",
+              [feature, encode_json(rules)]
+            )
+          end
+        end
+      end
+
+      def rename(old_name, new_name)
+        transaction do |client|
+          client.exec_params("DELETE FROM #{table} WHERE name = $1",
+                             [new_name])
+
+          client.exec_params("UPDATE #{table} SET name = $1 WHERE name = $2",
+                             [new_name, old_name])
+        end
+      end
+
+      def remove(feature)
+        exec("DELETE FROM #{table} WHERE name = $1", [feature])
+      end
+
+      def setup
+        exec <<~SQL
+          CREATE TABLE IF NOT EXISTS #{table} (
+            name text NOT NULL CHECK (name <> ''),
+            rules jsonb NOT NULL DEFAULT '{}'::jsonb,
+            CONSTRAINT unique_name UNIQUE(name)
+          )
+        SQL
+      end
+
+      private
+
+      def conn
+        pool.with_connection do |connection|
+          client = connection.raw_connection
+
+          yield client
+        end
+      end
+
+      def exec(sql, params = [])
+        conn do |client|
+          if params.empty?
+            client.exec(sql)
+          else
+            client.exec_params(sql, params)
+          end
+        end
+      end
+
+      def transaction(&block)
+        conn do |client|
+          client.transaction(&block)
+        end
+      end
+
+      def encode_array(value)
+        PG::TextEncoder::Array.new.encode(value)
+      end
+
+      def encode_json(value)
+        PG::TextEncoder::JSON.new.encode(value)
+      end
+    end
+  end
+end

data/lib/flippant/adapters/redis.rb

@@ -9,35 +9,32 @@ module Flippant
 
       DEFAULT_KEY = "flippant-features"
 
-      attr_reader :client, :key, :serializer
-
-      def_delegators :serializer, :dump, :load
+      attr_reader :client, :set_key, :serializer
 
       def initialize(client: ::Redis.current,
-                     key: DEFAULT_KEY,
+                     set_key: DEFAULT_KEY,
                      serializer: Flippant.serializer)
         @client = client
-        @key = key
         @serializer = serializer
+        @set_key = set_key
+      end
+
+      def setup
+        true
       end
 
       def add(feature)
-        client.sadd(key, normalize(feature))
+        client.sadd(set_key, feature)
       end
 
-      def remove(feature)
-        client.multi do
-          client.srem(key, feature)
-          client.del(namespace(feature))
+      def breakdown(actor = nil)
+        features(:all).each_with_object({}) do |fkey, memo|
+          memo[fkey] = actor.nil? ? feature_rules(fkey) : enabled?(fkey, actor)
         end
       end
 
-      def enable(feature, group, values = [])
-        add(feature)
-
-        change_values(namespace(feature), group) do |old|
-          (old | values).sort
-        end
+      def clear
+        client.smembers(set_key).each { |fkey| remove(fkey) }
       end
 
       def disable(feature, group, values = [])
@@ -54,32 +51,25 @@ module Flippant
         maybe_cleanup(feature)
       end
 
-      def rename(old_feature, new_feature)
-        old_feature = normalize(old_feature)
-        new_feature = normalize(new_feature)
-        old_namespaced = namespace(old_feature)
-        new_namespaced = namespace(new_feature)
+      def enable(feature, group, values = [])
+        add(feature)
 
-        client.watch(old_namespaced, new_namespaced) do
-          client.multi do
-            client.srem(key, old_feature)
-            client.sadd(key, new_feature)
-            client.rename(old_namespaced, new_namespaced)
-          end
+        change_values(namespace(feature), group) do |old|
+          (old | values).sort
         end
       end
 
       def enabled?(feature, actor, registered = Flippant.registered)
         client.hgetall(namespace(feature)).any? do |group, values|
           if (block = registered[group])
-            block.call(actor, load(values))
+            block.call(actor, serializer.load(values))
           end
         end
       end
 
-      def exists?(feature, group = nil)
+      def exists?(feature, group)
         if group.nil?
-          client.sismember(key, feature)
+          client.sismember(set_key, feature)
         else
           client.hexists(namespace(feature), group)
         end
@@ -87,7 +77,7 @@ module Flippant
 
       def features(filter = :all)
         if filter == :all
-          client.smembers(key).sort
+          client.smembers(set_key).sort
         else
           features(:all).select do |fkey|
             client.hexists(namespace(fkey), filter)
@@ -95,14 +85,38 @@ module Flippant
         end
       end
 
-      def breakdown(actor = nil)
-        features(:all).each_with_object({}) do |fkey, memo|
-          memo[fkey] = actor.nil? ? feature_rules(fkey) : enabled?(fkey, actor)
+      def load(loaded)
+        client.multi do
+          loaded.each do |feature, rules|
+            client.sadd(set_key, feature)
+
+            rules.each do |group, values|
+              client.hset(namespace(feature), group, serializer.dump(values))
+            end
+          end
         end
       end
 
-      def clear
-        client.smembers(key).each { |fkey| remove(fkey) }
+      def remove(feature)
+        client.multi do
+          client.srem(set_key, feature)
+          client.del(namespace(feature))
+        end
+      end
+
+      def rename(old_feature, new_feature)
+        old_feature = old_feature
+        new_feature = new_feature
+        old_namespaced = namespace(old_feature)
+        new_namespaced = namespace(new_feature)
+
+        client.watch(old_namespaced, new_namespaced) do
+          client.multi do
+            client.srem(set_key, old_feature)
+            client.sadd(set_key, new_feature)
+            client.rename(old_namespaced, new_namespaced)
+          end
+        end
       end
 
       private
@@ -111,26 +125,22 @@ module Flippant
         namespaced = namespace(feature)
 
         client.hgetall(namespaced).each_with_object({}) do |(key, val), memo|
-          memo[key] = load(val)
+          memo[key] = serializer.load(val)
         end
       end
 
       def get_values(namespaced, group)
-        load(client.hget(namespaced, group)) || []
+        serializer.load(client.hget(namespaced, group)) || []
       end
 
       def maybe_cleanup(feature)
         namespaced = namespace(feature)
 
-        client.srem(key, feature) if client.hkeys(namespaced).empty?
+        client.srem(set_key, feature) if client.hkeys(namespaced).empty?
       end
 
       def namespace(feature)
-        "#{key}-#{normalize(feature)}"
-      end
-
-      def normalize(feature)
-        feature.to_s.downcase.strip
+        "#{set_key}-#{feature}"
       end
 
       def change_values(namespaced, group)
@@ -139,7 +149,7 @@ module Flippant
           new_values = yield(old_values)
 
           client.multi do
-            client.hset(namespaced, group, dump(new_values))
+            client.hset(namespaced, group, serializer.dump(new_values))
           end
         end
       end

data/lib/flippant/rules.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Flippant
+  module Rules
+    def self.enabled_for_actor?(rules, actor, groups = Flippant.registered)
+      rules.any? do |name, values|
+        if (block = groups[name])
+          block.call(actor, values)
+        end
+      end
+    end
+  end
+end

data/lib/flippant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flippant
-  VERSION = "0.6.0"
+  VERSION = "0.9.0"
 end

data/lib/flippant.rb

@@ -5,9 +5,11 @@ require "json"
 module Flippant
   autoload :Error, "flippant/errors"
   autoload :Registry, "flippant/registry"
+  autoload :Rules, "flippant/rules"
 
   module Adapter
     autoload :Memory, "flippant/adapters/memory"
+    autoload :Postgres, "flippant/adapters/postgres"
     autoload :Redis, "flippant/adapters/redis"
   end
 
@@ -17,15 +19,10 @@ module Flippant
   attr_writer :adapter, :registry, :serializer
 
   def_delegators :adapter,
-                 :add,
                  :breakdown,
                  :clear,
-                 :disable,
-                 :enabled?,
-                 :exists?,
                  :features,
-                 :remove,
-                 :rename
+                 :setup
 
   def_delegators :registry,
                  :register,
@@ -35,10 +32,46 @@ module Flippant
 
   # Guarded Delegation
 
+  def add(feature)
+    adapter.add(normalize(feature))
+  end
+
+  def dump(path)
+    File.open(path, "w+") do |file|
+      file << serializer.dump(breakdown)
+    end
+  end
+
+  def exists?(features, group = nil)
+    adapter.exists?(normalize(features), group)
+  end
+
   def enable(feature, group, values = [])
     raise Flippant::Error, "Unknown group: #{group}" unless registered?(group)
 
-    adapter.enable(feature, group, values)
+    adapter.enable(normalize(feature), group, values)
+  end
+
+  def enabled?(feature, actor)
+    adapter.enabled?(normalize(feature), actor)
+  end
+
+  def disable(feature, group, values = [])
+    adapter.disable(normalize(feature), group, values)
+  end
+
+  def load(path)
+    File.open(path, "r") do |file|
+      adapter.load(serializer.load(file.read))
+    end
+  end
+
+  def rename(old_name, new_name)
+    adapter.rename(normalize(old_name), normalize(new_name))
+  end
+
+  def remove(feature)
+    adapter.remove(normalize(feature))
   end
 
   # Configuration
@@ -66,4 +99,10 @@ module Flippant
     else adapter.clear && registry.clear
     end
   end
+
+  private
+
+  def normalize(feature)
+    feature.to_s.downcase.strip
+  end
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: flippant
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Parker Selbert
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-08 00:00:00.000000000 Z
+date: 2018-03-20 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -39,47 +81,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.52'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.52'
 description: Fast feature toggling for applications
 email:
 - parker@sorentwo.com
@@ -90,12 +132,14 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".tool-versions"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/adapters.rb
 - bin/console
 - bin/rspec
 - bin/rubocop
@@ -103,6 +147,7 @@ files:
 - flippant.gemspec
 - lib/flippant.rb
 - lib/flippant/adapters/memory.rb
+- lib/flippant/adapters/postgres.rb
 - lib/flippant/adapters/redis.rb
 - lib/flippant/errors.rb
 - lib/flippant/registry.rb
@@ -128,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Fast feature toggling for applications