string_wizard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 77a377b78f738c3a61b4b851407971dca945528bf2b6107e741219c91ff126c4
+  data.tar.gz: 6bb673e6a74c0996fe1f5432bd36c7315f3960ac2139f4d6b113c920e028bd6f
+SHA512:
+  metadata.gz: aef54bddf1d3424e24d9901dedbe651325c12dcaffd53fb2d86d2b2cb8af48e68303d6152364459258c12565c081079864c54cb10abf8212f5ab4979717d0659
+  data.tar.gz: 8dd77cf902dc0f192904c8558eb27cfe5bbd5c34465f637b1feb6839d06d02f324334d8b285cf65650f749659d0e04fccb47265dee2b4f6e3eaf36684e5b15cb

data/lib/string_enhancer/core_ext.rb

@@ -0,0 +1,156 @@
+class String
+  # Returns a string with the first letter of each word capitalized
+  def titleize
+    StringEnhancer.titleize(self)
+  end
+
+  # Returns a string with all vowels removed
+  def remove_vowels
+    StringEnhancer.remove_vowels(self)
+  end
+
+  # Returns a string with all consonants removed
+  def remove_consonants
+    StringEnhancer.remove_consonants(self)
+  end
+
+  # Returns true if the string is a palindrome
+  def palindrome?
+    StringEnhancer.palindrome?(self)
+  end
+
+  # Returns a string with alternating case
+  def alternating_case
+    StringEnhancer.alternating_case(self)
+  end
+
+  # Returns a string with words in reverse order
+  def reverse_words
+    StringEnhancer.reverse_words(self)
+  end
+
+  # Advanced string analysis
+  def analyze
+    StringEnhancer.analyze(self)
+  end
+
+  # Pattern matching
+  def match_pattern(pattern)
+    StringEnhancer.match_pattern(self, pattern)
+  end
+
+  def matches_pattern?(pattern_name)
+    StringEnhancer::PatternMatcher.match_pattern(self, pattern_name)
+  end
+
+  def extract_patterns
+    StringEnhancer::PatternMatcher.extract_patterns(self)
+  end
+
+  def validate_format(pattern_name)
+    StringEnhancer::PatternMatcher.validate_format(self, pattern_name)
+  end
+
+  def sanitize(pattern_name)
+    StringEnhancer::PatternMatcher.sanitize(self, pattern_name)
+  end
+
+  # String transformation chain
+  def transform
+    StringEnhancer::Transformer.transform(self)
+  end
+
+  # String similarity
+  def similarity(other)
+    StringEnhancer.similarity(self, other)
+  end
+
+  # Parallel processing
+  def self.process_batch(strings, batch_size: 100, &block)
+    StringEnhancer.process_batch(strings, batch_size: batch_size, &block)
+  end
+
+  def self.analyze_batch(strings, batch_size: 100)
+    StringEnhancer.analyze_batch(strings, batch_size: batch_size)
+  end
+
+  def self.transform_batch(strings, transformations, batch_size: 100)
+    StringEnhancer.transform_batch(strings, transformations, batch_size: batch_size)
+  end
+
+  def self.similarity_matrix(strings, batch_size: 100)
+    StringEnhancer.similarity_matrix(strings, batch_size: batch_size)
+  end
+
+  # Encryption
+  def encrypt(key, algorithm: 'AES-256-CBC')
+    StringEnhancer.encrypt(self, key, algorithm: algorithm)
+  end
+
+  def self.decrypt(encrypted_str, key, algorithm: 'AES-256-CBC')
+    StringEnhancer.decrypt(encrypted_str, key, algorithm: algorithm)
+  end
+
+  def hash(algorithm: :sha256)
+    StringEnhancer.hash(self, algorithm: algorithm)
+  end
+
+  def secure_compare(other)
+    StringEnhancer.secure_compare(self, other)
+  end
+
+  # Fuzzy matching
+  def fuzzy_match(candidates, threshold: 0.8)
+    StringEnhancer.fuzzy_match(self, candidates, threshold: threshold)
+  end
+
+  def best_match(candidates, threshold: 0.8)
+    StringEnhancer.best_match(self, candidates, threshold: threshold)
+  end
+
+  # Validation methods
+  def valid_email?
+    StringEnhancer.valid_email?(self)
+  end
+
+  def valid_url?
+    StringEnhancer.valid_url?(self)
+  end
+
+  def valid_phone?
+    StringEnhancer.valid_phone?(self)
+  end
+
+  def valid_date?(format: '%Y-%m-%d')
+    StringEnhancer.valid_date?(self, format: format)
+  end
+
+  def valid_time?
+    StringEnhancer.valid_time?(self)
+  end
+
+  def valid_ip?
+    StringEnhancer.valid_ip?(self)
+  end
+
+  def valid_credit_card?
+    StringEnhancer.valid_credit_card?(self)
+  end
+
+  def valid_hex_color?
+    StringEnhancer.valid_hex_color?(self)
+  end
+
+  def valid_json?
+    StringEnhancer.valid_json?(self)
+  end
+
+  def valid_xml?
+    StringEnhancer.valid_xml?(self)
+  end
+
+  # Clear memoization cache
+  def self.clear_cache
+    StringEnhancer.clear_cache
+  end
+end 

data/lib/string_enhancer/encryption.rb

@@ -0,0 +1,67 @@
+module StringEnhancer
+  module Encryption
+    require 'openssl'
+    require 'base64'
+
+    class << self
+      def encrypt(str, key, algorithm: 'AES-256-CBC')
+        cipher = OpenSSL::Cipher.new(algorithm)
+        cipher.encrypt
+        cipher.key = Digest::SHA256.digest(key)
+        iv = cipher.random_iv
+        
+        encrypted = cipher.update(str) + cipher.final
+        Base64.strict_encode64(iv + encrypted)
+      end
+
+      def decrypt(encrypted_str, key, algorithm: 'AES-256-CBC')
+        decoded = Base64.strict_decode64(encrypted_str)
+        cipher = OpenSSL::Cipher.new(algorithm)
+        cipher.decrypt
+        cipher.key = Digest::SHA256.digest(key)
+        
+        iv = decoded[0...cipher.iv_len]
+        encrypted = decoded[cipher.iv_len..-1]
+        
+        cipher.iv = iv
+        cipher.update(encrypted) + cipher.final
+      end
+
+      def hash(str, algorithm: :sha256)
+        case algorithm
+        when :sha256
+          Digest::SHA256.hexdigest(str)
+        when :sha512
+          Digest::SHA512.hexdigest(str)
+        when :md5
+          Digest::MD5.hexdigest(str)
+        else
+          raise Error, "Unsupported hash algorithm: #{algorithm}"
+        end
+      end
+
+      def secure_compare(str1, str2)
+        return false unless str1.bytesize == str2.bytesize
+        
+        result = 0
+        str1.bytes.zip(str2.bytes) do |b1, b2|
+          result |= b1 ^ b2
+        end
+        result.zero?
+      end
+
+      def generate_salt(length = 16)
+        OpenSSL::Random.random_bytes(length)
+      end
+
+      def pbkdf2(str, salt, iterations: 10000, key_length: 32)
+        OpenSSL::PKCS5.pbkdf2_hmac_sha1(
+          str,
+          salt,
+          iterations,
+          key_length
+        )
+      end
+    end
+  end
+end 

data/lib/string_enhancer/pattern_matcher.rb

@@ -0,0 +1,41 @@
+module StringEnhancer
+  module PatternMatcher
+    # Predefined patterns for common use cases
+    PATTERNS = {
+      email: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i,
+      url: %r{\Ahttps?://[^\s/$.?#].[^\s]*\z},
+      phone: /\A\+?[\d\s\-()]{10,}\z/,
+      date: /\A\d{4}-\d{2}-\d{2}\z/,
+      time: /\A([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?\z/,
+      ip_address: /\A(\d{1,3}\.){3}\d{1,3}\z/,
+      credit_card: /\A\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\z/,
+      hex_color: /\A#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})\z/
+    }.freeze
+
+    def self.match_pattern(str, pattern_name)
+      pattern = PATTERNS[pattern_name.to_sym]
+      raise PatternMatchError, "Unknown pattern: #{pattern_name}" unless pattern
+      
+      pattern.match?(str)
+    end
+
+    def self.extract_patterns(str)
+      matches = {}
+      PATTERNS.each do |name, pattern|
+        matches[name] = str.scan(pattern)
+      end
+      matches
+    end
+
+    def self.validate_format(str, pattern_name)
+      match_pattern(str, pattern_name)
+    end
+
+    def self.sanitize(str, pattern_name)
+      pattern = PATTERNS[pattern_name.to_sym]
+      raise PatternMatchError, "Unknown pattern: #{pattern_name}" unless pattern
+      
+      str.gsub(pattern, '')
+    end
+  end
+end 

data/lib/string_enhancer/transformer.rb

@@ -0,0 +1,76 @@
+module StringEnhancer
+  module Transformer
+    class Chain
+      def initialize(str)
+        @str = str
+        @transformations = []
+      end
+
+      def titleize
+        @transformations << :titleize
+        self
+      end
+
+      def upcase
+        @transformations << :upcase
+        self
+      end
+
+      def downcase
+        @transformations << :downcase
+        self
+      end
+
+      def reverse
+        @transformations << :reverse
+        self
+      end
+
+      def strip
+        @transformations << :strip
+        self
+      end
+
+      def remove_vowels
+        @transformations << :remove_vowels
+        self
+      end
+
+      def remove_consonants
+        @transformations << :remove_consonants
+        self
+      end
+
+      def alternating_case
+        @transformations << :alternating_case
+        self
+      end
+
+      def reverse_words
+        @transformations << :reverse_words
+        self
+      end
+
+      def custom(&block)
+        @transformations << block
+        self
+      end
+
+      def apply
+        result = @str.dup
+        @transformations.each do |transformation|
+          if transformation.is_a?(Proc)
+            result = transformation.call(result)
+          else
+            result = StringEnhancer.transform(result, transformation)
+          end
+        end
+        result
+      end
+    end
+
+    def self.transform(str)
+      Chain.new(str)
+    end
+  end
+end 

data/lib/string_enhancer/validator.rb

@@ -0,0 +1,45 @@
+module StringEnhancer
+  module Validator
+    class << self
+      def valid_email?(str)
+        str.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+      end
+
+      def valid_url?(str)
+        str.match?(%r{\Ahttps?://[^\s/$.?#].[^\s]*\z})
+      end
+
+      def valid_phone?(str)
+        str.match?(/\A\+?[\d\s\-()]{10,}\z/)
+      end
+
+      def valid_date?(str, format: '%Y-%m-%d')
+        Date.strptime(str, format) rescue false
+      end
+
+      def valid_time?(str)
+        str.match?(/\A([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?\z/)
+      end
+
+      def valid_ip?(str)
+        str.match?(/\A(\d{1,3}\.){3}\d{1,3}\z/)
+      end
+
+      def valid_credit_card?(str)
+        str.match?(/\A\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\z/)
+      end
+
+      def valid_hex_color?(str)
+        str.match?(/\A#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})\z/)
+      end
+
+      def valid_json?(str)
+        JSON.parse(str) rescue false
+      end
+
+      def valid_xml?(str)
+        Nokogiri::XML(str) rescue false
+      end
+    end
+  end
+end

data/lib/string_enhancer/version.rb

@@ -0,0 +1,3 @@
+module StringEnhancer
+  VERSION = "0.1.0"
+end 

data/lib/string_wizard/version.rb

@@ -0,0 +1,3 @@
+module StringWizard
+  VERSION = "0.1.0"
+end 

data/lib/string_wizard.rb

@@ -0,0 +1,261 @@
+require "string_wizard/version"
+require "string_wizard/core_ext"
+require "string_wizard/pattern_matcher"
+require "string_wizard/transformer"
+require "string_wizard/validator"
+require "json"
+require "nokogiri"
+require "date"
+
+module StringWizard
+  class Error < StandardError; end
+  class PatternMatchError < Error; end
+  class EncryptionError < Error; end
+
+  # Memoization cache for expensive operations
+  @memo_cache = {}
+
+  class << self
+    # Basic string operations
+    def titleize(str)
+      str.split.map(&:capitalize).join(' ')
+    end
+
+    def remove_vowels(str)
+      str.gsub(/[aeiouAEIOU]/, '')
+    end
+
+    def remove_consonants(str)
+      str.gsub(/[^aeiouAEIOU\s]/, '')
+    end
+
+    def palindrome?(str)
+      normalized = str.downcase.gsub(/[^a-z0-9]/, '')
+      normalized == normalized.reverse
+    end
+
+    def alternating_case(str)
+      str.chars.each_with_index.map do |char, index|
+        index.even? ? char.upcase : char.downcase
+      end.join
+    end
+
+    def reverse_words(str)
+      str.split.reverse.join(' ')
+    end
+
+    # Advanced string analysis
+    def analyze(str)
+      {
+        length: str.length,
+        word_count: str.split.size,
+        character_frequency: character_frequency(str),
+        vowel_count: str.scan(/[aeiouAEIOU]/).size,
+        consonant_count: str.scan(/[^aeiouAEIOU\s\W]/).size,
+        digit_count: str.scan(/\d/).size,
+        special_char_count: str.scan(/[^a-zA-Z0-9\s]/).size,
+        entropy: calculate_entropy(str),
+        readability_score: calculate_readability(str)
+      }
+    end
+
+    # Pattern matching
+    def match_pattern(str, pattern)
+      regex = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern)
+      match = regex.match(str)
+      return nil unless match
+
+      if match.named_captures.any?
+        match.named_captures
+      else
+        match.captures
+      end
+    end
+
+    # String transformation chain
+    def transform(str, *transformations)
+      transformations.inject(str) do |result, transformation|
+        case transformation
+        when :titleize then titleize(result)
+        when :upcase then result.upcase
+        when :downcase then result.downcase
+        when :reverse then result.reverse
+        when :strip then result.strip
+        when :remove_vowels then remove_vowels(result)
+        when :remove_consonants then remove_consonants(result)
+        when :alternating_case then alternating_case(result)
+        when :reverse_words then reverse_words(result)
+        else
+          raise Error, "Unknown transformation: #{transformation}"
+        end
+      end
+    end
+
+    # Memoized character frequency analysis
+    def character_frequency(str)
+      @memo_cache["frequency_#{str}"] ||= begin
+        frequency = Hash.new(0)
+        str.each_char { |char| frequency[char] += 1 }
+        frequency
+      end
+    end
+
+    # Clear memoization cache
+    def clear_cache
+      @memo_cache.clear
+    end
+
+    # String similarity methods
+    def similarity(str1, str2)
+      return 1.0 if str1 == str2
+      return 0.0 if str1.empty? || str2.empty?
+
+      # Calculate Levenshtein distance
+      distance = levenshtein_distance(str1, str2)
+      max_length = [str1.length, str2.length].max
+      1.0 - (distance.to_f / max_length)
+    end
+
+    # Encryption
+    def encrypt(str, key, algorithm: 'AES-256-CBC')
+      Encryption.encrypt(str, key, algorithm: algorithm)
+    end
+
+    def decrypt(encrypted_str, key, algorithm: 'AES-256-CBC')
+      Encryption.decrypt(encrypted_str, key, algorithm: algorithm)
+    end
+
+    def hash(str, algorithm: :sha256)
+      Encryption.hash(str, algorithm: algorithm)
+    end
+
+    def secure_compare(str1, str2)
+      Encryption.secure_compare(str1, str2)
+    end
+
+    # String validation
+    def valid_email?(str)
+      str.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+    end
+
+    def valid_url?(str)
+      str.match?(/\Ahttps?:\/\/[\w\-]+(\.[\w\-]+)+[\/#?]?.*\z/i)
+    end
+
+    def valid_phone?(str)
+      str.match?(/\A\+?[\d\s\-()]+\z/)
+    end
+
+    def valid_date?(str, format: '%Y-%m-%d')
+      Date.strptime(str, format)
+      true
+    rescue Date::Error
+      false
+    end
+
+    def valid_time?(str)
+      str.match?(/\A([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?\z/)
+    end
+
+    def valid_ip?(str)
+      str.match?(/\A(\d{1,3}\.){3}\d{1,3}\z/) &&
+        str.split('.').all? { |octet| octet.to_i.between?(0, 255) }
+    end
+
+    def valid_credit_card?(str)
+      # Remove all non-digit characters
+      digits = str.gsub(/\D/, '').chars.map(&:to_i)
+      return false if digits.empty?
+
+      # Luhn algorithm
+      sum = 0
+      digits.reverse.each_with_index do |digit, index|
+        if index.odd?
+          doubled = digit * 2
+          sum += doubled > 9 ? doubled - 9 : doubled
+        else
+          sum += digit
+        end
+      end
+
+      (sum % 10).zero?
+    end
+
+    def valid_hex_color?(str)
+      str.match?(/\A#[0-9A-Fa-f]{6}\z/)
+    end
+
+    def valid_json?(str)
+      JSON.parse(str)
+      true
+    rescue JSON::ParserError
+      false
+    end
+
+    def valid_xml?(str)
+      Nokogiri::XML(str) { |config| config.strict }
+      true
+    rescue Nokogiri::XML::SyntaxError
+      false
+    end
+
+    private
+
+    # Levenshtein distance calculation
+    def levenshtein_distance(str1, str2)
+      m = str1.length
+      n = str2.length
+      return m if n == 0
+      return n if m == 0
+
+      d = Array.new(m + 1) { Array.new(n + 1) }
+
+      (0..m).each { |i| d[i][0] = i }
+      (0..n).each { |j| d[0][j] = j }
+
+      (1..m).each do |i|
+        (1..n).each do |j|
+          cost = str1[i - 1] == str2[j - 1] ? 0 : 1
+          d[i][j] = [
+            d[i - 1][j] + 1,     # deletion
+            d[i][j - 1] + 1,     # insertion
+            d[i - 1][j - 1] + cost # substitution
+          ].min
+        end
+      end
+
+      d[m][n]
+    end
+
+    # Calculate string entropy
+    def calculate_entropy(str)
+      return 0.0 if str.empty?
+
+      frequency = character_frequency(str)
+      length = str.length.to_f
+
+      -frequency.values.sum do |count|
+        probability = count / length
+        probability * Math.log2(probability)
+      end
+    end
+
+    # Calculate readability score
+    def calculate_readability(str)
+      words = str.split
+      sentences = str.split(/[.!?]+/)
+      syllables = words.sum { |word| count_syllables(word) }
+
+      return 0.0 if words.empty? || sentences.empty?
+
+      # Flesch-Kincaid Grade Level
+      (0.39 * (words.size / sentences.size.to_f)) +
+        (11.8 * (syllables / words.size.to_f)) - 15.59
+    end
+
+    # Count syllables in a word
+    def count_syllables(word)
+      word.downcase.gsub(/[^a-z]/, '').scan(/[aeiouy]+/).size
+    end
+  end
+end 

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: string_wizard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hassan Tahir
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: date
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Provides a wizard's toolkit of string manipulation methods that aren't
+  available in Ruby's standard library
+email:
+- hassantahirjaura@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/string_enhancer/core_ext.rb
+- lib/string_enhancer/encryption.rb
+- lib/string_enhancer/pattern_matcher.rb
+- lib/string_enhancer/transformer.rb
+- lib/string_enhancer/validator.rb
+- lib/string_enhancer/version.rb
+- lib/string_wizard.rb
+- lib/string_wizard/version.rb
+homepage: https://github.com/hassantahir176/string_wizard
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A magical collection of string manipulation and validation methods
+test_files: []