updated matcher and evaluator

chillaq · chillaq · commit 80c207f165d5 · 2025-05-06T12:16:14.000-07:00
diff --git a/lib/splitclient-rb/engine/matchers/rule_based_segment_matcher.rb b/lib/splitclient-rb/engine/matchers/rule_based_segment_matcher.rb
@@ -7,12 +7,11 @@ module SplitIoClient
   class RuleBasedSegmentMatcher < Matcher
     MATCHER_TYPE = 'IN_RULE_BASED_SEGMENT'
 
-    def initialize(rule_based_segments_repository, segments_repository, segment_name, config, evaluator)
+    def initialize(segments_repository, rule_based_segments_repository, segment_name, config)
       super(config.logger)
       @rule_based_segments_repository = rule_based_segments_repository
       @segments_repository = segments_repository
       @segment_name = segment_name
-      @evaluator = evaluator
       @config = config
     end
 
@@ -28,18 +27,40 @@ def match?(args)
 
       return false if rule_based_segment[:excluded][:keys].include?([args[:value]])
 
-      return false if @segments_repository.contains?(rule_based_segment[:excluded][:segments])
+      rule_based_segment[:excluded][:segments].each do |segment|
+        return false if segment[:type] == 'standard' and @segments_repository.in_segment?(segment[:name], args[:value])
+        
+        if segment[:type] == 'rule-based'
+          return true if match_rbs(@rule_based_segments_repository.get_rule_based_segment(segment[:name])[:conditions], args)
+        end
+      end
 
       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)
+        matches = Helpers::EvaluatorHelper.matcher_type(condition, @segments_repository, @rule_based_segments_repository).match?(args)
       end
       @logger.debug("[InRuleSegmentMatcher] #{@segment_name} is in rule based segment -> #{matches}")
 
       matches
     end
+
+    private
+
+    def match_rbs(conditions, args)
+      conditions.each do |condition|
+        next if condition.empty?
+
+        return true if Helpers::EvaluatorHelper::matcher_type(SplitIoClient::Condition.new(condition, @config), 
+              @segments_repository, @rule_based_segments_repository).match?(
+                matching_key: args[:matching_key],
+                bucketing_key: args[:value],
+                attributes: args[:attributes]
+              )
+      end
+      return false
+    end
   end
 end
diff --git a/lib/splitclient-rb/engine/parser/condition.rb b/lib/splitclient-rb/engine/parser/condition.rb
@@ -230,6 +230,13 @@ def matcher_in_list_semver(params)
       )
     end
 
+    def matcher_in_rule_based_segment(params)
+      matcher = params[:matcher]
+      segment_name = matcher[:userDefinedSegmentMatcherData] && matcher[:userDefinedSegmentMatcherData][:segmentName]
+
+      RuleBasedSegmentMatcher.new(params[:segments_repository], params[:rule_based_segments_repository], segment_name, @config)
+    end
+
     #
     # @return [object] the negate value for this condition
     def negate
diff --git a/lib/splitclient-rb/engine/parser/evaluator.rb b/lib/splitclient-rb/engine/parser/evaluator.rb
@@ -2,7 +2,7 @@ module SplitIoClient
   module Engine
     module Parser
       class Evaluator
-        def initialize(segments_repository, splits_repository, config)
+        def initialize(segments_repository, splits_repository, rb_segment_repository, config)
           @splits_repository = splits_repository
           @segments_repository = segments_repository
           @config = config
@@ -59,7 +59,7 @@ def match(split, keys, attributes)
               in_rollout = true
             end
 
-            condition_matched = Helpers::EvaluatorHelper::matcher_type(condition, @segments_repository).match?(
+            condition_matched = Helpers::EvaluatorHelper::matcher_type(condition, @segments_repository, @rb_segment_repository).match?(
               matching_key: keys[:matching_key],
               bucketing_key: keys[:bucketing_key],
               evaluator: self,
diff --git a/lib/splitclient-rb/helpers/evaluator_helper.rb b/lib/splitclient-rb/helpers/evaluator_helper.rb
@@ -3,15 +3,14 @@
 module SplitIoClient
   module Helpers
     class EvaluatorHelper
-      def self.matcher_type(condition, segments_repository)
+      def self.matcher_type(condition, segments_repository, rb_segment_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)
+                          matcher_instance(matcher[:matcherType], condition, matcher, segments_repository, rb_segment_repository)
                         end
           end
         end
@@ -25,10 +24,10 @@ def self.matcher_type(condition, segments_repository)
         final_matcher
       end
 
-      def self.matcher_instance(type, condition, matcher, segments_repository)
+      def self.matcher_instance(type, condition, matcher, segments_repository, rb_segment_repository)
         condition.send(
           "matcher_#{type.downcase}",
-          matcher: matcher, segments_repository: segments_repository
+          matcher: matcher, segments_repository: segments_repository, rule_based_segments_repository: rb_segment_repository
         )
       end
     end
diff --git a/spec/engine/matchers/rule_based_segment_matcher_spec.rb b/spec/engine/matchers/rule_based_segment_matcher_spec.rb
@@ -8,31 +8,62 @@
   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
+      expect(described_class.new(nil, nil, nil, config).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)
+      matcher = described_class.new(segments_repository, rbs_repositoy, 'foo', config)
       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)
+      evaluator = SplitIoClient::Engine::Parser::Evaluator.new(segments_repository, splits_repository, rbs_repositoy, true)
       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)
+      rbs_repositoy.update([{:name => 'foo', :trafficTypeName => 'tt_name_1', :conditions => [], :excluded => {:keys => ['key1'], :segments => [{:name => 'segment1', :type => 'standard'}]}}], [], -1)
+      matcher = described_class.new(segments_repository, rbs_repositoy, 'foo', config)
       expect(matcher.match?(value: 'key2')).to be false
     end
 
+    it 'return true if excluded rb segment is matched' do
+      rbs_repositoy = SplitIoClient::Cache::Repositories::RuleBasedSegmentsRepository.new(config)
+      rbs = {:name => 'sample_rule_based_segment', :trafficTypeName => 'tt_name_1', :conditions => [], :excluded => {:keys => [], :segments => [{:name => 'no_excludes', :type => 'rule-based'}]}}
+      rbs2 = {:name => 'no_excludes', :trafficTypeName => 'tt_name_1', 
+          :conditions => [{
+              :matcherGroup => {
+                :combiner => "AND",
+                :matchers => [
+                  {
+                    :keySelector => {
+                      :trafficType  => "user",
+                      :attribute => "email"
+                    },
+                    :matcherType => "ENDS_WITH",
+                    :negate => false,
+                    :whitelistMatcherData => {
+                      :whitelist => [
+                        "@split.io"
+                      ]
+                    }
+                  }
+                ]
+              }
+            }
+          ], :excluded => {:keys => [], :segments => []}}
+
+      rbs_repositoy.update([rbs, rbs2], [], -1)
+      matcher = described_class.new(segments_repository, rbs_repositoy, 'sample_rule_based_segment', config)
+      expect(matcher.match?(value: 'bilal@split.io', attributes: {'email': 'bilal@split.io'})).to be true
+      expect(matcher.match?(value: 'bilal', attributes: {'email': 'bilal'})).to be false
+    end
+
     it 'return true if condition matches' do
       rule_based_segment = { :name => 'corge', :trafficTypeName => 'tt_name_5', 
       :excluded => {:keys => [], :segments => []},
@@ -58,9 +89,75 @@
 
       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)
+      matcher = described_class.new(segments_repository, rbs_repositoy, 'corge', config)
       expect(matcher.match?({:matching_key => 'user', :attributes => {}})).to be false
       expect(matcher.match?({:matching_key => 'k1', :attributes => {}})).to be true
     end
+
+    it 'return true if dependent rb segment matches' do
+      rbs_repositoy = SplitIoClient::Cache::Repositories::RuleBasedSegmentsRepository.new(config)
+      rbs = {
+        :changeNumber => 5,
+        :name => "dependent_rbs",
+        :status => "ACTIVE",
+        :trafficTypeName => "user",
+        :excluded =>{:keys =>["mauro@split.io","gaston@split.io"],:segments =>[]},
+        :conditions => [
+          {
+            :matcherGroup => {
+              :combiner => "AND",
+              :matchers => [
+                {
+                  :keySelector => {
+                    :trafficType => "user",
+                    :attribute => "email"
+                  },
+                  :matcherType => "ENDS_WITH",
+                  :negate => false,
+                  :whitelistMatcherData => {
+                    :whitelist => [
+                      "@split.io"
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        ]}
+      rbs2 = {
+        :changeNumber => 5,
+        :name => "sample_rule_based_segment",
+        :status => "ACTIVE",
+        :trafficTypeName => "user",
+        :excluded => {
+          :keys => [],
+          :segments => []
+        },
+        :conditions => [
+          {
+            :conditionType => "ROLLOUT",
+            :matcherGroup => {
+              :combiner => "AND",
+              :matchers => [
+                {
+                  :keySelector => {
+                    :trafficType => "user"
+                  },
+                  :matcherType => "IN_RULE_BASED_SEGMENT",
+                  :negate => false,
+                  :userDefinedSegmentMatcherData => {
+                    :segmentName => "dependent_rbs"
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+      rbs_repositoy.update([rbs, rbs2], [], -1)
+      matcher = described_class.new(segments_repository, rbs_repositoy, 'sample_rule_based_segment', config)
+      expect(matcher.match?(value: 'bilal@split.io', attributes: {'email': 'bilal@split.io'})).to be true
+      expect(matcher.match?(value: 'bilal', attributes: {'email': 'bilal'})).to be false
+    end        
   end
 end
diff --git a/spec/engine/parser/evaluator_spec.rb b/spec/engine/parser/evaluator_spec.rb
@@ -4,10 +4,11 @@
 
 describe SplitIoClient::Engine::Parser::Evaluator do
   let(:segments_repository) { SplitIoClient::Cache::Repositories::SegmentsRepository.new(@default_config) }
+  let(:rule_based_segments_repository) { SplitIoClient::Cache::Repositories::RuleBasedSegmentsRepository.new(@default_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(@default_config, flag_sets_repository, flag_set_filter) }
-  let(:evaluator) { described_class.new(segments_repository, splits_repository, true) }
+  let(:evaluator) { described_class.new(segments_repository, splits_repository, rule_based_segments_repository, true) }
 
   let(:killed_split) { { killed: true, defaultTreatment: 'default' } }
   let(:archived_split) { { status: 'ARCHIVED' } }

Original file line number	Diff line number	Diff line change
`@@ -230,6 +230,13 @@ def matcher_in_list_semver(params)`
`230`	`230`	`)`
`231`	`231`	`end`
`232`	`232`
	`233`	`+ def matcher_in_rule_based_segment(params)`
	`234`	`+ matcher = params[:matcher]`
	`235`	`+ segment_name = matcher[:userDefinedSegmentMatcherData] && matcher[:userDefinedSegmentMatcherData][:segmentName]`
	`236`	`+`
	`237`	`+ RuleBasedSegmentMatcher.new(params[:segments_repository], params[:rule_based_segments_repository], segment_name, @config)`
	`238`	`+ end`
	`239`	`+`
`233`	`240`	`#`
`234`	`241`	`# @return [object] the negate value for this condition`
`235`	`242`	`def negate`