togls 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f956666596995d557aa56048b785db8f490f73dc
-  data.tar.gz: ffa83b7c726ef586d20c169c6cf3d3189ee8207c
+  metadata.gz: e723acd976b3387ca90f419b1bb628f6aba617ab
+  data.tar.gz: 528b2d7d8575d3c54e5fcec95a65c3f3d371d2a8
 SHA512:
-  metadata.gz: 50b448deb27e15b7815cafa0e02d366a01643038ca1a689695547e48234f0a2aafe5161cea5a9c9461d7b179022dd2cd22d8b8080756f3c62d760220a92e20f9
-  data.tar.gz: 00963574a1dbef269a279ae8b42294a11042a194f80b366f38b9136a5d23e4eba23a634d16705b1f8990ad9c4f56821db4bb754b8d3d05aba9ded8d8da6ba6a9
+  metadata.gz: 03327c8c5b355d7297a6c56274567be505f15cc267862a85d7c32cbb602614298e5fb00869abebbe3c9c90a02d6b320330507645470c4a4a3bc42b4c82f756b6
+  data.tar.gz: daae0c8edfdac0b28a602200525679e9db989c5fc091a0aaf4077439d586ce449d44dbffdfc33ca3b8dbea6ea899f8c3d0694a55fe051bd5185fc735c0777f66

data/.ruby-version

@@ -1 +1 @@
-2.2.2
+2.2.3

data/.travis.yml

@@ -1,3 +1,4 @@
 language: ruby
 rvm:
+  - 2.2.3
   - 2.2.2

data/CODE_OF_CONDUCT.md

@@ -1,13 +1,30 @@
 # Contributor Code of Conduct
 
-As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+As contributors and maintainers of this project, we pledge to respect
+all people who contribute through reporting issues, posting feature
+requests, updating documentation, submitting pull requests or patches,
+and other activities.
 
-We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+We are committed to making participation in this project a
+harassment-free experience for everyone, regardless of level of
+experience, gender, gender identity and expression, sexual orientation,
+disability, personal appearance, body size, race, age, or religion.
 
-Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+Examples of unacceptable behavior by participants include the use of
+sexual language or imagery, derogatory comments or personal attacks,
+trolling, public or private harassment, insults, or other unprofessional
+conduct.
 
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+Project maintainers have the right and responsibility to remove, edit,
+or reject comments, commits, code, wiki edits, issues, and other
+contributions that are not aligned to this Code of Conduct. Project
+maintainers who do not follow the Code of Conduct may be removed from
+the project team.
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+Instances of abusive, harassing, or otherwise unacceptable behavior may
+be reported by opening an issue or contacting one or more of the project
+maintainers.
 
-This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)
+This Code of Conduct is adapted from the [Contributor
+Covenant](http:contributor-covenant.org), version 1.0.0, available at
+[http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/ChangeLog.md

@@ -6,6 +6,13 @@ versions, as well as provide a rough history.
 
 #### Next Release
 
+#### v1.1.0
+
+* Add `off?` method for asking if a defined feature is off
+* Add feature toggle overrides
+* Rearchitect to support concept of repositories and datastores allowing
+  further growth in the future
+
 #### v1.0.0
 
 * Require human readable description to define a feature toggle

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in togl.gemspec
 gemspec
 
-gem "codeclimate-test-reporter", group: :test, require: nil
+gem "codeclimate-test-reporter", "~> 0.4.8", group: :test, require: nil

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Brian Miller
+Copyright (c) 2015 Brian Miller, Andrew De Ponte, Ryan Hedges
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,13 +1,15 @@
-[![Version](https://img.shields.io/gem/v/togls.svg)](https://rubygems.org/gems/togls)
+[![Gem Version](https://badge.fury.io/rb/togls.svg)](http://badge.fury.io/rb/togls)
 [![Build Status](https://travis-ci.org/codebreakdown/togls.svg?branch=master)](https://travis-ci.org/codebreakdown/togls)
-[![Code Climate](https://img.shields.io/codeclimate/github/codebreakdown/togls.svg)](https://codeclimate.com/github/codebreakdown/togls)
-[![Code
-Coverage](https://img.shields.io/codeclimate/coverage/github/codebreakdown/togls.svg)](https://codeclimate.com/github/codebreakdown/togls)
+[![Code Climate](https://codeclimate.com/github/codebreakdown/togls/badges/gpa.svg)](https://codeclimate.com/github/codebreakdown/togls)
+[![Test Coverage](https://codeclimate.com/github/codebreakdown/togls/badges/coverage.svg)](https://codeclimate.com/github/codebreakdown/togls/coverage)
 [![Dependency Status](https://gemnasium.com/codebreakdown/togls.svg)](https://gemnasium.com/codebreakdown/togls)
 
 # Togls
 
-A lightweight feature toggle library.
+A lightweight, simple, and yet extremely flexible feature toggle library
+for Ruby. It prides itself on being designed in such a manner that it is
+extremely flexible and yet still provides a simple, clear, and
+meaningful interface.
 
 ## Installation
 
@@ -27,32 +29,41 @@ Or install it yourself as:
 
 ## Basic Usage
 
-The basic usage of `Togls` is outlined below.
+At the core `togls` is primarily used by performing two distinct
+actions.
+
+1. Defining Feature Toggles
+2. Evaluating Feature Toggles
 
 ### Defining Feature Toggles
 
-The first thing to do to use `Togls` is to define your feature toggles. The
-following is an example of how you might define your feature toggles. It is
-recommended this live in its own file. In Rails projects we recommend putting
-it in `config/initializers/togls_features.rb`.
+In order to use `togls`, you first have to define some feature toggles.
+It is highly recommended that you define your feature toggles in their
+own file. If you are using `togls` in a Rails project we recommend
+putting it in `config/initializers/togls_features.rb`. If you are using
+`togls` in a generic Ruby project you can locate it wherever you like.
+However, the feature definitions **must** be loaded before they can be
+evaluated.
+
+The following, `config/initializers/togls_features.rb`, is an example of
+how one would define some basic feature toggles.
 
 ```ruby
 Togls.features do
   # Set this feature to always be on
-  feature(:pop_up_login_form, "use the pop up login instead of normal login").on 
+  feature(:pop_up_login_form, "use pop up login instead of normal login").on 
+
   # Set this feature to always be off
   feature(:send_follup_email, "send the follow up email").off
-  # Create a group rule
-  rule = Togls::Rules::Group.new(["user@email.com"])
-  feature(:new_contact_form, "use new contact form instead of old one").on(rule)
 end
 ```
 
 ### Evaluating Feature Toggles
 
-Once you have defined your feature toggles. The next thing you would likely
-want to do is conditionally control something based on them. The following are
-a few examples of how you would do this given the above.
+Once you have defined your feature toggles. The next thing you would
+likely want to do is conditionally control something based on them. The
+following are a few examples of how you would do this given the feature
+definitions provided above.
 
 ```ruby
 if Togls.feature(:pop_up_login_form).on?
@@ -61,193 +72,147 @@ else
   # Use normal non-pop up login form
 end
 
+...
+
 if Togls.feature(:send_follup_email).on?
   # send the follow up email
 end
-
-if Togls.feature(:new_contact_form).on?("user@email.com")
-  # Use new contact form
-else
-  # Use old contact form
-end
 ```
 
-**Note:** The default behaviour for any feature that has not been defined that
-is accessed is to default to false.
-
-### Output Feature Toggles
-
-One other use case that we support as part of the *Basic Usage* is outputing all
-of the features in your system and their respective, **states** (`on`, `off`, `?` -
-unkown due to *Complex Rule*), **key**, and **human readable descrption**.
-
-We provide this functionality via a [rake](https://github.com/ruby/rake) task.
-
-#### Load rake task
+**Note:** Feature toggles that are evaluated but have **not** been
+defined will default to **off**.
 
-To use it you must first load the provided
-[rake](https://github.com/ruby/rake) file. This can be done in a number of
-different ways.
+### Override Feature Toggles
 
-##### Load rake task in another gem
+Toggles can be overriden using environment variables following the
+naming scheme provided below. This is especially useful when wanting to
+change state of toggles within your development environment, without
+altering the codified default state.
 
-To use it in another gem you can use the following in the second gem's
-`Rakefile`.
+The naming scheme for overriding toggles is simply the key of the
+feature toggle in all caps with `TOGLS_` prefixed to it. For example if
+we had the following feature toggle defined.
 
 ```ruby
-spec = Gem::Specification.find_by_name 'togls'
-load "#{spec.gem_dir}/lib/tasks/togls.rake"
-```
-
-**Note:** The features must be defined and loaded before calling this task or
-it will error out informing you that you need to define your features first.
-
-##### Load rake task in a Rails app
-
-To use the it in a Rails app you can do so by adding the following to the
-`Rakefile`.
-
-```ruby
-namespace :togls do
-  task :features => [:environment] do
-  end
+Togls.features do
+  # Set this feature to always be on
+  feature(:pop_up_login_form, "use pop up login instead of normal login").on
 end
-
-spec = Gem::Specification.find_by_name 'togls'
-load "#{spec.gem_dir}/lib/tasks/togls.rake"
 ```
 
-**Note:** The first hunk where it defines an empty `togls:features` tasks is
-important in Rails because it takes advantage of
-[rake](https://github.com/ruby/rake) task stacking and calls out the Rails
-environment as a dependency. That way before the `togls:feature` task is
-executed the `config/initializers/togls_features.rb` file is loaded which
-defines the feature toggles.
+We could override this by setting the value of the
+`TOGLS_POP_UP_LOGIN_FORM` environment variable to `"false"`. If you want
+to override a feature toggle to an on state you can set the
+`TOGLS_POP_UP_LOGIN_FORM` environment variable to `"true"`.
 
-#### Verify rake task loaded
+### Toggle Features based on Group Membership  
 
-To verify that the rake task is loaded you can run `rake -T` and you should
-see something similar to the following in the output.
+`togls` provides out of the box support for toggling features based on
+group membership. This basically allows you to have a feature **on** for
+members of a defined group and **off** for non-members. This can be
+extremely useful if you want to enable features for a small alpha test
+group for example.
 
-```text
-rake togls:features                     # Output all features including status (on, off, ? - unknown due to complex rule), ke...
-```
-
-#### Run the rake task
+**Note:** This is implemented using `togls` extremely robust [custom
+rules](https://github.com/codebreakdown/togls/wiki/Custom-Rules) system.
+The following example is just one of the many powerful things you can do
+with `togls` and [custom
+rules](https://github.com/codebreakdown/togls/wiki/Custom-Rules).
 
-Once you have verified the task is loaded and available you can run it as
-follows.
+#### Defining Group based Feature Toggles
 
-```shell
-rake togls:features
-```
+The following is an example definition of a feature that toggles on
+based on group membership.
 
-The following is an example of what the output might look like if you defined
-a few test features.
+```ruby
+# Create a group rule so the feature is on if the user is a member of
+# the group.
+alpha_testers = Togls::Rules::Group.new(["user1@email.com",
+                                         "user2@example.com"])
 
-```text
- on - :test1 - test 1 feature
-off - :test2 - test 2 feature
-off - :test3 - test 3 feature
+Togls.features do
+  feature(:new_contact_form, "use new contact form").on(alpha_testers)
+end
 ```
 
-## Advanced Usage
+The above is really broken down into two steps.
 
-Below is a breakdown of some of the more advanced features of `Togls` which
-aren't necessary in order to use it for basic feature toggles.
+1. Construct the
+   [rule](https://github.com/codebreakdown/togls/wiki/Provided-Rules-Reference)
+   you want to use
+2. Define the feature toggle and pass the
+   [rule](https://github.com/codebreakdown/togls/wiki/Provided-Rules-Reference)
+   to its `on()` method
 
-### Custom Rules
+In the above example we construct an instance of the
+[Togls::Rules::Group](https://github.com/codebreakdown/togls/wiki/Provided-Rules-Reference#toglsrulesgroup)
+rule, passing it the list of alpha tester email addresses.
+[Togls::Rules::Group](https://github.com/codebreakdown/togls/wiki/Provided-Rules-Reference#toglsrulesgroup)
+is a rule that `togls` provides to make your life a bit simpler.
 
-`Togls` is specifically architected on top of a generic concept of a
-`Togls::Rule`.  This empowers the users to define any custom rules they would
-like and use them to control their feature toggles.  For example, you could
-use them to do A/B testing, define alpha test group, give a percentage of a
-user base a feature, etc.
+Then we define a feature, `:new_contact_form`, that will be on for
+alpha testers and off for people that don't fall within that group.
 
-### Simple Rules
+#### Evaluating Group based Feature Toggles
 
-A simple rule can be defined by creating a rule object and passing a block. In
-the following example any feature using the `gmail_rule` would only be on if
-the given `target` contained `gmail.com` at the end of the `target`.
+Group based rules are evaluated by using the `on?` method. However, in
+this case we have to pass the `on?` method the `target`. The `target` in
+this case is the email address of the current user. The target is the
+identifier that you want to check if it belongs to the group or not.
 
 ```ruby
-# Only allow users with email addresses at gmail.com
-gmail_rule = Togls::Rule.new { |target| target =~ /gmail.com$/ }
-
-Togls.features do
-  feature(:only_gmail_users).on(gmail_rule)
+if Togls.feature(:new_contact_form).on?(current_user.email)
+  # Use new contact form
+else
+  # Use old contact form
 end
 ```
 
-### Complex Rules
-
-To implement a more complex rule, a new rule object can be defined under
-`Togls::Rules` that abides by the following.
-
-- inherits from `Togls::Rule` or a decendent of it
-- has an instance method named `run` that takes either a default value
-  parameter of `target` or a required paramter of `target`.
-
-    ```ruby
-    def run(target = 'foo')
-    ...
-    end
-    
-    # or
+**Note:** In the above example I reference `current_user.email`. This is
+not something that `togls` provides. It is simply a common way for
+Ruby/Rails applications to implement access to the concept of the current user.
 
-    def run(target)
-    ...
-    end
-    ```
+#### Groups of Anything
 
-- has the instance method named `run` return a boolean value identifying if
-  that feature should be on(`true`)/off(`false`) given the `target`.
+You could just as easily have used user ids instead of email addresses
+in the example above and it would look something like the following:
 
-Thats it!
-
-#### Example Complex Rule
-
-Internally `Togls` uses these *Complex Rules* to provide functionality and
-will evolve to contain more official rules over time. If you have a generic
-*Complex Rule* you think should be part of `Togls` please make a pull request.
+```ruby
+# Create a group rule so the feature is on if the user is a member of
+# the group.
+alpha_testers = Togls::Rules::Group.new([1, 23, 42, 83])
 
-A prime example of a *Complex Rule* provided by `Togls` is the
-`Togls::Rules::Group` rule. You can see it below.
+Togls.features do
+  feature(:new_contact_form, "use new contact form").on(alpha_testers)
+end
+```
 
 ```ruby
-module Togls
-  module Rules
-    class Group < Rule
-      def initialize(list)
-        @list = list
-      end
-
-      def run(target)
-        @list.include?(target)
-      end
-    end
-  end
+if Togls.feature(:new_contact_form).on?(current_user.id)
+  # Use new contact form
+else
+  # Use old contact form
 end
 ```
 
-Lets take a closer look at exactly what is going on here.
-
-- it is inheriting from the `Togls::Rule` class which meets one of the minimum
-  requirements for a rule.
-- its defines constructor takes an array identifiers and stores them. These
-  identifiers could be id numbers, email address, etc. **Note:** This
-  constructor is completely different than that of `Togls::Rule`. This
-  is fine because it is **not** a requirements that the constructor match.
-- its `run` method returns a boolean value identifying if the feature should
-  be on(`true`)/off(`false`) for the given `target`. It does so by identifying
-  if the array passed in at construction time `include?` the given `target`.
-  This meets one of the minimum requirement for a rule.
-- its `run` method signature requires a `target`. This meets a minimum
-  requirement for a rule as well. It also makes sense in the case of group
-  based rule as it has to have something to compare against the group.
-
-*Complex Rules* are a simple yet extremely power concept that you shouldn't
-hesitate to use.
+The key take away is that the
+[Togls::Rules::Group](https://github.com/codebreakdown/togls/wiki/Provided-Rules-Reference#toglsrulesgroup)
+rule can be used to define any group you like.
+
+## Advanced Usage
+
+`togls` is capable of much, much more. We have strategically avoided
+including details of advanced usage in the `README.md` as to not
+overwhelm people on first impression. For more details on some of the
+more advanced features feel free to check out our
+[Wiki](https://github.com/codebreakdown/togls/wiki). Just a few of the
+many things it contains are [Provided Rules
+Reference](https://github.com/codebreakdown/togls/wiki/Provided-Rules-Reference),
+[Custom
+Rules](https://github.com/codebreakdown/togls/wiki/Custom-Rules),
+[Review Feature
+Toggles](https://github.com/codebreakdown/togls/wiki/Review-Feature-Toggles),
+etc.
 
 ## Development
 

data/lib/tasks/togls.rake

@@ -1,8 +1,8 @@
 namespace :togls do
   desc "Output all features including status (on, off, ? - unknown due to complex rule), key, description"
   task :features do
-    Togls.features.each do |key, feature|
-      puts feature.to_s
+    Togls.features.each do |toggle|
+      puts toggle.to_s
     end
   end
 end

data/lib/togls/errors.rb

@@ -1,3 +1,6 @@
 module Togls
   class NoFeaturesError < StandardError; end
+  class MissingDriver < StandardError; end
+  class InvalidDriver < StandardError; end
+  class NotImplemented < StandardError; end
 end

data/lib/togls/feature.rb

@@ -3,36 +3,12 @@ module Togls
     attr_reader :key, :description
 
     def initialize(key, description)
-      @key = key
+      @key = key.to_s
       @description = description
-      off
     end
 
-    def on(rule = nil)
-      if rule.nil?
-        rule = Togls::Rules::Boolean.new(true)
-      end
-      @rule = rule 
-      self
-    end
-
-    def off
-      @rule = Togls::Rules::Boolean.new(false)
-      self
-    end
-
-    def on?(target = nil)
-      @rule.run(target)
-    end
-
-    def to_s
-      if @rule.is_a?(Togls::Rules::Boolean)
-        display_value = @rule.run ? ' on' : 'off'
-      else
-        display_value = '  ?'
-      end
-
-      "#{display_value} - #{@key.inspect} - #{@description}"
+    def id
+      @key
     end
   end
 end

data/lib/togls/feature_repository.rb

@@ -0,0 +1,43 @@
+module Togls
+  class FeatureRepository
+    def initialize(drivers)
+      if !drivers.is_a?(Array)
+        raise Togls::InvalidDriver.new("FeatureRepository requires a valid driver")
+      end
+      if drivers.empty?
+        raise Togls::MissingDriver.new("FeatureRepository requires a driver")
+      end
+      @drivers = drivers
+    end
+
+    def store(feature)
+      feature_data = extract_feature_data(feature)
+      @drivers.each do |driver|
+        driver.store(feature.id, feature_data)
+      end
+    end
+
+    def extract_feature_data(feature)
+      { "key" => feature.key, "description" => feature.description }
+    end
+
+    def fetch_feature_data(id)
+      feature_data = nil
+      @drivers.reverse.each do |driver|
+        feature_data = driver.get(id)
+        break if feature_data
+      end
+      feature_data
+    end
+
+    def get(feature_id)
+      feature_data = fetch_feature_data(feature_id)
+      reconstitute_feature(feature_data)
+    end
+
+    def reconstitute_feature(feature_data)
+      Togls::Feature.new(feature_data["key"],
+                         feature_data["description"])
+    end
+  end
+end

data/lib/togls/feature_repository_drivers/in_memory_driver.rb

@@ -0,0 +1,17 @@
+module Togls
+  module FeatureRepositoryDrivers
+    class InMemoryDriver
+      def initialize
+        @features = {}
+      end
+
+      def store(feature_id, feature_data)
+        @features[feature_id] = feature_data
+      end
+
+      def get(feature_id)
+        @features[feature_id]
+      end
+    end
+  end
+end

data/lib/togls/feature_repository_drivers.rb

@@ -0,0 +1,4 @@
+module Togls
+  module FeatureRepositoryDrivers
+  end
+end

data/lib/togls/feature_toggle_registry.rb

@@ -0,0 +1,46 @@
+module Togls
+  class FeatureToggleRegistry
+    def initialize
+      @toggle_repository_drivers = [
+        Togls::ToggleRepositoryDrivers::InMemoryDriver.new,
+        Togls::ToggleRepositoryDrivers::EnvOverrideDriver.new]
+      @feature_repository_drivers =
+        [Togls::FeatureRepositoryDrivers::InMemoryDriver.new]
+      @rule_repository_drivers =
+        [Togls::RuleRepositoryDrivers::InMemoryDriver.new]
+      @feature_repository = Togls::FeatureRepository.new(@feature_repository_drivers)
+      @rule_repository = Togls::RuleRepository.new(@rule_repository_drivers)
+      @toggle_repository = Togls::ToggleRepository.new(@toggle_repository_drivers,
+                                    @feature_repository, @rule_repository)
+      @boolean_true_rule = Togls::Rules::Boolean.new(true)
+      @boolean_false_rule = Togls::Rules::Boolean.new(false)
+      @rule_repository.store(@boolean_false_rule)
+      @rule_repository.store(@boolean_true_rule)
+    end
+
+    def self.create(&feature_toggles)
+      feature_toggle_registry = self.new
+      feature_toggle_registry.instance_eval(&feature_toggles)
+      return feature_toggle_registry
+    end
+
+    def feature(key, desc)
+      feature = Togls::Feature.new(key, desc)
+      toggle = Togls::Toggle.new(feature)
+      @toggle_repository.store(toggle)
+      Togls::Toggler.new(@toggle_repository, toggle)
+    end
+
+    def get(key)
+      toggle = @toggle_repository.get(key.to_s)
+      if toggle.is_a?(Togls::NullToggle)
+        Togls.logger.warn("Feature identified by '#{key}' has not been defined")
+      end
+      return toggle
+    end
+
+    def registry
+      @toggle_repository.all
+    end
+  end
+end

data/lib/togls/helpers.rb

@@ -0,0 +1,7 @@
+module Togls
+  module Helpers
+    def self.sha1(klass, data)
+      Digest::SHA1.hexdigest("#{klass}:#{data.to_s}")
+    end
+  end
+end

data/lib/togls/null_toggle.rb

@@ -0,0 +1,16 @@
+module Togls
+  class NullToggle < Togls::Toggle
+    def initialize
+      feature = Togls::Feature.new("null", "the official null feature")
+      super(feature)
+    end
+
+    def on
+      self
+    end
+
+    def off
+      self
+    end
+  end
+end

data/lib/togls/rule.rb

@@ -1,11 +1,19 @@
 module Togls
   class Rule
-    def initialize(&rule)
-      @definition = rule  
+    attr_reader :data
+
+    def initialize(data=nil)
+      @data = data  
+    end
+
+    def run(key, target = nil)
+      raise Togls::NotImplemented.new(
+        "Rule's #run method must be implemented"
+      )
     end
 
-    def run(target = nil)
-      @definition.call(target)
+    def id
+      Togls::Helpers.sha1(self.class, @data)
     end
   end
 end

data/lib/togls/rule_repository.rb

@@ -0,0 +1,42 @@
+module Togls
+  class RuleRepository
+    def initialize(drivers)
+      if !drivers.is_a?(Array)
+        raise Togls::InvalidDriver.new("RuleRepository requires a valid driver")
+      end
+      if drivers.empty?
+        raise Togls::MissingDriver.new("RuleRepository requires a driver")
+      end
+      @drivers = drivers
+    end
+
+    def store(rule)
+      rule_data = extract_storage_payload(rule)
+      @drivers.each do |driver|
+        driver.store(rule.id, rule_data)
+      end
+    end
+ 
+    def extract_storage_payload(rule)
+      return { "klass" => rule.class, "data" => rule.data }
+    end
+
+    def fetch_rule_data(id)
+      rule_data = nil
+      @drivers.reverse.each do |driver|
+        rule_data = driver.get(id)
+        break if rule_data
+      end
+      rule_data
+    end
+
+    def get(rule_id)
+      rule_data = fetch_rule_data(rule_id)
+      reconstitute_rule(rule_data)
+    end
+
+    def reconstitute_rule(rule_data)
+      rule_data["klass"].new(rule_data["data"])
+    end
+  end
+end

data/lib/togls/rule_repository_drivers/in_memory_driver.rb

@@ -0,0 +1,17 @@
+module Togls
+  module RuleRepositoryDrivers
+    class InMemoryDriver
+      def initialize
+        @rules = {}
+      end
+
+      def store(rule_id, rule_data)
+        @rules[rule_id] = rule_data
+      end
+      
+      def get(rule_id)
+        @rules[rule_id]
+      end
+    end
+  end
+end

data/lib/togls/rule_repository_drivers.rb

@@ -0,0 +1,5 @@
+module Togls
+  module RuleRepositoryDrivers
+
+  end
+end

data/lib/togls/rules/boolean.rb

@@ -1,12 +1,8 @@
 module Togls
   module Rules
     class Boolean < Rule
-      def initialize(bool)
-        @bool = bool
-      end
-
-      def run(target = nil)
-        return @bool
+      def run(key, target = nil)
+        return @data
       end
     end
   end

data/lib/togls/rules/group.rb

@@ -1,12 +1,8 @@
 module Togls
   module Rules
     class Group < Rule
-      def initialize(list)
-        @list = list
-      end
-
-      def run(target)
-        @list.include?(target)
+      def run(key, target)
+        @data.include?(target)
       end
     end
   end

data/lib/togls/toggle.rb

@@ -0,0 +1,33 @@
+module Togls
+  class Toggle
+    attr_reader :feature
+    attr_accessor :rule
+
+    def initialize(feature)
+      @feature = feature
+      @rule = Togls::Rules::Boolean.new(false)
+    end
+
+    def id
+      @feature.id
+    end
+
+    def on?(target = nil)
+      @rule.run(@feature.key, target)
+    end
+
+    def off?(target = nil)
+      return !@rule.run(@feature.key, target)
+    end
+
+    def to_s
+      if @rule.is_a?(Togls::Rules::Boolean)
+        display_value = @rule.run(@feature.key) ? ' on' : 'off'
+      else
+        display_value = '  ?'
+      end
+
+      "#{display_value} - #{@feature.key} - #{@feature.description}"
+    end
+  end
+end

data/lib/togls/toggle_repository.rb

@@ -0,0 +1,71 @@
+module Togls
+  class ToggleRepository
+    def initialize(drivers, feature_repository, rule_repository)
+      if !drivers.is_a?(Array)
+        raise Togls::InvalidDriver.new("ToggleRepository requires a valid driver")
+      end
+      if drivers.empty?
+        raise Togls::MissingDriver.new("ToggleRepository requires a driver")
+      end
+      @drivers = drivers
+      @feature_repository = feature_repository
+      @rule_repository = rule_repository
+    end
+
+    def store(toggle)
+      @feature_repository.store(toggle.feature)
+      @rule_repository.store(toggle.rule)
+      payload = extract_storage_payload(toggle)
+
+      @drivers.each do |driver|
+        driver.store(toggle.id, payload)
+      end
+    end
+
+    def extract_storage_payload(toggle)
+      { "feature_id" => toggle.feature.id, "rule_id" => toggle.rule.id }
+    end
+
+    def get(id)
+      toggle_data = fetch_toggle_data(id)
+      if toggle_data
+        return reconstitute_toggle(toggle_data)
+      else
+        return Togls::NullToggle.new
+      end
+    end
+
+    def reconstitute_toggle(toggle_data)
+      feature = @feature_repository.get(toggle_data["feature_id"])
+      rule = @rule_repository.get(toggle_data["rule_id"])
+      toggle = Togls::Toggle.new(feature)
+      toggle.rule = rule
+      return toggle
+    end
+
+    def fetch_toggle_data(id)
+      toggle_data = nil
+      @drivers.reverse.each do |driver|
+        toggle_data = driver.get(id)
+        break if toggle_data
+      end
+      toggle_data
+    end
+
+    def fetch_all_toggle_data
+      toggle_data_collection = {}
+      @drivers.each do |driver|
+        toggle_data_collection.merge!(driver.all)
+      end
+      toggle_data_collection
+    end
+
+    def all
+      toggle_data_collection = fetch_all_toggle_data.values
+
+      toggle_data_collection.map do |toggle_data|
+        reconstitute_toggle(toggle_data)
+      end
+    end
+  end
+end

data/lib/togls/toggle_repository_drivers/env_override_driver.rb

@@ -0,0 +1,32 @@
+module Togls
+  module ToggleRepositoryDrivers
+    class EnvOverrideDriver
+      def store(toggle_id, toggle_data)
+      end
+
+      def get(toggle_id)
+        if ENV[toggle_env_key(toggle_id)]
+          if ENV[toggle_env_key(toggle_id)] == "true"
+            return { "feature_id" => toggle_id,
+                     "rule_id" => Togls::Helpers.sha1(Togls::Rules::Boolean, true) }
+          else
+            return { "feature_id" => toggle_id,
+                     "rule_id" => Togls::Helpers.sha1(Togls::Rules::Boolean, false) }
+          end
+        else
+          return nil
+        end
+      end
+
+      def all
+        return {}
+      end
+
+      private
+
+      def toggle_env_key(toggle_id)
+        return "TOGLS_#{toggle_id.to_s.upcase}"
+      end
+    end
+  end
+end

data/lib/togls/toggle_repository_drivers/in_memory_driver.rb

@@ -0,0 +1,21 @@
+module Togls
+  module ToggleRepositoryDrivers
+    class InMemoryDriver
+      def initialize
+        @toggles = {}
+      end
+
+      def store(toggle_id, toggle_data)
+        @toggles[toggle_id] = toggle_data
+      end
+
+      def get(toggle_id)
+        @toggles[toggle_id]
+      end
+
+      def all
+        @toggles
+      end
+    end
+  end
+end

data/lib/togls/toggle_repository_drivers.rb

@@ -0,0 +1,5 @@
+module Togls
+  module ToggleRepositoryDrivers
+
+  end
+end

data/lib/togls/toggler.rb

@@ -0,0 +1,24 @@
+module Togls
+  class Toggler
+    def initialize(toggle_repository, toggle)
+      @toggle_repository = toggle_repository
+      @toggle = toggle
+    end
+
+    def on(rule = nil)
+      if rule.nil?
+        rule = Togls::Rules::Boolean.new(true)
+      end
+      @toggle.rule = rule
+      @toggle_repository.store(@toggle)
+      @toggle
+    end
+
+    def off
+      rule = Togls::Rules::Boolean.new(false)
+      @toggle.rule = rule
+      @toggle_repository.store(@toggle)
+      @toggle
+    end
+  end
+end

data/lib/togls/version.rb

@@ -1,3 +1,3 @@
 module Togls
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/togls.rb

@@ -1,26 +1,40 @@
 require "togls/version"
 require "togls/errors"
-require "togls/feature_registry"
+require "togls/helpers"
+require "togls/toggle_repository_drivers"
+require "togls/toggle_repository_drivers/in_memory_driver"
+require "togls/toggle_repository_drivers/env_override_driver"
+require "togls/feature_repository_drivers"
+require "togls/feature_repository_drivers/in_memory_driver"
+require "togls/rule_repository_drivers"
+require "togls/rule_repository_drivers/in_memory_driver"
+require "togls/toggler"
+require "togls/feature_toggle_registry"
+require "togls/feature_repository"
+require "togls/rule_repository"
+require "togls/toggle_repository"
 require "togls/feature"
+require "togls/toggle"
+require "togls/null_toggle"
 require "togls/rule"
 require "togls/rules"
 require "logger"
 
 module Togls
-  def self.features(&features)
-    if !features.nil?
-      @feature_registry = FeatureRegistry.create(&features)
+  def self.features(&feature_toggles)
+    if !feature_toggles.nil?
+      @feature_toggle_registry = FeatureToggleRegistry.create(&feature_toggles)
     else
-      if @feature_registry.nil?
+      if @feature_toggle_registry.nil?
         raise Togls::NoFeaturesError, "Need to define features before you can get them"
       else
-        @feature_registry.registry
+        @feature_toggle_registry.registry
       end
     end
   end
   
   def self.feature(key)
-    @feature_registry.get(key)
+    return @feature_toggle_registry.get(key)
   end
 
   def self.logger

data/togls.gemspec

@@ -6,8 +6,8 @@ require 'togls/version'
 Gem::Specification.new do |spec|
   spec.name          = "togls"
   spec.version       = Togls::VERSION
-  spec.authors       = ["Brian Miller", "Andrew DePonte"]
-  spec.email         = ["brimil01@gmail.com", "cyphactor@gmail.com"]
+  spec.authors       = ["Brian Miller", "Andrew DePonte", "Ryan Hedges"]
+  spec.email         = ["brimil01@gmail.com", "cyphactor@gmail.com", "ryanhedges@gmail.com"]
 
   spec.summary       = %q{An ultra light weight yet ridiculously powerful ruby feature toggle gem.}
   spec.description   = %q{An ultra light weight yet ridiculously powerful ruby feature toggle gem that supports the concept of release toggles and business toggles.}
@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "pry", "~> 0.10"
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: togls
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Brian Miller
 - Andrew DePonte
+- Ryan Hedges
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-19 00:00:00.000000000 Z
+date: 2015-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,11 +54,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
 description: An ultra light weight yet ridiculously powerful ruby feature toggle gem
   that supports the concept of release toggles and business toggles.
 email:
 - brimil01@gmail.com
 - cyphactor@gmail.com
+- ryanhedges@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -75,15 +91,30 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- contributing/togls_architecture.monopic
 - lib/tasks/togls.rake
 - lib/togls.rb
 - lib/togls/errors.rb
 - lib/togls/feature.rb
-- lib/togls/feature_registry.rb
+- lib/togls/feature_repository.rb
+- lib/togls/feature_repository_drivers.rb
+- lib/togls/feature_repository_drivers/in_memory_driver.rb
+- lib/togls/feature_toggle_registry.rb
+- lib/togls/helpers.rb
+- lib/togls/null_toggle.rb
 - lib/togls/rule.rb
+- lib/togls/rule_repository.rb
+- lib/togls/rule_repository_drivers.rb
+- lib/togls/rule_repository_drivers/in_memory_driver.rb
 - lib/togls/rules.rb
 - lib/togls/rules/boolean.rb
 - lib/togls/rules/group.rb
+- lib/togls/toggle.rb
+- lib/togls/toggle_repository.rb
+- lib/togls/toggle_repository_drivers.rb
+- lib/togls/toggle_repository_drivers/env_override_driver.rb
+- lib/togls/toggle_repository_drivers/in_memory_driver.rb
+- lib/togls/toggler.rb
 - lib/togls/version.rb
 - togls.gemspec
 homepage: http://github.com/codebreakdown/togls
@@ -106,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: An ultra light weight yet ridiculously powerful ruby feature toggle gem.

data/lib/togls/feature_registry.rb

@@ -1,29 +0,0 @@
-module Togls
-  class FeatureRegistry
-    def initialize
-      @registry = {}
-      @default_feature = Feature.new(:default, "the official default feature").tap {|f| f.on(Rule.new { false }) }
-    end
-
-    def self.create(&features)
-      registry = self.new
-      registry.instance_eval(&features) 
-      registry
-    end
-
-    def feature(tag, desc)
-      @registry[tag.to_sym] = Feature.new(tag.to_sym, desc)
-    end
-
-    def get(key)
-      @registry.fetch(key) do |key|
-        Togls.logger.warn("Feature identified by #{key} has not been defined")
-        @default_feature
-      end
-    end
-
-    def registry
-      @registry
-    end
-  end
-end