livr2 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 81c9134b5dc59c32088f0b285b159697bfbbeb1a
+  data.tar.gz: 59b4324bcefda407cbe41a677cc553abe72bafd6
+SHA512:
+  metadata.gz: df65daa6d49b6444826e8e510f912cf7f84519b0fc28699e534b673279ae3f6099656a956ebace58d947bdfa416f5e8b1486f888e92c1cec5781c8a7409b1161
+  data.tar.gz: 7a150d4c4ce0108f60a5285aff998fbb64598c020c354c3cbf62c4fba01219ab3da82e8936466e48d41bdd1b3a955d78afa29f3e6d78c7fb82f62dc82b7e9641

data/.gitignore

@@ -0,0 +1 @@
+.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color spec

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    livr2 (2.0.0)
+      activesupport (~> 5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.10.3)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  livr2!
+  rspec (= 3.7)
+
+BUNDLED WITH
+   1.16.0.pre.3

data/Readme.md

@@ -0,0 +1,114 @@
+
+# LIVR Validator
+LIVR.Validator - Lightweight validator supporting Language Independent Validation Rules Specification (LIVR)
+
+# SYNOPSIS
+Common usage:
+
+```ruby
+gem 'livr2'
+require 'livr'
+
+validator = LIVR::Validator.new({
+    'name'      => 'required',
+    'email'     => [ 'required', 'email' ],
+    'gender'    => { 'one_of' => ['male', 'female'] },
+    'phone'     => { 'max_length' => 10 },
+    'password'  => [ 'required', {min_length : 10} ],
+    'password2' => { 'equal_to_field' => 'password' }
+});
+
+valid_data = validator.validate(user_data)
+
+if (valid_data) {
+    save_user(validData)
+} else {
+    handle_errors(validator.get_errors)
+}
+```
+
+
+You can use modifiers separately or can combine them with validation:
+
+```ruby
+var validator = LIVR::Validator.new({
+    email: [ 'required', 'trim', 'email', 'to_lc' ]
+});
+```
+
+
+Feel free to register your own rules:
+
+You can use aliases(prefferable, syntax covered by the specification) for a lot of cases:
+
+```ruby
+var validator = LIVR::Validator.new({
+    password: ['required', 'strong_password']
+});
+
+validator.register_aliased_rule({
+    name: 'strong_password',
+    rules: {min_length: 6},
+    error: 'WEAK_PASSWORD'
+});
+```
+
+Or you can write more sophisticated rules directly:
+
+```ruby
+validator = LIVR::Validator.new({
+    password: ['required', 'strong_password']
+})
+
+class StrongPassword
+    def call(value, *other_args)
+        # We already have "required" rule to check that the value is present
+        return if value == nil || value == ""
+        if value.length < 6
+            return 'WEAK_PASSWORD'
+        end
+    end
+end
+```
+
+# DESCRIPTION
+This ruby gem is an implementation of LIVR Specification.
+See ['LIVR Specification'](http://livr-spec.org) for detailed documentation and list of supported rules.
+
+Features:
+
+ * Rules are declarative and language independent
+ * Any number of rules for each field
+ * Return together errors for all fields
+ * Excludes all fields that do not have validation rules described
+ * Has possibility to validatate complex hierarchical structures
+ * Easy to describe and undersand rules
+ * Returns understandable error codes(not error messages)
+ * Easy to add own rules
+ * Rules are be able to change results output ("trim", "nested\_object", for example)
+ * Multipurpose (user input validation, configs validation, contracts programming etc)
+
+# INSTALL
+
+#### as a gem
+
+```bash
+gem install livr2
+```
+
+#### in rails
+
+Add to Gemfile
+
+```ruby
+gem "livr2"
+```
+
+
+# AUTHORS
+
+## Ruby implementation
+Vitaliy Yanchuk (@fuksito)
+
+## Idea and specification
+Viktor Turskyi (@koorchik)

data/lib/livr.rb

@@ -0,0 +1,61 @@
+require 'pry'
+require 'json'
+require 'date'
+require 'active_support/all'
+
+require_relative "livr/validator.rb"
+require_relative "livr/rule.rb"
+require_relative "livr/aliased_rule.rb"
+require_relative "livr/rules/common.rb"
+require_relative "livr/rules/string.rb"
+require_relative "livr/rules/numeric.rb"
+require_relative "livr/rules/special.rb"
+require_relative "livr/rules/modifiers.rb"
+require_relative "livr/rules/meta.rb"
+
+module LIVR
+  DEFAULT_RULES = {
+    required:       Rules::Common::Required,
+    not_empty:      Rules::Common::NotEmpty,
+    not_empty_list: Rules::Common::NotEmptyList,
+    any_object:     Rules::Common::AnyObject,
+
+    string:         Rules::String::String,
+    eq:             Rules::String::Eq,
+    one_of:         Rules::String::OneOf,
+    max_length:     Rules::String::MaxLength,
+    min_length:     Rules::String::MinLength,
+    length_equal:   Rules::String::LengthEqual,
+    length_between: Rules::String::LengthBetween,
+    like:           Rules::String::Like,
+
+    integer:          Rules::Numeric::Integer,
+    positive_integer: Rules::Numeric::PositiveInteger,
+    decimal:          Rules::Numeric::Decimal,
+    positive_decimal: Rules::Numeric::PositiveDecimal,
+    max_number:       Rules::Numeric::MaxNumber,
+    min_number:       Rules::Numeric::MinNumber,
+    number_between:   Rules::Numeric::NumberBetween,
+
+    email:          Rules::Special::Email,
+    equal_to_field: Rules::Special::EqualToField,
+    url:            Rules::Special::Url,
+    iso_date:       Rules::Special::IsoDate,
+
+    default:    Rules::Modifiers::Default,
+    trim:       Rules::Modifiers::Trim,
+    to_lc:      Rules::Modifiers::ToLc,
+    to_uc:      Rules::Modifiers::ToUc,
+    remove:     Rules::Modifiers::Remove,
+    leave_only: Rules::Modifiers::LeaveOnly,
+
+    nested_object:             Rules::Meta::NestedObject,
+    variable_object:           Rules::Meta::VariableObject,
+    list_of:                   Rules::Meta::ListOf,
+    list_of_objects:           Rules::Meta::ListOfObjects,
+    list_of_different_objects: Rules::Meta::ListOfDifferentObjects,
+    or:                        Rules::Meta::Or,
+  }.with_indifferent_access
+
+  Validator.register_default_rules(DEFAULT_RULES)
+end

data/lib/livr/aliased_rule.rb

@@ -0,0 +1,26 @@
+module LIVR
+  class AliasedRule
+
+    def initialize(_alias)
+      raise "Alias name required" unless _alias["name"]
+      raise "Alias rules required" unless _alias["rules"].present?
+
+      @alias = _alias
+      @validator = Validator.new(value: Array.wrap(@alias["rules"]))
+    end
+
+    def new(*args)
+      self
+    end
+
+    def call(value, user_data, field_results)
+      result = @validator.validate({ value: value })
+      if result
+        field_results << result[:value]
+        return
+      else
+        return @alias.fetch("error", @validator.get_errors)
+      end
+    end
+  end
+end

data/lib/livr/rule.rb

@@ -0,0 +1,21 @@
+module LIVR
+  class Rule
+
+    def initialize(*)
+    end
+
+    def call(value, user_data, field_results)
+      raise NotImplementedError
+    end
+
+    private
+
+    def is_primitive(value)
+      [Numeric, String, TrueClass, FalseClass].any?{|klass| value.is_a?(klass) }
+    end
+
+    def is_no_value(value)
+      value == nil || value == ""
+    end
+  end
+end

data/lib/livr/rules/common.rb

@@ -0,0 +1,35 @@
+module LIVR
+  module Rules
+    module Common
+
+      class Required < Rule
+        def call(value, user_data, field_results)
+          return if value.in?([[], {}])
+          "REQUIRED" if value.blank?
+        end
+      end
+
+      class NotEmpty < Rule
+        def call(value, user_data, field_results)
+          "CANNOT_BE_EMPTY" if value == ""
+        end
+      end
+
+      class NotEmptyList < Rule
+        def call(list, user_data, field_results)
+          return "CANNOT_BE_EMPTY" if is_no_value(list)
+          return "CANNOT_BE_EMPTY" if list.is_a?(Array) && list.blank?
+          return "FORMAT_ERROR" unless list.is_a?(Array)
+        end
+      end
+
+      class AnyObject < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return "FORMAT_ERROR" unless value.is_a?(Hash)
+        end
+      end
+
+    end
+  end
+end

data/lib/livr/rules/meta.rb

@@ -0,0 +1,200 @@
+module LIVR
+  module Rules
+    module Meta
+
+      class NestedObject < Rule
+        def initialize(livr)
+          @validator = Validator.new(livr).prepare
+        end
+
+        def call(nested_object, user_data, field_results)
+          return if is_no_value(nested_object)
+          return 'FORMAT_ERROR' unless nested_object.is_a?(Hash)
+
+          result = @validator.validate(nested_object)
+
+          if result
+            field_results << result
+            return
+          else
+            return @validator.get_errors
+          end
+        end
+      end
+
+      class VariableObject < Rule
+        def initialize(selector_field, livrs)
+          @selector_field = selector_field
+          @validators = {}
+          livrs.each do |selector_value, livr|
+            @validators[selector_value] = Validator.new(livr).prepare
+          end
+        end
+
+        def call(object, user_data, field_results)
+          return if is_no_value(object)
+          if ( !object.is_a?(Hash) || !object[@selector_field] || !@validators[ object[@selector_field] ] )
+            return 'FORMAT_ERROR'
+          end
+
+          validator = @validators.fetch(object.fetch(@selector_field))
+          result = validator.validate(object)
+
+          if result
+            field_results << result
+            return
+          else
+            return validator.get_errors
+          end
+        end
+      end
+
+      class ListOf < Rule
+        def initialize(*rules)
+          livr = { field: rules.flatten }
+          @validator = Validator.new(livr).prepare
+        end
+
+        def call(values, user_data, field_results)
+          return if is_no_value(values)
+          return 'FORMAT_ERROR' unless values.is_a?(Array)
+
+          results = []
+          errors = []
+          has_errors = false
+
+          values.each do |value|
+            result = @validator.validate(field: value)
+
+            if result
+              results << result[:field]
+              errors << nil
+            else
+              has_errors = true
+              errors << @validator.get_errors[:field]
+              results << nil
+            end
+          end
+
+          if has_errors
+            return errors
+          else
+            field_results << results
+            return
+          end
+        end
+      end
+
+      class ListOfObjects < Rule
+        def initialize(livr)
+          @validator = Validator.new(livr).prepare
+        end
+
+        def call(objects, user_data, field_results)
+          return if is_no_value(objects)
+          return 'FORMAT_ERROR' unless objects.is_a?(Array)
+
+          results = []
+          errors = []
+          has_errors = false
+
+          objects.each do |object|
+            result = @validator.validate(object)
+
+            if result
+              results << result
+              errors << nil
+            else
+              has_errors = true
+              errors << @validator.get_errors
+              results << nil
+            end
+          end
+
+          if has_errors
+            return errors
+          else
+            field_results << results
+            return
+          end
+
+        end
+      end
+
+      class ListOfDifferentObjects < Rule
+        def initialize(selector_field, livrs)
+          @selector_field = selector_field
+          @validators = {}
+          livrs.each do |selector_value, livr|
+            @validators[selector_value] = Validator.new(livr).prepare
+          end
+        end
+
+        def call(objects, user_data, field_results)
+          return if is_no_value(objects)
+          return 'FORMAT_ERROR' unless objects.is_a?(Array)
+
+          results = []
+          errors = []
+          has_errors = false
+
+          objects.each do |object|
+            if !object.is_a?(Hash) || !object[@selector_field] || !@validators[ object[@selector_field] ]
+              errors << 'FORMAT_ERROR'
+              next
+            end
+
+            validator = @validators[ object[@selector_field] ]
+            result = validator.validate(object)
+
+            if result
+              results << result
+              errors << nil
+            else
+              has_errors = true
+              errors << validator.get_errors
+              results << nil
+            end
+          end
+
+          if has_errors
+            return errors
+          else
+            field_results << results
+            return
+          end
+        end
+      end
+
+
+      class Or < Rule
+        def initialize(*rule_sets)
+          @rule_sets = rule_sets
+          @validators = @rule_sets.map do |rules|
+            livr = { field: rules }
+            Validator.new(livr).prepare
+          end
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+
+          last_error = nil
+          @validators.each do |validator|
+            result = validator.validate(field: value)
+            if result
+              field_results << result[:field]
+              return nil
+            else
+              last_error = validator.get_errors[:field]
+            end
+          end
+
+          last_error ? last_error : nil
+        end
+      end
+
+    end
+  end
+end
+