string_validator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a5a08752d7f73d74fa45b4dec5d17815e71bb547c30a1364540923bb10e5649a
+  data.tar.gz: 75c37d3612370ccefa9504d2b466b0a06a9e618363c2a6d0bd53df43663f4136
+SHA512:
+  metadata.gz: 192ae47895b814e8b8bbbb268009e8f9a6ed77135e8718f6948758fb92eb25bd46317d59ba3b40e04c1c14e44774aeb47e4081cbbeede870063ba51d3213b360
+  data.tar.gz: 1da02180de5a833956a6ae3a6aae356bc5518240f9a9452a981fb0e4f0adf92a15e61dd30d83975e8d7bc0b01eb0784ce3cf1a5d9f32c851c4a731b3e670a4e0

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## [0.1.0] - 2025-02-16
+
+### Added
+
+- Initial release
+- Validators: `is_email?`, `is_url?`, `is_ip?`, `is_empty?`, `is_length?`, `is_alpha?`, `is_alphanumeric?`, `is_numeric?`, `is_int?`, `is_float?`, `is_boolean?`, `is_json?`, `is_base64?`, `is_hex_color?`, `is_uuid?`, `is_ascii?`, `is_slug?`, `is_mac_address?`, `is_credit_card?`, `is_md5?`, `is_hexadecimal?`, `contains?`, `equals?`, `is_in?`
+- Sanitizers: `escape`, `unescape`, `trim`, `blacklist`, `whitelist`, `strip_low`, `to_boolean`, `to_int`, `to_float`
+- `StringValidator.valid?(str, :validator_name, **options)` for safe validation with NotStringError

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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.

data/README.md

@@ -0,0 +1,146 @@
+# StringValidator
+
+A Ruby port of [validator.js](https://github.com/validatorjs/validator.js) — a comprehensive library of **string validators** and **sanitizers** for Ruby and Rails.
+
+Validator.js has 23k+ GitHub stars and 18M+ weekly npm downloads. Until now, Ruby had no single gem offering the same API. Use this for API params, form input, background jobs, or any place you need to validate or sanitize strings.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "string_validator"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install globally:
+
+```bash
+gem install string_validator
+```
+
+## Usage
+
+All methods are on the `StringValidator` module. Input must be a String (validator.js is strings-only too).
+
+### Validators
+
+Return `true` or `false`.
+
+```ruby
+require "string_validator"
+
+StringValidator.is_email?("foo@bar.com")        # => true
+StringValidator.is_email?("invalid")            # => false
+
+StringValidator.is_url?("https://example.com") # => true
+StringValidator.is_url?("not a url")            # => false
+
+StringValidator.is_ip?("192.168.1.1")          # => true
+StringValidator.is_ip?("::1", version: 6)       # => true
+
+StringValidator.is_empty?("  ")                 # => false
+StringValidator.is_empty?("  ", ignore_whitespace: true) # => true
+
+StringValidator.is_length?("hello", min: 1, max: 10) # => true
+
+StringValidator.is_alpha?("abc")                # => true
+StringValidator.is_alphanumeric?("user123")    # => true
+StringValidator.is_numeric?("42.5")            # => true
+StringValidator.is_int?("42", min: 0, max: 100) # => true
+StringValidator.is_float?("3.14")              # => true
+
+StringValidator.is_boolean?("true")            # => true
+StringValidator.is_boolean?("yes", loose: true) # => true
+
+StringValidator.is_json?('{"a":1}')             # => true
+StringValidator.is_base64?("SGVsbG8=")         # => true
+StringValidator.is_hex_color?("#ff0000")       # => true
+StringValidator.is_uuid?("550e8400-e29b-41d4-a716-446655440000") # => true
+StringValidator.is_ascii?("Hello")             # => true
+StringValidator.is_slug?("my-post-title")     # => true
+StringValidator.is_mac_address?("01:02:03:04:05:ab") # => true
+StringValidator.is_credit_card?("4111111111111111") # => true (Luhn check)
+StringValidator.is_md5?("d41d8cd98f00b204e9800998ecf8427e") # => true
+StringValidator.is_hexadecimal?("0a1f")       # => true
+
+StringValidator.contains?("hello world", "world") # => true
+StringValidator.equals?("foo", "foo")          # => true
+StringValidator.is_in?("red", %w[red green blue]) # => true
+```
+
+### Sanitizers
+
+Return a transformed string (or the original if not a string).
+
+```ruby
+StringValidator.escape("<script>alert('x')</script>")
+# => "&lt;script&gt;alert(&#x27;x&#x27;)&lt;&#x2F;script&gt;"
+
+StringValidator.trim("  hello  ")              # => "hello"
+StringValidator.blacklist("hello world", "ol") # => "he wrd"
+StringValidator.whitelist("abc123", "0123456789") # => "123"
+StringValidator.whitelist("abc123", "a-c0-9")      # => "abc123"
+StringValidator.strip_low("hello\x00world")   # => "helloworld"
+
+StringValidator.to_boolean("true")             # => true
+StringValidator.to_boolean("false")           # => false
+StringValidator.to_boolean("yes", strict: false) # => true
+StringValidator.to_int("42")                  # => 42
+StringValidator.to_float("3.14")              # => 3.14
+
+StringValidator.unescape("&lt;tag&gt;")        # => "<tag>"
+```
+
+### Rails / ActiveModel
+
+Use in custom validators or in models:
+
+```ruby
+# app/validators/email_validator.rb
+class EmailValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if value.blank?
+    unless StringValidator.is_email?(value.to_s)
+      record.errors.add(attribute, options[:message] || "is not a valid email")
+    end
+  end
+end
+```
+
+Or inline:
+
+```ruby
+validate :email_format
+
+def email_format
+  return if email.blank?
+  errors.add(:email, "invalid") unless StringValidator.is_email?(email)
+end
+```
+
+### Safe validation helper
+
+Raises `StringValidator::NotStringError` if the input is not a String:
+
+```ruby
+StringValidator.valid?("user@example.com", :is_email?) # => true
+StringValidator.valid?(nil, :is_email?)               # => raises NotStringError
+```
+
+## Supported Ruby
+
+Ruby 3.0+.
+
+## License
+
+MIT. See [LICENSE](LICENSE.txt).
+
+## Credits
+
+API and behavior are inspired by [validator.js](https://github.com/validatorjs/validator.js) (MIT). This gem is an independent Ruby implementation for the Ruby community.

data/lib/string_validator/sanitizers.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module StringValidator
+  module Sanitizers
+    HTML_ESCAPE = {
+      "&" => "&",
+      "<" => "&lt;",
+      ">" => "&gt;",
+      '"' => "&quot;",
+      "'" => "&#x27;",
+      "/" => "&#x2F;"
+    }.freeze
+
+    def escape(str)
+      return str unless str.is_a?(String)
+      str.gsub(/[&<>"'\/]/, HTML_ESCAPE)
+    end
+
+    def trim(str, chars = nil)
+      return str unless str.is_a?(String)
+      if chars
+        str.gsub(/\A[#{Regexp.escape(chars)}]+|[#{Regexp.escape(chars)}]+\z/, "")
+      else
+        str.strip
+      end
+    end
+
+    def blacklist(str, chars)
+      return str unless str.is_a?(String)
+      str.delete(chars)
+    end
+
+    def whitelist(str, chars)
+      return str unless str.is_a?(String)
+      str.each_char.select { |c| chars.include?(c) }.join
+    end
+
+    def strip_low(str, keep_new_lines: false)
+      return str unless str.is_a?(String)
+      if keep_new_lines
+        str.each_char.select { |c| c.ord >= 32 || c == "\n" }.join
+      else
+        str.each_char.select { |c| c.ord >= 32 }.join
+      end
+    end
+
+    def to_boolean(str, strict: true)
+      return str unless str.is_a?(String)
+      s = str.downcase.strip
+      return true if s == "true" || s == "1"
+      return false if s == "false" || s == "0"
+      return true if !strict && %w[yes y].include?(s)
+      return false if !strict && %w[no n].include?(s)
+      str
+    end
+
+    def to_int(str, radix: 10)
+      return str unless str.is_a?(String)
+      Integer(str, radix)
+    rescue ArgumentError
+      str
+    end
+
+    def to_float(str)
+      return str unless str.is_a?(String)
+      Float(str)
+    rescue ArgumentError
+      str
+    end
+
+    def unescape(str)
+      return str unless str.is_a?(String)
+      str
+        .gsub("&amp;", "&")
+        .gsub("&lt;", "<")
+        .gsub("&gt;", ">")
+        .gsub("&quot;", '"')
+        .gsub("&#x27;", "'")
+        .gsub("&#x2F;", "/")
+    end
+  end
+end

data/lib/string_validator/validators.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "uri"
+require "json"
+require "base64"
+
+module StringValidator
+  module Validators
+    # RFC 5322 simplified email regex (validator.js compatible)
+    EMAIL_REGEX = /\A[^\s@]+@[^\s@]+\.[^\s@]+\z/
+
+    def is_email?(str, allow_display_name: false, require_tld: true)
+      return false unless str.is_a?(String)
+      s = str.strip
+      s = s.gsub(/\A.*<([^>]+)>\z/, '\1') if allow_display_name
+      return false if s.include?("..") || s.start_with?(".") || s.include?("@.")
+      return false if require_tld && !s.include?(".")
+      s.match?(EMAIL_REGEX)
+    end
+
+    def is_url?(str, protocols: %w[http https ftp], require_protocol: false, require_tld: true)
+      return false unless str.is_a?(String)
+      s = str.strip
+      return false if s.include?(" ")
+      if require_protocol
+        return false unless protocols.any? { |p| s.downcase.start_with?("#{p}:") }
+      end
+      begin
+        uri = ::URI.parse(s)
+        return false if uri.host.nil? && uri.opaque.nil?
+        if require_tld && uri.host && !uri.host.include?(".")
+        return false
+      end
+      true
+      rescue ::URI::InvalidURIError
+        false
+      end
+    end
+
+    def is_ip?(str, version: nil)
+      return false unless str.is_a?(String)
+      case version
+      when 4, "4"
+        str.match?(/\A(?:(?:25[0-5]|2[0-4]\d|1?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|1?\d\d?)\z/)
+      when 6, "6"
+        str.match?(/\A(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\z/) ||
+          str.match?(/\A::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}\z/) ||
+          str.match?(/\A(?:[0-9a-fA-F]{1,4}:){1,7}:\z/) # simplified IPv6
+      else
+        is_ip?(str, version: 4) || is_ip?(str, version: 6)
+      end
+    end
+
+    def is_empty?(str, ignore_whitespace: false)
+      return false unless str.is_a?(String)
+      s = ignore_whitespace ? str.strip : str
+      s.empty?
+    end
+
+    def is_length?(str, min: 0, max: nil)
+      return false unless str.is_a?(String)
+      len = str.length
+      return false if len < min
+      return false if max && len > max
+      true
+    end
+
+    def is_alpha?(str, locale: "en-US")
+      return false unless str.is_a?(String)
+      return str.match?(/\A[a-zA-Z]+\z/) if locale.to_s.downcase.start_with?("en")
+      str.match?(/\A\p{L}+\z/)
+    end
+
+    def is_alphanumeric?(str, locale: "en-US")
+      return false unless str.is_a?(String)
+      return str.match?(/\A[a-zA-Z0-9]+\z/) if locale.to_s.downcase.start_with?("en")
+      str.match?(/\A[\p{L}0-9]+\z/)
+    end
+
+    def is_numeric?(str, no_symbols: false)
+      return false unless str.is_a?(String)
+      return str.match?(/\A\d+\z/) if no_symbols
+      str.match?(/\A[-+]?\d*\.?\d+\z/)
+    end
+
+    def is_int?(str, min: nil, max: nil, allow_leading_zeroes: true)
+      return false unless str.is_a?(String)
+      return false if !allow_leading_zeroes && str.match?(/\A0\d+\z/)
+      return false unless str.match?(/\A[-+]?\d+\z/)
+      n = str.to_i
+      return false if min && n < min
+      return false if max && n > max
+      true
+    end
+
+    def is_float?(str, min: nil, max: nil)
+      return false unless str.is_a?(String)
+      return false unless str.match?(/\A[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?\z/)
+      n = str.to_f
+      return false if min && n < min
+      return false if max && n > max
+      true
+    end
+
+    def is_boolean?(str, loose: false)
+      return false unless str.is_a?(String)
+      strict = %w[true false 0 1]
+      loose_list = strict + %w[yes no]
+      list = loose ? loose_list : strict
+      list.include?(str.downcase)
+    end
+
+    def is_json?(str, allow_primitives: false)
+      return false unless str.is_a?(String)
+      return true if allow_primitives && %w[true false null].include?(str.strip)
+      ::JSON.parse(str)
+      true
+    rescue ::JSON::ParserError
+      false
+    end
+
+    def is_base64?(str, url_safe: false)
+      return false unless str.is_a?(String)
+      regex = url_safe ? /\A[A-Za-z0-9_-]*\z/ : /\A[A-Za-z0-9+\/=]*\z/
+      return false unless str.match?(regex)
+      return true if str.empty?
+      s = url_safe ? str.tr("-_", "+/") : str
+      ::Base64.strict_decode64(s)
+      true
+    rescue ::ArgumentError
+      false
+    end
+
+    def is_hex_color?(str, require_hashtag: false)
+      return false unless str.is_a?(String)
+      return false if require_hashtag && !str.start_with?("#")
+      str.match?(/\A#?([0-9a-fA-F]{3}){1,2}\z/)
+    end
+
+    def is_uuid?(str, version: nil)
+      return false unless str.is_a?(String)
+      uuid_regex = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89ab][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\z/
+      return str.match?(uuid_regex) if version.nil?
+      v = version.to_s
+      return false unless str.match?(uuid_regex)
+      str[14] == v
+    end
+
+    def is_ascii?(str)
+      return false unless str.is_a?(String)
+      str.ascii_only?
+    end
+
+    def is_slug?(str)
+      return false unless str.is_a?(String)
+      str.match?(/\A[a-z0-9]+(?:-[a-z0-9]+)*\z/)
+    end
+
+    def is_mac_address?(str, no_separators: false)
+      return false unless str.is_a?(String)
+      if no_separators
+        str.match?(/\A[0-9a-fA-F]{12}\z/)
+      else
+        str.match?(/\A[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}\z/) ||
+          str.match?(/\A[0-9a-fA-F]{2}(-[0-9a-fA-F]{2}){5}\z/) ||
+          str.match?(/\A[0-9a-fA-F]{2}(\.[0-9a-fA-F]{2}){5}\z/) ||
+          str.match?(/\A[0-9a-fA-F]{2}( [0-9a-fA-F]{2}){5}\z/)
+      end
+    end
+
+    def contains?(str, seed, ignore_case: false, min_occurrences: 1)
+      return false unless str.is_a?(String)
+      s = str
+      s = s.downcase if ignore_case
+      se = ignore_case ? seed.downcase : seed
+      count = s.scan(Regexp.escape(se)).size
+      count >= min_occurrences
+    end
+
+    def equals?(str, comparison)
+      return false unless str.is_a?(String)
+      str == comparison.to_s
+    end
+
+    def is_in?(str, values)
+      return false unless str.is_a?(String)
+      Array(values).map(&:to_s).include?(str)
+    end
+
+    def is_credit_card?(str, provider: nil)
+      return false unless str.is_a?(String)
+      digits = str.gsub(/\D/, "")
+      return false unless digits.length >= 13 && digits.length <= 19
+      return false unless luhn_valid?(digits)
+      return true if provider.nil? || provider.to_s.empty?
+      case provider.to_s.downcase
+      when "visa" then digits.start_with?("4")
+      when "mastercard", "master" then digits.match?(/\A5[1-5]\d{14}\z/) || digits.match?(/\A2(?:2[2-9]|[3-6]\d|7[01])\d{12}\z/)
+      when "amex" then digits.match?(/\A3[47]\d{13}\z/)
+      when "discover" then digits.start_with?("6011", "65", "644", "645", "646", "647", "648", "649") || digits.match?(/\A62\d{14}\z/)
+      else true
+      end
+    end
+
+    def is_md5?(str)
+      return false unless str.is_a?(String)
+      str.match?(/\A[0-9a-fA-F]{32}\z/)
+    end
+
+    def is_hexadecimal?(str)
+      return false unless str.is_a?(String)
+      str.match?(/\A[0-9a-fA-F]+\z/)
+    end
+
+    private
+
+    def luhn_valid?(digits)
+      sum = 0
+      digits.reverse.chars.each_with_index do |c, i|
+        n = c.to_i
+        n *= 2 if i.odd?
+        n -= 9 if n > 9
+        sum += n
+      end
+      (sum % 10).zero?
+    end
+  end
+end

data/lib/string_validator/version.rb

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

data/lib/string_validator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "string_validator/version"
+require "string_validator/validators"
+require "string_validator/sanitizers"
+
+module StringValidator
+  extend Validators
+  extend Sanitizers
+
+  class Error < StandardError; end
+  class NotStringError < Error; end
+
+  def self.valid?(str, validator_name, **options)
+    raise NotStringError, "input must be a String" unless str.is_a?(String)
+    public_send(validator_name, str, **options)
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: string_validator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Raj Panchal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-02-16 00:00:00.000000000 Z
+dependencies: []
+description: A comprehensive library of string validators (is_email?, is_url?, is_ip?,
+  etc.) and sanitizers (escape, trim, etc.) for Ruby. Brings validator.js-style API
+  to Ruby/Rails.
+email:
+- rajpanchal2810@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/string_validator.rb
+- lib/string_validator/sanitizers.rb
+- lib/string_validator/validators.rb
+- lib/string_validator/version.rb
+homepage: https://github.com/rajpanchal01/string_validator
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rajpanchal01/string_validator
+  source_code_uri: https://github.com/rajpanchal01/string_validator
+  changelog_uri: https://github.com/rajpanchal01/string_validator/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: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key: 
+specification_version: 4
+summary: String validators and sanitizers for Ruby - port of validator.js
+test_files: []