regexp-collection 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45559910057c4ccfc7fb57aee7e9d01498240fa06076fef024d92fbf55b8293c
-  data.tar.gz: bb626104a9313351dd649bc258ed2de344644b1acff0355e30e185ce0d84852a
+  metadata.gz: 1a60da99e09e095dce40bd8e2426d7a1f90ebbcf05c7cc61dddd43caf13636de
+  data.tar.gz: f1577df60f58d153f9796ad313e0f3b387cd5455dba5254a1fbf1c4d6d860aba
 SHA512:
-  metadata.gz: c9203a7296812da92648050be8b7559a4ba5c065b6fc3893ed53a626ba838583ac876a1c14117d25680bc824516fd5ae464bd4dc98e31a16c9bc6ecaece8430d
-  data.tar.gz: a6ca39bc415baec308057c66e8f685c5d99344db822dfc3692b733cfc48168ae5efea76bfc8eee0b5c25a64e035f3c125325d6c849c2be160ce0ffc3b0af10c5
+  metadata.gz: 83385593804f1db3b824120d3d3336281dd354b1376e2dadff451909b4071b01f4214be800891ea314d746a0a01fb34af230f4d544a054ce25c6ab337aedd0f4
+  data.tar.gz: 6289d769ddbe2cfe1bf56bd17830b4a579ddb8df5e4e168b05fbedb5e40b0699c9cac9bdaa952055f294567155c5c5e5eadc52d035e387521f649754bb3fff99

data/.ruby-version

@@ -1 +1 @@
-2.5.1
+4.0.7

data/Gemfile

@@ -1,9 +1,5 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 source "https://rubygems.org"
 
 gemspec
-
-gem "rake", "~> 12.3"
-gem "test-unit", "~> 3.2"

data/Gemfile.lock

@@ -1,24 +1,30 @@
 PATH
   remote: .
   specs:
-    regexp-collection (1.0.1)
+    regexp-collection (2.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    power_assert (1.1.3)
-    rake (12.3.1)
-    test-unit (3.2.8)
+    power_assert (3.1.0)
+    rake (13.4.2)
+    test-unit (3.7.8)
       power_assert
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.7)
-  rake (~> 12.3)
+  rake (~> 13.4)
   regexp-collection!
-  test-unit (~> 3.2)
+  test-unit (~> 3.7)
+
+CHECKSUMS
+  bundler (4.0.22) sha256=d8d5ec84c8555e0af71db63ed7aee4d1a8fb839ec46d84212d61979242a5d75a
+  power_assert (3.1.0) sha256=fefe98ed5d3140628138f3f9f9194d6ece01f1320e69700d3c928adca7518251
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  regexp-collection (2.0.0)
+  test-unit (3.7.8) sha256=689d1ca53f4d46f678b4e5d68d8e4294f87fc5e8b9238cc4de7c5727e8d65943
 
 BUNDLED WITH
-   1.16.5
+  4.0.22

data/Rakefile

@@ -1,7 +1,12 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
+require "bundler/gem_tasks"
 require "rake/testtask"
 
 ENV["TESTOPTS"] = "--verbose"
-Rake::TestTask.new { |t| t.libs << "test" }
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/test_*.rb"
+end
+
+task default: :test

data/lib/regexp-collection.rb

@@ -1,19 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
-module Regexp::Collection
-  module Numbers
-    class << self
-      attr_accessor :integer, :decimal, :natural_including_zero, :natural_excluding_zero
-
-      def natural(zero = false)
-        zero ? natural_including_zero : natural_excluding_zero
-      end
-    end
-
-    self.integer                = /\A(?:-?[1-9]\d*\z)|(?:\A0)\z/.freeze
-    self.decimal                = /\A(?:-?[1-9]\d*(?:\.\d+)?\z)|(?:\A0(?:\.\d+)?)\z/.freeze
-    self.natural_including_zero = /\A(?:0\z)|(?:\A[1-9]\d*)\z/.freeze
-    self.natural_excluding_zero = /\A[1-9]\d*\z/.freeze
-  end
-end
+require_relative "regexp_collection"

data/lib/{regexp-collection → regexp_collection}/version.rb

@@ -1,6 +1,5 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Regexp::Collection
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/regexp_collection.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Regexp::Collection
+  module Number
+    class << self
+      attr_accessor :integer, :decimal, :natural_including_zero, :natural_excluding_zero, :hexadecimal
+
+      def natural(zero = false)
+        zero ? natural_including_zero : natural_excluding_zero
+      end
+    end
+
+    # Matches integers without leading zeros (except single 0), e.g., -10, 0, 42
+    self.integer = /\A(?:-?[1-9]\d*|0)\z/.freeze
+
+    # Matches decimals: integers or numbers with a dot followed by digits.
+    # Correctly supports negative decimals while rejecting -0 and -0.0
+    self.decimal = /\A(?:-?[1-9]\d*(?:\.\d+)?|-0\.\d*[1-9]\d*|0(?:\.\d+)?)\z/.freeze
+
+    # Matches natural numbers including 0
+    self.natural_including_zero = /\A(?:0|[1-9]\d*)\z/.freeze
+
+    # Matches natural numbers strictly greater than 0
+    self.natural_excluding_zero = /\A[1-9]\d*\z/.freeze
+
+    # Matches hexadecimal literals with 0x or 0X prefix (case-insensitive hex digits)
+    self.hexadecimal = /\A0[xX][a-fA-F0-9]+\z/.freeze
+  end
+
+  module Time
+    class << self
+      attr_accessor :seconds_required, :seconds_not_permitted, :seconds_optional
+    end
+
+    # HH:MM:SS (hour 0-23, single digit permitted: 0-9)
+    self.seconds_required = /\A(?:[01]?\d|2[0-3]):[0-5]\d:[0-5]\d\z/.freeze
+
+    # HH:MM
+    self.seconds_not_permitted = /\A(?:[01]?\d|2[0-3]):[0-5]\d\z/.freeze
+
+    # HH:MM or HH:MM:SS
+    self.seconds_optional = /\A(?:[01]?\d|2[0-3]):[0-5]\d(?::[0-5]\d)?\z/.freeze
+  end
+
+  module Crypto
+    class << self
+      attr_accessor \
+        :trx_wallet_address_base58,
+        :evm_wallet_address,
+        :evm_transaction_hash,
+        :tx_mainnet_wallet_address_bech32,
+        :tx_testnet_wallet_address_bech32,
+        :xrp_wallet_address_bech32
+    end
+
+    # Tron Base58Check address: starts with T, 34 chars total, excludes 0, O, I, l
+    self.trx_wallet_address_base58 = /\AT[1-9A-HJ-NP-Za-km-z]{33}\z/.freeze
+
+    # EVM address: 0x followed by exactly 40 hexadecimal characters
+    self.evm_wallet_address = /\A0x[a-fA-F0-9]{40}\z/.freeze
+
+    # EVM transaction hash: 0x followed by exactly 64 hexadecimal characters
+    self.evm_transaction_hash = /\A0x[a-fA-F0-9]{64}\z/.freeze
+
+    self.tx_mainnet_wallet_address_bech32 = /\Acore1[02-9ac-hj-np-z]{38}\z/.freeze
+
+    self.tx_testnet_wallet_address_bech32 = /\Atestcore1[02-9ac-hj-np-z]{38}\z/.freeze
+
+    # XRP Ledger uses a custom Base58 dictionary and starts with 'r', length 25-34 chars
+    self.xrp_wallet_address_bech32 = /\Ar[rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz]{24,33}\z/.freeze
+  end
+
+  module UUID
+    class << self
+      attr_accessor :v4
+    end
+
+    # UUID version 4 strict validation (e.g., 123e4567-e89b-12d3-a456-426614174000)
+    # 13th character must be '4', 17th character must be 8, 9, a, b, A, or B.
+    self.v4 = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\z/.freeze
+  end
+end

data/regexp-collection.gemspec

@@ -1,19 +1,24 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
-require File.expand_path("../lib/regexp-collection/version", __FILE__)
+require_relative "lib/regexp_collection/version"
 
 Gem::Specification.new do |s|
   s.name                  = "regexp-collection"
   s.version               = Regexp::Collection::VERSION
-  s.author                = "Yaroslav Konoplov"
-  s.email                 = "eahome00@gmail.com"
-  s.summary               = "Regular expression collection for Ruby."
-  s.description           = "A gem providing pre-made and tested typical regular expressions for applications."
+  s.authors               = ["Yaroslav Konoplov"]
+  s.email                 = ["eahome00@gmail.com"]
+  s.summary               = "Regular expression collection for Ruby"
+  s.description           = "A gem providing pre-made and tested typical regular expressions for applications"
   s.homepage              = "https://github.com/yivo/regexp-collection"
   s.license               = "MIT"
-  s.files                 = `git ls-files -z`.split("\x0")
-  s.test_files            = `git ls-files -z -- {test,spec,features}/*`.split("\x0")
+
+  s.required_ruby_version = [">= 3.0", "< 5.0"]
+
+  s.files                 = Dir.chdir File.expand_path(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
   s.require_paths         = ["lib"]
-  s.add_development_dependency "bundler", "~> 1.7"
+
+  s.add_development_dependency "rake", "~> 13.4"
+  s.add_development_dependency "test-unit", "~> 3.7"
 end

data/repomix-output.xml

@@ -0,0 +1,569 @@
+This file is a merged representation of the entire codebase, combined into a single document by Repomix.
+
+<file_summary>
+This section contains a summary of this file.
+
+<purpose>
+This file contains a packed representation of the entire repository's contents.
+It is designed to be easily consumable by AI systems for analysis, code review,
+or other automated processes.
+</purpose>
+
+<file_format>
+The content is organized as follows:
+1. This summary section
+2. Repository information
+3. Directory structure
+4. Repository files (if enabled)
+5. Multiple file entries, each consisting of:
+  - File path as an attribute
+  - Full contents of the file
+</file_format>
+
+<usage_guidelines>
+- This file should be treated as read-only. Any changes should be made to the
+  original repository files, not this packed version.
+- When processing this file, use the file path to distinguish
+  between different files in the repository.
+- Be aware that this file may contain sensitive information. Handle it with
+  the same level of security as you would the original repository.
+</usage_guidelines>
+
+<notes>
+- Some files may have been excluded based on .gitignore rules and Repomix's configuration
+- Binary files are not included in this packed representation. Please refer to the Repository Structure section for a complete list of file paths, including binary files
+- Files matching patterns in .gitignore are excluded
+- Files matching default ignore patterns are excluded
+- Files are sorted by Git change count (files with more changes are at the bottom)
+</notes>
+
+</file_summary>
+
+<directory_structure>
+lib/
+  regexp_collection/
+    version.rb
+  regexp_collection.rb
+  regexp-collection.rb
+test/
+  test_helper.rb
+  test_regexp_collection.rb
+.gitignore
+.ruby-version
+Gemfile
+LICENSE
+Rakefile
+README.md
+regexp-collection.gemspec
+</directory_structure>
+
+<files>
+This section contains the contents of the repository's files.
+
+<file path="lib/regexp_collection/version.rb">
+# frozen_string_literal: true
+
+module Regexp::Collection
+  VERSION = "2.0.0"
+end
+</file>
+
+<file path="lib/regexp_collection.rb">
+# frozen_string_literal: true
+
+module Regexp::Collection
+  module Number
+    class << self
+      attr_accessor :integer, :decimal, :natural_including_zero, :natural_excluding_zero, :hexadecimal
+
+      def natural(zero = false)
+        zero ? natural_including_zero : natural_excluding_zero
+      end
+    end
+
+    # Matches integers without leading zeros (except single 0), e.g., -10, 0, 42
+    self.integer = /\A(?:-?[1-9]\d*|0)\z/.freeze
+
+    # Matches decimals: integers or numbers with a dot followed by digits.
+    # Correctly supports negative decimals while rejecting -0 and -0.0
+    self.decimal = /\A(?:-?[1-9]\d*(?:\.\d+)?|-0\.\d*[1-9]\d*|0(?:\.\d+)?)\z/.freeze
+
+    # Matches natural numbers including 0
+    self.natural_including_zero = /\A(?:0|[1-9]\d*)\z/.freeze
+
+    # Matches natural numbers strictly greater than 0
+    self.natural_excluding_zero = /\A[1-9]\d*\z/.freeze
+
+    # Matches hexadecimal literals with 0x or 0X prefix (case-insensitive hex digits)
+    self.hexadecimal = /\A0[xX][a-fA-F0-9]+\z/.freeze
+  end
+
+  module Time
+    class << self
+      attr_accessor :seconds_required, :seconds_not_permitted, :seconds_optional
+    end
+
+    # HH:MM:SS (hour 0-23, single digit permitted: 0-9)
+    self.seconds_required = /\A(?:[01]?\d|2[0-3]):[0-5]\d:[0-5]\d\z/.freeze
+
+    # HH:MM
+    self.seconds_not_permitted = /\A(?:[01]?\d|2[0-3]):[0-5]\d\z/.freeze
+
+    # HH:MM or HH:MM:SS
+    self.seconds_optional = /\A(?:[01]?\d|2[0-3]):[0-5]\d(?::[0-5]\d)?\z/.freeze
+  end
+
+  module Crypto
+    class << self
+      attr_accessor \
+        :trx_wallet_address_base58,
+        :evm_wallet_address,
+        :evm_transaction_hash,
+        :tx_mainnet_wallet_address_bech32,
+        :tx_testnet_wallet_address_bech32
+    end
+
+    # Tron Base58Check address: starts with T, 34 chars total, excludes 0, O, I, l
+    self.trx_wallet_address_base58 = /\AT[1-9A-HJ-NP-Za-km-z]{33}\z/.freeze
+
+    # EVM address: 0x followed by exactly 40 hexadecimal characters
+    self.evm_wallet_address = /\A0x[a-fA-F0-9]{40}\z/.freeze
+
+    # EVM transaction hash: 0x followed by exactly 64 hexadecimal characters
+    self.evm_transaction_hash = /\A0x[a-fA-F0-9]{64}\z/.freeze
+
+    self.tx_mainnet_wallet_address_bech32 = /\Acore1[02-9ac-hj-np-z]{38}\z/.freeze
+
+    self.tx_testnet_wallet_address_bech32 = /\Atestcore1[02-9ac-hj-np-z]{38}\z/.freeze
+  end
+end
+</file>
+
+<file path="test/test_helper.rb">
+# frozen_string_literal: true
+
+require "test-unit"
+require "regexp_collection"
+
+Test::Unit::TestCase.test_order = :random
+</file>
+
+<file path="test/test_regexp_collection.rb">
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class RegexpCollectionTest < Test::Unit::TestCase
+  test "Version constant" do
+    assert_not_nil Regexp::Collection::VERSION
+    assert_true Regexp::Collection::VERSION.match?(/\A\d+\.\d+\.\d+\z/)
+  end
+
+  test "Number.integer" do
+    regexp = Regexp::Collection::Number.integer
+
+    # Valid
+    assert_true "0".match?(regexp)
+    assert_true "1".match?(regexp)
+    assert_true "2".match?(regexp)
+    assert_true "-1".match?(regexp)
+    assert_true "10".match?(regexp)
+    assert_true "100".match?(regexp)
+    assert_true "1000".match?(regexp)
+    assert_true "9999".match?(regexp)
+    assert_true "-9999".match?(regexp)
+    assert_true "9000000".match?(regexp)
+
+    # Invalid - zero variations
+    assert_false "-0".match?(regexp)
+    assert_false "+0".match?(regexp)
+    assert_false "00".match?(regexp)
+    assert_false "-00".match?(regexp)
+    assert_false "+00".match?(regexp)
+
+    # Invalid - leading plus and leading zeros
+    assert_false "+1".match?(regexp)
+    assert_false "+42".match?(regexp)
+    assert_false "01".match?(regexp)
+    assert_false "-01".match?(regexp)
+
+    # Invalid - characters and formatting
+    assert_false "".match?(regexp)
+    assert_false " ".match?(regexp)
+    assert_false "-".match?(regexp)
+    assert_false "1xx".match?(regexp)
+    assert_false "xx1".match?(regexp)
+    assert_false "-x1".match?(regexp)
+    assert_false "-1x".match?(regexp)
+    assert_false "1,000".match?(regexp)
+    assert_false "1.0".match?(regexp)
+
+    # Edge cases - multiline injection checks (\A and \z)
+    assert_false "1\n".match?(regexp)
+    assert_false "\n1".match?(regexp)
+    assert_false "1\n2".match?(regexp)
+  end
+
+  test "Number.decimal" do
+    regexp = Regexp::Collection::Number.decimal
+
+    # Valid - integers
+    assert_true "0".match?(regexp)
+    assert_true "1".match?(regexp)
+    assert_true "-1".match?(regexp)
+    assert_true "100".match?(regexp)
+
+    # Valid - standard decimals
+    assert_true "0.0".match?(regexp)
+    assert_true "0.5".match?(regexp)
+    assert_true "0.12345".match?(regexp)
+    assert_true "1.0".match?(regexp)
+    assert_true "-1.0".match?(regexp)
+    assert_true "12.34".match?(regexp)
+    assert_true "-12.34".match?(regexp)
+
+    # Valid - negative fractions strictly less than 0
+    assert_true "-0.5".match?(regexp)
+    assert_true "-0.01".match?(regexp)
+    assert_true "-0.00001".match?(regexp)
+
+    # Invalid - zero forms
+    assert_false "-0".match?(regexp)
+    assert_false "+0".match?(regexp)
+    assert_false "-0.0".match?(regexp)
+    assert_false "-0.00".match?(regexp)
+    assert_false "+0.0".match?(regexp)
+    assert_false "+00.0".match?(regexp)
+
+    # Invalid - leading plus and leading zeros
+    assert_false "+1".match?(regexp)
+    assert_false "+1.0".match?(regexp)
+    assert_false "+0.5".match?(regexp)
+    assert_false "01".match?(regexp)
+    assert_false "01.5".match?(regexp)
+
+    # Invalid - structure
+    assert_false ".".match?(regexp)
+    assert_false ".5".match?(regexp)
+    assert_false "-.5".match?(regexp)
+    assert_false "1.".match?(regexp)
+    assert_false "1.2.3".match?(regexp)
+    assert_false "-1.5x".match?(regexp)
+    assert_false "1e5".match?(regexp)
+    assert_false "".match?(regexp)
+
+    # Edge cases - multiline injection checks
+    assert_false "1.5\n".match?(regexp)
+    assert_false "\n1.5".match?(regexp)
+  end
+
+  test "Number.natural" do
+    # Default argument must equal natural(false)
+    assert_equal Regexp::Collection::Number.natural(false), Regexp::Collection::Number.natural
+
+    # natural(true) - including zero
+    reg_with_zero = Regexp::Collection::Number.natural(true)
+    assert_true "0".match?(reg_with_zero)
+    assert_true "1".match?(reg_with_zero)
+    assert_true "16".match?(reg_with_zero)
+    assert_true "999999".match?(reg_with_zero)
+    assert_false "-0".match?(reg_with_zero)
+    assert_false "+0".match?(reg_with_zero)
+    assert_false "00".match?(reg_with_zero)
+    assert_false "-1".match?(reg_with_zero)
+    assert_false "+1".match?(reg_with_zero)
+    assert_false "0.0".match?(reg_with_zero)
+    assert_false "1.0".match?(reg_with_zero)
+    assert_false "0foo".match?(reg_with_zero)
+    assert_false "0\n".match?(reg_with_zero)
+
+    # natural(false) - excluding zero
+    reg_without_zero = Regexp::Collection::Number.natural(false)
+    assert_false "0".match?(reg_without_zero)
+    assert_true "1".match?(reg_without_zero)
+    assert_true "16".match?(reg_without_zero)
+    assert_false "-1".match?(reg_without_zero)
+    assert_false "+1".match?(reg_without_zero)
+    assert_false "01".match?(reg_without_zero)
+    assert_false "".match?(reg_without_zero)
+  end
+
+  test "Number.hexadecimal" do
+    regexp = Regexp::Collection::Number.hexadecimal
+
+    # Valid
+    assert_true "0x0".match?(regexp)
+    assert_true "0x1".match?(regexp)
+    assert_true "0xabcdef".match?(regexp)
+    assert_true "0xABCDEF".match?(regexp)
+    assert_true "0x1a2B3c".match?(regexp)
+    assert_true "0X1a2b".match?(regexp)
+    assert_true "0XDEADBEEF".match?(regexp)
+
+    # Invalid
+    assert_false "".match?(regexp)
+    assert_false "0x".match?(regexp)
+    assert_false "0X".match?(regexp)
+    assert_false "abcdef".match?(regexp)
+    assert_false "x12".match?(regexp)
+    assert_false "0x12g".match?(regexp)
+    assert_false "0x12Z".match?(regexp)
+    assert_false "-0x12".match?(regexp)
+    assert_false " 0x12".match?(regexp)
+    assert_false "0x12\n".match?(regexp)
+  end
+
+  test "Time.seconds_required" do
+    regexp = Regexp::Collection::Time.seconds_required
+
+    # Valid
+    assert_true "00:00:00".match?(regexp)
+    assert_true "01:00:00".match?(regexp)
+    assert_true "1:00:00".match?(regexp)
+    assert_true "12:11:10".match?(regexp)
+    assert_true "12:10:09".match?(regexp)
+    assert_true "23:59:59".match?(regexp)
+
+    # Invalid - missing or excess parts
+    assert_false "".match?(regexp)
+    assert_false "12".match?(regexp)
+    assert_false "12:11".match?(regexp)
+    assert_false "12:11:".match?(regexp)
+    assert_false ":12:11:10".match?(regexp)
+    assert_false "12:0:0".match?(regexp)
+    assert_false "12:10:09.111".match?(regexp)
+
+    # Invalid - boundaries
+    assert_false "24:00:00".match?(regexp)
+    assert_false "25:00:00".match?(regexp)
+    assert_false "12:60:00".match?(regexp)
+    assert_false "12:11:60".match?(regexp)
+
+    # Edge cases
+    assert_false "+12:11:10".match?(regexp)
+    assert_false "12:11:10foo".match?(regexp)
+    assert_false "12:11:10\n".match?(regexp)
+  end
+
+  test "Time.seconds_optional" do
+    regexp = Regexp::Collection::Time.seconds_optional
+
+    # Valid
+    assert_true "00:00".match?(regexp)
+    assert_true "00:00:00".match?(regexp)
+    assert_true "1:00".match?(regexp)
+    assert_true "1:00:00".match?(regexp)
+    assert_true "12:11".match?(regexp)
+    assert_true "12:11:10".match?(regexp)
+    assert_true "23:59".match?(regexp)
+    assert_true "23:59:59".match?(regexp)
+
+    # Invalid
+    assert_false "".match?(regexp)
+    assert_false "12".match?(regexp)
+    assert_false "12:".match?(regexp)
+    assert_false "12:11:".match?(regexp)
+    assert_false "24:00".match?(regexp)
+    assert_false "24:00:00".match?(regexp)
+    assert_false "12:60".match?(regexp)
+    assert_false "12:11:60".match?(regexp)
+    assert_false "12:11:10\n".match?(regexp)
+  end
+
+  test "Time.seconds_not_permitted" do
+    regexp = Regexp::Collection::Time.seconds_not_permitted
+
+    # Valid
+    assert_true "00:00".match?(regexp)
+    assert_true "01:00".match?(regexp)
+    assert_true "1:00".match?(regexp)
+    assert_true "12:11".match?(regexp)
+    assert_true "23:59".match?(regexp)
+
+    # Invalid
+    assert_false "".match?(regexp)
+    assert_false "12:11:10".match?(regexp)
+    assert_false "01:00:00".match?(regexp)
+    assert_false "24:00".match?(regexp)
+    assert_false "12:60".match?(regexp)
+    assert_false "12:11\n".match?(regexp)
+  end
+
+  test "Crypto.trx_wallet_address_base58" do
+    regexp = Regexp::Collection::Crypto.trx_wallet_address_base58
+
+    # Valid TRON Base58 addresses (starts with T, 34 chars)
+    assert_true "TNDzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+    assert_true "TN3W4H6rK2ce4vX9YnFQHwKENnHjoxb3m9".match?(regexp)
+    assert_true "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH".match?(regexp)
+
+    # Invalid - wrong prefix
+    assert_false "ANDzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+    assert_false "41DzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+
+    # Invalid - incorrect length
+    assert_false "TNDzfERD73nNqaTTrvNX7moW2GFp3W5am".match?(regexp)  # 33 chars
+    assert_false "TNDzfERD73nNqaTTrvNX7moW2GFp3W5amzz".match?(regexp) # 35 chars
+
+    # Invalid - non-Base58 characters (0, O, I, l)
+    assert_false "T0DzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+    assert_false "TODzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+    assert_false "TIDzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+    assert_false "TlDzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+
+    # Invalid - spaces and newlines
+    assert_false " TNDzfERD73nNqaTTrvNX7moW2GFp3W5amz".match?(regexp)
+    assert_false "TNDzfERD73nNqaTTrvNX7moW2GFp3W5amz\n".match?(regexp)
+    assert_false "".match?(regexp)
+  end
+
+  test "Crypto.evm_wallet_address" do
+    regexp = Regexp::Collection::Crypto.evm_wallet_address
+
+    # Valid (40 hex chars after 0x)
+    assert_true "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045".match?(regexp)
+    assert_true "0x0000000000000000000000000000000000000000".match?(regexp)
+    assert_true "0xffffffffffffffffffffffffffffffffffffffff".match?(regexp)
+    assert_true "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".match?(regexp)
+
+    # Invalid - non-hex characters (g-z, G-Z)
+    assert_false "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA9604G".match?(regexp)
+    assert_false "0xZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ".match?(regexp)
+
+    # Invalid - missing prefix
+    assert_false "d8dA6BF26964aF9D7eEd9e03E53415D37aA96045".match?(regexp)
+
+    # Invalid - incorrect length
+    assert_false "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA9604".match?(regexp)   # 39 chars
+    assert_false "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA960455".match?(regexp) # 41 chars
+
+    # Invalid - spaces and newlines
+    assert_false " 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045".match?(regexp)
+    assert_false "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045\n".match?(regexp)
+    assert_false "".match?(regexp)
+  end
+
+  test "Crypto.evm_transaction_hash" do
+    regexp = Regexp::Collection::Crypto.evm_transaction_hash
+
+    # Valid (64 hex chars after 0x)
+    assert_true "0x5c504ed432cb51138b309d43e110f94f6470077cbe40191498b82a8763046ad1".match?(regexp)
+    assert_true "0x5C504ED432CB51138B309D43E110F94F6470077CBE40191498B82A8763046AD1".match?(regexp)
+    assert_true "0x0000000000000000000000000000000000000000000000000000000000000000".match?(regexp)
+
+    # Invalid - non-hex characters
+    assert_false "0x5c504ed432cb51138b309d43e110f94f6470077cbe40191498b82a8763046adG".match?(regexp)
+
+    # Invalid - missing prefix
+    assert_false "5c504ed432cb51138b309d43e110f94f6470077cbe40191498b82a8763046ad1".match?(regexp)
+
+    # Invalid - length
+    assert_false "0x5c504ed432cb51138b309d43e110f94f6470077cbe40191498b82a8763046ad".match?(regexp)   # 63 chars
+    assert_false "0x5c504ed432cb51138b309d43e110f94f6470077cbe40191498b82a8763046ad11".match?(regexp) # 65 chars
+
+    # Invalid - spaces and newlines
+    assert_false "0x5c504ed432cb51138b309d43e110f94f6470077cbe40191498b82a8763046ad1\n".match?(regexp)
+    assert_false "".match?(regexp)
+  end
+end
+</file>
+
+<file path=".gitignore">
+*.gem
+.bundle
+pkg/
+tmp/
+/.idea
+</file>
+
+<file path="Gemfile">
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+</file>
+
+<file path="Rakefile">
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+ENV["TESTOPTS"] = "--verbose"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/test_*.rb"
+end
+
+task default: :test
+</file>
+
+<file path="lib/regexp-collection.rb">
+# frozen_string_literal: true
+
+require_relative "regexp_collection"
+</file>
+
+<file path=".ruby-version">
+4.0.7
+</file>
+
+<file path="LICENSE">
+The MIT License (MIT)
+
+Copyright (c) 2018 Yaroslav Konoplov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+</file>
+
+<file path="README.md">
+# regexp-collection
+
+A gem providing pre-made and tested typical regular expressions for applications.
+</file>
+
+<file path="regexp-collection.gemspec">
+# frozen_string_literal: true
+
+require_relative "lib/regexp_collection/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "regexp-collection"
+  s.version               = Regexp::Collection::VERSION
+  s.authors               = ["Yaroslav Konoplov"]
+  s.email                 = ["eahome00@gmail.com"]
+  s.summary               = "Regular expression collection for Ruby"
+  s.description           = "A gem providing pre-made and tested typical regular expressions for applications"
+  s.homepage              = "https://github.com/yivo/regexp-collection"
+  s.license               = "MIT"
+
+  s.required_ruby_version = [">= 3.0", "< 5.0"]
+
+  s.files                 = Dir.chdir File.expand_path(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  s.require_paths         = ["lib"]
+
+  s.add_development_dependency "rake", "~> 13.4"
+  s.add_development_dependency "test-unit", "~> 3.7"
+end
+</file>
+
+</files>

metadata

@@ -1,31 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: regexp-collection
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Yaroslav Konoplov
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '13.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
-description: A gem providing pre-made and tested typical regular expressions for applications.
-email: eahome00@gmail.com
+        version: '13.4'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: A gem providing pre-made and tested typical regular expressions for applications
+email:
+- eahome00@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -38,15 +52,14 @@ files:
 - README.md
 - Rakefile
 - lib/regexp-collection.rb
-- lib/regexp-collection/version.rb
+- lib/regexp_collection.rb
+- lib/regexp_collection/version.rb
 - regexp-collection.gemspec
-- test/helper.rb
-- test/test-regexp-collection.rb
+- repomix-output.xml
 homepage: https://github.com/yivo/regexp-collection
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -54,18 +67,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '5.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 4.0.22
 specification_version: 4
-summary: Regular expression collection for Ruby.
-test_files:
-- test/helper.rb
-- test/test-regexp-collection.rb
+summary: Regular expression collection for Ruby
+test_files: []

data/test/helper.rb

@@ -1,6 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-Bundler.require
-
-Test::Unit::TestCase.test_order = :random

data/test/test-regexp-collection.rb

@@ -1,115 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require_relative "helper"
-
-class RegexpCollectionTest < Test::Unit::TestCase
-  test "Numbers.integer" do
-    regexp = Regexp::Collection::Numbers.integer
-    assert_true "1".match?(regexp)
-    assert_true "2".match?(regexp)
-    assert_false "01".match?(regexp)
-    assert_false "-0".match?(regexp)
-    assert_false "-00".match?(regexp)
-    assert_false "+0".match?(regexp)
-    assert_false "+00".match?(regexp)
-    assert_false "+1".match?(regexp)
-    assert_true "-1".match?(regexp)
-    assert_true "10".match?(regexp)
-    assert_false "1xx".match?(regexp)
-    assert_false "xx1".match?(regexp)
-    assert_false "-x1".match?(regexp)
-    assert_false "-1x".match?(regexp)
-    assert_true "10".match?(regexp)
-    assert_true "100".match?(regexp)
-    assert_true "1000".match?(regexp)
-    assert_true "9999".match?(regexp)
-    assert_true "9000000".match?(regexp)
-    assert_false "00".match?(regexp)
-    assert_false " ".match?(regexp)
-  end
-
-  test "Numbers.decimal" do
-    regexp = Regexp::Collection::Numbers.decimal
-    assert_true "1".match?(regexp)
-    assert_true "2".match?(regexp)
-    assert_false "01".match?(regexp)
-    assert_false "-0".match?(regexp)
-    assert_false "+0".match?(regexp)
-    assert_false "+1".match?(regexp)
-    assert_true "-1".match?(regexp)
-    assert_true "10".match?(regexp)
-    assert_false "1xx".match?(regexp)
-    assert_false "xx1".match?(regexp)
-    assert_false "-x1".match?(regexp)
-    assert_false "-1x".match?(regexp)
-    assert_false "-1.5x".match?(regexp)
-    assert_true "10".match?(regexp)
-    assert_true "100".match?(regexp)
-    assert_true "1000".match?(regexp)
-    assert_true "9999".match?(regexp)
-    assert_true "9000000".match?(regexp)
-    assert_false "-0.0".match?(regexp)
-    assert_false "+0.0".match?(regexp)
-    assert_false "+1.0".match?(regexp)
-    assert_true "-1.0".match?(regexp)
-    assert_true "0.0".match?(regexp)
-    assert_false "+00.0".match?(regexp)
-  end
-
-  test "Numbers.natural(true)" do
-    regexp = Regexp::Collection::Numbers.natural(true)
-    assert_true "0".match?(regexp)
-    assert_false "-0".match?(regexp)
-    assert_false "+0".match?(regexp)
-    assert_false "0.0".match?(regexp)
-    assert_false "-0.0".match?(regexp)
-    assert_false "+0.0".match?(regexp)
-    assert_false "00".match?(regexp)
-    assert_true "1".match?(regexp)
-    assert_false "-1".match?(regexp)
-    assert_false "+1".match?(regexp)
-    assert_false "1.0".match?(regexp)
-    assert_false "-1.0".match?(regexp)
-    assert_false "+1.0".match?(regexp)
-    assert_false "1.1".match?(regexp)
-    assert_false "-1.1".match?(regexp)
-    assert_false "+1.1".match?(regexp)
-    assert_false "foo".match?(regexp)
-    assert_false "0foo".match?(regexp)
-    assert_false "-0foo".match?(regexp)
-    assert_false "+0foo".match?(regexp)
-    assert_false "1foo".match?(regexp)
-    assert_false "-1foo".match?(regexp)
-    assert_false "+1foo".match?(regexp)
-    assert_true "16".match?(regexp)
-  end
-
-  test "Numbers.natural(false)" do
-    regexp = Regexp::Collection::Numbers.natural(false)
-    assert_false "0".match?(regexp)
-    assert_false "-0".match?(regexp)
-    assert_false "+0".match?(regexp)
-    assert_false "0.0".match?(regexp)
-    assert_false "-0.0".match?(regexp)
-    assert_false "+0.0".match?(regexp)
-    assert_false "00".match?(regexp)
-    assert_true "1".match?(regexp)
-    assert_false "-1".match?(regexp)
-    assert_false "+1".match?(regexp)
-    assert_false "1.0".match?(regexp)
-    assert_false "-1.0".match?(regexp)
-    assert_false "+1.0".match?(regexp)
-    assert_false "1.1".match?(regexp)
-    assert_false "-1.1".match?(regexp)
-    assert_false "+1.1".match?(regexp)
-    assert_false "foo".match?(regexp)
-    assert_false "0foo".match?(regexp)
-    assert_false "-0foo".match?(regexp)
-    assert_false "+0foo".match?(regexp)
-    assert_false "1foo".match?(regexp)
-    assert_false "-1foo".match?(regexp)
-    assert_false "+1foo".match?(regexp)
-    assert_true "16".match?(regexp)
-  end
-end