regexer 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7467fda4e27fd5886a4fd0c455ad5ebe4cb8db161c6c06bf99bb5912f907c9a
-  data.tar.gz: 98c6ca7fe45449a814575e13fc98cd343dc2fafd7e0e4962261a459212924add
+  metadata.gz: aa1cee078c860f7e156663ec53e028f497b80ad1ab75dd4ddd63bb6dcc863eac
+  data.tar.gz: 2fe31a71bbe3fedc1c5e5fc21fef2cbe8f9109266c7fb57bee7fce477655a396
 SHA512:
-  metadata.gz: 51192fa1910ff86346c8da105030a9c33810e3c1974b38dc22676a77eb7a5eefab597155132ad174dcd8fee12da2fc746fe703e86418a68c7f97ec2d666b9d3b
-  data.tar.gz: 37490e66c2c56d24a5af2b1dc7c8ad2631f188df0582f391946b02c8e97a13830641a46deb1e61c365276018678c77729f6350bfaac1a550d5d86ef44a0a2418
+  metadata.gz: 5ba8841c57b7f87ad5c6a9bfdae871ab31262f2c158f48625fada5a12405762f419f533f9e7ed745a0a7f0692d2165267857698da970f4ded1cd01526a8c734a
+  data.tar.gz: 58610f6cb9a40103a0c59f695b1717de7b3704d57f34798f1a7dd0615c56c85c29c29d6a55f46f7a1350e12a330d6f7a8c40c3c15bf4deb49be40c429990bfa3

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

@@ -23,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
@@ -99,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
@@ -160,16 +146,24 @@ 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)
+
+        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}]")
       @final_pattern += pattern_object.raw_pattern
       pattern_object
@@ -180,6 +174,95 @@ module Regexer
 
       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
@@ -188,9 +271,6 @@ module Regexer
       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
@@ -202,5 +282,23 @@ module Regexer
     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

@@ -4,6 +4,7 @@ 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
@@ -13,12 +14,15 @@ module Regexer
     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
-        from_to_hash_handler = ::Regexer::Utils::Handlers::AnyCharacterInInputValueHandlers::FromToHashHandler.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

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

@@ -2,16 +2,18 @@
 
 require "regexer/exceptions/invalid_value_error"
 require "regexer/models/character_range_pattern"
+require "regexer/models/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)
-        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}"
+        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
 
@@ -34,8 +36,16 @@ module Regexer
           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) || character_range?(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.1.0"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexer
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Genesis Ivan Ilagan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-09 00:00:00.000000000 Z
+date: 2023-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -86,6 +86,7 @@ files:
 - 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