is_valid 0.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ceff1381c62339c48a7f157c4aa467c1187dde72880935aab100dc4ca88b28c3
+  data.tar.gz: abde930fdd77d2b8efbc7e1050318678fd40f5fbfa01566595160b4bdf45129b
+SHA512:
+  metadata.gz: 35cef062c842b9761aa03121fae7ed8fa8da89c5605e310e41d9bb6b69ffa8cb189759daf9b2f1617d58608c214ec6b64689861aa3207d13dafc8b3659d9be96
+  data.tar.gz: 14f31ef5236d975fcde2ffae4f90d78570df177499637c4685720bb738d5151d006504fdd1feecd37f3903fe75f16053290273dc76311108e195146df58880cb

data/lib/is_valid.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'modules/validators'
+require_relative 'modules/errors'
+
+# Ruby Gem to make a validation of a variable or a hash, based on regular expressions
+# or own pre-defined validation templates in an easy way. See full documentation on GitHub.
+class IsValid
+  include Validators
+  include Errors
+
+  TYPES = %w[string array hash class module symbol].freeze
+  STRICT_TYPES = %w[integer float].freeze
+
+  @rules = {}
+  @templates = {}
+  @errors = {}
+  @all_keys = false
+  @strict_types = false
+
+  def initialize(settings = {})
+    @templates = settings[:templates] || {}
+    @errors = settings[:errors] || {}
+    @all_keys = settings[:all_keys] || false
+    @strict_types = settings[:strict_types] || false
+    rules = settings[:rules] || {}
+    types_hash = {}
+    TYPES.each do |type|
+      types_hash[type.to_sym] = type
+    end
+    validators = init_rules
+    @rules = validators.merge(rules)
+    @rules = @rules.merge(types_hash)
+  end
+
+  def check(val, rules)
+    validated = rules.is_a?(String) ? check_with_types(val, rules) : check_one_of_rules(val, rules)
+    validated.is_a?(Array) ? false : validated
+  end
+
+  def check_with_types(val, rule_name)
+    return true if rule_name == 'any'
+    return val.nil? if rule_name == 'nil'
+    return val.is_a?(Object.const_get(rule_name.capitalize)) if TYPES.include?(rule_name)
+    return val.is_a?(Object.const_get(rule_name.capitalize)) if @strict_types && STRICT_TYPES.include?(rule_name)
+    return [true, false].include?(val) if @strict_types && rule_name == 'boolean'
+
+    rule = @rules[rule_name.to_sym]
+    val.to_s.match?(rule)
+  end
+
+  def rule_exists(rule)
+    !rule.nil? && @rules[rule.to_sym].nil?
+  end
+
+  def check_one_of_rules(val, rules, key = 'variable')
+    errors = []
+    rules.each do |rule|
+      if rule_exists(rule)
+        errors << error_no_rule(rule)
+      elsif !check(val, rule)
+        errors << error_not_valid(key, rule, @errors)
+      end
+    end
+    !errors.empty? && errors.length == rules.length ? errors : true
+  end
+
+  def check_hash(hash_var, template, errors = [])
+    template_rules = @templates[template.to_sym]
+    return [error_no_template(template)] if template_rules.nil?
+
+    req_errors = check_required(hash_var, template_rules)
+    return req_errors unless req_errors.empty?
+
+    hash_var.each do |key, val|
+      rules = template_rules[key.to_sym]
+      if @all_keys && rules.nil?
+        errors << error_no_key(key, template)
+      elsif !rules.nil?
+        rules = [rules] if rules.is_a?(String)
+        validated = check_one_of_rules(val, rules, key)
+        errors += validated if validated != true
+        inner = check_hash(val, template, errors) if val.is_a?(Hash)
+        errors += inner if !inner.nil? && inner != true
+      end
+    end
+    errors.empty? ? true : errors.uniq
+  end
+
+  def check_required(hash_var, template_rules)
+    errors = []
+    template_rules.each_key do |key|
+      if key.match?('_required$')
+        key = key.to_s.gsub(/_required$/, '')
+        errors << error_required_key(key) if hash_var[key.to_sym].nil?
+      end
+    end
+    errors
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: is_valid
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+platform: ruby
+authors:
+- Sergei Illarionov (www.butteff.ru/en/)
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+description: |-
+  Ruby Gem to make a validation of a variable or a hash, based on regular expressions
+    or own pre-defined validation templates in an easy way. See full documentation on GitHub.
+email: butteff.ru@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/is_valid.rb
+homepage: https://butteff.ru/en/
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/butteff/is_valid_ruby_gem
+  rubygems_mfa_required: 'true'
+post_install_message: You can find docs about is_valid gem on https://butteff.ru/en/extensions
+  or on https://github.com/butteff/is_valid_ruby_gem
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Validation of a variable or a hash, based on pre-defined or own easy rules
+test_files: []