used build for semver class

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

@@ -16,17 +16,17 @@ def initialize(attribute, start_value, end_value, logger, validator)
     end
 
     def match?(args)
-      @logger.log_if_debug('[BetweenSemverMatcher] evaluating value and attributes.')
-      return false unless @validator.valid_matcher_arguments(args) && args[:attributes][@attribute.to_sym].is_a?(String)
+      @logger.debug('[BetweenSemverMatcher] evaluating value and attributes.')
+      return false unless @validator.valid_matcher_arguments(args)
 
       value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
       unless !value_to_match.nil? && !@semver_start.nil? && !@semver_end.nil?
-        @logger.log_if_debug('betweenStringMatcherData is required for BETWEEN_SEMVER matcher type')
+        @logger.error('betweenStringMatcherData is required for BETWEEN_SEMVER matcher type')
         return false
       end
       matches = ([0, -1].include?(@semver_start.compare(value_to_match)) &&
                  [0, 1].include?(@semver_end.compare(value_to_match)))
-      @logger.log_if_debug("[BetweenMatcher] #{value_to_match} matches -> #{matches}")
+      @logger.debug("[BetweenMatcher] #{value_to_match} matches -> #{matches}")
       matches
     end
   end

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

@@ -15,16 +15,16 @@ def initialize(attribute, string_value, logger, validator)
     end
 
     def match?(args)
-      @logger.log_if_debug('[EqualsToSemverMatcher] evaluating value and attributes.')
-      return false unless @validator.valid_matcher_arguments(args) && args[:attributes][@attribute.to_sym].is_a?(String)
+      @logger.debug('[EqualsToSemverMatcher] evaluating value and attributes.')
+      return false unless @validator.valid_matcher_arguments(args)
 
       value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
       unless !value_to_match.nil? && [email protected]?
-        @logger.log_if_debug('stringMatcherData is required for EQUAL_TO_SEMVER matcher type')
+        @logger.error('stringMatcherData is required for EQUAL_TO_SEMVER matcher type')
         return false
       end
-      matches = @semver.compare(value_to_match).zero?
-      @logger.log_if_debug("[EqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches = (@semver.version == value_to_match.version)
+      @logger.debug("[EqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
       matches
     end
   end

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

@@ -15,16 +15,16 @@ def initialize(attribute, string_value, logger, validator)
     end
 
     def match?(args)
-      @logger.log_if_debug('[GreaterThanOrEqualsToSemverMatcher] evaluating value and attributes.')
-      return false unless @validator.valid_matcher_arguments(args) && args[:attributes][@attribute.to_sym].is_a?(String)
+      @logger.debug('[GreaterThanOrEqualsToSemverMatcher] evaluating value and attributes.')
+      return false unless @validator.valid_matcher_arguments(args)
 
       value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
       unless !value_to_match.nil? && [email protected]?
-        @logger.log_if_debug('stringMatcherData is required for GREATER_THAN_OR_EQUAL_TO_SEMVER matcher type')
+        @logger.error('stringMatcherData is required for GREATER_THAN_OR_EQUAL_TO_SEMVER matcher type')
         return false
       end
       matches = [0, 1].include?(value_to_match.compare(@semver))
-      @logger.log_if_debug("[GreaterThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      @logger.debug("[GreaterThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
       matches
     end
   end

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

@@ -10,21 +10,21 @@ def initialize(attribute, list_value, logger, validator)
       super(logger)
       @validator = validator
       @attribute = attribute
-      @semver_list = list_value.map { |item| SplitIoClient::Semver.new(item) }
+      @semver_list = list_value.map { |item| SplitIoClient::Semver.build(item, logger) }
       @logger = logger
     end
 
     def match?(args)
-      @logger.log_if_debug('[InListSemverMatcher] evaluating value and attributes.')
-      return false unless @validator.valid_matcher_arguments(args)
+      @logger.debug('[InListSemverMatcher] evaluating value and attributes.')
+      return false unless @validator.valid_matcher_arguments(args) && args[:attributes][@attribute.to_sym].is_a?(String)
 
-      value_to_match = args[:attributes][@attribute.to_sym]
-      unless value_to_match.is_a?(String)
-        @logger.log_if_debug('whitelistMatcherData is required for IN_LIST_SEMVER matcher type')
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      unless !value_to_match.nil? && @semver_list.all? { |n| !n.nil? }
+        @logger.error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type')
         return false
       end
-      matches = (@semver_list.map { |item| item.compare(SplitIoClient::Semver.new(value_to_match)) }).any?(&:zero?)
-      @logger.log_if_debug("[InListSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches = (@semver_list.map { |item| item.version == value_to_match.version }).any? { |item| item == true }
+      @logger.debug("[InListSemverMatcher] #{value_to_match} matches -> #{matches}")
       matches
     end
   end

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

@@ -15,16 +15,16 @@ def initialize(attribute, string_value, logger, validator)
     end
 
     def match?(args)
-      @logger.log_if_debug('[LessThanOrEqualsToSemverMatcher] evaluating value and attributes.')
-      return false unless @validator.valid_matcher_arguments(args) && args[:attributes][@attribute.to_sym].is_a?(String)
+      @logger.debug('[LessThanOrEqualsToSemverMatcher] evaluating value and attributes.')
+      return false unless @validator.valid_matcher_arguments(args)
 
       value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
       unless !value_to_match.nil? && [email protected]?
-        @logger.log_if_debug('stringMatcherData is required for LESS_THAN_OR_EQUAL_TO_SEMVER matcher type')
+        @logger.error('stringMatcherData is required for LESS_THAN_OR_EQUAL_TO_SEMVER matcher type')
         return false
       end
       matches = [0, -1].include?(value_to_match.compare(@semver))
-      @logger.log_if_debug("[LessThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      @logger.debug("[LessThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
       matches
     end
   end

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

@@ -6,16 +6,17 @@ class Semver
     PRE_RELEASE_DELIMITER = '-'
     VALUE_DELIMITER = '.'
 
-    attr_reader :major, :minor, :patch, :pre_release, :is_stable, :old_version
+    attr_reader :major, :minor, :patch, :pre_release, :is_stable, :version
 
     def initialize(version)
       @major = 0
       @minor = 0
       @patch = 0
       @pre_release = []
       @is_stable = false
-      @old_version = version
-      parse
+      @version = ''
+      @metadata = ''
+      parse(version)
     end
 
     #
@@ -26,21 +27,25 @@ def initialize(version)
     # @return [type] Semver instance
     def self.build(version, logger)
       new(version)
-    rescue RuntimeError => e
-      logger.warn("Failed to parse Semver data:  #{e}")
+    rescue NoMethodError => e
+      logger.error("Failed to parse Semver data, incorrect data type:  #{e}")
+      nil
+    rescue StandardError => e
+      logger.error("Failed to parse Semver data:  #{e}")
       nil
     end
 
     #
-    # Check if there is any metadata characters in self._old_version.
+    # Check if there is any metadata characters in version.
     #
     # @return [type] String semver without the metadata
     #
-    def remove_metadata_if_exists
-      index = @old_version.index(METADATA_DELIMITER)
-      return @old_version if index.nil?
+    def remove_metadata_if_exists(old_version)
+      index = old_version.index(METADATA_DELIMITER)
+      return old_version if index.nil?
 
-      @old_version[0, index]
+      @metadata = old_version[index + 1, old_version.length]
+      old_version[0, index]
     end
 
     # Compare the current Semver object to a given Semver object, return:
@@ -52,7 +57,7 @@ def remove_metadata_if_exists
     #
     # @returns [Integer] based on comparison
     def compare(to_compare)
-      return 0 if @old_version == to_compare.old_version
+      return 0 if @version == to_compare.version
 
       # Compare major, minor, and patch versions numerically
       return compare_attributes(to_compare) if compare_attributes(to_compare) != 0
@@ -68,10 +73,10 @@ def integer?(value)
     end
 
     #
-    # Parse the string in self._old_version to update the other internal variables
+    # Parse the string in version to update the other internal variables
     #
-    def parse
-      without_metadata = remove_metadata_if_exists
+    def parse(old_version)
+      without_metadata = remove_metadata_if_exists(old_version)
 
       index = without_metadata.index(PRE_RELEASE_DELIMITER)
       if index.nil?
@@ -100,6 +105,9 @@ def assign_major_minor_and_patch(version)
       @major = parts[0].to_i
       @minor = parts[1].to_i
       @patch = parts[2].to_i
+      @version = "#{@major}#{VALUE_DELIMITER}#{@minor}#{VALUE_DELIMITER}#{@patch}"
+      @version += "#{PRE_RELEASE_DELIMITER}#{@pre_release.join('.')}" unless @pre_release.empty?
+      @version += "#{METADATA_DELIMITER}#{@metadata}" unless @metadata.empty?
     end
 
     #

spec/cache/repositories/splits_repository_spec.rb

@@ -126,7 +126,7 @@
             }
         }]
       }
-      repository.update([split], [], -1)
+      repository.update([split.dup], [], -1)
       expect(repository.get_split('corge')[:conditions]).to eq [SplitIoClient::Cache::Repositories::SplitsRepository::DEFAULT_CONDITIONS_TEMPLATE]
 
       # test with multiple conditions

spec/engine/matchers/matches_between_semver_matcher_spec.rb

@@ -11,29 +11,29 @@
   let(:config) { SplitIoClient::SplitConfig.new }
 
   it 'initilized params' do
-    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.logger, config.split_validator)
     expect(matcher.attribute).to eq("version")
     semver_start = matcher.instance_variable_get(:@semver_start)
-    expect(semver_start.instance_variable_get(:@old_version)).to eq("2.1.8")
+    expect(semver_start.instance_variable_get(:@version)).to eq("2.1.8")
     semver_end = matcher.instance_variable_get(:@semver_end)
-    expect(semver_end.instance_variable_get(:@old_version)).to eq("2.1.11")
+    expect(semver_end.instance_variable_get(:@version)).to eq("2.1.11")
   end
 
   it 'matches' do
-    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": "2.1.8+rc"})).to eq(true)
     expect(matcher.match?(:attributes=>{"version": "2.1.9"})).to eq(true)
     expect(matcher.match?(:attributes=>{"version": "2.1.11-rc12"})).to eq(true)
   end
 
   it 'does not match' do
-    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": "2.1.5"})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": "2.1.12-rc1"})).to eq(false)
   end
 
   it 'invalid attribute' do
-    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:betweenStringMatcherData][:start], raw[:betweenStringMatcherData][:end], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": 2.1})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": nil})).to eq(false)
   end

spec/engine/matchers/matches_equal_to_semver_matcher_spec.rb

@@ -11,28 +11,27 @@
   let(:config) { SplitIoClient::SplitConfig.new }
 
   it 'initilized params' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
     expect(matcher.attribute).to eq("version")
     semver = matcher.instance_variable_get(:@semver)
-    expect(semver.instance_variable_get(:@old_version)).to eq("2.1.8")
+    expect(semver.instance_variable_get(:@version)).to eq("2.1.8")
   end
 
   it 'matches' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
-    expect(matcher.match?(:attributes=>{"version": "2.1.8+rc"})).to eq(true)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": "2.1.8"})).to eq(true)
   end
 
   it 'does not match' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
+    expect(matcher.match?(:attributes=>{"version": "2.1.8+rc"})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": "2.1.5"})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": "2.1.5-rc1"})).to eq(false)
   end
 
   it 'invalid attribute' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": 2.1})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": nil})).to eq(false)
   end
-
 end

spec/engine/matchers/matches_greater_than_or_equal_to_semver_matcher_spec.rb

@@ -11,28 +11,28 @@
   let(:config) { SplitIoClient::SplitConfig.new }
 
   it 'initilized params' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
     expect(matcher.attribute).to eq("version")
     semver = matcher.instance_variable_get(:@semver)
-    expect(semver.instance_variable_get(:@old_version)).to eq("2.1.8")
+    expect(semver.instance_variable_get(:@version)).to eq("2.1.8")
   end
 
   it 'matches' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": "2.1.8+rc"})).to eq(true)
     expect(matcher.match?(:attributes=>{"version": "2.1.8"})).to eq(true)
     expect(matcher.match?(:attributes=>{"version": "2.1.11"})).to eq(true)
     expect(matcher.match?(:attributes=>{"version": "2.2.0"})).to eq(true)
   end
 
   it 'does not match' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
-    expect(matcher.match?(:attributes=>{"version": "2.1.5"})).to eq(false)
-    expect(matcher.match?(:attributes=>{"version": "2.1.5-rc1"})).to eq(false)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
+    expect(matcher.match?(:attributes=>{"version": "2.1.7"})).to eq(false)
+    expect(matcher.match?(:attributes=>{"version": "2.0.22"})).to eq(false)
   end
 
   it 'invalid attribute' do
-    matcher = described_class.new("version", raw[:stringMatcherData], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:stringMatcherData], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": 2.1})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": nil})).to eq(false)
   end

spec/engine/matchers/matches_in_list_semver_matcher_spec.rb

@@ -11,28 +11,29 @@
   let(:config) { SplitIoClient::SplitConfig.new }
 
   it 'initilized params' do
-    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.logger, config.split_validator)
     expect(matcher.attribute).to eq("version")
     semver_list = matcher.instance_variable_get(:@semver_list)
-    expect(semver_list[0].instance_variable_get(:@old_version)).to eq("2.1.8")
-    expect(semver_list[1].instance_variable_get(:@old_version)).to eq("2.1.11")
+    expect(semver_list[0].instance_variable_get(:@version)).to eq("2.1.8")
+    expect(semver_list[1].instance_variable_get(:@version)).to eq("2.1.11")
   end
 
   it 'matches' do
-    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.split_logger, config.split_validator)
-    expect(matcher.match?(:attributes=>{"version": "2.1.8+rc"})).to eq(true)
+    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.logger, config.split_validator)
+    expect(matcher.match?(:attributes=>{"version": "2.1.8"})).to eq(true)
     expect(matcher.match?(:attributes=>{"version": "2.1.11"})).to eq(true)
   end
 
   it 'does not match' do
-    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.logger, config.split_validator)
+    expect(matcher.match?(:attributes=>{"version": "2.1.8+rc"})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": "2.1.7"})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": "2.1.11-rc12"})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": "2.1.8-rc1"})).to eq(false)
   end
 
   it 'invalid attribute' do
-    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.split_logger, config.split_validator)
+    matcher = described_class.new("version", raw[:whitelistMatcherData][:whitelist], config.logger, config.split_validator)
     expect(matcher.match?(:attributes=>{"version": 2.1})).to eq(false)
     expect(matcher.match?(:attributes=>{"version": nil})).to eq(false)
   end