regexer 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92070599c885225a8466e24f2bf46d3b5aea40c2ec205e8da99af425bf00d4e3
-  data.tar.gz: 42ce090a8b56be47aa2ca63caf8ec4c85868ff7229c7fec327b02086413b2327
+  metadata.gz: d7467fda4e27fd5886a4fd0c455ad5ebe4cb8db161c6c06bf99bb5912f907c9a
+  data.tar.gz: 98c6ca7fe45449a814575e13fc98cd343dc2fafd7e0e4962261a459212924add
 SHA512:
-  metadata.gz: 8040c4d4a11602ccdf7ad2059f0474d57890af8613ba678c911dd6f2699cff6a74b18b64fbe56ef3a8b86656f849b1520ff06c4fdc4f7b8a7686dd408d008c4a
-  data.tar.gz: 142da4ce9ad77977a7379e514be5206647b08eb727f0422fa31af97827a29d552ddd0ed687f6a79cdababf0be6f4e00481bbd336dbde4c8c79f0ad507a935653
+  metadata.gz: 51192fa1910ff86346c8da105030a9c33810e3c1974b38dc22676a77eb7a5eefab597155132ad174dcd8fee12da2fc746fe703e86418a68c7f97ec2d666b9d3b
+  data.tar.gz: 37490e66c2c56d24a5af2b1dc7c8ad2631f188df0582f391946b02c8e97a13830641a46deb1e61c365276018678c77729f6350bfaac1a550d5d86ef44a0a2418

data/lib/regexer/models/character_range_pattern.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Regexer
+  module Models
+    # The main model for character range patterns
+    class CharacterRangePattern
+      attr_reader :from, :to
+
+      def initialize(from, to)
+        @from = Regexp.escape(from)
+        @to = Regexp.escape(to)
+      end
+    end
+  end
+end

data/lib/regexer/pattern_builder.rb

@@ -3,10 +3,12 @@ require "regexer/validators/contains_value_validator"
 require "regexer/validators/any_character_in_validator"
 require "regexer/exceptions/no_block_given_error"
 require "regexer/models/pattern"
+require "regexer/models/character_range_pattern"
 require "regexer/utils/single_entity_checker"
 require "regexer/utils/quantifier_value_generator"
 require "regexer/utils/pattern_sanitizer"
 require "regexer/utils/string_helper"
+require "regexer/utils/any_character_in_value_transformer"
 require "pry"
 
 module Regexer
@@ -165,12 +167,7 @@ module Regexer
     def has_any_character_in(*values)
       combined_pattern = values.reduce("") do |pattern, value|
         Regexer::Validators::AnyCharacterInValidator.value_valid?(value)
-        if value.instance_of?(Hash)
-          Regexer::Validators::FromToValidator.valid_values?("ascii_character", value[:from], value[:to])
-          pattern + "#{value[:from]}-#{value[:to]}"
-        else
-          pattern + Regexer::Utils::PatternSanitizer.sanitize(value)
-        end
+        pattern + Regexer::Utils::AnyCharacterInValueTransformer.transform(value)
       end
 
       pattern_object = Regexer::Models::Pattern.new("[#{combined_pattern}]")
@@ -178,10 +175,17 @@ module Regexer
       pattern_object
     end
 
+    def has_any_character_not_in(*values)
+      pattern = has_any_character_in(*values)&.raw_pattern
+
+      pattern_object = Regexer::Models::Pattern.new(String.new(pattern).insert(1, "^"), single_entity: true)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+    end
+
     # VALUE BUILDER METHOD THAT IS COMPATIBILE WITH THE PATTERN BUILDER
     def character_range(from:, to:)
       Regexer::Validators::FromToValidator.valid_values?("ascii_character", from, to)
-      { from: Regexp.escape(from), to: Regexp.escape(to) }
+      Regexer::Models::CharacterRangePattern.new(from, to)
     end
 
     alias word_character has_word_character
@@ -197,5 +201,6 @@ module Regexer
     alias none_or_one_instance_of has_none_or_one_instance_of
     alias group has_group
     alias any_character_in has_any_character_in
+    alias any_character_not_in has_any_character_not_in
   end
 end

data/lib/regexer/utils/any_character_in_value_transformer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/any_character_in_input_value_handlers/base"
+require "regexer/utils/handlers/any_character_in_input_value_handlers/basic_types_handler"
+require "regexer/utils/handlers/any_character_in_input_value_handlers/character_range_pattern_handler"
+require "regexer/utils/handlers/any_character_in_input_value_handlers/from_to_hash_handler"
+
+module Regexer
+  module Utils
+    # A Utility Class that transforms a given value based on
+    # its types so that it is compatible with the
+    # has_any_character_in or has_any_character_not_in methods
+    class AnyCharacterInValueTransformer
+      def self.transform(value)
+        basic_types_handler = ::Regexer::Utils::Handlers::AnyCharacterInInputValueHandlers::BasicTypesHandler.new
+        char_range_pattern_handler =
+          ::Regexer::Utils::Handlers::AnyCharacterInInputValueHandlers::CharacterRangePatternHandler.new
+        from_to_hash_handler = ::Regexer::Utils::Handlers::AnyCharacterInInputValueHandlers::FromToHashHandler.new
+
+        basic_types_handler.next_handler(char_range_pattern_handler)
+                           .next_handler(from_to_hash_handler)
+
+        basic_types_handler.handle(value) || ""
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/any_character_in_input_value_handlers/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/base_handler"
+
+module Regexer
+  module Utils
+    module Handlers
+      module AnyCharacterInInputValueHandlers
+        # The base class for the handling of input values of
+        # has_any_character_in method
+        class Base < ::Regexer::Utils::Handlers::BaseHandler
+          def next_handler(handler)
+            @next_handler = handler
+
+            handler
+          end
+
+          def give_to_next_handler(value)
+            @next_handler&.handle(value) if @next_handler
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/any_character_in_input_value_handlers/basic_types_handler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/any_character_in_input_value_handlers/base"
+require "regexer/utils/pattern_sanitizer"
+
+module Regexer
+  module Utils
+    module Handlers
+      module AnyCharacterInInputValueHandlers
+        # A handler class to check if input value is one of the valid
+        # basic data types e.g. String, Integer, Float
+        # If its one of the basic types, just return a sanitized
+        # value for regex
+        class BasicTypesHandler < Base
+          def handle(value)
+            if value.instance_of?(String) || value.instance_of?(Integer) || value.instance_of?(Float)
+              Regexer::Utils::PatternSanitizer.sanitize(value)
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/any_character_in_input_value_handlers/character_range_pattern_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/any_character_in_input_value_handlers/base"
+require "regexer/models/character_range_pattern"
+
+module Regexer
+  module Utils
+    module Handlers
+      module AnyCharacterInInputValueHandlers
+        # A handler class to check if input value is a CharacterRangePattern object
+        # if true, should return a string based on values in that object
+        class CharacterRangePatternHandler < Base
+          def handle(value)
+            if value.instance_of?(Regexer::Models::CharacterRangePattern)
+              "#{value.from}-#{value.to}"
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/any_character_in_input_value_handlers/from_to_hash_handler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/any_character_in_input_value_handlers/base"
+require "regexer/models/character_range_pattern"
+require "regexer/validators/from_to_validator"
+
+module Regexer
+  module Utils
+    module Handlers
+      module AnyCharacterInInputValueHandlers
+        # A handler class to check if input value is a Hash with from & to keys only
+        # if true, should return a regex escaped string based on values in that Hash
+        class FromToHashHandler < Base
+          def handle(value)
+            if value.instance_of?(Hash) && value.keys == %i[from to]
+              Regexer::Validators::FromToValidator.valid_values?("ascii_character", value[:from], value[:to])
+              "#{Regexp.escape(value[:from])}-#{Regexp.escape(value[:to])}"
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/validators/any_character_in_validator.rb

@@ -1,15 +1,18 @@
 # frozen_string_literal: true
 
 require "regexer/exceptions/invalid_value_error"
-require "regexer/models/pattern"
+require "regexer/models/character_range_pattern"
 
 module Regexer
   module Validators
     # A Validator Class for validating values being passed to has_any_character_in Regexer::Pattern method
     class AnyCharacterInValidator
       def self.value_valid?(value)
-        error_message = "Value should only be of type String or Integer or Hash with from & to keys"
-        raise Regexer::Exceptions::InvalidValueError, error_message unless valid?(value)
+        char_range_model = "Regexer::Models::CharacterRangePattern"
+        valid_hash_model = "Hash with from & to keys"
+        valid_basic_types = "String or Integer or Float"
+        message = "Value should only be of type #{valid_basic_types} or #{char_range_model} or #{valid_hash_model}"
+        raise Regexer::Exceptions::InvalidValueError, message unless valid?(value)
       end
 
       class << self
@@ -27,8 +30,12 @@ module Regexer
           value.instance_of?(Hash) && value.keys == %i[from to]
         end
 
+        def character_range?(value)
+          value.instance_of?(Regexer::Models::CharacterRangePattern)
+        end
+
         def valid?(value)
-          number?(value) || string?(value) || from_to_hash?(value)
+          number?(value) || string?(value) || character_range?(value) || from_to_hash?(value)
         end
       end
     end

data/lib/regexer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Regexer
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Genesis Ivan Ilagan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-08 00:00:00.000000000 Z
+date: 2022-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -78,8 +78,14 @@ files:
 - lib/regexer.rb
 - lib/regexer/exceptions/invalid_value_error.rb
 - lib/regexer/exceptions/no_block_given_error.rb
+- lib/regexer/models/character_range_pattern.rb
 - lib/regexer/models/pattern.rb
 - lib/regexer/pattern_builder.rb
+- lib/regexer/utils/any_character_in_value_transformer.rb
+- lib/regexer/utils/handlers/any_character_in_input_value_handlers/base.rb
+- lib/regexer/utils/handlers/any_character_in_input_value_handlers/basic_types_handler.rb
+- lib/regexer/utils/handlers/any_character_in_input_value_handlers/character_range_pattern_handler.rb
+- lib/regexer/utils/handlers/any_character_in_input_value_handlers/from_to_hash_handler.rb
 - lib/regexer/utils/handlers/base_handler.rb
 - lib/regexer/utils/handlers/quantifier_options_handlers/base.rb
 - lib/regexer/utils/handlers/quantifier_options_handlers/exactly_option_handler.rb