splitclient-rb 6.2.0 → 6.3.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b65188c13bdff2ab3b11f0f313ace352a3eac9c9c82df2876b577f879eede39
-  data.tar.gz: 1dac618f445a50911325d12e2cef429acb0b2b47f556e8ec8a2a79cc1a86f989
+  metadata.gz: 5b5098cf06d8181cb623522e84629c6df7cc454f7b9a636ec4f872935f73675a
+  data.tar.gz: 835d12570cfc5d16a227a8f39279ed71c874c0361cdb1bc4ee07979d168d3aa8
 SHA512:
-  metadata.gz: 92cf25d901ecdab6e5d2f4cdc202a34b04afcfa14e3ab3215303be6d1903fc9c0d597285fa6f54e8fa4cdbfb3f4260d26e54bad5ae3923855d02b5ce18acbb9e
-  data.tar.gz: 2ed3da2f6670579608805480ff0267b7a918945dae8a835df8866869280c41586928f22ea34e3b88fa12030587ed472c98d0e722eddb41835ea998f50b477577
+  metadata.gz: 357ab23aa02a12191044afc3069000dd41d3c67e36ccb62417c6aef8a9e87baf08573ba82a96068e5b5270f138801cfab2e61ccb2a781d0a40e815a31babf642
+  data.tar.gz: f607e6c9b7e8484f86f1b1f6af36f3dd0cff3bb4edba5fdcda6de6f6a6b67452c8894938065c8d8f12025833eee72793f568a544de42da547f84133717494422

data/CHANGES.txt

@@ -1,3 +1,12 @@
+6.3.0 (Apr 22, 2019)
+
+- Added Dynamic Configurations support through two new methods that mimick the regular ones, changing the type of what is returned.
+  - get_treatment_with_config: Same as get_treatment but returning the treatment with it's config.
+  - get_treatments_with_config: Same as get_treatments, but instead of a map of string it returns a map of treatments with config.
+- Added configs to SplitViews returned by the manager module.
+- Updated localhost mode. Now besides supporting the old text files with `.split` extension (to be deprecated soon), we support YAML (.yaml/.yml) files where you can
+  define configurations for your treatments and also whitelisted keys. Read more in our docs!
+
 6.2.0 (Mar 7th, 2019)
 - Reworked SplitClient#destroy to ensure events, impressions and metrics are sent to Split backend when called
 - Ensured destroy is called when keyboard interrupts are sent to the application

data/NEWS

@@ -1,3 +1,12 @@
+6.3.0 (Apr 22, 2019)
+
+- Added Dynamic Configurations support through two new methods that mimick the regular ones, changing the type of what is returned.
+  - get_treatment_with_config: Same as get_treatment but returning the treatment with it's config.
+  - get_treatments_with_config: Same as get_treatments, but instead of a map of string it returns a map of treatments with config.
+- Added configs to SplitViews returned by the manager module.
+- Updated localhost mode. Now besides supporting the old text files with `.split` extension (to be deprecated soon), we support YAML (.yaml/.yml) files where you can
+  define configurations for your treatments and also whitelisted keys. Read more in our docs!
+  
 6.2.0
 Ensure SDK flushes information to Split servers on client destroy
 Fix for compatibility issue between Faraday < 0.13 and net-http-persistent 3

data/lib/splitclient-rb/clients/localhost_split_client.rb

@@ -27,31 +27,56 @@ module SplitIoClient
       'ruby-'+SplitIoClient::VERSION
     end
 
+    #
+    # obtains the treatments and configs for a given set of features
+    #
+    # @param key [string] evaluation key, only used with yaml split files
+    # @param split_names [array] name of the features being validated
+    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
+    #
+    # @return [hash] map of treatments (split_name, treatment)
+    def get_treatments_with_config(key, split_names, attributes = nil)
+      get_localhost_treatments(key, split_names, attributes, 'get_treatments_with_config')
+    end
+
+    #
+    # obtains the treatments for a given set of features
+    #
+    # @param key [string] evaluation key, only used with yaml split files
+    # @param split_names [array] name of the features being validated
+    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
+    #
+    # @return [hash] map of treatments (split_name, treatment_name)
     def get_treatments(key, split_names, attributes = nil)
-      split_names.each_with_object({}) do |name, memo|
-        memo.merge!(name => get_treatment(key, name, attributes))
-      end
+      treatments = get_localhost_treatments(key, split_names, attributes)
+      return treatments if treatments.nil?
+      keys = treatments.keys
+      treats = treatments.map { |_,t| t[:treatment]  }
+      Hash[keys.zip(treats)]
     end
 
     #
     # obtains the treatment for a given feature
     #
-    # @param id [string] user id
-    # @param feature [string] name of the feature that is being validated
+    # @param key [string] evaluation key, only used with yaml split files
+    # @param split_name [string] name of the feature that is being validated
+    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
     #
-    # @return [Treatment]  treatment constant value
-    def get_treatment(id, feature, attributes = nil)
-      unless id
-        SplitIoClient.configuration.logger.warn('id was null for feature: ' + feature)
-        return SplitIoClient::Engine::Models::Treatment::CONTROL
-      end
-
-      unless feature
-        SplitIoClient.configuration.logger.warn('feature was null for id: ' + id)
-        return SplitIoClient::Engine::Models::Treatment::CONTROL
-      end
+    # @return [string] corresponding treatment
+    def get_treatment(key, split_name, attributes = nil)
+      get_localhost_treatment(key, split_name, attributes)[:treatment]
+    end
 
-      result = get_localhost_treatment(feature)
+    #
+    # obtains the treatment and config for a given feature
+    #
+    # @param key [string] evaluation key, only used with yaml split files
+    # @param split_name [string] name of the feature that is being validated
+    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
+    #
+    # @return [hash]  corresponding treatment and config
+    def get_treatment_with_config(key, split_name, attributes = nil)
+      get_localhost_treatment(key, split_name, attributes, 'get_treatment_with_config')
     end
 
     def track
@@ -59,17 +84,6 @@ module SplitIoClient
 
     private
 
-    #
-    # auxiliary method to get the treatments avoding exceptions
-    #
-    # @param id [string] user id
-    # @param feature [string] name of the feature that is being validated
-    #
-    # @return [Treatment]  tretment constant value
-    def get_treatment_without_exception_handling(id, feature, attributes = nil)
-      get_treatment(id, feature, attributes)
-    end
-
     #
     # method to check if the sdk is running in localhost mode based on api key
     #
@@ -78,14 +92,92 @@ module SplitIoClient
       true
     end
 
+    # @param key [string] evaluation key, only used with yaml split files
+    # @param split_name [string] name of the feature that is being validated
     #
-    # method to check the treatment for the given feature in localhost mode
-    #
-    # @return [boolean] true if the feature is available in localhost mode, false otherwise
-    def get_localhost_treatment(feature)
-      treatment = @localhost_mode_features.select { |h| h[:feature] == feature }.last || {}
+    # @return [Hash] corresponding treatment and config, control otherwise
+    def get_localhost_treatment(key, split_name, attributes, calling_method = 'get_treatment')
+      control_treatment = { label: Engine::Models::Label::EXCEPTION, treatment: SplitIoClient::Engine::Models::Treatment::CONTROL, config: nil }
+      parsed_control_treatment = parsed_treatment(control_treatment)
+
+      bucketing_key, matching_key = keys_from_key(key)
+      return parsed_control_treatment unless SplitIoClient::Validators.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
+
+      sanitized_split_name = split_name.to_s.strip
 
-      treatment[:treatment] || SplitIoClient::Engine::Models::Treatment::CONTROL
+      if split_name.to_s != sanitized_split_name
+        SplitIoClient.configuration.logger.warn("get_treatment: split_name #{split_name} has extra whitespace, trimming")
+        split_name = sanitized_split_name
+      end
+
+      treatment = @localhost_mode_features.select { |h| h[:feature] == split_name && has_key(h[:keys], key) }.last
+
+      if treatment.nil?
+        treatment = @localhost_mode_features.select { |h| h[:feature] == split_name && h[:keys] == nil }.last
+      end
+
+      if treatment && treatment[:treatment]
+        {
+          treatment: treatment[:treatment],
+          config: treatment[:config]
+        }
+      else
+        parsed_control_treatment
+      end
+    end
+
+    def get_localhost_treatments(key, split_names, attributes = nil, calling_method = 'get_treatments')
+      return nil unless SplitIoClient::Validators.valid_get_treatments_parameters(calling_method, split_names)
+
+      sanitized_split_names = sanitize_split_names(calling_method, split_names)
+
+      if sanitized_split_names.empty?
+        SplitIoClient.configuration.logger.error("#{calling_method}: split_names must be a non-empty Array")
+        return {}
+      end
+
+      split_names.each_with_object({}) do |split_name, memo|
+        memo.merge!(split_name => get_treatment_with_config(key, split_name, attributes))
+      end
+    end
+
+    def sanitize_split_names(calling_method, split_names)
+      split_names.compact.uniq.select do |split_name|
+        if (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
+          true
+        elsif split_name.is_a?(String) && split_name.empty?
+          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an empty split_name, split_name must be a non-empty String or a Symbol")
+          false
+        else
+          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an invalid split_name, split_name must be a non-empty String or a Symbol")
+          false
+        end
+      end
+    end
+
+    def parsed_treatment(treatment_data)
+      {
+        treatment: treatment_data[:treatment],
+        config: treatment_data[:config]
+      }
+    end
+
+    def has_key(keys, key)
+      case keys
+        when Array then keys.include? key
+        when String then keys == key
+      else
+        false
+      end
+    end
+
+    def keys_from_key(key)
+      case key
+      when Hash
+        key.values_at(:bucketing_key, :matching_key).map { |k| k.nil? ? nil : k }
+      else
+        [nil, key].map { |k| k.nil? ? nil : k }
+      end
     end
   end
 end

data/lib/splitclient-rb/clients/split_client.rb

@@ -18,109 +18,35 @@ module SplitIoClient
       @adapter = adapter
     end
 
-    def get_treatments(key, split_names, attributes = {})
-      return nil unless SplitIoClient::Validators.valid_get_treatments_parameters(split_names)
-
-      sanitized_split_names = sanitize_split_names(split_names)
-
-      if sanitized_split_names.empty?
-        SplitIoClient.configuration.logger.error('get_treatments: split_names must be a non-empty Array')
-        return {}
-      end
-
-      bucketing_key, matching_key = keys_from_key(key)
-      bucketing_key = bucketing_key ? bucketing_key.to_s : nil
-      matching_key = matching_key ? matching_key.to_s : nil
-
-      evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, true)
-      start = Time.now
-      treatments_labels_change_numbers =
-        @splits_repository.get_splits(sanitized_split_names).each_with_object({}) do |(name, data), memo|
-          memo.merge!(name => get_treatment(key, name, attributes, data, false, true, evaluator))
-        end
-      latency = (Time.now - start) * 1000.0
-      # Measure
-      @adapter.metrics.time('sdk.get_treatments', latency)
-
-      unless SplitIoClient.configuration.disable_impressions
-        time = (Time.now.to_f * 1000.0).to_i
-        @impressions_repository.add_bulk(
-          matching_key, bucketing_key, treatments_labels_change_numbers, time
-        )
-
-        route_impressions(sanitized_split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
-      end
-
-      split_names_keys = treatments_labels_change_numbers.keys
-      treatments = treatments_labels_change_numbers.values.map { |v| v[:treatment] }
-
-      Hash[split_names_keys.zip(treatments)]
-    end
-
-    #
-    # obtains the treatment for a given feature
-    #
-    # @param key [String/Hash] user id or hash with matching_key/bucketing_key
-    # @param split_name [String/Array] name of the feature that is being validated or array of them
-    # @param attributes [Hash] attributes to pass to the treatment class
-    # @param split_data [Hash] split data, when provided this method doesn't fetch splits_repository for the data
-    # @param store_impressions [Boolean] impressions aren't stored if this flag is false
-    # @param multiple [Hash] internal flag to signal if method is called by get_treatments
-    # @param evaluator [Evaluator] Evaluator class instance, used to cache treatments
-    #
-    # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
     def get_treatment(
         key, split_name, attributes = {}, split_data = nil, store_impressions = true,
         multiple = false, evaluator = nil
       )
-
-      control_treatment = { label: Engine::Models::Label::EXCEPTION, treatment: SplitIoClient::Engine::Models::Treatment::CONTROL }
-      parsed_control_treatment = parsed_treatment(multiple, control_treatment)
-
-      bucketing_key, matching_key = keys_from_key(key)
-
-      return parsed_control_treatment unless valid_client && SplitIoClient::Validators.valid_get_treatment_parameters(key, split_name, matching_key, bucketing_key, attributes)
-
-      bucketing_key = bucketing_key ? bucketing_key.to_s : nil
-      matching_key = matching_key.to_s
-      sanitized_split_name = split_name.to_s.strip
-
-      if split_name.to_s != sanitized_split_name
-        SplitIoClient.configuration.logger.warn("get_treatment: split_name #{split_name} has extra whitespace, trimming")
-        split_name = sanitized_split_name
+      treatment = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator)
+      if multiple
+         treatment.tap { |t| t.delete(:config) }
+      else
+        treatment[:treatment]
       end
+    end
 
-      evaluator ||= Engine::Parser::Evaluator.new(@segments_repository, @splits_repository)
-
-      begin
-        start = Time.now
-
-        split = multiple ? split_data : @splits_repository.get_split(split_name)
-
-        if split.nil?
-          SplitIoClient.configuration.logger.warn("split_name: #{split_name} does not exist. Returning CONTROL")
-          return parsed_control_treatment
-        end
-
-        treatment_data =
-          evaluator.call(
-          { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
-        )
-
-        latency = (Time.now - start) * 1000.0
-        store_impression(split_name, matching_key, bucketing_key, treatment_data, store_impressions, attributes)
-
-        # Measure
-        @adapter.metrics.time('sdk.get_treatment', latency) unless multiple
-      rescue StandardError => error
-        SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
-
-        store_impression(split_name, matching_key, bucketing_key, control_treatment, store_impressions, attributes)
+    def get_treatment_with_config(
+        key, split_name, attributes = {}, split_data = nil, store_impressions = true,
+        multiple = false, evaluator = nil
+      )
+      treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, 'get_treatment_with_config')
+    end
 
-        return parsed_control_treatment
-      end
+    def get_treatments(key, split_names, attributes = {})
+      treatments = treatments(key, split_names, attributes)
+      return treatments if treatments.nil?
+      keys = treatments.keys
+      treats = treatments.map { |_,t| t[:treatment]  }
+      Hash[keys.zip(treats)]
+    end
 
-      parsed_treatment(multiple, treatment_data)
+    def get_treatments_with_config(key, split_names, attributes = {})
+      treatments(key, split_names, attributes,'get_treatments_with_config')
     end
 
     def destroy
@@ -198,8 +124,8 @@ module SplitIoClient
     end
 
     def keys_from_key(key)
-      case key.class.to_s
-      when 'Hash'
+      case key
+      when Hash
         key.values_at(:bucketing_key, :matching_key).map { |k| k.nil? ? nil : k }
       else
         [nil, key].map { |k| k.nil? ? nil : k }
@@ -208,25 +134,29 @@ module SplitIoClient
 
     def parsed_treatment(multiple, treatment_data)
       if multiple
+      {
+        treatment: treatment_data[:treatment],
+        label: treatment_data[:label],
+        change_number: treatment_data[:change_number],
+        config: treatment_data[:config]
+      }
+      else
         {
           treatment: treatment_data[:treatment],
-          label: treatment_data[:label],
-          change_number: treatment_data[:change_number]
+          config: treatment_data[:config]
         }
-      else
-        treatment_data[:treatment]
       end
     end
 
-    def sanitize_split_names(split_names)
+    def sanitize_split_names(calling_method, split_names)
       split_names.compact.uniq.select do |split_name|
         if (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
           true
         elsif split_name.is_a?(String) && split_name.empty?
-          SplitIoClient.configuration.logger.warn('get_treatments: you passed an empty split_name, split_name must be a non-empty String or a Symbol')
+          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an empty split_name, split_name must be a non-empty String or a Symbol")
           false
         else
-          SplitIoClient.configuration.logger.warn('get_treatments: you passed an invalid split_name, split_name must be a non-empty String or a Symbol')
+          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an invalid split_name, split_name must be a non-empty String or a Symbol")
           false
         end
       end
@@ -241,5 +171,113 @@ module SplitIoClient
       end
       SplitIoClient.configuration.valid_mode
     end
+
+    def treatments(key, split_names, attributes = {}, calling_method = 'get_treatments')
+      return nil unless SplitIoClient::Validators.valid_get_treatments_parameters(calling_method, split_names)
+
+      sanitized_split_names = sanitize_split_names(calling_method, split_names)
+
+      if sanitized_split_names.empty?
+        SplitIoClient.configuration.logger.error("#{calling_method}: split_names must be a non-empty Array")
+        return {}
+      end
+
+      bucketing_key, matching_key = keys_from_key(key)
+      bucketing_key = bucketing_key ? bucketing_key.to_s : nil
+      matching_key = matching_key ? matching_key.to_s : nil
+
+      evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, true)
+      start = Time.now
+      treatments_labels_change_numbers =
+        @splits_repository.get_splits(sanitized_split_names).each_with_object({}) do |(name, data), memo|
+          memo.merge!(name => treatment(key, name, attributes, data, false, true, evaluator))
+        end
+      latency = (Time.now - start) * 1000.0
+      # Measure
+      @adapter.metrics.time('sdk.' + calling_method, latency)
+
+      unless SplitIoClient.configuration.disable_impressions
+        time = (Time.now.to_f * 1000.0).to_i
+        @impressions_repository.add_bulk(
+          matching_key, bucketing_key, treatments_labels_change_numbers, time
+        )
+
+        route_impressions(sanitized_split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
+      end
+
+      split_names_keys = treatments_labels_change_numbers.keys
+      treatments = treatments_labels_change_numbers.values.map do |v|
+        {
+          treatment: v[:treatment],
+          config: v[:config]
+        }
+      end
+      Hash[split_names_keys.zip(treatments)]
+    end
+
+    #
+    # obtains the treatment for a given feature
+    #
+    # @param key [String/Hash] user id or hash with matching_key/bucketing_key
+    # @param split_name [String/Array] name of the feature that is being validated or array of them
+    # @param attributes [Hash] attributes to pass to the treatment class
+    # @param split_data [Hash] split data, when provided this method doesn't fetch splits_repository for the data
+    # @param store_impressions [Boolean] impressions aren't stored if this flag is false
+    # @param multiple [Hash] internal flag to signal if method is called by get_treatments
+    # @param evaluator [Evaluator] Evaluator class instance, used to cache treatments
+    #
+    # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
+    def treatment(
+        key, split_name, attributes = {}, split_data = nil, store_impressions = true,
+        multiple = false, evaluator = nil, calling_method = 'get_treatment'
+      )
+      control_treatment = { label: Engine::Models::Label::EXCEPTION, treatment: SplitIoClient::Engine::Models::Treatment::CONTROL, config: nil }
+      parsed_control_treatment = parsed_treatment(multiple, control_treatment)
+
+      bucketing_key, matching_key = keys_from_key(key)
+
+      return parsed_control_treatment unless valid_client && SplitIoClient::Validators.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
+
+      bucketing_key = bucketing_key ? bucketing_key.to_s : nil
+      matching_key = matching_key.to_s
+      sanitized_split_name = split_name.to_s.strip
+
+      if split_name.to_s != sanitized_split_name
+        SplitIoClient.configuration.logger.warn("#{calling_method}: split_name #{split_name} has extra whitespace, trimming")
+        split_name = sanitized_split_name
+      end
+
+      evaluator ||= Engine::Parser::Evaluator.new(@segments_repository, @splits_repository)
+
+      begin
+        start = Time.now
+
+        split = multiple ? split_data : @splits_repository.get_split(split_name)
+
+        if split.nil?
+          SplitIoClient.configuration.logger.warn("split_name: #{split_name} does not exist. Returning CONTROL")
+          return parsed_control_treatment
+        end
+
+        treatment_data =
+          evaluator.call(
+          { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
+        )
+
+        latency = (Time.now - start) * 1000.0
+        store_impression(split_name, matching_key, bucketing_key, treatment_data, store_impressions, attributes)
+
+        # Measure
+        @adapter.metrics.time('sdk.' + calling_method, latency) unless multiple
+      rescue StandardError => error
+        SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+
+        store_impression(split_name, matching_key, bucketing_key, control_treatment, store_impressions, attributes)
+
+        return parsed_control_treatment
+      end
+
+      parsed_treatment(multiple, treatment_data)
+    end
   end
 end

data/lib/splitclient-rb/engine/api/client.rb

@@ -18,7 +18,7 @@ module SplitIoClient
         end
       rescue StandardError => e
         SplitIoClient.configuration.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
-        raise 'Split SDK failed to connect to backend to retrieve information'
+        raise e, 'Split SDK failed to connect to backend to retrieve information', e.backtrace
       end
 
       def post_api(url, api_key, data, headers = {}, params = {})
@@ -37,7 +37,7 @@ module SplitIoClient
         end
       rescue StandardError => e
         SplitIoClient.configuration.logger.warn("#{e}\nURL:#{url}\ndata:#{data}\nparams:#{params}")
-        raise 'Split SDK failed to connect to backend to post information'
+        raise e, 'Split SDK failed to connect to backend to post information', e.backtrace
       end
 
       private

data/lib/splitclient-rb/engine/parser/evaluator.rb

@@ -26,7 +26,7 @@ module SplitIoClient
               match(split, keys, attributes)
             end
           else
-            treatment_hash(Models::Label::KILLED, split[:defaultTreatment], split[:changeNumber])
+            treatment_hash(Models::Label::KILLED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
           end
 
           @cache[digest] = treatment if cache_result
@@ -36,6 +36,11 @@ module SplitIoClient
 
         private
 
+        def split_configurations(treatment, split)
+          return nil if split[:configurations].nil?
+          split[:configurations][treatment.to_sym]
+        end
+
         def match(split, keys, attributes)
           in_rollout = false
           key = keys[:bucketing_key] ? keys[:bucketing_key] : keys[:matching_key]
@@ -52,7 +57,7 @@ module SplitIoClient
                 bucket = splitter.bucket(splitter.count_hash(key, split[:trafficAllocationSeed].to_i, legacy_algo))
 
                 if bucket > split[:trafficAllocation]
-                  return treatment_hash(Models::Label::NOT_IN_SPLIT, split[:defaultTreatment], split[:changeNumber])
+                  return treatment_hash(Models::Label::NOT_IN_SPLIT, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
                 end
               end
 
@@ -71,13 +76,13 @@ module SplitIoClient
             result = splitter.get_treatment(key, split[:seed], condition.partitions, split[:algo])
 
             if result.nil?
-              return treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber])
+              return treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
             else
-              return treatment_hash(c[:label], result, split[:changeNumber])
+              return treatment_hash(c[:label], result, split[:changeNumber],split_configurations(result, split))
             end
           end
 
-          treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber])
+          treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
         end
 
         def matcher_type(condition)
@@ -102,8 +107,8 @@ module SplitIoClient
           end
         end
 
-        def treatment_hash(label, treatment, change_number = nil)
-          { label: label, treatment: treatment, change_number: change_number }
+        def treatment_hash(label, treatment, change_number = nil, configurations = nil)
+          { label: label, treatment: treatment, change_number: change_number, config: configurations }
         end
 
         def matcher_instance(type, condition, matcher)

data/lib/splitclient-rb/localhost_split_factory.rb

@@ -2,7 +2,7 @@ module SplitIoClient
   class LocalhostSplitFactory
     attr_reader :client, :manager
 
-    def initialize(splits_file, reload_rate = nil)
+    def initialize(splits_file, reload_rate = nil, logger = nil)
       @splits_file = splits_file
       @reload_rate = reload_rate
 

data/lib/splitclient-rb/localhost_utils.rb

@@ -1,5 +1,7 @@
 module SplitIoClient
   module LocalhostUtils
+
+    require 'yaml'
     #
     # method to set localhost mode features by reading the given .splits
     #
@@ -24,12 +26,33 @@ module SplitIoClient
     end
 
     def store_features(splits_file)
+      yaml_extensions = [".yml", ".yaml"]
+      if yaml_extensions.include? File.extname(splits_file)
+        store_yaml_features(splits_file)
+      else
+        store_plain_text_features(splits_file)
+      end
+    end
+
+    private
+
+    def store_plain_text_features(splits_file)
       File.open(splits_file).each do |line|
         feature, treatment = line.strip.split(' ')
 
         next if line.start_with?('#') || line.strip.empty?
 
-        @localhost_mode_features << { feature: feature, treatment: treatment }
+        @localhost_mode_features << { feature: feature, treatment: treatment, key: nil, config: nil }
+      end
+    end
+
+    def store_yaml_features(splits_file)
+      YAML.load(File.read(splits_file)).each do |feature|
+        feat_symbolized_keys = feature[feature.keys.first].inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+        feat_symbolized_keys[:config] = feat_symbolized_keys[:config].to_json
+
+        @localhost_mode_features << { feature: feature.keys.first }.merge(feat_symbolized_keys)
       end
     end
   end

data/lib/splitclient-rb/managers/localhost_split_manager.rb

@@ -21,15 +21,32 @@ module SplitIoClient
     #
     # @returns a split view
     def split(split_name)
-      @localhost_mode_features.find { |x| x[:feature] == split_name }
+      features = @localhost_mode_features.find_all { |feat| feat[:feature] == split_name }
+
+      return nil if features.nil?
+
+      treatments = features.map { |feat| feat[:treatment] }
+
+      configs = Hash[ features.map { |feat| [ feat[:treatment].to_sym, feat[:config] ] } ]
+
+      {
+        change_number: nil,
+        killed:       false,
+        name:         split_name,
+        traffic_type:  nil,
+        treatments:   treatments,
+        configs: configs
+      }
     end
 
     #
     # method to get the split list from the client
     #
-    # @returns [object] array of splits
+    # @returns Array of split view
     def splits
-      @localhost_mode_features
+      split_names.map do |split_name|
+        split(split_name)
+      end
     end
 
     #
@@ -37,9 +54,7 @@ module SplitIoClient
     #
     # @returns [object] array of split names (String)
     def split_names
-      @localhost_mode_features.each_with_object([]) do |split, memo|
-        memo << split[:feature]
-      end
+      @localhost_mode_features.map{ |feat| feat[:feature]}.uniq
     end
   end
 end

data/lib/splitclient-rb/managers/split_manager.rb

@@ -75,7 +75,8 @@ module SplitIoClient
           traffic_type_name: split[:trafficTypeName],
           killed: split[:killed],
           treatments: treatments,
-          change_number: split[:changeNumber]
+          change_number: split[:changeNumber],
+          configs: split[:configurations] || {}
         }
     end
   end

data/lib/splitclient-rb/split_factory_builder.rb

@@ -5,12 +5,24 @@ module SplitIoClient
     def self.build(api_key, config = {})
       case api_key
       when 'localhost'
-        splits_file = config[:path]? config[:path] : File.join(Dir.home, '.split')
+        SplitIoClient.configure( { logger: config[:logger] } )
 
-        LocalhostSplitFactory.new(splits_file, config[:reload_rate])
+        LocalhostSplitFactory.new(split_file(config[:split_file]), config[:reload_rate])
       else
         SplitFactory.new(api_key, config)
       end
     end
+
+    private
+
+    def self.split_file(split_file_path)
+      return split_file_path unless split_file_path.nil?
+
+      SplitIoClient.configuration.logger.warn('Localhost mode: .split mocks ' \
+        'will be deprecated soon in favor of YAML files, which provide more ' \
+        'targeting power. Take a look in our documentation.')
+
+      File.join(Dir.home, '.split')
+    end
   end
 end

data/lib/splitclient-rb/validators.rb

@@ -4,16 +4,16 @@ module SplitIoClient
   module Validators
     extend self
 
-    def valid_get_treatment_parameters(key, split_name, matching_key, bucketing_key, attributes)
-      valid_key?(key) &&
-        valid_split_name?(split_name) &&
-        valid_matching_key?(matching_key) &&
-        valid_bucketing_key?(key, bucketing_key) &&
-        valid_attributes?(attributes)
+    def valid_get_treatment_parameters(method, key, split_name, matching_key, bucketing_key, attributes)
+      valid_key?(method, key) &&
+        valid_split_name?(method, split_name) &&
+        valid_matching_key?(method, matching_key) &&
+        valid_bucketing_key?(method, key, bucketing_key) &&
+        valid_attributes?(method, attributes)
     end
 
-    def valid_get_treatments_parameters(split_names)
-      valid_split_names?(split_names)
+    def valid_get_treatments_parameters(method, split_names)
+      valid_split_names?(method, split_names)
     end
 
     def valid_track_parameters(key, traffic_type_name, event_type, value)
@@ -24,7 +24,7 @@ module SplitIoClient
     end
 
     def valid_split_parameters(split_name)
-      valid_split_name?(split_name, :split)
+      valid_split_name?(:split, split_name)
     end
 
     def valid_matcher_arguments(args)
@@ -68,7 +68,7 @@ module SplitIoClient
       SplitIoClient.configuration.logger.error("#{method}: #{key} is too long - must be #{SplitIoClient.configuration.max_key_size} characters or less")
     end
 
-    def valid_split_name?(split_name, method = :get_treatment)
+    def valid_split_name?(method, split_name)
       if split_name.nil?
         log_nil(:split_name, method)
         return false
@@ -87,62 +87,62 @@ module SplitIoClient
       true
     end
 
-    def valid_key?(key)
+    def valid_key?(method, key)
       if key.nil?
-        log_nil(:key, :get_treatment)
+        log_nil(:key, method)
         return false
       end
 
       true
     end
 
-    def valid_matching_key?(matching_key)
+    def valid_matching_key?(method, matching_key)
       if matching_key.nil?
-        log_nil(:matching_key, :get_treatment)
+        log_nil(:matching_key, method)
         return false
       end
 
       unless number_or_string?(matching_key)
-        log_invalid_type(:matching_key, :get_treatment)
+        log_invalid_type(:matching_key, method)
         return false
       end
 
       if empty_string?(matching_key)
-        log_empty_string(:matching_key, :get_treatment)
+        log_empty_string(:matching_key, method)
         return false
       end
 
-      log_convert_numeric(:matching_key, :get_treatment, matching_key) if matching_key.is_a? Numeric
+      log_convert_numeric(:matching_key, method, matching_key) if matching_key.is_a? Numeric
 
       if matching_key.size > SplitIoClient.configuration.max_key_size
-        log_key_too_long(:matching_key, :get_treatment)
+        log_key_too_long(:matching_key, method)
         return false
       end
 
       true
     end
 
-    def valid_bucketing_key?(key, bucketing_key)
+    def valid_bucketing_key?(method, key, bucketing_key)
       if key.is_a? Hash
         if bucketing_key.nil?
-          log_nil(:bucketing_key, :get_treatment)
+          log_nil(:bucketing_key, method)
           return false
         end
 
         unless number_or_string?(bucketing_key)
-          log_invalid_type(:bucketing_key, :get_treatment)
+          log_invalid_type(:bucketing_key, method)
           return false
         end
 
         if empty_string?(bucketing_key)
-          log_empty_string(:bucketing_key, :get_treatment)
+          log_empty_string(:bucketing_key, method)
           return false
         end
 
-        log_convert_numeric(:bucketing_key, :get_treatment, bucketing_key) if bucketing_key.is_a? Numeric
+        log_convert_numeric(:bucketing_key, method, bucketing_key) if bucketing_key.is_a? Numeric
 
         if bucketing_key.size > SplitIoClient.configuration.max_key_size
-          log_key_too_long(:bucketing_key, :get_treatment)
+          log_key_too_long(:bucketing_key, method)
           return false
         end
       end
@@ -150,18 +150,18 @@ module SplitIoClient
       true
     end
 
-    def valid_split_names?(split_names)
+    def valid_split_names?(method, split_names)
       unless !split_names.nil? && split_names.is_a?(Array)
-        SplitIoClient.configuration.logger.error('get_treatments: split_names must be a non-empty Array')
+        SplitIoClient.configuration.logger.error("#{method}: split_names must be a non-empty Array")
         return false
       end
 
       true
     end
 
-    def valid_attributes?(attributes)
+    def valid_attributes?(method, attributes)
       unless attributes.nil? || attributes.is_a?(Hash)
-        SplitIoClient.configuration.logger.error('get_treatment: attributes must be of type Hash')
+        SplitIoClient.configuration.logger.error("#{method}: attributes must be of type Hash")
         return false
       end
 

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '6.2.0'
+  VERSION = '6.3.0.pre.rc1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.3.0.pre.rc1
 platform: ruby
 authors:
 - Split Software
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-07 00:00:00.000000000 Z
+date: 2019-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allocation_stats
@@ -402,9 +402,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.7.6