regexer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 92070599c885225a8466e24f2bf46d3b5aea40c2ec205e8da99af425bf00d4e3
+  data.tar.gz: 42ce090a8b56be47aa2ca63caf8ec4c85868ff7229c7fec327b02086413b2327
+SHA512:
+  metadata.gz: 8040c4d4a11602ccdf7ad2059f0474d57890af8613ba678c911dd6f2699cff6a74b18b64fbe56ef3a8b86656f849b1520ff06c4fdc4f7b8a7686dd408d008c4a
+  data.tar.gz: 142da4ce9ad77977a7379e514be5206647b08eb727f0422fa31af97827a29d552ddd0ed687f6a79cdababf0be6f4e00481bbd336dbde4c8c79f0ad507a935653

data/lib/regexer/exceptions/invalid_value_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Regexer
+  module Exceptions
+    # An Exception Class For General Invalid Value Errors
+    class InvalidValueError < StandardError
+      def initialize(message = nil)
+        super(message)
+      end
+    end
+  end
+end

data/lib/regexer/exceptions/no_block_given_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Regexer
+  module Exceptions
+    # An Exception Class For no block given error
+    class NoBlockGivenError < StandardError
+      def initialize(message = nil)
+        super(message)
+      end
+    end
+  end
+end

data/lib/regexer/models/pattern.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+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
+        @regex_escaped = regex_escaped
+        @single_entity = single_entity
+      end
+
+      def regex_escaped?
+        @regex_escaped
+      end
+
+      def single_entity?
+        @single_entity
+      end
+
+      def regex
+        /#{raw_pattern}/
+      end
+    end
+  end
+end

data/lib/regexer/pattern_builder.rb

@@ -0,0 +1,201 @@
+require "regexer/validators/from_to_validator"
+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/utils/single_entity_checker"
+require "regexer/utils/quantifier_value_generator"
+require "regexer/utils/pattern_sanitizer"
+require "regexer/utils/string_helper"
+require "pry"
+
+module Regexer
+  # A Class that contains core methods for building regex patterns
+  class PatternBuilder
+    def initialize(&block)
+      @final_pattern = ""
+      instance_exec(&block)
+    end
+
+    def result
+      Regexer::Models::Pattern.new(@final_pattern, single_entity: false)
+    end
+
+    private
+
+    # STRUCTS
+    ConsecutiveOptions = Struct.new(:exactly, :minimum, :maximum)
+
+    # SPECIAL FUNCTION CHARACTERS
+    # MOSTLY IMPLEMENTATION OF SPECIAL CHARACTERS IN REGEX
+    def starts_with(value)
+      pattern = contains(value)&.raw_pattern
+
+      pattern_object = Regexer::Models::Pattern.new(String.new(pattern).insert(0, "^"), single_entity: false)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    end
+
+    def ends_with(value)
+      pattern = contains(value)&.raw_pattern
+
+      pattern_object = Regexer::Models::Pattern.new(String.new(pattern).insert(-1, "$"), single_entity: false)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    end
+
+    # REGEX QUANTIFIERS
+    def has_consecutive_instances_of(value, exactly: nil, minimum: nil, maximum: nil)
+      pattern = contains(value)&.raw_pattern
+
+      quantifier_pattern = Regexer::Utils::QuantifierValueGenerator
+                           .generate(ConsecutiveOptions.new(exactly, minimum, maximum))
+      pattern_object = Regexer::Models::Pattern.new(
+        String.new(pattern).insert(-1, quantifier_pattern),
+        single_entity: false
+      )
+
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    end
+
+    def has_none_or_consecutive_instances_of(value)
+      pattern = contains(value)&.raw_pattern
+
+      pattern_object = Regexer::Models::Pattern.new(String.new(pattern).insert(-1, "*"), single_entity: false)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    end
+
+    def has_none_or_one_instance_of(value)
+      pattern = contains(value)&.raw_pattern
+
+      pattern_object = Regexer::Models::Pattern.new(String.new(pattern).insert(-1, "?"), single_entity: false)
+      Regexer::Utils::StringHelper.update_string_pattern(@final_pattern, pattern, pattern_object.raw_pattern)
+      pattern_object
+    end
+
+    # BASIC EASE OF USE PATTERNS
+    def has_letter(from:, to:)
+      Regexer::Validators::FromToValidator.valid_values?("letter", from, to)
+      pattern_object = Regexer::Models::Pattern.new("[#{from}-#{to}]")
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_number(from:, to:)
+      Regexer::Validators::FromToValidator.valid_values?("number", from, to)
+      pattern_object = Regexer::Models::Pattern.new("[#{from}-#{to}]")
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def has_ascii_character(from:, to:)
+      Regexer::Validators::FromToValidator.valid_values?("ascii_character", from, to)
+      pattern_object = Regexer::Models::Pattern.new("[#{Regexp.escape(from)}-#{Regexp.escape(to)}]")
+      @final_pattern += pattern_object.raw_pattern
+      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
+      pattern_object
+    end
+
+    def has_any_character_except_new_line
+      pattern_object = Regexer::Models::Pattern.new(".")
+      @final_pattern += pattern_object.raw_pattern
+      pattern_object
+    end
+
+    def contains(value)
+      Regexer::Validators::ContainsValueValidator.value_valid?(value)
+
+      sanitized_pattern = Regexer::Utils::PatternSanitizer.sanitize(value)
+
+      pattern_object = if ::Regexer::Utils::SingleEntityChecker.single_entity?(value)
+                         Regexer::Models::Pattern.new(sanitized_pattern)
+                       else
+                         Regexer::Models::Pattern.new("(#{sanitized_pattern})")
+                       end
+
+      Regexer::Utils::StringHelper.update_string_pattern(
+        @final_pattern,
+        value.instance_of?(::Regexer::Models::Pattern) ? sanitized_pattern : "",
+        pattern_object.raw_pattern
+      )
+      pattern_object
+    end
+
+    def has_group(&block)
+      raise Regexer::Exceptions::NoBlockGivenError unless block_given?
+
+      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)
+      pattern_object
+    end
+
+    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
+      end
+
+      pattern_object = Regexer::Models::Pattern.new("[#{combined_pattern}]")
+      @final_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) }
+    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
+    alias number has_number
+    alias ascii_character has_ascii_character
+    alias consecutive_instances_of has_consecutive_instances_of
+    alias none_or_consecutive_instances_of has_none_or_consecutive_instances_of
+    alias none_or_one_instance_of has_none_or_one_instance_of
+    alias group has_group
+    alias any_character_in has_any_character_in
+  end
+end

data/lib/regexer/utils/handlers/base_handler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Regexer
+  module Utils
+    module Handlers
+      # A Base interface class for handlers
+      class BaseHandler
+        def handle
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def next_handler(_handler)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/base_handler"
+
+module Regexer
+  module Utils
+    module Handlers
+      module QuantifierOptionsHandler
+        # The base class for the quantifier options handler
+        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/quantifier_options_handlers/exactly_option_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/quantifier_options_handlers/base"
+require "regexer/validators/consecutive_instances_of_options_value_validator"
+
+module Regexer
+  module Utils
+    module Handlers
+      module QuantifierOptionsHandler
+        # A handler class to return the appropriate quantifier value
+        # if given the exactly option
+        class ExactlyOptionHandler < Base
+          def handle(value)
+            if value.exactly
+              Regexer::Validators::ConsecutiveInstancesOfOptionsValueValidator.value_valid?(value.exactly)
+              "{#{value.exactly}}"
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/quantifier_options_handlers/min_max_option_handler.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/quantifier_options_handlers/base"
+require "regexer/validators/consecutive_instances_of_options_value_validator"
+
+module Regexer
+  module Utils
+    module Handlers
+      module QuantifierOptionsHandler
+        # A handler class to return the appropriate quantifier value
+        # if given the minimum & maximum options only
+        class MinMaxOptionHandler < Base
+          def handle(value)
+            if value.maximum
+              raise ArgumentError, "missing minimum keyword argument" unless value.minimum
+
+              Regexer::Validators::ConsecutiveInstancesOfOptionsValueValidator.value_valid?(value.minimum)
+              Regexer::Validators::ConsecutiveInstancesOfOptionsValueValidator.value_valid?(value.maximum)
+              Regexer::Validators::ConsecutiveInstancesOfOptionsValueValidator
+                .min_max_range_valid?(value.minimum, value.maximum)
+
+              "{#{value.minimum},#{value.maximum}}"
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/quantifier_options_handlers/minimum_option_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/quantifier_options_handlers/base"
+require "regexer/validators/consecutive_instances_of_options_value_validator"
+
+module Regexer
+  module Utils
+    module Handlers
+      module QuantifierOptionsHandler
+        # A handler class to return the appropriate quantifier value
+        # if given the minimum option only
+        class MinimumOptionHandler < Base
+          def handle(value)
+            if value.minimum && !value.maximum
+              Regexer::Validators::ConsecutiveInstancesOfOptionsValueValidator.value_valid?(value.minimum)
+              "{#{value.minimum},}"
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/quantifier_options_handlers/no_option_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/quantifier_options_handlers/base"
+require "regexer/validators/consecutive_instances_of_options_value_validator"
+
+module Regexer
+  module Utils
+    module Handlers
+      module QuantifierOptionsHandler
+        # A handler class to return the appropriate quantifier value
+        # if given no options
+        class NoOptionHandler < Base
+          def handle(value)
+            if !value.exactly && !value.minimum && !value.maximum
+              "+"
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/base_handler"
+
+module Regexer
+  module Utils
+    module Handlers
+      module SingleEntityCheckerValueHandler
+        # The base class for the single engtity checker value handler
+        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/single_entity_checker_value_handlers/number_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/single_entity_checker_value_handlers/base"
+
+module Regexer
+  module Utils
+    module Handlers
+      module SingleEntityCheckerValueHandler
+        # A handler class to check if a number is considered as single entity or not
+        # if this handler sees that the value is not a number, it will then pass it to
+        # the next handler
+        class NumberHandler < Base
+          def handle(value)
+            if value.instance_of?(Integer)
+              value.digits.length == 1
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/single_entity_checker_value_handlers/pattern_object_handler.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/single_entity_checker_value_handlers/base"
+
+module Regexer
+  module Utils
+    module Handlers
+      module SingleEntityCheckerValueHandler
+        # A handler class to check if a pattern object is considered as single entity or not
+        # if this handler sees that the value is not a pattern object, it will then pass it to
+        # the next handler
+        class PatternObjectHandler < Base
+          def handle(value)
+            if value.instance_of?(::Regexer::Models::Pattern)
+              value.single_entity?
+            else
+              give_to_next_handler(value)
+            end
+          end
+
+          private
+
+          def wrapped_in_parentheses?(value)
+            value.raw_pattern[0] == "(" && value.raw_pattern[-1] == ")"
+          end
+
+          def wrapped_in_square_brackets?(value)
+            value.raw_pattern[0] == "[" && value.raw_pattern[-1] == "]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/handlers/single_entity_checker_value_handlers/string_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/single_entity_checker_value_handlers/base"
+
+module Regexer
+  module Utils
+    module Handlers
+      module SingleEntityCheckerValueHandler
+        # A handler class to check if a string value is considered as single entity or not
+        # if this handler sees that the value is not a string, it will then pass it to
+        # the next handler
+        class StringHandler < Base
+          def handle(value)
+            if value.instance_of?(String)
+              value.length == 1
+            else
+              give_to_next_handler(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/pattern_sanitizer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "regexer/models/pattern"
+
+module Regexer
+  module Utils
+    # A Utility Class that sanitizes a given value (mostly values given from the pattern builder)
+    # that is valid for regex
+    class PatternSanitizer
+      def self.sanitize(value)
+        if value.instance_of?(Regexer::Models::Pattern)
+          sanitize(value.raw_pattern) unless value.regex_escaped?
+          value.raw_pattern
+        else
+          Regexp.escape(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/regexer/utils/quantifier_value_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/quantifier_options_handlers/exactly_option_handler"
+require "regexer/utils/handlers/quantifier_options_handlers/minimum_option_handler"
+require "regexer/utils/handlers/quantifier_options_handlers/min_max_option_handler"
+require "regexer/utils/handlers/quantifier_options_handlers/no_option_handler"
+
+module Regexer
+  module Utils
+    # A Utility Class that generates a quantifier value based on
+    # the given options
+    class QuantifierValueGenerator
+      def self.generate(value)
+        exactly_option_handler = ::Regexer::Utils::Handlers::QuantifierOptionsHandler::ExactlyOptionHandler.new
+        minimum_option_handler = ::Regexer::Utils::Handlers::QuantifierOptionsHandler::MinimumOptionHandler.new
+        min_max_option_handler = ::Regexer::Utils::Handlers::QuantifierOptionsHandler::MinMaxOptionHandler.new
+        no_option_handler = ::Regexer::Utils::Handlers::QuantifierOptionsHandler::NoOptionHandler.new
+
+        exactly_option_handler.next_handler(minimum_option_handler)
+                              .next_handler(min_max_option_handler)
+                              .next_handler(no_option_handler)
+
+        exactly_option_handler.handle(value) || ""
+      end
+    end
+  end
+end

data/lib/regexer/utils/single_entity_checker.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "regexer/utils/handlers/single_entity_checker_value_handlers/string_handler"
+require "regexer/utils/handlers/single_entity_checker_value_handlers/number_handler"
+require "regexer/utils/handlers/single_entity_checker_value_handlers/pattern_object_handler"
+
+module Regexer
+  module Utils
+    # A Utility Class that checks if a value is a single entity or not
+    class SingleEntityChecker
+      def self.single_entity?(value)
+        string_handler = ::Regexer::Utils::Handlers::SingleEntityCheckerValueHandler::StringHandler.new
+        number_handler = ::Regexer::Utils::Handlers::SingleEntityCheckerValueHandler::NumberHandler.new
+        pattern_object_handler = ::Regexer::Utils::Handlers::SingleEntityCheckerValueHandler::PatternObjectHandler.new
+
+        string_handler.next_handler(number_handler)
+                      .next_handler(pattern_object_handler)
+
+        string_handler.handle(value) || false
+      end
+    end
+  end
+end

data/lib/regexer/utils/string_helper.rb

@@ -0,0 +1,15 @@
+module Regexer
+  module Utils
+    # A Utility Class that contains helper methods
+    # in dealing with strings
+    class StringHelper
+      def self.update_string_pattern(pattern_to_update, previous_appended_pattern, new_pattern)
+        if !previous_appended_pattern.empty? && pattern_to_update.end_with?(previous_appended_pattern)
+          pattern_to_update.sub!(/(#{Regexp.escape(previous_appended_pattern)})$/) { new_pattern }
+        else
+          pattern_to_update << new_pattern
+        end
+      end
+    end
+  end
+end

data/lib/regexer/validators/any_character_in_validator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "regexer/exceptions/invalid_value_error"
+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)
+        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)
+      end
+
+      class << self
+        private
+
+        def number?(value)
+          value.instance_of?(Integer) || value.instance_of?(Float)
+        end
+
+        def string?(value)
+          value.instance_of?(String)
+        end
+
+        def from_to_hash?(value)
+          value.instance_of?(Hash) && value.keys == %i[from to]
+        end
+
+        def valid?(value)
+          number?(value) || string?(value) || from_to_hash?(value)
+        end
+      end
+    end
+  end
+end

data/lib/regexer/validators/ascii_character_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "regexer/exceptions/invalid_value_error"
+
+module Regexer
+  module Validators
+    # A Validator Class for validating if a value is a single letter
+    class AsciiCharacterValidator
+      def self.ascii_character?(value)
+        error_message = "Value should only be a single character in the ascii table"
+        raise Regexer::Exceptions::InvalidValueError, error_message unless string?(value) && single_ascii_letter?(value)
+      end
+
+      class << self
+        private
+
+        def string?(value)
+          value.instance_of?(String)
+        end
+
+        def single_ascii_letter?(value)
+          value.length == 1 && value.match?(/[[:ascii:]]/)
+        end
+      end
+    end
+  end
+end

data/lib/regexer/validators/consecutive_instances_of_options_value_validator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "regexer/exceptions/invalid_value_error"
+
+module Regexer
+  module Validators
+    # A Validator Class for validating option values being passed to consecutive_instances_of Regexer::Pattern method
+    class ConsecutiveInstancesOfOptionsValueValidator
+      def self.value_valid?(value)
+        error_message = "Value should only be of type Integer"
+
+        raise Regexer::Exceptions::InvalidValueError, error_message unless integer?(value)
+      end
+
+      def self.min_max_range_valid?(min_value, max_value)
+        error_message = "minimum value is larger than maximum value"
+
+        raise RangeError, error_message unless min_value < max_value
+      end
+
+      private_class_method def self.integer?(value)
+        value.instance_of?(Integer)
+      end
+    end
+  end
+end

data/lib/regexer/validators/contains_value_validator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "regexer/exceptions/invalid_value_error"
+require "regexer/models/pattern"
+
+module Regexer
+  module Validators
+    # A Validator Class for validating values being passed to contains Regexer::Pattern method
+    class ContainsValueValidator
+      def self.value_valid?(value)
+        error_message = "Value should only be of type String or Integer or Float or Regexer::Models::Pattern"
+        raise Regexer::Exceptions::InvalidValueError, error_message unless valid?(value)
+      end
+
+      class << self
+        private
+
+        def number?(value)
+          value.instance_of?(Integer) || value.instance_of?(Float)
+        end
+
+        def string?(value)
+          value.instance_of?(String)
+        end
+
+        def pattern?(value)
+          value.instance_of?(Regexer::Models::Pattern)
+        end
+
+        def valid?(value)
+          number?(value) || string?(value) || pattern?(value)
+        end
+      end
+    end
+  end
+end

data/lib/regexer/validators/from_to_validator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "regexer/validators/letter_validator"
+require "regexer/validators/number_validator"
+require "regexer/validators/ascii_character_validator"
+
+module Regexer
+  module Validators
+    # A Validator Class for validating range values in Regexer::Pattern methods
+    # that takes in from and to values as method arguments
+    class FromToValidator
+      def self.valid_values?(value_type, from_value, to_value)
+        case value_type
+        when "number"
+          Regexer::Validators::NumberValidator.number?(from_value)
+          Regexer::Validators::NumberValidator.number?(to_value)
+        when "letter"
+          Regexer::Validators::LetterValidator.letter?(from_value)
+          Regexer::Validators::LetterValidator.letter?(to_value)
+        when "ascii_character"
+          Regexer::Validators::AsciiCharacterValidator.ascii_character?(from_value)
+          Regexer::Validators::AsciiCharacterValidator.ascii_character?(to_value)
+        end
+
+        validate_range(from_value, to_value)
+      end
+
+      private_class_method def self.validate_range(from_value, to_value)
+        raise RangeError, "From value is greater than the To value" if from_value > to_value
+      end
+    end
+  end
+end

data/lib/regexer/validators/letter_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "regexer/exceptions/invalid_value_error"
+
+module Regexer
+  module Validators
+    # A Validator Class for validating if a value is a single letter
+    class LetterValidator
+      def self.letter?(value)
+        error_message = "Value should only be a single letter"
+        raise Regexer::Exceptions::InvalidValueError, error_message unless string?(value) && single_letter?(value)
+      end
+
+      class << self
+        private
+
+        def string?(value)
+          value.instance_of?(String)
+        end
+
+        def single_letter?(value)
+          value.length == 1 && value.match?(/[[:alpha:]]/)
+        end
+      end
+    end
+  end
+end

data/lib/regexer/validators/number_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "regexer/exceptions/invalid_value_error"
+
+module Regexer
+  module Validators
+    # A Validator Class for validating if a value is an integer from 0 - 9
+    class NumberValidator
+      def self.number?(value)
+        error_message = "Value should only be an integer from 0 to 9"
+        raise Regexer::Exceptions::InvalidValueError, error_message unless integer?(value) && in_0_to_9?(value)
+      end
+
+      class << self
+        private
+
+        def integer?(value)
+          value.instance_of?(Integer)
+        end
+
+        def in_0_to_9?(value)
+          (0..9).to_a.include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/regexer/version.rb

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

data/lib/regexer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "regexer/version"
+require "regexer/pattern_builder"
+
+module Regexer
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: regexer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Genesis Ivan Ilagan
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: A ruby DSL for building regex patterns in a human readable format. Regexer
+  aims in making regex more easily read, learned and understood at first glance. Syntax
+  wise, it is inspired by FactoryBot and RSpec
+email:
+- ivanilagan1109@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/regexer.rb
+- lib/regexer/exceptions/invalid_value_error.rb
+- lib/regexer/exceptions/no_block_given_error.rb
+- lib/regexer/models/pattern.rb
+- lib/regexer/pattern_builder.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
+- lib/regexer/utils/handlers/quantifier_options_handlers/min_max_option_handler.rb
+- lib/regexer/utils/handlers/quantifier_options_handlers/minimum_option_handler.rb
+- lib/regexer/utils/handlers/quantifier_options_handlers/no_option_handler.rb
+- lib/regexer/utils/handlers/single_entity_checker_value_handlers/base.rb
+- lib/regexer/utils/handlers/single_entity_checker_value_handlers/number_handler.rb
+- lib/regexer/utils/handlers/single_entity_checker_value_handlers/pattern_object_handler.rb
+- lib/regexer/utils/handlers/single_entity_checker_value_handlers/string_handler.rb
+- lib/regexer/utils/pattern_sanitizer.rb
+- lib/regexer/utils/quantifier_value_generator.rb
+- lib/regexer/utils/single_entity_checker.rb
+- lib/regexer/utils/string_helper.rb
+- lib/regexer/validators/any_character_in_validator.rb
+- lib/regexer/validators/ascii_character_validator.rb
+- lib/regexer/validators/consecutive_instances_of_options_value_validator.rb
+- lib/regexer/validators/contains_value_validator.rb
+- lib/regexer/validators/from_to_validator.rb
+- lib/regexer/validators/letter_validator.rb
+- lib/regexer/validators/number_validator.rb
+- lib/regexer/version.rb
+homepage: https://github.com/IvanIlagan/regexer-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/IvanIlagan/regexer-ruby
+  source_code_uri: https://github.com/IvanIlagan/regexer-ruby
+  changelog_uri: https://github.com/IvanIlagan/regexer-ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A ruby DSL for generating regex patterns
+test_files: []