ruby-livr 2.0.0

data/lib/livr/rules/modifiers.rb

@@ -0,0 +1,68 @@
+module LIVR
+  module Rules
+    module Modifiers
+      class Default < Rule
+        def initialize(default_value)
+          @default_value = default_value
+        end
+
+        def call(value, user_data, field_results)
+          if is_no_value(value)
+            field_results << @default_value
+          end
+          return
+        end
+      end
+
+      class Trim < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value) || value.is_a?(Hash)
+          field_results << value.to_s.mb_chars.strip
+          return
+        end
+      end
+
+      class ToLc < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value) || value.is_a?(Hash)
+          field_results << value.to_s.mb_chars.downcase
+          return
+        end
+      end
+
+      class ToUc < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value) || value.is_a?(Hash)
+          field_results << value.to_s.mb_chars.upcase
+          return
+        end
+      end
+
+      class Remove < Rule
+        def initialize(chars)
+          @chars = chars
+          @re = Regexp.compile("[#{Regexp.quote(@chars)}]")
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value) || value.is_a?(Hash)
+          field_results << value.to_s.mb_chars.gsub(@re, '')
+          return
+        end
+      end
+
+      class LeaveOnly < Rule
+        def initialize(chars)
+          @chars = chars
+          @re = Regexp.compile("[^#{Regexp.quote(@chars)}]")
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value) || value.is_a?(Hash)
+          field_results << value.to_s.mb_chars.gsub(@re, '')
+          return
+        end
+      end
+    end
+  end
+end

data/lib/livr/rules/numeric.rb

@@ -0,0 +1,136 @@
+module LIVR
+  module Rules
+    module Numeric
+
+      class Integer < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value_int = Integer(value.to_s) rescue nil
+          if value_int.nil?
+            return "NOT_INTEGER"
+          end
+
+          field_results << value_int
+          return
+        end
+      end
+
+
+      class PositiveInteger < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value_int = Integer(value.to_s) rescue nil
+
+          return "NOT_POSITIVE_INTEGER" if value_int.nil?
+          return "NOT_POSITIVE_INTEGER" unless value_int.positive?
+
+          field_results << value_int
+          return
+        end
+      end
+
+      class Decimal < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value_int = Float(value.to_s) rescue nil
+          return "NOT_DECIMAL" if value_int.nil?
+
+          field_results << value_int
+          return
+        end
+      end
+
+
+      class PositiveDecimal < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value_float = Float(value.to_s) rescue nil
+          return "NOT_POSITIVE_DECIMAL" if value_float.nil?
+          return "NOT_POSITIVE_DECIMAL" unless value_float.positive?
+
+          field_results << value_float
+          return
+        end
+      end
+
+      class MaxNumber < Rule
+        def initialize(max_number)
+          @max_number = max_number
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value = Float(value.to_s) rescue nil
+          if value.nil?
+            return "NOT_NUMBER"
+          end
+
+          if value > @max_number
+            return "TOO_HIGH"
+          else
+            field_results << value
+            return
+          end
+        end
+      end
+
+      class MinNumber < Rule
+        def initialize(min_number)
+          @min_number = min_number
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value = Float(value.to_s) rescue nil
+          if value.nil?
+            return "NOT_NUMBER"
+          end
+
+          if value < @min_number
+            return "TOO_LOW"
+          else
+            field_results << value
+            return
+          end
+        end
+      end
+
+      class NumberBetween < Rule
+        def initialize(min_number, max_number)
+          @min_number = min_number
+          @max_number = max_number
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value = Float(value.to_s) rescue nil
+          if value.nil?
+            return "NOT_NUMBER"
+          end
+
+
+          return "TOO_LOW"  if value < @min_number
+          return "TOO_HIGH" if value > @max_number
+
+          field_results << value
+          return
+        end
+      end
+
+    end
+  end
+end

data/lib/livr/rules/special.rb

@@ -0,0 +1,65 @@
+module LIVR
+  module Rules
+    module Special
+
+      class Email < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          value = value.to_s
+          email_re = /^([\w\-_+]+(?:\.[\w\-_+]+)*)@((?:[\w\-]+\.)*\w[\w\-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
+          return "WRONG_EMAIL" unless email_re.match(value)
+          return "WRONG_EMAIL" if  /\@.*\@/.match(value)
+          return "WRONG_EMAIL" if /\@.*_/.match(value)
+          return
+        end
+      end
+
+      class EqualToField < Rule
+        def initialize(field)
+          @field = field
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          return "FIELDS_NOT_EQUAL" if value != user_data[@field]
+        end
+      end
+
+      class Url < Rule
+        URL_RE_STR = '^(?:(?:http|https)://)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[0-1]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))\\.?|localhost)(?::\\d{2,5})?(?:[/?#]\\S*)?$'
+        URL_RE =  Regexp.compile(URL_RE_STR, "i")
+        MAX_URL_LENGTH = 2083
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          if value.length < MAX_URL_LENGTH && URL_RE.match(value)
+            return
+          else
+            'WRONG_URL'
+          end
+        end
+      end
+
+      class IsoDate < Rule
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' if !is_primitive(value)
+
+          return "WRONG_DATE" unless value.length == "YYYY-MM-DD".length
+
+          date = Date.strptime(value, '%Y-%m-%d') rescue nil
+          unless date
+            return "WRONG_DATE"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/livr/rules/string.rb

@@ -0,0 +1,150 @@
+module LIVR
+  module Rules
+    module String
+
+      class String < Rule
+        def call(value, user_data, field_results)
+          return if value.in? [nil, ""]
+          return 'FORMAT_ERROR' unless is_primitive(value)
+
+          field_results << value.to_s
+
+          return nil
+        end
+      end
+
+      class Eq < Rule
+        def initialize(allowed_value)
+          @allowed_value = allowed_value
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' unless is_primitive(value)
+
+          if value.to_s == @allowed_value.to_s
+            field_results << @allowed_value
+            return
+          end
+
+          return 'NOT_ALLOWED_VALUE'
+        end
+      end
+
+      class OneOf < Rule
+        def initialize(*allowed_values)
+          @allowed_values = allowed_values.flatten
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' unless is_primitive(value)
+
+          @allowed_values.each do |allowed_value|
+            if allowed_value.to_s == value.to_s
+              field_results << allowed_value
+              return
+            end
+          end
+
+          return 'NOT_ALLOWED_VALUE'
+        end
+      end
+
+      class MaxLength < Rule
+        def initialize(max_length)
+          @max_length = max_length
+        end
+
+        def call(value, user_data, field_results)
+          return if value.in? [nil, ""]
+          return 'FORMAT_ERROR' unless is_primitive(value)
+
+          return 'TOO_LONG' if value.to_s.length > @max_length
+          field_results << value.to_s
+          return
+        end
+      end
+
+      class MinLength < Rule
+        def initialize(min_length)
+          @min_length = min_length
+        end
+
+        def call(value, user_data, field_results)
+          return if is_no_value(value)
+          return 'FORMAT_ERROR' unless is_primitive(value)
+          if value.to_s.length < @min_length
+            return 'TOO_SHORT'
+          end
+
+          field_results << value.to_s
+          return
+        end
+      end
+
+      class LengthEqual < Rule
+        def initialize(length)
+          @length = length
+        end
+
+        def call(value, user_data, field_results)
+          return if value.in? [nil, ""]
+          return 'FORMAT_ERROR' unless is_primitive(value)
+
+          value = value.to_s
+          return 'TOO_SHORT' if value.length < @length
+          return 'TOO_LONG'  if value.length > @length
+
+          field_results << value
+
+          return
+        end
+      end
+
+      class LengthBetween < Rule
+        def initialize(min_length, max_length)
+          @min_length = min_length
+          @max_length = max_length
+        end
+
+        def call(value, user_data, field_results)
+          return if value.in? [nil, ""]
+          return 'FORMAT_ERROR' unless is_primitive(value)
+
+          value = value.to_s
+          return 'TOO_SHORT' if value.length < @min_length
+          return 'TOO_LONG'  if value.length > @max_length
+
+          field_results << value
+
+          return
+        end
+      end
+
+      class Like < Rule
+        def initialize(re_str, flags=nil)
+          @re_str = re_str
+          @flags = flags
+        end
+
+        def call(value, user_data, field_results)
+          return if value.in? [nil, ""]
+          return 'FORMAT_ERROR' unless is_primitive(value)
+
+          value = value.to_s
+          regexp = Regexp.compile(@re_str, @flags)
+
+          unless regexp.match(value)
+            return 'WRONG_FORMAT'
+          end
+
+          field_results << value
+
+          return
+        end
+      end
+
+    end
+  end
+end

data/lib/livr/validator.rb

@@ -0,0 +1,134 @@
+module LIVR
+  class Validator
+    def initialize(rules, is_auto_trim=false)
+      @rules = rules
+      @is_prepared = false
+      @validator_builders = {}
+      @validators = {}
+      @is_auto_trim = is_auto_trim
+
+      register_default_rules
+    end
+
+    def self.register_default_rules(rules)
+      @@default_rules ||= {}
+      @@default_rules.merge!(rules.with_indifferent_access)
+    end
+
+    def register_aliased_rule(_alias)
+      register_rules( _alias["name"] =>  AliasedRule.new(_alias) )
+    end
+
+    def prepare
+      @rules.each do |field, field_rules|
+        field_rules = Array.wrap(field_rules)
+        @validators[field] = field_rules.map do |field_rule|
+          rule_name, rule_args = parse_rule(field_rule)
+          build_validator(rule_name, rule_args)
+        end
+        @is_prepared = true
+      end
+      self
+    end
+
+    def validate(user_data)
+      prepare unless @is_prepared
+
+      unless user_data.is_a?(Hash)
+        @errors = 'FORMAT_ERROR'
+        return
+      end
+
+      if @is_auto_trim
+        user_data = auto_trim(user_data)
+      end
+
+      @result = {}
+      @errors = {}
+
+      @validators.each do |field, validators|
+        next if validators.blank?
+        next if !@rules.has_key?(field)
+
+        value = user_data[field]
+        validators.each do |validator|
+          field_results = []
+          field_value = @result.fetch(field, value)
+          error_code = validator.call(field_value, user_data, field_results)
+
+          if error_code
+            @errors[field] = error_code
+            break
+          elsif field_results.present?
+            @result[field] = field_results.first
+          elsif user_data.has_key?(field) && !@result.has_key?(field)
+            @result[field] = value
+          end
+        end
+      end
+
+      if @errors.present?
+        return false
+      else
+        @errors = nil
+        return @result
+      end
+    end
+
+    def register_rules(rules)
+      @validator_builders.merge!(rules)
+      self
+    end
+
+    def get_errors
+      @errors
+    end
+
+    private
+
+    def register_default_rules
+      register_rules(@@default_rules || [])
+    end
+
+    def parse_rule(livr_rule)
+      name = nil
+      args = nil
+
+      case livr_rule
+      when Hash
+        name = livr_rule.keys.first
+        args = Array.wrap(livr_rule[name])
+      else
+        name = livr_rule
+        args = []
+      end
+
+      [ name, args ]
+    end
+
+    def build_validator(name, args)
+      if @validator_builders[name].blank?
+        raise "Rule ['#{name}'] not registered"
+      end
+      @validator_builders[name].new(*args)
+    end
+
+    private
+
+    def auto_trim(user_data)
+      case user_data
+      when String
+        user_data.strip
+      when Array
+        user_data.map{|v| auto_trim(v) }
+      when Hash
+        user_data.each do |key, value|
+          user_data[key] = auto_trim(value)
+        end
+      else
+        user_data
+      end
+    end
+
+  end
+end