string_pattern 2.3.0 → 2.5.0

data/lib/string/pattern/validate.rb

@@ -32,6 +32,11 @@ class StringPattern
     if (not_expected_errors.include?(:min_length) or not_expected_errors.include?(:max_length)) and !not_expected_errors.include?(:length)
       not_expected_errors.push(:length)
     end
+    if pattern.is_a?(Regexp)
+      return false if text_to_validate.nil?
+      detected_errors = StringPattern.regexp_full_match?(pattern, text_to_validate.to_s) ? [] : [:value]
+      return StringPattern.validation_decision(detected_errors, expected_errors, not_expected_errors)
+    end
     if pattern.kind_of?(Array) and pattern.size == 1
       pattern = pattern[0]
     elsif pattern.kind_of?(Array) and pattern.size > 1
@@ -54,7 +59,7 @@ class StringPattern
           max_length = patt.max_length.clone
           symbol_type = patt.symbol_type.clone
         else
-          puts "String pattern class not supported (#{pat.class} for #{pat})"
+          StringPattern.log_message("String pattern class not supported (#{pat.class} for #{pat})")
           return false
         end
 
@@ -133,7 +138,9 @@ class StringPattern
         required_chars << rd if rd.size == 1
       }
       if (required_chars.flatten & excluded_data.flatten).size > 0
-        puts "pattern argument not valid on StringPattern.validate, a character cannot be required and excluded at the same time: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+        message = "pattern argument not valid on StringPattern.validate, a character cannot be required and excluded at the same time: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+        raise StringPattern::InvalidPatternError, message if @raise_on_error
+        StringPattern.log_message(message)
         return ""
       end
     end
@@ -183,38 +190,106 @@ class StringPattern
           end
         }
       else #symbol_type=="@"
-        string = text_to_validate
-        wrong = %w(.. __ -- ._ _. .- -. _- -_ @. @_ @- .@ _@ -@ @@)
-        if !(Regexp.union(*wrong) === string) #don't include any or the wrong strings
-          if string.index("@").to_i > 0 and
-             string[0..(string.index("@") - 1)].scan(/([a-z0-9]+([\+\._\-][a-z0-9]|)*)/i).join == string[0..(string.index("@") - 1)] and
-             string[(string.index("@") + 1)..-1].scan(/([0-9a-z]+([\.-][a-z0-9]|)*)/i).join == string[string[(string.index("@") + 1)..-1]]
-            error_regular_expression = false
-          else
-            error_regular_expression = true
-          end
-        else
-          error_regular_expression = true
-        end
-
+        error_regular_expression = !StringPattern.valid_email?(text_to_validate)
         if error_regular_expression
           detected_errors.push(:value)
         end
       end
     end
 
-    if expected_errors.size == 0 and not_expected_errors.size == 0
-      return detected_errors.uniq
+    StringPattern.validation_decision(detected_errors, expected_errors, not_expected_errors)
+  end
+
+  def self.validation_decision(detected_errors, expected_errors, not_expected_errors)
+    if expected_errors.size == 0 && not_expected_errors.size == 0
+      detected_errors.uniq
+    elsif (expected_errors & detected_errors) == expected_errors && (not_expected_errors & detected_errors).empty?
+      true
     else
-      if expected_errors & detected_errors == expected_errors
-        if (not_expected_errors & detected_errors).size > 0
-          return false
-        else
-          return true
-        end
-      else
-        return false
-      end
+      false
+    end
+  end
+
+  # True when +text+ matches the whole +regexp+, not a substring.
+  def self.regexp_full_match?(regexp, text)
+    return false unless text.is_a?(String)
+    anchored = Regexp.new("\\A(?:#{regexp.source})\\z", regexp.options)
+    anchored.match?(text)
+  rescue RegexpError
+    false
+  end
+
+  # Describes why +text+ does or does not match +pattern+.
+  # @return [Hash] :valid, :errors, :message, and :index (segment index for arrays)
+  def self.explain(text: nil, pattern: nil, **synonyms)
+    text = synonyms[:text_to_validate] if text.nil? && synonyms.key?(:text_to_validate)
+    text = synonyms[:validate] if text.nil? && synonyms.key?(:validate)
+
+    if pattern.is_a?(Array) && pattern.size > 1
+      return explain_array(text, pattern)
+    end
+
+    errors = validate(text: text, pattern: pattern)
+    if errors == true || (errors.is_a?(Array) && errors.empty?)
+      { valid: true, errors: [], message: "valid", index: nil }
+    elsif errors.is_a?(Array)
+      { valid: false, errors: errors, message: "invalid: #{errors.join(', ')}", index: nil }
+    else
+      { valid: false, errors: [:value], message: "invalid", index: nil }
+    end
+  end
+
+  def self.explain_array(text, patterns)
+    ok, index, errors = match_segments(text.to_s, patterns, 0)
+    if ok
+      { valid: true, errors: [], message: "valid", index: nil }
+    else
+      { valid: false, errors: errors, message: "segment #{index} does not match: #{errors.join(', ')}", index: index }
+    end
+  end
+
+  def self.match_segments(text, patterns, index)
+    if patterns.empty?
+      return [true, nil, []] if text.empty?
+      return [false, index, [:length]]
+    end
+
+    if patterns.size == 1
+      errors = validate(text: text, pattern: patterns[0])
+      return [true, nil, []] if errors == true || (errors.is_a?(Array) && errors.empty?)
+      errs = errors.is_a?(Array) ? errors : [:value]
+      return [false, index, errs]
+    end
+
+    info = segment_bounds(patterns[0])
+    return [false, index, [:value]] if info.nil?
+
+    best = nil
+    (info[:min]..info[:max]).each do |n|
+      next if n > text.length
+      errors = validate(text: text[0, n], pattern: patterns[0])
+      next unless errors == true || (errors.is_a?(Array) && errors.empty?)
+      ok, idx, errs = match_segments(text[n..], patterns[1..], index + 1)
+      return [true, nil, []] if ok
+      best = [idx, errs] if best.nil? || idx > best[0]
+    end
+
+    return [false, best[0], best[1]] if best
+
+    errors = validate(text: text, pattern: patterns[0])
+    errs = errors.is_a?(Array) ? errors : [:value]
+    errs = [:value] if errs.empty?
+    [false, index, errs]
+  end
+
+  def self.segment_bounds(pat)
+    pattern_like = pat.to_s.scan(/(\d+)-(\d+):(.+)/).size > 0 || pat.to_s.scan(/^!?(\d+):(.+)/).size > 0
+    if pat.is_a?(String) && (!optimistic || !pattern_like)
+      { min: pat.length, max: pat.length }
+    elsif pat.is_a?(Symbol) || pat.is_a?(String)
+      analyzed = analyze(pat, silent: true)
+      return nil unless analyzed.is_a?(Struct)
+      { min: analyzed.min_length, max: analyzed.max_length }
     end
   end
 end

data/lib/string_pattern/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class StringPattern
+  VERSION = "2.5.0"
+end

data/lib/string_pattern.rb

@@ -1,6 +1,9 @@
 SP_ADD_TO_RUBY = true if !defined?(SP_ADD_TO_RUBY)
+require_relative "string_pattern/version"
 require_relative "string/pattern/add_to_ruby" if SP_ADD_TO_RUBY
 require_relative "string/pattern/analyze"
+require_relative "string/pattern/checksum"
+require_relative "string/pattern/email"
 require_relative "string/pattern/generate"
 require_relative "string/pattern/validate"
 
@@ -29,10 +32,47 @@ require_relative "string/pattern/validate"
 #             Array of words to be avoided from resultant strings.
 # block_list_enabled: (TrueFalse, default: false)
 #             If true block_list will be take in consideration
+#
+# @example Generate a string
+#   StringPattern.generate("10:N")  # => "3448910834"
+# @example Validate and get errors
+#   StringPattern.validate(text: "ab", pattern: "6:N")  # => [:min_length, :length]
 class StringPattern
+  # Raised when an invalid pattern is used and {raise_on_error} is true.
+  InvalidPatternError = Class.new(StandardError)
+  # Raised when generation is impossible (e.g. exhausted by dont_repeat) and {raise_on_error} is true.
+  GenerationImpossibleError = Class.new(StandardError)
+
+  # Wraps Random so +rand+ matches Kernel#rand for negative limits and zero.
+  # Array#sample calls +rand+ with a positive integer.
+  class RandomSource
+    def initialize(random)
+      @random = random
+    end
+
+    def rand(limit = nil)
+      return @random.rand if limit.nil?
+      if limit.is_a?(Integer) && limit.negative?
+        @random.rand(-limit)
+      elsif limit == 0
+        @random.rand
+      else
+        @random.rand(limit)
+      end
+    end
+  end
+
   class << self
-    attr_accessor :national_chars, :optimistic, :dont_repeat, :cache, :cache_values, :default_infinite, :word_separator, :block_list, :block_list_enabled
+    # @return [String, nil] When set, warning messages are sent here instead of +puts+.
+    attr_accessor :logger
+    # @return [Boolean] When true, invalid patterns or impossible generation raise instead of returning "".
+    attr_accessor :raise_on_error
+    attr_accessor :national_chars, :optimistic, :dont_repeat, :cache, :cache_values, :default_infinite, :word_separator, :block_list, :block_list_enabled, :block_list_regexp
   end
+  SCOPE_KEYS = %i[
+    dont_repeat block_list block_list_enabled block_list_regexp
+    national_chars optimistic word_separator raise_on_error logger
+  ].freeze
   @national_chars = (("a".."z").to_a + ("A".."Z").to_a).join
   @optimistic = true
   @cache = Hash.new()
@@ -42,6 +82,9 @@ class StringPattern
   @word_separator = "_"
   @block_list_enabled = false
   @block_list = []
+  @logger = nil
+  @raise_on_error = false
+  @block_list_regexp = false
   NUMBER_SET = ("0".."9").to_a
   SPECIAL_SET = [" ", "~", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "+", "=", "{", "}", "[", "]", "'", ";", ":", "?", ">", "<", "`", "|", "/", '"']
   ALPHA_SET_LOWER = ("a".."z").to_a
@@ -63,4 +106,113 @@ class StringPattern
     @national_chars = par
   end
 
+  def self.log_message(message)
+    if @logger
+      @logger.warn(message)
+    else
+      puts message
+    end
+  end
+
+  # Returns true if +text+ matches +pattern+; false otherwise. Uses validate under the hood.
+  # @param text [String] (synonyms: text_to_validate, validate)
+  # @param pattern [String, Symbol, Array]
+  # @return [Boolean]
+  def self.valid?(text: nil, pattern: nil, **synonyms)
+    text = synonyms[:text_to_validate] if text.nil? && synonyms.key?(:text_to_validate)
+    text = synonyms[:validate] if text.nil? && synonyms.key?(:validate)
+    return false if text.nil? || pattern.nil?
+    result = validate(text: text, pattern: pattern, **synonyms)
+    pattern.is_a?(Array) ? result == true : result.is_a?(Array) && result.empty?
+  end
+
+  # Generates up to +n+ distinct strings for +pattern+. Uses a temporary dont_repeat state.
+  # Keyword arguments, including +seed:+, are forwarded to {generate}. A seed advances one
+  # Random across the whole sample so successive values differ.
+  # @param pattern [String, Symbol, Array, Regexp]
+  # @param n [Integer]
+  # @return [Array<String>]
+  def self.sample(pattern, n, seed: nil, **options)
+    return [] if n <= 0
+
+    rng = StringPattern::RandomSource.new(seed.nil? ? Random.new : Random.new(seed))
+    old_dont = @dont_repeat
+    old_cache = @cache_values.dup
+    started = true
+    @dont_repeat = true
+    @cache_values = {}
+    results = []
+    n.times do
+      s = generate(pattern, _rng: rng, **options)
+      break if s.nil? || s.empty?
+      results << s
+    end
+    results
+  ensure
+    if started
+      @dont_repeat = old_dont
+      @cache_values = old_cache
+    end
+  end
+
+  # Runs +block+ with the given settings and restores the previous values afterwards.
+  # @return [Object] the block's result
+  def self.with(**options)
+    unknown = options.keys - SCOPE_KEYS
+    raise ArgumentError, "unknown option: #{unknown.join(', ')}" unless unknown.empty?
+
+    saved = {}
+    SCOPE_KEYS.each { |key| saved[key] = instance_variable_get("@#{key}") }
+    options.each do |key, value|
+      if key == :national_chars
+        self.national_chars = value
+      else
+        instance_variable_set("@#{key}", value)
+      end
+    end
+    yield
+  ensure
+    if saved
+      saved.each do |key, value|
+        if key == :national_chars
+          self.national_chars = value unless @national_chars == value
+        else
+          instance_variable_set("@#{key}", value)
+        end
+      end
+    end
+  end
+
+  # Restores configuration defaults and clears pattern and generated-value caches.
+  # @return [void]
+  def self.reset!
+    self.national_chars = (("a".."z").to_a + ("A".."Z").to_a).join
+    @optimistic = true
+    @dont_repeat = false
+    @default_infinite = 10
+    @word_separator = "_"
+    @block_list_enabled = false
+    @block_list = []
+    @block_list_regexp = false
+    @logger = nil
+    @raise_on_error = false
+    @cache = {}
+    @cache_values = {}
+    nil
+  end
+
+  # Generates a random UUID v4 (e.g. "550e8400-e29b-41d4-a716-446655440000").
+  # @return [String]
+  def self.uuid
+    require "securerandom"
+    SecureRandom.uuid
+  end
+
+  # Returns true if +str+ is a valid UUID v4 format (8-4-4-4-12 hex with version and variant bits).
+  # @param str [String]
+  # @return [Boolean]
+  def self.valid_uuid?(str)
+    return false unless str.is_a?(String)
+    str.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i)
+  end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: string_pattern
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Mario Ruiz
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-20 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: regexp_parser
@@ -39,10 +38,12 @@ email: marioruizs@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 files:
 - ".yardopts"
+- CHANGELOG.md
 - LICENSE
 - README.md
 - data/english/adjs.json
@@ -61,14 +62,16 @@ files:
 - data/spanish/palabras9.json
 - lib/string/pattern/add_to_ruby.rb
 - lib/string/pattern/analyze.rb
+- lib/string/pattern/checksum.rb
+- lib/string/pattern/email.rb
 - lib/string/pattern/generate.rb
 - lib/string/pattern/validate.rb
 - lib/string_pattern.rb
+- lib/string_pattern/version.rb
 homepage: https://github.com/MarioRuiz/string_pattern
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -76,15 +79,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: 'Generate easily random strings following a simple pattern or regular expression.
   ''10-20:Xn/x/''.generate #>qBstvc6JN8ra. Also generate words in English or Spanish.