togls 2.2.1 → 3.0.0.pre.rc.1

data/lib/togls/rule_repository_drivers/env_override_driver.rb

@@ -0,0 +1,22 @@
+module Togls
+  module RuleRepositoryDrivers
+    # Rule Repository Environment Override Driver
+    #
+    # The Rule Repository Environment Driver provides the interface to store and
+    # retrieve rules. This is intended to be used by a Rule Repository instance.
+    class EnvOverrideDriver
+      def store(rule_id, rule_data)
+      end
+
+      def get(rule_id)
+        if rule_id == Togls::Helpers.sha1(Togls::Rules::Boolean, true) 
+          return { 'type_id' => 'boolean', 'data' => true, 'target_type' => Togls::TargetTypes::NONE.to_s }
+        elsif rule_id == Togls::Helpers.sha1(Togls::Rules::Boolean, false)
+          return { 'type_id' => 'boolean', 'data' => false, 'target_type' => Togls::TargetTypes::NONE.to_s }
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/togls/rule_type_registry.rb

@@ -0,0 +1,38 @@
+module Togls
+  class RuleTypeRegistry
+    def initialize(rule_type_repository)
+      @rule_type_repository = rule_type_repository
+    end
+
+    def expand(&block)
+      instance_eval(&block)
+      self
+    end
+
+    def register(type_id, klass)
+      verify_uniqueness_of_type_id(type_id)
+      verify_uniqueness_of_rule_type_klass(klass)
+      @rule_type_repository.store(type_id, klass)
+    end
+
+    def verify_uniqueness_of_type_id(type_id)
+      if @rule_type_repository.include?(type_id)
+        raise RuleTypeAlreadyDefined, "Rule Type identified by '#{type_id}' has already been registered"
+      end
+    end
+
+    def verify_uniqueness_of_rule_type_klass(klass)
+      if @rule_type_repository.include_klass?(klass)
+        raise RuleTypeAlreadyDefined, "Rule Type with class '#{klass}' has already been registered"
+      end
+    end
+
+    def get(type_id)
+      @rule_type_repository.get_klass(type_id)
+    end
+
+    def get_type_id(klass_string)
+      @rule_type_repository.get_type_id(klass_string)
+    end
+  end
+end

data/lib/togls/rule_type_repository.rb

@@ -0,0 +1,57 @@
+module Togls
+  class RuleTypeRepository
+    def initialize(drivers)
+      @drivers = drivers
+    end
+
+    def store(type_id, klass)
+      @drivers.each do |driver|
+        driver.store(type_id.to_s, klass.to_s, klass.title, klass.description,
+                     klass.target_type.to_s)
+      end
+    end
+
+    def include?(type_id)
+      type = get_klass(type_id)
+      type ? true : false
+    end
+
+    def include_klass?(klass)
+      type = get_type_id(klass)
+      type ? true : false
+    end
+
+    def get_klass(type_id)
+      klass_string = fetch_klass_string(type_id.to_s)
+      return Object.const_get(klass_string) if klass_string
+      klass_string
+    end
+
+    def get_type_id(klass)
+      fetch_type_id(klass.to_s)
+    end
+
+    private
+
+    def reverse_drivers(&block)
+      val = nil
+      @drivers.reverse.each do |driver|
+        val = block.call(driver) if block_given?
+        break if val
+      end
+      val
+    end
+
+    def fetch_klass_string(type_id)
+      reverse_drivers do |driver|
+        driver.get_klass(type_id)
+      end
+    end
+
+    def fetch_type_id(klass_str)
+      reverse_drivers do |driver|
+        driver.get_type_id(klass_str)
+      end
+    end
+  end
+end

data/lib/togls/rule_type_repository_drivers/in_memory_driver.rb

@@ -0,0 +1,52 @@
+module Togls
+  module RuleTypeRepositoryDrivers
+    class InMemoryDriver
+      def initialize
+        @rule_types = {}
+        @rule_type_meta_data = {}
+        @type_ids = {}
+        @rule_types_lock = Mutex.new
+      end
+
+      def store(type_id, klass_str, title, description, target_type)
+        @rule_types_lock.synchronize do
+          @rule_types[type_id] = klass_str
+          @rule_type_meta_data[type_id] = { title: title,
+                                            description: description,
+                                            target_type: target_type }
+          @type_ids[klass_str] = type_id
+        end
+      end
+
+      def get_klass(type_id)
+        @rule_types_lock.synchronize do
+          if @rule_types.has_key?(type_id)
+            @rule_types[type_id].dup
+          else
+            nil
+          end
+        end
+      end
+
+      def get_type_meta_data(type_id)
+        @rule_types_lock.synchronize do
+          if @rule_types.has_key?(type_id)
+            @rule_type_meta_data[type_id].dup
+          else
+            nil
+          end
+        end
+      end
+
+      def get_type_id(klass_str)
+        @rule_types_lock.synchronize do
+          if @type_ids.has_key?(klass_str)
+            @type_ids[klass_str].dup
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/togls/rule_type_repository_drivers.rb

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

data/lib/togls/rules/boolean.rb

@@ -6,7 +6,7 @@ module Togls
     # it's initialization data and when evaluated determines the toggle state
     # based on the initialization value. Example:
     #
-    # always_on = Togls::Rules::Boolean.new(true)
+    # always_on = Togls::Rules::Boolean.new(:boolean, true)
     # Togls.features do
     #   feature(:foo).on(always_on)
     # end
@@ -15,6 +15,26 @@ module Togls
     #   ...
     # end
     class Boolean < Rule
+      def self.title
+        "Boolean"
+      end
+
+      def self.description
+        %Q{
+The Boolean rule type is the base line rule for Togls. It allows you to
+flag a feature on/off by specifing a boolean value as the initialization
+data. For example:
+
+Togls::Rules::Boolean.new(:boolean, true) # rule that always evaluates to on
+
+Togls::Rules::Boolean.new(:boolean, false) # rule that always evaluates to off
+        }
+      end
+
+      def self.target_type
+        Togls::TargetTypes::NONE
+      end
+
       def run(_key, _target = nil)
         @data
       end

data/lib/togls/rules/group.rb

@@ -17,6 +17,32 @@ module Togls
     #   ...
     # end
     class Group < Rule
+      def self.title
+        "Group"
+      end
+
+      def self.description
+        %Q{
+The Group rule allows you to define an arbitrary collection of objects to be
+used in evaluating against the target. Specify the initialization data as an
+array of inclusive identifiers for the group. When the feature toggle is
+evaluated if the passed in target is included in the group then it is evaluated
+to on. If not, it evaluates to off. Examples:
+
+# Group defined by user ids
+alpha_testers = Togls::Rules::Group.new([23, 343, 222, 123])
+
+# Group defined by email addresses
+beta_testers = Togls::Rules::Group.new(['bob@example.com', 'cindy@example.com'])
+
+Togls.release do
+  feature(:foo, 'some foo desc').on(beta_testers)
+end
+
+Togls.feature(:foo).on?('jack@example.com') # evalutes to false (a.k.a. off)
+        }
+      end
+
       def run(_key, target)
         @data.include?(target)
       end

data/lib/togls/target_types.rb

@@ -0,0 +1,9 @@
+module Togls
+  module TargetTypes
+    # one (explicit one), none (explicity none), either (explicit for null
+    # toggle case), not set (original explicit hasn't been set yet)
+    NONE = :none
+    NOT_SET = :not_set
+    EITHER = :either
+  end
+end

data/lib/togls/toggle.rb

@@ -5,34 +5,78 @@ module Togls
   # responsibility is binding a specific rule to a specific feature. Toggle's by
   # default are associated with a boolean rule initialized to false.
   class Toggle
-    attr_reader :feature
-    attr_accessor :rule
+    attr_reader :feature, :rule
 
     def initialize(feature)
       @feature = feature
-      @rule = Togls::Rules::Boolean.new(false)
+      @rule = Togls::Rules::Boolean.new(:boolean, false)
     end
 
     def id
       @feature.id
     end
 
+    def rule=(rule)
+      raise Togls::RuleFeatureTargetTypeMismatch unless target_matches?(rule)
+      @rule = rule
+    end
+
+    # feature target type | rule target type | match? | notes
+    # -------------------------------------------------------
+    # NOT_SET             | NONE             | true   |
+    # NONE                | NONE             | true   |
+    # something (foo)     | NONE             | true   |
+    # NOT_SET             | NOT_SET          | false  | broken - shouldn't happen
+    # NONE                | NOT_SET          | false  | broken - shouldn't happen
+    # something (foo)     | NOT_SET          | false  | broken - shouldn't happen
+    # NOT_SET             | something (foo)  | false  | broken - shouldn't happen
+    # NONE                | something (foo)  | false  |
+    # something (foo)     | something (foo)  | true   |
+    # something (foo)     | something (bar)  | false  |
+    def target_matches?(rule)
+      if rule.target_type == Togls::TargetTypes::NONE
+        return true
+      elsif rule.target_type == Togls::TargetTypes::NOT_SET
+        Togls.logger.warn "Rule (id: #{rule.id}) cannot have target type of :not_set"
+        return false
+      elsif @feature.target_type == Togls::TargetTypes::NOT_SET
+        Togls.logger.warn "Feature (key: #{feature.key}) cannot have target type of :not_set when rule (id: #{rule.id}) specifies a target type (target_type: #{rule.target_type}"
+        return false
+      elsif rule.target_type == @feature.target_type
+        return true
+      else
+        false
+      end
+    end
+
+    # feature.target_type | target.nil? | valid target
+    # NONE                | false       | FALSE - EXCEPTION
+    # :foo                | true        | FALSE - EXCEPTION
+    # NONE                | true        | true
+    # :foo                | false       | true
+    # NOT_SET             | ignored     | true - broken
+    # EITHER              | true        | true
+    # EITHER              | false       | true
+    def validate_target(target)
+      is_explicit_target_type = @feature.target_type != Togls::TargetTypes::NONE &&
+        @feature.target_type != Togls::TargetTypes::NOT_SET &&
+        @feature.target_type != Togls::TargetTypes::EITHER
+      if @feature.target_type == Togls::TargetTypes::NONE && target
+        raise Togls::UnexpectedEvaluationTarget
+      elsif is_explicit_target_type && target.nil?
+        raise Togls::EvaluationTargetMissing
+      end
+      # Is valid
+    end
+
     def on?(target = nil)
+      validate_target(target)
       @rule.run(@feature.key, target)
     end
 
     def off?(target = nil)
+      validate_target(target)
       !@rule.run(@feature.key, target)
     end
-
-    def to_s
-      display_value = if @rule.is_a?(Togls::Rules::Boolean)
-                        @rule.run(@feature.key) ? ' on' : 'off'
-                      else
-                        '  ?'
-                      end
-
-      "#{display_value} - #{@feature.key} - #{@feature.description}"
-    end
   end
 end

data/lib/togls/toggle_registry.rb

@@ -0,0 +1,45 @@
+module Togls
+  # Toggle Registry
+  #
+  # The Toggle Registry conceptually houses a registry of toggles. It
+  # accomplishes this by interfacing with the provided feature
+  # repository, and toggle repository. This plays a significant portion
+  # in the primary DSL as well.
+  class ToggleRegistry
+    def initialize(feature_repository, toggle_repository)
+      @feature_repository = feature_repository
+      @toggle_repository = toggle_repository
+    end
+
+    def expand(&block)
+      instance_eval(&block)
+      self
+    end
+
+    def feature(key, desc, target_type: Togls.default_feature_target_type)
+      verify_uniqueness_of_feature(key)
+      feature = Togls::Feature.new(key, desc, target_type)
+      toggle = Togls::Toggle.new(feature)
+      @toggle_repository.store(toggle)
+      Togls::Toggler.new(@toggle_repository, toggle)
+    end
+
+    def verify_uniqueness_of_feature(key)
+      if @feature_repository.include?(key.to_s)
+        raise FeatureAlreadyDefined, "Feature identified by '#{key}' has already been defined"
+      end
+    end
+
+    def get(key)
+      toggle = @toggle_repository.get(key.to_s)
+      if toggle.is_a?(Togls::ToggleMissingToggle)
+        Togls.logger.warn("Feature identified by '#{key}' has not been defined")
+      end
+      toggle
+    end
+
+    def all
+      @toggle_repository.all
+    end
+  end
+end

data/lib/togls/toggle_repository.rb

@@ -32,15 +32,30 @@ module Togls
     def get(id)
       toggle_data = fetch_toggle_data(id)
       return reconstitute_toggle(toggle_data) if toggle_data
-      Togls::NullToggle.new
+      Togls::ToggleMissingToggle.new
     end
 
     def reconstitute_toggle(toggle_data)
-      feature = @feature_repository.get(toggle_data['feature_id'])
-      rule = @rule_repository.get(toggle_data['rule_id'])
+      begin
+        feature = @feature_repository.get(toggle_data['feature_id'])
+      rescue Togls::RepositoryFeatureDataInvalid => e
+        return Togls::NullToggle.new
+      end
+
+      begin
+        rule = @rule_repository.get(toggle_data['rule_id'])
+      rescue Togls::RepositoryRuleDataInvalid => e
+        return Togls::NullToggle.new
+      end
+
       toggle = Togls::Toggle.new(feature)
-      toggle.rule = rule
-      toggle
+      begin
+        toggle.rule = rule
+        toggle
+      rescue Togls::RuleFeatureTargetTypeMismatch
+        Togls.logger.warn("Feature (#{feature.key}) with target type '#{feature.target_type}' has a rule (#{rule.id}) mismatch with target type '#{rule.target_type}'")
+        return Togls::RuleFeatureMismatchToggle.new
+      end
     end
 
     def fetch_toggle_data(id)

data/lib/togls/toggler.rb

@@ -1,23 +1,27 @@
+require 'forwardable'
 module Togls
   # Toggle Toggler
   #
   # The Toggle Toggler provides the convenience interface of being able to
   # toggle a feature on/off via the `on` or `off` methods respectively.
   class Toggler
+    extend Forwardable
+    def_delegators :@toggle, :on?, :off?, :feature, :rule
+
     def initialize(toggle_repository, toggle)
       @toggle_repository = toggle_repository
       @toggle = toggle
     end
 
     def on(rule = nil)
-      rule = Togls::Rules::Boolean.new(true) if rule.nil?
+      rule = Togls::Rules::Boolean.new(:boolean, true) if rule.nil?
       @toggle.rule = rule
       @toggle_repository.store(@toggle)
       @toggle
     end
 
     def off
-      rule = Togls::Rules::Boolean.new(false)
+      rule = Togls::Rules::Boolean.new(:boolean, false)
       @toggle.rule = rule
       @toggle_repository.store(@toggle)
       @toggle

data/lib/togls/version.rb

@@ -1,3 +1,3 @@
 module Togls
-  VERSION = '2.2.1'.freeze
+  VERSION = '3.0.0-rc.1'.freeze
 end

data/lib/togls.rb

@@ -1,6 +1,7 @@
 require 'togls/version'
 require 'togls/errors'
 require 'togls/helpers'
+require 'togls/target_types'
 require 'togls/toggle_repository_drivers'
 require 'togls/toggle_repository_drivers/in_memory_driver'
 require 'togls/toggle_repository_drivers/env_override_driver'
@@ -8,9 +9,13 @@ 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/rule_repository_drivers/env_override_driver'
+require 'togls/rule_type_repository_drivers'
+require 'togls/rule_type_repository_drivers/in_memory_driver'
 require 'togls/toggler'
-require 'togls/feature_toggle_registry'
-require 'togls/test_toggle_registry'
+require 'togls/rule_type_repository'
+require 'togls/rule_type_registry'
+require 'togls/toggle_registry'
 require 'togls/feature_repository'
 require 'togls/rule_repository'
 require 'togls/toggle_repository'
@@ -20,12 +25,14 @@ require 'togls/null_toggle'
 require 'togls/rule'
 require 'togls/rules'
 require 'logger'
-require 'togls/release_toggle_registry_manager'
+require 'togls/feature_toggle_registry_manager'
+require 'togls/default_feature_target_type_manager'
 
 # Togls
 #
 # Togls is the primary interface to the out of the box toggle registry. It is
 # the namespace the DSL is exposed under.
 module Togls
-  include ReleaseToggleRegistryManager
+  include FeatureToggleRegistryManager
+  include DefaultFeatureTargetTypeManager
 end

data/togls.gemspec

@@ -27,6 +27,6 @@ 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 'rspec', '~> 3.4'
   spec.add_development_dependency 'pry', '~> 0.10'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: togls
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 3.0.0.pre.rc.1
 platform: ruby
 authors:
 - Brian Miller
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-24 00:00:00.000000000 Z
+date: 2016-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -46,14 +46,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -93,26 +93,31 @@ files:
 - bin/console
 - bin/setup
 - contributing/togls_architecture.monopic
-- lib/tasks/togls.rake
 - lib/togls.rb
+- lib/togls/default_feature_target_type_manager.rb
 - lib/togls/errors.rb
 - lib/togls/feature.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/feature_toggle_registry_manager.rb
 - lib/togls/helpers.rb
 - lib/togls/null_toggle.rb
-- lib/togls/release_toggle_registry_manager.rb
 - lib/togls/rule.rb
 - lib/togls/rule_repository.rb
 - lib/togls/rule_repository_drivers.rb
+- lib/togls/rule_repository_drivers/env_override_driver.rb
 - lib/togls/rule_repository_drivers/in_memory_driver.rb
+- lib/togls/rule_type_registry.rb
+- lib/togls/rule_type_repository.rb
+- lib/togls/rule_type_repository_drivers.rb
+- lib/togls/rule_type_repository_drivers/in_memory_driver.rb
 - lib/togls/rules.rb
 - lib/togls/rules/boolean.rb
 - lib/togls/rules/group.rb
-- lib/togls/test_toggle_registry.rb
+- lib/togls/target_types.rb
 - lib/togls/toggle.rb
+- lib/togls/toggle_registry.rb
 - lib/togls/toggle_repository.rb
 - lib/togls/toggle_repository_drivers.rb
 - lib/togls/toggle_repository_drivers/env_override_driver.rb
@@ -135,9 +140,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1

data/lib/tasks/togls.rake

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

data/lib/togls/feature_toggle_registry.rb

@@ -1,57 +0,0 @@
-module Togls
-  # Feature Toggle Registry
-  #
-  # The Feature Toggle Registry conceptually houses a registry of toggles. It
-  # accomplishes this by technically housing a toggle repository, rule
-  # repository, and feature repository which is uses to store and retrieve the
-  # respective entities. This plays a significant portion in the primary DSL as
-  # well.
-  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)
-      @rule_repository.store(Togls::Rules::Boolean.new(true))
-      @rule_repository.store(Togls::Rules::Boolean.new(false))
-    end
-
-    def self.create(&block)
-      feature_toggle_registry = new
-      feature_toggle_registry.instance_eval(&block)
-      feature_toggle_registry
-    end
-
-    def expand(&block)
-      instance_eval(&block)
-      self
-    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
-      toggle
-    end
-
-    def all
-      @toggle_repository.all
-    end
-  end
-end