determinator 0.12.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17f714ab0a57974a7934bdcf86631e65e4e5111d
-  data.tar.gz: 82caf2b07f4a891cc2621fc1ef72aa8c569347b1
+  metadata.gz: 3b01c8573e10fbc219e4cd44c85696a8c34f4283
+  data.tar.gz: f7a43c6e60f22ef9947fbe04e5313db4b28982c8
 SHA512:
-  metadata.gz: 37b01ffc666efd680e085365b61b4516cf3c5300e7b215e98e0dde2e1472ea494f7fc5748f811420f137452ee163ed86488f47360205631cc825e2c896780948
-  data.tar.gz: d974d0c38bf2f3963dfa4661252e9bd41b5ef5d5d11ee3e91a2a85658254ca96d90ec5ae8c1d7b5e332065e7254bd0ff79db4cdb7a091a04a76b2e8094f7fd4a
+  metadata.gz: 66c567515540a0cc5adc1b9978b2a33b57d7f66135a0d6413847bccc68ee69d7a0954979333dda96bad701eba3879b1ac9e4c38785f18a4bf5c9ddc0f51ac668
+  data.tar.gz: 3329ee1b0ea3c1f59dc010675e2e2f89173dfc7c346b06ccb4248cb67e8c29b1ff13041a969f0400911a41fa93e0656b921ec5c9d9984e7d44f4634cec2c1a59

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "spec/standard_cases"]
+	path = spec/standard_cases
+	url = https://github.com/deliveroo/determinator-standard-tests

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# v1.0.0 (2018-02-05)
+
+⚠️ This release includes breaking changes ⚠️
+
+Breaking change:
+- Changes retrieval caching so that 404s are cached as well as positive feature retrievals. This means that an unconfigured feature won't result in a thundering herd of requests to Florence. (#46)
+
+Feature:
+- Changes tests to use the [Determinator standard tests](https://github.com/deliveroo/determinator-standard-tests) (#41)
+- Supports the use of the 'single' bucket type for features, which allows (only) feature flags to be on or off, without any `id` or `guid` specified. (#41)
+- Adds Determintion callbacks: trigger a block when a determination is made, allowing for experiment tracking. (#45)
+
 # v0.12.1 (2018-02-01)
 
 Bug Fix:

data/Guardfile

@@ -3,4 +3,5 @@ guard :rspec, cmd: 'rspec' do
   watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
   watch(%r{^spec/factories/.+\.rb}) { "spec" }
   watch('spec/spec_helper.rb')      { "spec" }
+  watch(%r{^spec/standard_cases/})  { "spec/determinator/control_spec.rb" }
 end

data/README.md

@@ -81,19 +81,34 @@ Determinator requires a initialiser block somewhere in your application's boot p
 # config/initializers/determinator.rb
 
 require 'determinator/retrieve/routemaster'
+require 'active_support/cache'
+
 Determinator.configure(
-  retrieval: Determinator::Retrieve::Routemaster.new(
-    discovery_url: 'https://flo.dev/'
-    retrieval_cache: ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
-  ),
-  errors: -> error { NewRelic::Agent.notice_error(error) },
-  missing_features: -> feature_name { STATSD.increment 'determinator.missing_feature', tags: ["feature:#{name}"] }
+  retrieval: Determinator::Retrieve::Routemaster.new(discovery_url: 'https://flo.dev/'),
+  feature_cache: Determinator::Cache::FetchWrapper.new(
+    ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
+  )
 )
+Determinator.on_error(NewRelic::Agent.method(:notice_error))
+Determinator.on_missing_feature do |feature_name|
+  STATSD.increment 'determinator.missing_feature', tags: ["feature:#{name}"]
+end
+
+Determinator.on_determination do |id, guid, feature, determination|
+  if feature.experiment? && determination != false
+    YourTrackingSolution.record_variant_viewing(
+      user_id: id,
+      experiment_name: feature.name,
+      variant: determination
+    )
+  end
+end
 ```
 
 This configures the `Determinator.instance` with:
 
 - What **retrieval** mechanism should be used to get feature details
+- (recommended) How features should be **cached** as they're retrieved. This mechanism allows caching features _and_ missing features, so when a cache is configured a determination request for a missing feature on busy machines won't result in a thundering herd.
 - (optional) How **errors** should be reported
 - (optional) How **missing features** should be monitored (as they indicate something's up with your code or your set up!)
 
@@ -175,9 +190,13 @@ end
 
 * Check out [the specs for `RSpec::Determinator`](spec/rspec/determinator_spec.rb) to find out what you can do!
 
-### Retrieval Cache
+## Testing this library
 
-Determinator will function fully without a retrieval_cache set, although Determinator will produce 1 Redis query for every determination. By setting a `retrieval_cache` as an instance of `ActiveSupport::Cache::MemoryStore` (or equivalent) this can be reduced per application instance. This cache is not expired so *must* have a `expires_in` set, ideally to a short amount of time.
+This library makes use of the [Determinator Standard Tests](https://github.com/deliveroo/determinator-standard-tests) to ensure that it conforms to the same specification as determinator libraries in other languages. The standard tests can be updated to the latest ones available by updating the submodule:
+
+```bash
+git submodule foreach git pull origin master
+```
 
 ## Contributing
 

data/circle.yml

@@ -0,0 +1,3 @@
+checkout:
+  post:
+    - git submodule update --init

data/examples/determinator-rails/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../..
   specs:
-    determinator (0.11.1)
+    determinator (0.12.1)
       routemaster-drain (~> 3.0)
 
 GEM

data/examples/determinator-rails/app/controllers/index_controller.rb

@@ -3,10 +3,6 @@ class IndexController < ApplicationController
     is_colloquial = determinator.feature_flag_on?(:colloquial_welcome)
     emoji = determinator.which_variant(:welcome_emoji)
 
-    if emoji
-      # TODO: Track that this user saw a variant of this experiment
-    end
-
     message = [
       is_colloquial ? "hi world" : "hello world",
       emoji

data/examples/determinator-rails/config/initializers/determinator.rb

@@ -1,10 +1,22 @@
 require 'determinator/retrieve/routemaster'
+require 'active_support/cache'
 
-Determinator.configure(
-  retrieval: Determinator::Retrieve::Routemaster.new(
-    discovery_url: 'https://florence.dev/'
-    retrieval_cache: ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
-  )
-  # The following would allow tracking of errors in NewRelic
-  # errors: -> error { NewRelic::Agent.notice_error(error) }
+retrieval = Determinator::Retrieve::Routemaster.new(discovery_url: 'https://flo.dev/')
+feature_cache = Determinator::Cache::FetchWrapper.new(
+  ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
 )
+Determinator.configure(retrieval: retrieval, feature_cache: feature_cache)
+
+Determinator.on_error do |error|
+  # NewRelic::Agent.notice_error(error)
+end
+
+Determinator.on_missing_feature do |feature_name|
+  # STATSD.increment 'determinator.missing_feature', tags: ["feature:#{name}"]
+end
+
+Determinator.on_determination do |id, guid, feature, determination|
+  if feature.experiment? && determination != false
+    puts "TODO: Track that user #{id}/#{guid} saw the #{determination} variant of '#{feature.name}' for analysis"
+  end
+end

data/lib/determinator.rb

@@ -4,40 +4,91 @@ require 'determinator/feature'
 require 'determinator/target_group'
 require 'determinator/retrieve/routemaster'
 require 'determinator/retrieve/null_retriever'
+require 'determinator/cache/fetch_wrapper'
 
 module Determinator
-  # @param :retrieval [Determinator::Retrieve::Routemaster] A retrieval instance for Features
-  # @param :errors [#call, nil] a proc, accepting an error, which will be called with any errors which occur while determinating
-  # @param :missing_feature [#call, nil] a proc, accepting a feature name, which will be called any time a feature is requested but isn't available
-  def self.configure(retrieval:, errors: nil, missing_feature: nil)
-    @error_logger = errors if errors.respond_to?(:call)
-    @missing_feature_logger = missing_feature if missing_feature.respond_to?(:call)
-    @instance = Control.new(retrieval: retrieval)
-  end
+  class << self
+    # @param :retrieval [Determinator::Retrieve::Routemaster] A retrieval instance for Features
+    # @param :errors [#call, nil] a proc, accepting an error, which will be called with any errors which occur while determinating
+    # @param :missing_feature [#call, nil] a proc, accepting a feature name, which will be called any time a feature is requested but isn't available
+    # @param :feature_cache [#call, nil] a caching proc, accepting a feature name, which will return the named feature or yield (and store) if not available
+    def configure(retrieval:, errors: nil, missing_feature: nil, feature_cache: nil)
+      self.on_error_logger(&errors) if errors
+      self.on_missing_feature(&missing_feature) if missing_feature
+      @feature_cache = feature_cache if feature_cache.respond_to?(:call)
+      @instance = Control.new(retrieval: retrieval)
+    end
 
-  # @return [Determinator::Control] The currently active instance of determinator.
-  # @raises [RuntimeError] If no Determinator instance is set up (with `.configure`)
-  def self.instance
-    raise "No singleton Determinator instance defined" unless @instance
-    @instance
-  end
+    # Returns the currently configured Determinator::Control instance
+    #
+    # @return [Determinator::Control] The currently active instance of determinator.
+    # @raises [RuntimeError] If no Determinator instance is set up (with `.configure`)
+    def instance
+      raise "No singleton Determinator instance defined" unless @instance
+      @instance
+    end
 
-  # Returns the feature with the given name as Determinator uses it. This is useful for
-  # debugging issues with the retrieval mechanism which delivers features to Determinator.
-  # @returns [Determinator::Feature,nil] The feature details Determinator would use for a determination right now.
-  def self.feature_details(name)
-    instance.retrieval.retrieve(name)
-  end
+    # Defines how errors that shouldn't break your application should be logged
+    def on_error(&block)
+      @error_logger = block
+    end
 
-  def self.notice_error(error)
-    return unless @error_logger
+    # Defines how to record the moment when a feature which doesn't exist is requested.
+    # If this happens a lot it indicates poor set up, so can be useful for tracking.
+    def on_missing_feature(&block)
+      @missing_feature_logger = block
+    end
 
-    @error_logger.call(error)
-  end
+    # Defines code that should execute when a determination is completed. This is particularly
+    # helpful for preparing or sending events to record that an actor has seen a particular experiment variant.
+    #
+    # Please note that this block will be executed _synchronously_ before delivering the determination to the callsite.
+    #
+    # @yield [id, guid, feature, determination] Will be called when a determination was requested for the
+    #   specified `feature`, for the actor with `id` and `guid`, and received the determination `determination`.
+    # @yieldparam id [String, nil] The ID that was used to request the determination
+    # @yieldparam guid [String, nil] The GUID that was used to request the determination
+    # @yieldparam feature [Determinator::Feature] The feature that was requested
+    # @yieldparam determination [String,Boolean] The result of the determination
+    def on_determination(&block)
+      @determination_callback = block
+    end
+
+    # Returns the feature with the given name as Determinator uses it. This is useful for
+    # debugging issues with the retrieval mechanism which delivers features to Determinator.
+    # @returns [Determinator::Feature,nil] The feature details Determinator would use for a determination right now.
+    def feature_details(name)
+      with_retrieval_cache(name) { instance.retrieval.retrieve(name) }
+    end
+
+    # Allows Determinator to track that an error has happened with determination
+    # @api private
+    def notice_error(error)
+      return unless @error_logger
+
+      error = RuntimeError.new(error) unless error.is_a?(StandardError)
+      @error_logger.call(error)
+    end
+
+    # Allows Determinator to track that a feature was requested but was missing
+    # @api private
+    def notice_missing_feature(name)
+      return unless @missing_feature_logger
+
+      @missing_feature_logger.call(name)
+    end
+
+    def notice_determination(id, guid, feature, determination)
+      return unless @determination_callback
+      @determination_callback.call(id, guid, feature, determination)
+    end
 
-  def self.missing_feature(name)
-    return unless @missing_feature_logger
+    # Allows access to the chosen caching mechanism for any retrieval plugin.
+    # @api private
+    def with_retrieval_cache(name)
+      return yield unless @feature_cache.respond_to?(:call)
 
-    @missing_feature_logger.call(name)
+      @feature_cache.call(name) { yield }
+    end
   end
 end

data/lib/determinator/cache/fetch_wrapper.rb

@@ -0,0 +1,20 @@
+module Determinator
+  module Cache
+    class FetchWrapper
+      # @param cache [#fetch] An instance of a cache class which implements #fetch like ActiveSupport::Cache does
+      def initialize(cache)
+        @cache = cache
+      end
+
+      def call(feature_name)
+        @cache.fetch(key(feature_name)) { yield }
+      end
+
+      private
+
+      def key(feature_name)
+        "determinator:feature_cache:#{feature_name}"
+      end
+    end
+  end
+end

data/lib/determinator/control.rb

@@ -27,9 +27,10 @@ module Determinator
     # @param :id [#to_s] The id of the actor being determinated for
     # @param :guid [#to_s] The Anonymous id of the actor being determinated for
     # @param :properties [Hash<Symbol,String>] The properties of this actor which will be used for including this actor or not
+    # @raise [ArgumentError] When the arguments given to this method aren't ever going to produce a useful response
     # @return [true,false] Whether the feature is on (true) or off (false) for this actor
     def feature_flag_on?(name, id: nil, guid: nil, properties: {})
-      determinate(name, id: id, guid: guid, properties: properties) do |feature|
+      determinate_and_notice(name, id: id, guid: guid, properties: properties) do |feature|
         feature.feature_flag?
       end
     end
@@ -40,9 +41,10 @@ module Determinator
     # @param :id [#to_s] The id of the actor being determinated for
     # @param :guid [#to_s] The Anonymous id of the actor being determinated for
     # @param :properties [Hash<Symbol,String>] The properties of this actor which will be used for including this actor or not
+    # @raise [ArgumentError] When the arguments given to this method aren't ever going to produce a useful response
     # @return [false,String] Returns false, if the actor is not in this experiment, or otherwise the variant name.
     def which_variant(name, id: nil, guid: nil, properties: {})
-      determinate(name, id: id, guid: guid, properties: properties) do |feature|
+      determinate_and_notice(name, id: id, guid: guid, properties: properties) do |feature|
         feature.experiment?
       end
     end
@@ -55,26 +57,33 @@ module Determinator
 
     Indicators = Struct.new(:rollout, :variant)
 
-    def determinate(name, id:, guid:, properties:)
-      feature = retrieval.retrieve(name)
+    def determinate_and_notice(name, id:, guid:, properties:)
+      feature = Determinator.with_retrieval_cache(name) { retrieval.retrieve(name) }
+
       if feature.nil?
-        Determinator.missing_feature(name)
+        Determinator.notice_missing_feature(name)
         return false
       end
 
+      determinate(feature, id: id, guid: guid, properties: properties).tap do |determination|
+        Determinator.notice_determination(id, guid, feature, determination)
+      end
+    end
+
+    def determinate(feature, id:, guid:, properties:)
       # Calling method can place constraints on the feature, eg. experiment only
       return false if block_given? && !yield(feature)
 
-      # Overrides take precedence
-      return feature.override_value_for(id) if feature.overridden_for?(id)
-
+      # Inactive features are always, always off
       return false unless feature.active?
 
+      return feature.override_value_for(id) if feature.overridden_for?(id)
+
       target_group = choose_target_group(feature, properties)
       # Given constraints have excluded this actor from this experiment
       return false unless target_group
 
-      indicators = indicators_for(feature, id, guid)
+      indicators = indicators_for(feature, actor_identifier(feature, id, guid))
       # This actor isn't described in enough detail to form indicators
       return false unless indicators
 
@@ -86,30 +95,53 @@ module Determinator
       return true unless feature.experiment?
 
       variant_for(feature, indicators.variant)
+
+    rescue ArgumentError
+      raise
+
+    rescue => e
+      Determinator.notice_error(e)
+      false
     end
 
     def choose_target_group(feature, properties)
-      # Keys must be strings
-      normalised_properties = properties.each_with_object({}) do |(k, v), h|
-        h[k.to_s] = v
+      # Keys and values must be strings
+      normalised_properties = properties.each_with_object({}) do |(name, values), hash|
+        hash[name.to_s] = [*values].map(&:to_s)
       end
 
       feature.target_groups.select { |tg|
+        next false unless tg.rollout.between?(1, 65_536)
+
         tg.constraints.reduce(true) do |fit, (scope, *required)|
-          present = [*normalised_properties[scope.to_s]]
+          present = [*normalised_properties[scope]]
           fit && (required.flatten & present.flatten).any?
         end
       # Must choose target group deterministically, if more than one match
       }.sort_by { |tg| tg.rollout }.last
     end
 
-    def indicators_for(feature, id, guid)
-      # If we're slicing by guid then we never pay attention to id
-      actor_identifier = case feature.bucket_type
-                         when :id       then id
-                         when :guid     then guid
-                         when :fallback then id || guid
-                         end
+    def actor_identifier(feature, id, guid)
+      case feature.bucket_type
+      when :id
+        id
+      when :guid
+        return guid if guid.to_s != ''
+
+        raise ArgumentError, 'A GUID must always be given for GUID bucketed features'
+      when :fallback
+        identifier = (id || guid).to_s
+        return identifier if identifier != ''
+
+        raise ArgumentError, 'An ID or GUID must always be given for Fallback bucketed features'
+      when :single
+        'all'
+      else
+        Determinator.notice_error "Cannot process the '#{feature.bucket_type}' bucket type found in #{feature.name}"
+      end
+    end
+
+    def indicators_for(feature, actor_identifier)
       # No identified means not enough info was given by the caller
       # to determine an outcome for this feature
       return unless actor_identifier
@@ -132,12 +164,12 @@ module Determinator
       variant_weight_total = feature.variants.values.reduce(:+)
       scale_factor = 65_535 / variant_weight_total.to_f
 
+      sorted_variants = feature.variants.keys.sort
       # Find the variant the indicator sits within
-      previous_upper_bound = 0
-      feature.variants.each do |name, weight|
-        new_upper_bound = previous_upper_bound + scale_factor * weight
-        return name if indicator <= new_upper_bound
-        previous_upper_bound = new_upper_bound
+      upper_bound = 0
+      sorted_variants.each do |variant_name|
+        upper_bound = upper_bound + scale_factor * feature.variants[variant_name]
+        return variant_name if indicator <= upper_bound
       end
 
       raise ArgumentError, "A variant should have been found by this point, there is a bug in the code."

data/lib/determinator/feature.rb

@@ -5,21 +5,20 @@ module Determinator
   class Feature
     attr_reader :name, :identifier, :bucket_type, :variants, :target_groups, :active, :winning_variant
 
-    BUCKET_TYPES = %i(id guid fallback)
-
     def initialize(name:, identifier:, bucket_type:, target_groups:, variants: {}, overrides: {}, active: false, winning_variant: nil)
       @name = name.to_s
-      @identifier = identifier.to_s
+      @identifier = (identifier || name).to_s
       @variants = variants
-      @target_groups = target_groups
-      @winning_variant = winning_variant
+      @target_groups = parse_target_groups(target_groups)
+      @winning_variant = parse_outcome(winning_variant, allow_exclusion: false)
       @active = active
-
       @bucket_type = bucket_type.to_sym
-      raise ArgumentError, "Unknown bucket type: #{bucket_type}" unless BUCKET_TYPES.include?(@bucket_type)
 
       # To prevent confusion between actor id data types
-      @overrides = Hash[overrides.map { |k, v| [k.to_s, v] }]
+      @overrides = overrides.each_with_object({}) do |(identifier, outcome), hash|
+        parsed = parse_outcome(outcome, allow_exclusion: true)
+        hash[identifier.to_s] = parsed unless parsed.nil?
+      end
     end
 
     def active?
@@ -47,8 +46,40 @@ module Determinator
       overrides[id.to_s]
     end
 
+    # Validates the given outcome for this feature.
+    def parse_outcome(outcome, allow_exclusion:)
+      valid_outcomes = experiment? ? variants.keys : [true]
+      valid_outcomes << false if allow_exclusion
+      valid_outcomes.include?(outcome) ? outcome : nil
+    end
+
+    def ==(other)
+      Marshal.dump(self) == Marshal.dump(other)
+    end
+
     private
 
     attr_reader :overrides
+
+    def parse_target_groups(target_groups)
+      target_groups.map(&method(:parse_target_group)).compact
+    end
+
+    def parse_target_group(target_group)
+      return target_group if target_group.is_a? TargetGroup
+
+      constraints = target_group['constraints'].to_h
+
+      TargetGroup.new(
+        rollout: target_group['rollout'].to_i,
+        constraints: constraints.each_with_object({}) do |(key, value), hash|
+          hash[key.to_s] = [*value].map(&:to_s)
+        end
+      )
+
+    # Invalid target groups are ignored
+    rescue
+      nil
+    end
   end
 end

data/lib/determinator/retrieve/file.rb

@@ -0,0 +1,24 @@
+require 'pathname'
+
+module Determinator
+  module Retrieve
+    # A class which loads features from files within the initialized folder
+    class File
+      # @param :root [String,Pathname] The path to be used as the root to look in
+      # @param :serializer [#load] A serializer which will take the string of the read file and return a Feature object.
+      def initialize(root:, serializer: Determinator::Serializers::JSON )
+        @root = Pathname.new(root)
+        @serializer = serializer
+      end
+
+      def retrieve(feature_id)
+        feature = @root.join(feature_id)
+        return unless feature.exist?
+        @serializer.load(feature.read)
+      rescue => e
+        Determinator.notice_error(e)
+        nil
+      end
+    end
+  end
+end

data/lib/determinator/retrieve/routemaster.rb

@@ -1,7 +1,7 @@
 require 'uri'
 require 'routemaster/drain/caching'
 require 'routemaster/responses/hateoas_response'
-require 'determinator/retrieve/null_cache'
+require 'determinator/serializers/json'
 
 module Determinator
   module Retrieve
@@ -18,21 +18,18 @@ module Determinator
       CALLBACK_PATH = (URI.parse(ENV['ROUTEMASTER_CALLBACK_URL']).path rescue '/events').freeze
 
       # @param :discovery_url [String] The bootstrap URL of the instance of Florence which defines Features.
-      def initialize(discovery_url:, retrieval_cache: NullCache.new)
+      def initialize(discovery_url:)
         client = ::Routemaster::APIClient.new(
           response_class: ::Routemaster::Responses::HateoasResponse
         )
-        @retrieval_cache = retrieval_cache
         @actor_service = client.discover(discovery_url)
-
       end
 
       # Retrieves and processes the feature that goes by the given name on this retrieval mechanism.
       # @return [Determinator::Feature,nil] The details of the specified feature
       def retrieve(name)
-        cached_feature_lookup(name) do
-          @actor_service.feature.show(name)
-        end
+        obj = @actor_service.feature.show(name)
+        Determinator::Serializers::JSON.load(obj.body.to_hash)
       rescue ::Routemaster::Errors::ResourceNotFound
         # Don't be noisy
         nil
@@ -51,68 +48,6 @@ module Determinator
       def routemaster_app
         @routemaster_app ||= ::Routemaster::Drain::Caching.new
       end
-
-      def self.lookup_cache_key(feature_name)
-        "determinator_cache:#{feature_name}"
-      end
-
-      private
-
-      def cached_feature_lookup(feature_name)
-        build_feature_from_api_response(
-          @retrieval_cache.fetch(self.class.lookup_cache_key(feature_name)){ yield }
-        )
-      end
-
-      def build_feature_from_api_response(obj)
-        Feature.new(
-          name:          obj.body.name,
-          identifier:    obj.body.identifier,
-          bucket_type:   obj.body.bucket_type,
-          active:        obj.body.active,
-          target_groups: target_groups_attribute(obj.body.target_groups),
-          variants:      obj.body.variants.to_h,
-          overrides:     overrides_attribute(obj.body.overrides),
-          winning_variant: obj.body.winning_variant,
-        )
-      end
-
-      def target_groups_attribute(target_groups)
-        target_groups.map do |tg|
-          TargetGroup.new(
-            rollout: tg.rollout,
-            constraints: constraints_attribute(tg.constraints)
-          )
-        end
-      end
-
-      def constraints_attribute(constraints)
-        # TODO when FLO-3 closed: no need for legacy guard
-        return legacy_constraints_attribute(constraints) unless constraints.respond_to?(:each_pair)
-        constraints
-      end
-
-      def legacy_constraints_attribute(constraints)
-        constraints.each_with_object({}) do |constraint, h|
-          if h[constraint.scope]
-            h[constraint.scope] = [*h[constraint.scope], constraint.identifier]
-          else
-            h[constraint.scope] = constraint.identifier
-          end
-        end
-      end
-
-      def overrides_attribute(overrides)
-        # TODO when FLO-3 closed: no need for legacy guard
-        return legacy_overrides_attribute(overrides) unless overrides.respond_to?(:each_pair)
-        overrides
-      end
-
-      def legacy_overrides_attribute(overrides)
-        overrides.each_with_object({}) do |override, h|
-          h[override[:user_id]] = override[:variant]
-        end
-      end
     end
   end
 end

data/lib/determinator/serializers/json.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+module Determinator
+  module Serializers
+    module JSON
+      class << self
+        def dump(feature)
+          raise NotImplementedError
+        end
+
+        def load(string_or_hash)
+          obj = string_or_hash.is_a?(Hash) ? string_or_hash : ::JSON.parse(string_or_hash)
+
+          Determinator::Feature.new(
+            name:            obj['name'],
+            identifier:      obj['identifier'],
+            bucket_type:     obj['bucket_type'],
+            active:          (obj['active'] === true),
+            target_groups:   obj['target_groups'],
+            variants:        obj['variants'].to_h,
+            overrides:       obj['overrides'].to_h,
+            winning_variant: obj['winning_variant'].to_s,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/determinator/version.rb

@@ -1,3 +1,3 @@
 module Determinator
-  VERSION = '0.12.1'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: determinator
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 1.0.0
 platform: ruby
 authors:
 - JP Hastings-Spital
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-01 00:00:00.000000000 Z
+date: 2018-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: routemaster-drain
@@ -130,6 +130,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitmodules"
 - ".rspec"
 - ".travis.yml"
 - CHANGELOG.md
@@ -178,11 +179,13 @@ files:
 - examples/determinator-rails/public/robots.txt
 - lib/determinator.rb
 - lib/determinator/actor_control.rb
+- lib/determinator/cache/fetch_wrapper.rb
 - lib/determinator/control.rb
 - lib/determinator/feature.rb
-- lib/determinator/retrieve/null_cache.rb
+- lib/determinator/retrieve/file.rb
 - lib/determinator/retrieve/null_retriever.rb
 - lib/determinator/retrieve/routemaster.rb
+- lib/determinator/serializers/json.rb
 - lib/determinator/target_group.rb
 - lib/determinator/version.rb
 - lib/rspec/determinator.rb

data/lib/determinator/retrieve/null_cache.rb

@@ -1,5 +0,0 @@
-class NullCache
-  def fetch(name)
-    yield
-  end
-end