regexer 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92070599c885225a8466e24f2bf46d3b5aea40c2ec205e8da99af425bf00d4e3
-  data.tar.gz: 42ce090a8b56be47aa2ca63caf8ec4c85868ff7229c7fec327b02086413b2327
+  metadata.gz: aa1cee078c860f7e156663ec53e028f497b80ad1ab75dd4ddd63bb6dcc863eac
+  data.tar.gz: 2fe31a71bbe3fedc1c5e5fc21fef2cbe8f9109266c7fb57bee7fce477655a396
 SHA512:
-  metadata.gz: 8040c4d4a11602ccdf7ad2059f0474d57890af8613ba678c911dd6f2699cff6a74b18b64fbe56ef3a8b86656f849b1520ff06c4fdc4f7b8a7686dd408d008c4a
-  data.tar.gz: 142da4ce9ad77977a7379e514be5206647b08eb727f0422fa31af97827a29d552ddd0ed687f6a79cdababf0be6f4e00481bbd336dbde4c8c79f0ad507a935653
+  metadata.gz: 5ba8841c57b7f87ad5c6a9bfdae871ab31262f2c158f48625fada5a12405762f419f533f9e7ed745a0a7f0692d2165267857698da970f4ded1cd01526a8c734a
+  data.tar.gz: 58610f6cb9a40103a0c59f695b1717de7b3704d57f34798f1a7dd0615c56c85c29c29d6a55f46f7a1350e12a330d6f7a8c40c3c15bf4deb49be40c429990bfa3

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/models/pattern.rb

@@ -1,15 +1,28 @@
 # frozen_string_literal: true
 
+require "regexer/exceptions/invalid_value_error"
+
 module Regexer
   module Models
     # The main model for the patterns being build by pattern builder
     class Pattern
       attr_reader :raw_pattern
 
-      def initialize(pattern, regex_escaped: true, single_entity: true)
-        @raw_pattern = pattern
+      def initialize(pattern, regex_escaped: true, single_entity: true, regex_shorthand_character: false)
+        @raw_pattern = String.new(pattern)
         @regex_escaped = regex_escaped
         @single_entity = single_entity
+        @regex_shorthand_character = regex_shorthand_character
+      end
+
+      def +(other)
+        unless other.is_a?(Regexer::Models::Pattern)
+          raise TypeError,
+                "Unable to add #{other.class} to Regexer::Models::Pattern"
+        end
+
+        Regexer::Models::Pattern.new(@raw_pattern + other.raw_pattern, regex_escaped: @regex_escaped,
+                                                                       single_entity: @single_entity)
       end
 
       def regex_escaped?
@@ -23,6 +36,10 @@ module Regexer
       def regex
         /#{raw_pattern}/
       end
+
+      def regex_shorthand_character?
+        @regex_shorthand_character
+      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
@@ -21,6 +23,10 @@ module Regexer
       Regexer::Models::Pattern.new(@final_pattern, single_entity: false)
     end
 
+    def append_pattern(&block)
+      instance_exec(&block)
+    end
+
     private
 
     # STRUCTS
@@ -97,30 +103,12 @@ module Regexer
       pattern_object
     end
 
-    def has_word_character
-      pattern_object = Regexer::Models::Pattern.new("\\w")
-      @final_pattern += pattern_object.raw_pattern
-      pattern_object
-    end
-
     def _or_
       pattern_object = Regexer::Models::Pattern.new("\|")
       @final_pattern += pattern_object.raw_pattern
       pattern_object
     end
 
-    def has_whitespace_character
-      pattern_object = Regexer::Models::Pattern.new("\\s")
-      @final_pattern += pattern_object.raw_pattern
-      pattern_object
-    end
-
-    def has_digit_character
-      pattern_object = Regexer::Models::Pattern.new("\\d")
-      @final_pattern += pattern_object.raw_pattern
-      pattern_object
-    end
-
     def has_alphanumeric_character
       pattern_object = Regexer::Models::Pattern.new("[A-Za-z0-9]")
       @final_pattern += pattern_object.raw_pattern
@@ -158,19 +146,22 @@ module Regexer
       value = Regexer::PatternBuilder.new(&block).result
       sanitized_pattern = Regexer::Utils::PatternSanitizer.sanitize(value)
       pattern_object = Regexer::Models::Pattern.new("(#{sanitized_pattern})")
-      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, sanitized_pattern, pattern_object.raw_pattern)
+      @final_pattern += pattern_object.raw_pattern
       pattern_object
     end
 
     def has_any_character_in(*values)
+      all_pattern_model_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
+
+        all_pattern_model_values << value.raw_pattern if value.instance_of?(::Regexer::Models::Pattern)
+
+        pattern + Regexer::Utils::AnyCharacterInValueTransformer.transform(value)
+      end
+
+      unless all_pattern_model_values.empty?
+        ::Regexer::Utils::StringHelper.remove_pattern_in_the_end_of_string(@final_pattern, all_pattern_model_values)
       end
 
       pattern_object = Regexer::Models::Pattern.new("[#{combined_pattern}]")
@@ -178,15 +169,108 @@ 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)
+      pattern_object
+    end
+
+    # Shorthand characters
+    def has_whitespace_character
+      pattern_object = Regexer::Models::Pattern.new("\\s", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_non_whitespace_character
+      pattern_object = Regexer::Models::Pattern.new("\\S", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_digit_character
+      pattern_object = Regexer::Models::Pattern.new("\\d", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_word_character
+      pattern_object = Regexer::Models::Pattern.new("\\w", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_non_digit_character
+      pattern_object = Regexer::Models::Pattern.new("\\D", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_newline_character
+      pattern_object = Regexer::Models::Pattern.new("\\n", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_tab_character
+      pattern_object = Regexer::Models::Pattern.new("\\t", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_vertical_tab_character
+      pattern_object = Regexer::Models::Pattern.new("\\v", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_carriage_return_character
+      pattern_object = Regexer::Models::Pattern.new("\\r", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_form_feed_character
+      pattern_object = Regexer::Models::Pattern.new("\\f", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_non_word_character
+      pattern_object = Regexer::Models::Pattern.new("\\W", regex_shorthand_character: true)
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def contains_a_word_ending_with(value)
+      pattern = contains(value)&.raw_pattern
+      pattern_object = Regexer::Models::Pattern.new("#{pattern}\\b", single_entity: false)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    end
+
+    def contains_a_word_starting_with(value)
+      pattern = contains(value)&.raw_pattern
+      pattern_object = Regexer::Models::Pattern.new("\\b#{pattern}", single_entity: false)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    end
+
+    def contains_the_word(value)
+      pattern = contains(value)&.raw_pattern
+      pattern_object = Regexer::Models::Pattern.new("\\b#{pattern}\\b", single_entity: false)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    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
-    alias whitespace_character has_whitespace_character
-    alias digit_character has_digit_character
     alias alphanumeric_character has_alphanumeric_character
     alias any_character_except_new_line has_any_character_except_new_line
     alias letter has_letter
@@ -197,5 +281,24 @@ 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
+
+    # Shorthand character alias methods
+    alias word_character has_word_character
+    alias non_word_character has_non_word_character
+    alias whitespace_character has_whitespace_character
+    alias non_whitespace_character has_non_whitespace_character
+    alias digit_character has_digit_character
+    alias non_digit_character has_non_digit_character
+    alias newline_character has_newline_character
+    alias tab_character has_tab_character
+    alias vertical_tab_character has_vertical_tab_character
+    alias carriage_return_character has_carriage_return_character
+    alias form_feed_character has_form_feed_character
+    alias the_word contains_the_word
+    alias contains_a_word_with contains_the_word
+    alias a_word_with contains_the_word
+    alias a_word_starting_with contains_a_word_starting_with
+    alias a_word_ending_with contains_a_word_ending_with
   end
 end

data/lib/regexer/utils/any_character_in_value_transformer.rb

@@ -0,0 +1,31 @@
+# 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"
+require "regexer/utils/handlers/any_character_in_input_value_handlers/regex_shorthand_pattern_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
+        from_to_hash_handler = ::Regexer::Utils::Handlers::AnyCharacterInInputValueHandlers::FromToHashHandler.new
+        char_range_pattern_handler =
+          ::Regexer::Utils::Handlers::AnyCharacterInInputValueHandlers::CharacterRangePatternHandler.new
+        regex_shorthand_pattern_handler =
+          ::Regexer::Utils::Handlers::AnyCharacterInInputValueHandlers::RegexShorthandPatternHandler.new
+
+        basic_types_handler.next_handler(char_range_pattern_handler)
+                           .next_handler(from_to_hash_handler)
+                           .next_handler(regex_shorthand_pattern_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/utils/handlers/any_character_in_input_value_handlers/regex_shorthand_pattern_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/any_character_in_input_value_handlers/base"
+require "regexer/models/pattern"
+
+module Regexer
+  module Utils
+    module Handlers
+      module AnyCharacterInInputValueHandlers
+        # A handler class to check if input value is a Regexer::Models::Pattern object
+        # tagged as regex shorthand character
+        # this returns the raw_pattern of that object
+        class RegexShorthandPatternHandler < Base
+          def handle(value)
+            if value.instance_of?(Regexer::Models::Pattern) && value.regex_shorthand_character?
+              value.raw_pattern
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/string_helper.rb

@@ -10,6 +10,11 @@ module Regexer
           pattern_to_update << new_pattern
         end
       end
+
+      def self.remove_pattern_in_the_end_of_string(pattern_to_update, pattern_to_remove)
+        pattern_to_update
+          .sub!(/(#{Regexp.escape(pattern_to_remove)})$/) { "" } if pattern_to_update.end_with?(pattern_to_remove)
+      end
     end
   end
 end

data/lib/regexer/validators/any_character_in_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "regexer/exceptions/invalid_value_error"
+require "regexer/models/character_range_pattern"
 require "regexer/models/pattern"
 
 module Regexer
@@ -8,8 +9,12 @@ module Regexer
     # 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 = "Regexer::Models::CharacterRangePattern"
+        regex_shorthand_pattern = "Regexer::Models::Pattern as regex shorthand character"
+        hash_model = "Hash with from & to keys"
+        basic_types = "String, Integer, Float"
+        message = "Value should be one of type #{basic_types}, #{char_range}, #{hash_model}, #{regex_shorthand_pattern}"
+        raise Regexer::Exceptions::InvalidValueError, message unless valid?(value)
       end
 
       class << self
@@ -27,8 +32,20 @@ module Regexer
           value.instance_of?(Hash) && value.keys == %i[from to]
         end
 
+        def character_range?(value)
+          value.instance_of?(Regexer::Models::CharacterRangePattern)
+        end
+
+        def regex_shorthand_character_pattern?(value)
+          value.instance_of?(Regexer::Models::Pattern) && value.regex_shorthand_character?
+        end
+
         def valid?(value)
-          number?(value) || string?(value) || from_to_hash?(value)
+          number?(value) ||
+            string?(value) ||
+            character_range?(value) ||
+            from_to_hash?(value) ||
+            regex_shorthand_character_pattern?(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.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Genesis Ivan Ilagan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-08 00:00:00.000000000 Z
+date: 2023-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -78,8 +78,15 @@ 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/any_character_in_input_value_handlers/regex_shorthand_pattern_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