is_valid 0.1.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a630e0455a4889ed70aa01d3fda7d1295a44670992d6a2fe0e38376f97db86c
-  data.tar.gz: f57d9b9b9b48a7e8249f0729c60892ee7892eba630cfc118a9cf9c197f45a833
+  metadata.gz: 5f3124527532dea71ceca0bd29c6860041062dc600eea4fadc648a3d0a0a585a
+  data.tar.gz: 7bf5c3310a903232b5d1c3b55030774c3bbcfffac924358760cc7f2bf1a59735
 SHA512:
-  metadata.gz: 865393e3653a9e33504cc7d3692113e17b50fc0322ad6b991c8b1c22fad52f890260f888fbce59a585d74432cefcfa037e3566670ae797dec87e615b528e297f
-  data.tar.gz: 39ed0674d51b919649728f74abb025c04bf6e4ef906d3cfa6428500345683fefeef4eff5ee6831e7516cdaa30b5557e7028b859e09d5097662224c1839e608f3
+  metadata.gz: 40cd3210e308bce13e9c4293203d5448ddc1cfac633bd12e593bf5beacd135bea46f870a577f4f6496cc1e11c9d8970e21da1bf3367f852dbdb2c190e1c91003
+  data.tar.gz: fc2e6e5008fad2eca93f14c53dc871f79ce5c12bca995c7b03f4b93132f51a5c5d4aa0b56e15760c26d1112d28babaff35e242987c3791a4a53bdcb5aafdb67c

data/lib/is_valid.rb

@@ -1,44 +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
-  def initialize(templates = {}, rules = {})
-    @rules = {
-      integer: '^(\d)+$',
-      float: '^(\d)+.(\d)+$',
-      float_with_comma: '^(\d)+,(\d)+$',
-      word: '^(\w)+$',
-      words: '^(\w| )+$',
-      sentence: '^(\w| |,)+(\.|!|\?)$',
-      boolean: '^(1|0|true|false)$',
-      url: '^(http://|https://)(.)+\.(.)+$',
-      email: '^([a-z,A-Z,\-,\_,\.]*)@(.*)+\.(.*)$',
-      any: '(.*)+',
-      string: '(.*)+',
-      nil: nil
-    }
-    @rules = @rules.merge(rules)
-    @templates = templates
+  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 check(var, rule_name)
-    if rule_name[-1] == '*'
-      rule_name = rule_name[0..-2]
-      res = var.nil?
+  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
-    res ||= @rules[rule_name.to_sym].nil? ? var.nil? : var.to_s.match?(@rules[rule_name.to_sym])
-    res
+    errors.empty? ? true : errors.uniq
   end
 
-  def check_hash(hash_var, template)
+  def check_required(hash_var, template_rules)
     errors = []
-    rules = @templates[template.to_sym]
-    if !rules.nil?
-      hash_var.each do |key, val|
-        errors << "#{key} is not valid, should be #{rules[key.to_sym]}" unless !rules[key.to_sym].nil? && check(val, rules[key.to_sym])
+    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
-    else
-      p 'template with rules does not exist'
     end
-    errors.empty? ? true : errors
+    errors
   end
 end

metadata

@@ -1,18 +1,46 @@
 --- !ruby/object:Gem::Specification
 name: is_valid
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Sergei Illarionov (www.butteff.ru/en/)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-13 00:00:00.000000000 Z
-dependencies: []
-description: Ruby Gem to make a validation of a variable or a hash, based on regular
-  expressions or own predefined validation templates in an easy way. See full documentation
-  on GitHub.
+date: 2025-01-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: []
@@ -24,7 +52,8 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/butteff/is_valid_ruby_gem
-post_install_message: You can find docs about is_valid gem on https://butteff.ru/en/extensions.html
+  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:
@@ -43,5 +72,5 @@ requirements: []
 rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
-summary: Validation of a variable or a hash, based on predefined or own easy rules
+summary: Validation of a variable or a hash, based on pre-defined or own easy rules
 test_files: []