is_valid = IsValid.new #instance creation

#variables validation:
validation = is_valid.check(1, 'integer') #true or false
validation = is_valid.check('ok, it works!', 'sentence') #true or false

require 'is_valid'

#write own templates of rules (can be as many as you want inside the hash of templates)
templates = {
    settings: {
        url: 'url',
        is_confirmed: 'boolean',
        interval: 'integer',
    }
}

#instance creation:
is_valid = IsValid.new({templates: templates})

#hash to check:
hash_data = {
    url: 'https://butteff.ru/en/',
    is_confirmed: true,
    interval: 10,
}

validation = is_valid.check_hash(hash_data, 'settings') #true or array of errors

#define own validators to check variables (will be merged with the existed list):
own_validators = {
    has_country_from_the_list: '^(Russia|USA|UAE|Brazil)$',
    can_be_an_email: '^(.)+\@(.)+$',
}

#define own templates (can be as many as you want inside the hash of templates):
templates = {
    hey: {
        country: 'has_country_from_the_list',
        email: 'can_be_an_email',
    }
}


#instance creation:
is_valid = IsValid.new({templates: templates, rules: own_validators})

#hash to check:
hash_data = {
    country: 'Russia',
    email: '[email protected]',
}

validation = is_valid.check_hash(hash_data, 'hey') #true or array of errors

require 'is_valid'

#write own templates of rules (can be as many as you want inside the hash of templates)
templates = {
    settings: {
        name: 'string',
        girlfriend_name: ['string', 'nil'] #string or nil rule
    }
}

#instance creation:
is_valid = IsValid.new({templates: templates})

#hash to check:
hash_data_nil = {
    name: 'John',
    girlfriend_name: nil
}

hash_data = {
    name: 'John',
    girlfriend_name: 'Anna'
}

is_valid.check_hash(hash_data, 'settings') #valid
is_valid.check_hash(hash_data_nil, 'settings') #valid too

name_var = nil
is_valid.check(name_var, 'nil') #true

is_valid.check('http://butteff.ru', ['email', 'url']) #true or false

is_valid.check_one_of_rules('http://butteff.ru', ['email', 'url']) #true or an array of error texts

templates = {
    settings: {
        test_data: ['url', 'email'],
        is_confirmed: ['boolean', 'integer'],
        interval: ['integer', 'float']
    }
}

hash_to_check = {
    test_data: 'https://www.butteff.ru',
    is_confirmed: 'true',
    interval: '10'
}

is_valid = IsValid.new({ templates: templates })
is_valid.check_hash(hash_to_check, 'settings') #true or array full of error texts

templates = {
    hey: {
        number_int: 'integer',
        number_float: 'float'
    }
}

# hash to check:
hash_data_types = {
    number_int: 5,
    number_float: 555.55
}

hash_data_texts = {
    number_int: '5',
    number_float: '555.55'
}

# class initialization:
is_valid = IsValid.new({ templates: templates, strict_types: true })

validation = is_valid.check_hash(hash_data_types, 'hey') # valid
validation = is_valid.check_hash(hash_data_texts, 'hey') # not valid

is_valid = IsValid.new({ templates: templates })
validation = is_valid.check_hash(hash_data_texts, 'hey') # valid, because strict_types is false

templates = {
    settings: {
        url: 'url'
    }
}

hash_to_check = {
    url: 'https://www.butteff.ru/en/',
    is_confirmed: 'true',
}

is_valid = IsValid.new({ templates: templates })
is_valid.check_hash(hash_to_check, 'settings') #true

is_valid = IsValid.new({ templates: templates, all_keys: true })
is_valid.check_hash(hash_to_check, 'settings') #exception ['validation rule "is_confirmed" doesn't exist']

require 'is_valid'

templates = {
    settings: {
        url: 'url',
        is_confirmed: 'boolean',
        interval: 'integer'
    }
}

hash_to_check = {
    url: 'it is not an url',
    is_confirmed: 'it is not about a boolean',
    interval: 'not an integer'
}

errors = {
    url: 'error text 1',
    is_confirmed: 'error text 2',
    interval: 'error text 3'
}
is_valid = IsValid.new({ templates: templates, errors: errors })
is_valid.check_hash(hash_to_check, 'settings') #['error text 1', 'error text 2', 'error text 3'])

require 'is_valid'

templates = {
    settings: {
        url_required: 'url',
        site_name: 'string'
    }
}

hash_to_check = {
    url: 'https://butteff.ru',
    site_name: 'gem overview'
}

hash_to_check_without_name = {
    url: 'https://butteff.ru',
}

hash_to_check_without_url = {
    site_name: 'gem overview'
}

is_valid = IsValid.new({ templates: templates})
is_valid.check_hash(hash_to_check, 'settings') #valid
is_valid.check_hash(hash_to_check_without_name, 'settings') #valid
is_valid.check_hash(hash_to_check_without_url, 'settings') #not valid

template = {
    persons: {
    url: %w[url url_no_http],
    email: 'email',
    class: 'words',
    classmates: 'hash',
    people: 'hash',
    boys: 'hash',
    girls: 'hash'
    }
}

hash_to_check = {
    people: {
        url: 'https://people-fake.website.com',
        classmates: {
            boys: {
                class: 'boys class',
                email: '[email protected]',
                url: 'www.boysclass.ru'
            },
            girls: {
                class: 'girls class',
                email: '[email protected]',
                url: 'https://www.girls-class.ru'
            }
        }
    }
}

is_valid = IsValid.new({ templates: template })
valid = is_valid.check_hash(hash_to_check, 'persons') #true

params = {
    templates: {}, #template of validation rules
    rules: {}, #additional own created validators
    errors: {}, #own error texts based on keys
    all_keys: false, #check template to have all the same keys as a hash for a validation
    strict_types: false #strict types mode to check variable types too
}

is_valid = IsValid.new(params) #instance creation