togls 2.2.1 → 3.0.0.pre.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e07a68d3fc95321858fb09e282d568faa8957588
-  data.tar.gz: 6af7cd9bd40afb53d6d367b232e690d34e2d675d
+  metadata.gz: e15bb80dde590be56e09b63b345d321068356ed7
+  data.tar.gz: cf898035f7e06327aca28ba7805440fcfb123a09
 SHA512:
-  metadata.gz: 2d66393fb05305227911e1a9fd56e2b651cddd9e7efec9e6980ac37eae888fa16fa2fc6542ffdb5d5fa016be099c1566ff345f6b7e1b470f37a885433cab7de0
-  data.tar.gz: ef4b6e18ba83c0ab616a853daf405f606ce5b56db09e76a04c1230399e8feaa67ff13dae6b06361275d3d34a45e38280caf2becdd88cd694531e5f370f41507b
+  metadata.gz: 059266b27c515744c891db005dab8ac82485670a18749c3a857ee7996a2016287bba98a1ef9063a33495e937e967e3516dac505e51f5fe52f1cc499f17cb6d8d
+  data.tar.gz: ebe1d54110e5f27989a0f4fab4d5ebfcfc8f4c427776e5efb5fe40ce3c5e9a7716765a2c4aa75cb65db4c2be4c5f50b78533676e14660318124e88f5e1eb6a3d

data/.ruby-version

@@ -1 +1 @@
-2.3.0
+2.3.1

data/CHANGELOG.md

@@ -2,55 +2,126 @@
 
 The following are lists of the notable changes included with each release.
 This is intended to help keep people informed about notable changes between
-versions, as well as provide a rough history.
-
-#### Next Release
-
-### v2.2.1
-
-* Added: in-memory driver `set`, `get`, `all` Marshaling to correct a threading
-  reference based collision. Fixes issue #35
-
-### v2.2.0
-
-* Changed Togls to be thread-safe
-* Added Togls::TestToggleRegistry class for initializing test state
-* Added ability to create additional toggle registries
-
-### v2.1.1
-
-* Fixed issue #21, env variable override wasn't falling through to in
+versions, as well as provide a rough history. Each item is prefixed with
+one of the following labels: `Added`, `Changed`, `Deprecated`,
+`Removed`, `Fixed`, `Security`. We also use [Semantic
+Versioning](http://semver.org) to manage the versions of this gem so
+that you can set version constraints properly.
+
+#### [Unreleased] - now
+
+* `Changed`: The testing interface to allow for contract enforcement in tests
+  and allow altering existing feature rules within tests.
+* `Added`: `Togls.rule` method to simplify rule construction from `type_id`
+  ([#86](https://github.com/codebreakdown/togls/issues/86))
+* `Changed`: Rule construction to require an abstract rule `type_id`
+  ([#86](https://github.com/codebreakdown/togls/issues/86))
+* `Added`: Feature repository response validation
+* `Added`: validation of targets against feature target_type contract
+  ([#78](https://github.com/codebreakdown/togls/issues/78))
+* `Added`: setting a default feature target type
+  ([#69](https://github.com/codebreakdown/togls/issues/69))
+* `Added`: logging for target type mismatches/erroneous states
+  ([#69](https://github.com/codebreakdown/togls/issues/69))
+* `Changed`: in code feature rule association API to require `target_type`
+  ([#69](https://github.com/codebreakdown/togls/issues/69))
+* `Added`: rule instance target types and switch type checking over
+  ([#67](https://github.com/codebreakdown/togls/issues/67))
+* `Added`: optional target types, and target type checking
+  ([#65](https://github.com/codebreakdown/togls/issues/65))
+* `Changed`: rule type repository to store meta data
+  ([#62](https://github.com/codebreakdown/togls/issues/62))
+* `Added`: uniqueness check for rule types
+  ([#61](https://github.com/codebreakdown/togls/issues/61)
+* `Changed`: rule repository to use rule type repository
+  ([#59](https://github.com/codebreakdown/togls/issues/59))
+* `Added`: rule type registration
+  ([#59](https://github.com/codebreakdown/togls/issues/59))
+* `Changed`: driver construction to RegistryManager
+  ([#56](https://github.com/codebreakdown/togls/issues/56))
+* `Removed`: `TestToggleRegistry`
+  ([#56](https://github.com/codebreakdown/togls/issues/56))
+* `Changed`: `ReleaseToggleRegistry` to `ToggleRegistry`
+  ([#56](https://github.com/codebreakdown/togls/issues/56))
+* `Removed`: `features` rake task
+  ([#48](https://github.com/codebreakdown/togls/issues/48))
+* `Added`: `test_mode` block style method
+  ([#44](https://github.com/codebreakdown/togls/issues/44))
+* `Changed`: `Togls.features` to `Togls.release`
+  ([#38](https://github.com/codebreakdown/togls/issues/38))
+* `Changed`: Renamed `FeatureToggleRegistry` to `ReleaseToggleRegistry`
+  ([#41](https://github.com/codebreakdown/togls/issues/41))
+* `Added`: `FeatureToggleRegistryManager` methods, `enable_test_mode` &
+  `disable_test_mode`
+* `Removed`: `features=` setter
+* `Changed`: `FeatureRepository` moved from `Registry` to `RegistryManager` 
+  ([#40](https://github.com/codebreakdown/togls/issues/40))
+* `Removed`: `FeatureToggleRegistry.create` and `TestToggleRegistry.create`
+* `Changed`: `ReleaseToggleRegistryManager` to `FeatureToggleRegistryManager`
+* `Added`: Base Error class for Togls exceptions
+  ([#39](https://github.com/codebreakdown/togls/issues/39))
+* `Added`: Exception for when a feature has already been defined in the feature
+  repository
+  ([#42](https://github.com/codebreakdown/togls/issues/42))
+
+#### [v2.2.1] - 2016-03-24
+
+* `Added`: in-memory driver `set`, `get`, `all` Marshaling to correct a threading
+  reference based collision.
+  ([#35](https://github.com/codebreakdown/togls/issues/35))
+
+#### [v2.2.0] - 2016-03-04
+
+* `Changed`: Togls to be thread-safe
+* `Added`: `Togls::TestToggleRegistry` class for initializing test state
+* `Added`: ability to create additional toggle registries
+
+#### [v2.1.1] - 2015-12-14
+
+* `Fixed`: env variable override wasn't falling through to in
   code defined memory value.
+  ([#24](https://github.com/codebreakdown/togls/issues/24))
 
-### v2.1.0
+#### [v2.1.0] - 2015-11-24
 
-* Fixed #19, exceptions happened on evaluation after setting
+* `Fixed`: exceptions happened on evaluation after setting
   `Togls.features = nil`
+  ([#19](https://github.com/codebreakdown/togls/issues/19))
 
-### v2.0.0
+#### [v2.0.0] - 2015-11-23
 
-* Add ability to create empty feature toggle set via `Togls.features`
-* Add toggle definition expansion with multiple `Togls.features` blocks
-* Add set FeatureToggleRegistry instance, `Togls.features = toggle_registry`
-* Change `Togls.features` to return FeatureToggleRegistry instance
+* `Added`: ability to create empty feature toggle set via `Togls.features`
+* `Added`: toggle definition expansion with multiple `Togls.features` blocks
+* `Added`: set FeatureToggleRegistry instance, `Togls.features = toggle_registry`
+* `Changed`: `Togls.features` to return FeatureToggleRegistry instance
   rather than an Array of Toggle objects.
 
-#### v1.1.0
+#### [v1.1.0] - 2015-11-17
 
-* Add `off?` method for asking if a defined feature is off
-* Add feature toggle overrides
-* Rearchitect to support concept of repositories and datastores allowing
+* `Added`: `off?` method for asking if a defined feature is off
+* `Added`: feature toggle overrides
+* `Changed`: Architecture to support concept of repositories and datastores allowing
   further growth in the future
 
-#### v1.0.0
+#### [v1.0.0] - 2015-05-19
 
-* Require human readable description to define a feature toggle
-* Add rake task that outputs all the feature toggles states (on, off, ? -
+* `Changed`: to require human readable description to define a feature toggle
+* `Added`: rake task that outputs all the feature toggles states (on, off, ? -
   unknown due to Compex Rule), keys, and human readable descritpions
 
-#### v0.1.0
+#### [v0.1.0] - 2015-05-03
 
-* Add concept of Groups as a provided rule
-* Add concept of Rules and Custom Rules, allowing users to have more dynamic
+* `Added`: concept of Groups as a provided rule
+* `Added`: concept of Rules and Custom Rules, allowing users to have more dynamic
   feature toggles
-* Add basic feature toggles able to be switched on/off
+* `Added`: basic feature toggles able to be switched on/off
+
+[Unreleased]: https://github.com/codebreakdown/togls/compare/v2.2.1...HEAD
+[v2.2.1]: https://github.com/codebreakdown/togls/compare/v2.2.0...v2.2.1
+[v2.2.0]: https://github.com/codebreakdown/togls/compare/v2.1.1...v2.2.0
+[v2.1.1]: https://github.com/codebreakdown/togls/compare/v2.1.0...v2.1.1
+[v2.1.0]: https://github.com/codebreakdown/togls/compare/v2.0.0...v2.1.0
+[v2.0.0]: https://github.com/codebreakdown/togls/compare/v1.1.0...v2.0.0
+[v1.1.0]: https://github.com/codebreakdown/togls/compare/v1.0.0...v1.1.0
+[v1.0.0]: https://github.com/codebreakdown/togls/compare/v0.1.0...v1.0.0
+[v0.1.0]: https://github.com/codebreakdown/togls/compare/0fa2feb...v0.1.0

data/README.md

@@ -50,7 +50,7 @@ The following, `config/initializers/togls_features.rb`, is an example of
 how one would define some basic feature toggles.
 
 ```ruby
-Togls.features do
+Togls.release do
   # Set this feature to always be on
   feature(:pop_up_login_form, "use pop up login instead of normal login").on 
 
@@ -95,7 +95,7 @@ feature toggle in all caps with `TOGLS_` prefixed to it. For example if
 we had the following feature toggle defined.
 
 ```ruby
-Togls.features do
+Togls.release do
   # Set this feature to always be on
   feature(:pop_up_login_form, "use pop up login instead of normal login").on
 end
@@ -131,7 +131,7 @@ based on group membership.
 alpha_testers = Togls::Rules::Group.new(["user1@email.com",
                                          "user2@example.com"])
 
-Togls.features do
+Togls.release do
   feature(:new_contact_form, "use new contact form").on(alpha_testers)
 end
 ```
@@ -183,7 +183,7 @@ in the example above and it would look something like the following:
 # the group.
 alpha_testers = Togls::Rules::Group.new([1, 23, 42, 83])
 
-Togls.features do
+Togls.release do
   feature(:new_contact_form, "use new contact form").on(alpha_testers)
 end
 ```
@@ -207,14 +207,17 @@ 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
+many things it contains are
+[Testing with
+Toggles](https://github.com/codebreakdown/togls/wiki/Testing-with-Toggles),
+[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),
-[Testing with
-Toggles](https://github.com/codebreakdown/togls/wiki/Testing-with-Toggles)
+[Organize Toggle
+Definitions](https://github.com/codebreakdown/togls/wiki/Organize-Toggle-Definitions),
+[Creating Additional Toggle
+Registries](https://github.com/codebreakdown/togls/wiki/Create-Additional-Toggle-Registries),
 etc.
 
 ## Development

data/lib/togls/default_feature_target_type_manager.rb

@@ -0,0 +1,25 @@
+module Togls
+  module DefaultFeatureTargetTypeManager
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def default_feature_target_type(target_type = nil)
+        if target_type
+          if @default_feature_target_type
+            raise Togls::DefaultFeatureTargetTypeAlreadySet, 'the default feature target type has already been set'
+          else
+            @default_feature_target_type = target_type
+          end
+        else
+          if @default_feature_target_type
+            return @default_feature_target_type
+          else
+            return Togls::TargetTypes::NOT_SET
+          end
+        end
+      end
+    end
+  end
+end

data/lib/togls/errors.rb

@@ -1,6 +1,17 @@
 module Togls
-  class NoFeaturesError < StandardError; end
-  class MissingDriver < StandardError; end
-  class InvalidDriver < StandardError; end
-  class NotImplemented < StandardError; end
+  class Error < StandardError; end
+  class NoFeaturesError < Error; end
+  class MissingDriver < Error; end
+  class InvalidDriver < Error; end
+  class NotImplemented < Error; end
+  class FeatureAlreadyDefined < Error; end
+  class RuleTypeAlreadyDefined < Error; end
+  class RuleFeatureTargetTypeMismatch < Error; end
+  class RuleMissingTargetType < Error; end
+  class DefaultFeatureTargetTypeAlreadySet < Error; end
+  class FeatureMissingTargetType < Error; end
+  class EvaluationTargetMissing < Error; end
+  class UnexpectedEvaluationTarget < Error; end
+  class RepositoryFeatureDataInvalid < Error; end
+  class RepositoryRuleDataInvalid < Error; end
 end

data/lib/togls/feature.rb

@@ -6,13 +6,25 @@ module Togls
   class Feature
     attr_reader :key, :description
 
-    def initialize(key, description)
+    def initialize(key, description, target_type)
       @key = key.to_s
       @description = description
+      @target_type = target_type
+      raise Togls::FeatureMissingTargetType, "Feature '#{self.key}' is missing a required target type" if self.missing_target_type?
+    end
+
+    def target_type
+      return @target_type unless @target_type.nil?
+      return Togls::TargetTypes::NOT_SET
     end
 
     def id
       @key
     end
+
+    def missing_target_type?
+      return false if target_type && (target_type != Togls::TargetTypes::NOT_SET)
+      return true
+    end
   end
 end

data/lib/togls/feature_repository.rb

@@ -22,7 +22,7 @@ module Togls
     end
 
     def extract_feature_data(feature)
-      { 'key' => feature.key, 'description' => feature.description }
+      { 'key' => feature.key, 'description' => feature.description, 'target_type' => feature.target_type.to_s }
     end
 
     def fetch_feature_data(id)
@@ -34,14 +34,40 @@ module Togls
       feature_data
     end
 
+    def include?(feature_id)
+      result = fetch_feature_data(feature_id)
+      result.nil? ? false : true
+    end
+
     def get(feature_id)
       feature_data = fetch_feature_data(feature_id)
+      validate_feature_data(feature_data)
       reconstitute_feature(feature_data)
     end
 
     def reconstitute_feature(feature_data)
       Togls::Feature.new(feature_data['key'],
-                         feature_data['description'])
+                         feature_data['description'],
+                         feature_data['target_type'].to_sym)
+    end
+
+    def validate_feature_data(feature_data)
+      if feature_data.nil?
+        Togls.logger.debug("None of the feature repository drivers claim to have the feature")
+        raise Togls::RepositoryFeatureDataInvalid, "None of the feature repository drivers claim to have the feature"
+      end
+
+      ['key', 'description', 'target_type'].each do |k|
+        if !feature_data.has_key? k
+          Togls.logger.debug("One of the feature repository drivers returned feature data that is missing the '#{k}'")
+          raise Togls::RepositoryFeatureDataInvalid, "One of the feature repository drivers returned feature data that is missing the '#{k}'"
+        end
+
+        if !feature_data[k].is_a?(String)
+          Togls.logger.debug("One of the feature repository drivers returned feature data with '#{k}' not being a string")
+          raise Togls::RepositoryFeatureDataInvalid, "One of the feature repository drivers returned feature data with '#{k}' not being a string"
+        end
+      end
     end
   end
 end

data/lib/togls/feature_toggle_registry_manager.rb

@@ -0,0 +1,138 @@
+module Togls
+  # Feature Toggle Registry Manager
+  #
+  # This is the primary DSL interface. It provides a DSL to facilitate housing
+  # and managing a toggle registry.
+  module FeatureToggleRegistryManager
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    # Feature Toggle Registry Manager Class Methods
+    #
+    # The class methods that should be extended onto the module/class when
+    # FeatureToggleRegistryManager is included.
+    module ClassMethods
+      def release(&block)
+        release_blocks << block if block
+
+        release_toggle_registry.expand(&block) if block
+        release_toggle_registry
+      end
+
+      def release_blocks
+        @release_blocks ||= []
+      end
+
+      def rule_types(&block)
+        rule_type_registry.expand(&block) if block
+        rule_type_registry
+      end
+
+      def rule_type(type_id)
+        rule_type_registry.get(type_id)
+      end
+
+      def rule(type_id, data, target_type: Togls::TargetTypes::NOT_SET)
+        rule_type(type_id).new(type_id, data, target_type: target_type)
+      end
+
+      def feature(key)
+        Toggler.new(release_toggle_registry.instance_variable_get(:@toggle_repository), release_toggle_registry.get(key))
+      end
+
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def enable_test_mode
+        @previous_release_toggle_registry = @release_toggle_registry
+        @release_toggle_registry = test_toggle_registry
+      end
+
+      def disable_test_mode
+        @release_toggle_registry = @previous_release_toggle_registry
+      end
+
+      def test_mode
+        enable_test_mode
+        yield
+        disable_test_mode
+      end
+
+      private
+
+      def rule_type_repository
+        if @rule_type_repository.nil?
+          rule_type_repository_drivers = [RuleTypeRepositoryDrivers::InMemoryDriver.new]
+          @rule_type_repository = RuleTypeRepository.new(rule_type_repository_drivers)
+        end
+        @rule_type_repository
+      end
+
+      def rule_type_registry
+        if @rule_type_registry.nil?
+          @rule_type_registry = RuleTypeRegistry.new(rule_type_repository)
+          @rule_type_registry.register(:boolean, Togls::Rules::Boolean)
+          @rule_type_registry.register(:group, Togls::Rules::Group)
+        end
+        @rule_type_registry
+      end
+
+      def test_toggle_registry
+        feature_repository_drivers =
+          [Togls::FeatureRepositoryDrivers::InMemoryDriver.new]
+        test_feature_repository = Togls::FeatureRepository.new(
+          feature_repository_drivers)
+
+        rule_repository_drivers =
+          [Togls::RuleRepositoryDrivers::InMemoryDriver.new]
+        rule_repository = Togls::RuleRepository.new(rule_type_registry, rule_repository_drivers)
+
+        toggle_repository_drivers = [
+          Togls::ToggleRepositoryDrivers::InMemoryDriver.new]
+
+        toggle_repository = Togls::ToggleRepository.new(
+          toggle_repository_drivers, test_feature_repository, rule_repository)
+
+        tr = ToggleRegistry.new(test_feature_repository, toggle_repository)
+        release_blocks.each do |p|
+          tr.expand(&p)
+        end
+
+        return tr
+      end
+
+      def release_toggle_registry
+        if @release_toggle_registry.nil?
+          rule_repository_drivers = [
+            Togls::RuleRepositoryDrivers::InMemoryDriver.new,
+            Togls::RuleRepositoryDrivers::EnvOverrideDriver.new
+          ]
+
+          rule_repository = Togls::RuleRepository.new(rule_type_registry, rule_repository_drivers)
+
+          toggle_repository_drivers = [
+            Togls::ToggleRepositoryDrivers::InMemoryDriver.new,
+            Togls::ToggleRepositoryDrivers::EnvOverrideDriver.new
+          ]
+
+          toggle_repository = Togls::ToggleRepository.new(
+            toggle_repository_drivers, feature_repository, rule_repository)
+
+          @release_toggle_registry = ToggleRegistry.new(feature_repository,
+                                                        toggle_repository)
+        end
+        @release_toggle_registry
+      end
+
+      def feature_repository
+        if @feature_repository.nil?
+          feature_repository_drivers = [Togls::FeatureRepositoryDrivers::InMemoryDriver.new]
+          @feature_repository = Togls::FeatureRepository.new(feature_repository_drivers)
+        end
+        @feature_repository
+      end
+    end
+  end
+end

data/lib/togls/helpers.rb

@@ -3,8 +3,8 @@ module Togls
   #
   # Collection of helper methods used through the Togls library.
   module Helpers
-    def self.sha1(klass, data)
-      Digest::SHA1.hexdigest("#{klass}:#{data}")
+    def self.sha1(*args)
+      Digest::SHA1.hexdigest(args.join(':'))
     end
   end
 end

data/lib/togls/null_toggle.rb

@@ -5,7 +5,7 @@ module Togls
   # toggle found when requested to be retreived through a Toggle Repository.
   class NullToggle < Togls::Toggle
     def initialize
-      feature = Togls::Feature.new('null', 'the official null feature')
+      feature = Togls::Feature.new('null', 'the official null feature', Togls::TargetTypes::EITHER)
       super(feature)
     end
 
@@ -17,4 +17,7 @@ module Togls
       self
     end
   end
+
+  class ToggleMissingToggle < NullToggle; end
+  class RuleFeatureMismatchToggle < NullToggle; end
 end

data/lib/togls/rule.rb

@@ -4,10 +4,25 @@ module Togls
   # The Rule is an abstract base class that is intended to act as an interface
   # for other rules to be implemented against.
   class Rule
-    attr_reader :data
+    attr_reader :data, :type_id
 
-    def initialize(data = nil)
+    def self.title
+      raise Togls::NotImplemented, "Rule type title not implemented"
+    end
+
+    def self.description
+      raise Togls::NotImplemented, "Rule type description not implemented"
+    end
+
+    def self.target_type
+      Togls::TargetTypes::NOT_SET
+    end
+
+    def initialize(type_id, data = nil, target_type: Togls::TargetTypes::NOT_SET)
+      @type_id = type_id
       @data = data
+      @target_type = target_type
+      raise Togls::RuleMissingTargetType, "Rule '#{self.id}' of type '#{self.class}' is missing a required target type" if self.missing_target_type?
     end
 
     def run(key, target = nil)
@@ -15,7 +30,18 @@ module Togls
     end
 
     def id
-      Togls::Helpers.sha1(self.class, @data)
+      Togls::Helpers.sha1(@type_id, @data, target_type)
+    end
+
+    def target_type
+      return @target_type if @target_type && @target_type != Togls::TargetTypes::NOT_SET
+      return self.class.target_type unless self.class.target_type.nil?
+      return Togls::TargetTypes::NOT_SET
+    end
+
+    def missing_target_type?
+      return false if target_type && (target_type != Togls::TargetTypes::NOT_SET)
+      return true
     end
   end
 end

data/lib/togls/rule_repository.rb

@@ -5,7 +5,7 @@ module Togls
   # It does these by interfacing with Rule Repository Drivers which are passed
   # in during construction as an Array.
   class RuleRepository
-    def initialize(drivers)
+    def initialize(rule_type_registry, drivers)
       unless drivers.is_a?(Array)
         raise Togls::InvalidDriver, 'RuleRepository requires a valid driver'
       end
@@ -13,6 +13,7 @@ module Togls
         raise Togls::MissingDriver, 'RuleRepository requires a driver'
       end
       @drivers = drivers
+      @rule_type_registry = rule_type_registry
     end
 
     def store(rule)
@@ -23,7 +24,11 @@ module Togls
     end
 
     def extract_storage_payload(rule)
-      { 'klass' => rule.class, 'data' => rule.data }
+      {
+        'type_id' => @rule_type_registry.get_type_id(rule.class.to_s),
+        'data' => rule.data, 
+        'target_type' => rule.target_type.to_s
+      }
     end
 
     def fetch_rule_data(id)
@@ -37,11 +42,39 @@ module Togls
 
     def get(rule_id)
       rule_data = fetch_rule_data(rule_id)
+      validate_rule_data(rule_data)
       reconstitute_rule(rule_data)
     end
 
+    def validate_rule_data(rule_data)
+      if rule_data.nil?
+        Togls.logger.debug "None of the rule repository drivers claim to have the rule"
+        raise Togls::RepositoryRuleDataInvalid, "None of the rule repository drivers claim to have the rule"
+      end
+
+      ['type_id', 'data', 'target_type'].each do |k|
+        if !rule_data.has_key? k
+          Togls.logger.debug "One of the rule repository drivers returned rule data that is missing the '#{k}'"
+          raise Togls::RepositoryRuleDataInvalid, "One of the rule repository drivers returned rule data that is missing the '#{k}'"
+        end
+      end
+
+      ['type_id', 'target_type'].each do |k|
+        if !rule_data[k].is_a?(String)
+          Togls.logger.debug "One of the rule repository drivers returned rule data with '#{k}' not being a string"
+          raise Togls::RepositoryRuleDataInvalid, "One of the rule repository drivers returned rule data with '#{k}' not being a string"
+        end
+      end
+    end
+
     def reconstitute_rule(rule_data)
-      rule_data['klass'].new(rule_data['data'])
+      if rule_data.has_key?('target_type')
+        @rule_type_registry.get(rule_data['type_id'])\
+          .new(rule_data['type_id'].to_sym, rule_data['data'],
+               target_type: rule_data['target_type'].to_sym)
+      else
+        @rule_type_registry.get(rule_data['type_id']).new(rule_data['type_id'].to_sym, rule_data['data'])
+      end
     end
   end
 end