Added RBS matcher

Author: chillaq

lib/splitclient-rb.rb

@@ -48,6 +48,7 @@
 require 'splitclient-rb/helpers/decryption_helper'
 require 'splitclient-rb/helpers/util'
 require 'splitclient-rb/helpers/repository_helper'
+require 'splitclient-rb/helpers/evaluator_helper'
 require 'splitclient-rb/split_factory'
 require 'splitclient-rb/split_factory_builder'
 require 'splitclient-rb/split_config'
@@ -97,6 +98,7 @@
 require 'splitclient-rb/engine/matchers/less_than_or_equal_to_semver_matcher'
 require 'splitclient-rb/engine/matchers/between_semver_matcher'
 require 'splitclient-rb/engine/matchers/in_list_semver_matcher'
+require 'splitclient-rb/engine/matchers/rule_based_segment_matcher'
 require 'splitclient-rb/engine/evaluator/splitter'
 require 'splitclient-rb/engine/impressions/noop_unique_keys_tracker'
 require 'splitclient-rb/engine/impressions/unique_keys_tracker'

lib/splitclient-rb/cache/repositories/segments_repository.rb

@@ -83,6 +83,13 @@ def segment_keys_count
           0
         end
 
+        def contains?(segment_names)
+          if segment_names.empty?
+            return false
+          end
+          return segment_names.to_set.subset?(used_segment_names.to_set)
+        end
+
         private
 
         def segment_data(name)

lib/splitclient-rb/engine/matchers/rule_based_segment_matcher.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  #
+  # class to implement the user defined matcher
+  #
+  class RuleBasedSegmentMatcher < Matcher
+    MATCHER_TYPE = 'IN_RULE_BASED_SEGMENT'
+
+    def initialize(rule_based_segments_repository, segments_repository, segment_name, config, evaluator)
+      super(config.logger)
+      @rule_based_segments_repository = rule_based_segments_repository
+      @segments_repository = segments_repository
+      @segment_name = segment_name
+      @evaluator = evaluator
+      @config = config
+    end
+
+    #
+    # evaluates if the key matches the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] evaluation of the key against the segment
+    def match?(args)
+      rule_based_segment = @rule_based_segments_repository.get_rule_based_segment(@segment_name)
+      return false if rule_based_segment.nil?
+
+      return false if rule_based_segment[:excluded][:keys].include?([args[:value]])
+
+      return false if @segments_repository.contains?(rule_based_segment[:excluded][:segments])
+
+      matches = false
+      rule_based_segment[:conditions].each do |c|
+        condition = SplitIoClient::Condition.new(c, @config)
+        next if condition.empty?
+
+        matches = Helpers::EvaluatorHelper.matcher_type(condition, @segments_repository).match?(args)
+      end
+      @logger.debug("[InRuleSegmentMatcher] #{@segment_name} is in rule based segment -> #{matches}")
+
+      matches
+    end
+  end
+end

lib/splitclient-rb/engine/parser/condition.rb

@@ -246,6 +246,8 @@ def negate
     # @return [void]
     def set_partitions
       partitions_list = []
+      return partitions_list unless @data.key?('partitions')
+      
       @data[:partitions].each do |p|
         partition = SplitIoClient::Partition.new(p)
         partitions_list << partition

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

@@ -59,7 +59,7 @@ def match(split, keys, attributes)
               in_rollout = true
             end
 
-            condition_matched = matcher_type(condition).match?(
+            condition_matched = Helpers::EvaluatorHelper::matcher_type(condition, @segments_repository).match?(
               matching_key: keys[:matching_key],
               bucketing_key: keys[:bucketing_key],
               evaluator: self,
@@ -80,38 +80,9 @@ def match(split, keys, attributes)
           treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
         end
 
-        def matcher_type(condition)
-          matchers = []
-
-          @segments_repository.adapter.pipelined do
-            condition.matchers.each do |matcher|
-              matchers << if matcher[:negate]
-                condition.negation_matcher(matcher_instance(matcher[:matcherType], condition, matcher))
-              else
-                matcher_instance(matcher[:matcherType], condition, matcher)
-              end
-            end
-          end
-
-          final_matcher = condition.create_condition_matcher(matchers)
-
-          if final_matcher.nil?
-            @logger.error('Invalid matcher type')
-          else
-            final_matcher
-          end
-        end
-
         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)
-          condition.send(
-            "matcher_#{type.downcase}",
-            matcher: matcher, segments_repository: @segments_repository
-          )
-        end
       end
     end
   end

lib/splitclient-rb/helpers/evaluator_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Helpers
+    class EvaluatorHelper
+      def self.matcher_type(condition, segments_repository)
+        matchers = []
+
+        segments_repository.adapter.pipelined do
+          condition.matchers.each do |matcher|
+            matchers << if matcher[:negate]
+                          condition.negation_matcher(matcher_instance(matcher[:matcherType], condition, matcher))
+                        else
+                          matcher_instance(matcher[:matcherType], condition, matcher, segments_repository)
+                        end
+          end
+        end
+        final_matcher = condition.create_condition_matcher(matchers)
+
+        if final_matcher.nil?
+          config.logger.error('Invalid matcher type')
+        else
+          final_matcher
+        end
+        final_matcher
+      end
+
+      def self.matcher_instance(type, condition, matcher, segments_repository)
+        condition.send(
+          "matcher_#{type.downcase}",
+          matcher: matcher, segments_repository: segments_repository
+        )
+      end
+    end
+  end
+end

spec/engine/matchers/rule_based_segment_matcher_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SplitIoClient::RuleBasedSegmentMatcher do
+  let(:config) { SplitIoClient::SplitConfig.new(debug_enabled: true) }
+  let(:segments_repository) { SplitIoClient::Cache::Repositories::SegmentsRepository.new(config) }
+  let(:flag_sets_repository) {SplitIoClient::Cache::Repositories::MemoryFlagSetsRepository.new([])}
+  let(:flag_set_filter) {SplitIoClient::Cache::Filter::FlagSetsFilter.new([])}
+  let(:splits_repository) { SplitIoClient::Cache::Repositories::SplitsRepository.new(config, flag_sets_repository, flag_set_filter) }
+  let(:evaluator) { SplitIoClient::Engine::Parser::Evaluator.new(segments_repository, splits_repository, true) }
+
+
+  context '#string_type' do
+    it 'is not string type matcher' do
+      expect(described_class.new(nil, nil, nil, config, nil).string_type?).to be false
+    end
+  end
+
+  context 'test_matcher' do
+    it 'return false if excluded key is passed' do
+      rbs_repositoy = SplitIoClient::Cache::Repositories::RuleBasedSegmentsRepository.new(config)
+      rbs_repositoy.update([{name: 'foo', trafficTypeName: 'tt_name_1', conditions: [], excluded: {keys: ['key1'], segments: []}}], [], -1)
+      matcher = described_class.new(rbs_repositoy, segments_repository, 'foo', config, nil)
+      expect(matcher.match?(value: 'key1')).to be false
+    end
+
+    it 'return false if excluded segment is passed' do
+      rbs_repositoy = SplitIoClient::Cache::Repositories::RuleBasedSegmentsRepository.new(config)
+      segments_repository.add_to_segment({:name => 'segment1', :added => [], :removed => []})
+      rbs_repositoy.update([{name: 'foo', trafficTypeName: 'tt_name_1', conditions: [], excluded: {keys: ['key1'], segments: ['segment1']}}], [], -1)
+      matcher = described_class.new(rbs_repositoy, segments_repository, 'foo', config, nil)
+      expect(matcher.match?(value: 'key2')).to be false
+    end
+
+    it 'return true if condition matches' do
+      rule_based_segment = { :name => 'corge', :trafficTypeName => 'tt_name_5', 
+      :excluded => {:keys => [], :segments => []},
+      :conditions => [
+        {
+            :contitionType => 'WHITELIST',
+            :label => 'some_label',
+            :matcherGroup => {
+                :matchers => [
+                  {
+                    :keySelector => nil,
+                    :matcherType => 'WHITELIST',
+                    :whitelistMatcherData => {
+                      :whitelist => ['k1', 'k2', 'k3']
+                    },
+                    :negate => false,
+                  }
+                ],
+                :combiner => 'AND'
+            }
+        }]
+      }
+
+      rbs_repositoy = SplitIoClient::Cache::Repositories::RuleBasedSegmentsRepository.new(config)
+      rbs_repositoy.update([rule_based_segment], [], -1)
+      matcher = described_class.new(rbs_repositoy, segments_repository, 'corge', config, evaluator)
+      expect(matcher.match?({:matching_key => 'user', :attributes => {}})).to be false
+      expect(matcher.match?({:matching_key => 'k1', :attributes => {}})).to be true
+    end
+  end
+end