c80_shared 0.1.67 → 0.1.68

data/lib/dry/rules/and.rb

@@ -0,0 +1,11 @@
+module Dry
+  module Rules
+    class And < Dry::Rules::Composite
+
+      def valid?
+        left.valid? && right.valid? ? true : false
+      end
+
+    end
+  end
+end

data/lib/dry/rules/between.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class Between < Dry::Rules::Binary
+
+      def valid?
+        return true if right.include? left
+        add_error
+        false
+      end
+
+
+      def name
+        'between'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/binary.rb

@@ -0,0 +1,16 @@
+module Dry
+  module Rules
+    class Binary < Dry::Rule
+
+      def right
+        args[:right]
+      end
+
+
+      def left
+        value
+      end
+
+    end
+  end
+end

data/lib/dry/rules/collection.rb

@@ -0,0 +1,16 @@
+module Dry
+  module Rules
+    class Collection < Dry::Rules::Binary
+
+      def valid?
+        is_valid = true
+        [left, right].each do |rule|
+          res = rule.valid?
+          is_valid = res unless res
+        end
+        is_valid
+      end
+
+    end
+  end
+end

data/lib/dry/rules/composite.rb

@@ -0,0 +1,19 @@
+module Dry
+  module Rules
+    class Composite < Dry::Rules::Binary
+
+      private
+
+
+      def lt
+        @lt ||= left.clone
+      end
+
+
+      def rt
+        @rt ||= right.clone
+      end
+
+    end
+  end
+end

data/lib/dry/rules/equal.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class Equal < Dry::Rules::Binary
+
+      def valid?
+        return true if left.eql?(right)
+        add_error
+        false
+      end
+
+
+      def name
+        'eq'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/format.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class Format < Dry::Rules::Binary
+
+      def valid?
+        return true if left.to_s.match(right).present?
+        add_error
+        false
+      end
+
+
+      def name
+        'format'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/greater_than.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class GreaterThan < Dry::Rules::Binary
+
+      def valid?
+        return true if left > right
+        add_error
+        false
+      end
+
+
+      def name
+        'gt'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/greater_than_or_equal.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class GreaterThanOrEqual < Dry::Rules::Binary
+
+      def valid?
+        return true if left >= right
+        add_error
+        false
+      end
+
+
+      def name
+        'gt_eq'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/included.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class Included < Dry::Rules::Binary
+
+      def valid?
+        return true if right.include?(left)
+        add_error
+        false
+      end
+
+
+      def name
+        'included'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/length_between.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class LengthBetween < Dry::Rules::Binary
+
+      def valid?
+        return true if right.include? left.size
+        add_error
+        false
+      end
+
+
+      def name
+        'length_between'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/length_equal.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class LengthEqual < Dry::Rules::Binary
+
+      def valid?
+        return true if left.size == right
+        add_error
+        false
+      end
+
+
+      def name
+        'length_equal'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/less_than.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class LessThan < Dry::Rules::Binary
+
+      def valid?
+        return true if left < right
+        add_error
+        false
+      end
+
+
+      def name
+        'lt'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/less_than_or_equal.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class LessThanOrEqual < Dry::Rules::Binary
+
+      def valid?
+        return true if left <= right
+        add_error
+        false
+      end
+
+
+      def name
+        'lt_eq'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/max_length.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class MaxLength < Dry::Rules::Binary
+
+      def valid?
+        return true if left.size <= right
+        add_error
+        false
+      end
+
+
+      def name
+        'max_length'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/min_length.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class MinLength < Dry::Rules::Binary
+
+      def valid?
+        return true if left.size >= right
+        add_error
+        false
+      end
+
+
+      def name
+        'min_length'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/not_equal.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Rules
+    class NotEqual < Dry::Rules::Binary
+
+      def valid?
+        return true unless left.eql?(right)
+        add_error
+        false
+      end
+
+
+      def name
+        'not_eq'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/or.rb

@@ -0,0 +1,13 @@
+module Dry
+  module Rules
+    class Or < Dry::Rules::Composite
+
+      def valid?
+        return true if lt.valid? || rt.valid?
+        [lt.errors, rt.errors].each { |e| errors.merge!(e) if e.any? }
+        false
+      end
+
+    end
+  end
+end

data/lib/dry/rules/present.rb

@@ -0,0 +1,21 @@
+module Dry
+  module Rules
+    class Present < Dry::Rule
+
+      def valid?
+        return true if value.present?
+        add_error
+        false
+      end
+
+
+      private
+
+
+      def name
+        'present'
+      end
+
+    end
+  end
+end

data/lib/dry/rules/then.rb

@@ -0,0 +1,13 @@
+module Dry
+  module Rules
+    class Then < Dry::Rules::Composite
+
+      def valid?
+        return true if (!lt.valid? || rt.valid?)
+        errors.merge!(rt.errors)
+        false
+      end
+
+    end
+  end
+end

data/lib/dry/rules_factory.rb

@@ -0,0 +1,118 @@
+module Dry
+  class RulesFactory
+
+    attr_reader :value, :errors, :args
+
+    def initialize(value, errors = Dry::Errors.new, **args)
+      @value  = value
+      @errors = errors
+      @args   = args.symbolize_keys
+    end
+
+
+    def present?
+      Dry::Rules::Present.new(value, errors, args)
+    end
+
+
+    def equal?(right)
+      Dry::Rules::Equal.new(value, errors, build_args(right))
+    end
+    alias :eq? :equal?
+
+
+    def not_equal?(right)
+      Dry::Rules::NotEqual.new(value, errors, build_args(right))
+    end
+    alias :not_eq? :not_equal?
+
+
+    def greater_than?(right)
+      Dry::Rules::GreaterThan.new(value, errors, build_args(right))
+    end
+    alias :gt? :greater_than?
+
+
+    def greater_than_or_equal?(right)
+      Dry::Rules::GreaterThanOrEqual.new(value, errors, build_args(right))
+    end
+    alias :gt_eq? :greater_than_or_equal?
+
+
+    def less_than?(right)
+      Dry::Rules::LessThan.new(value, errors, build_args(right))
+    end
+    alias :lt? :less_than?
+
+
+    def less_than_or_equal?(right)
+      Dry::Rules::LessThanOrEqual.new(value, errors, build_args(right))
+    end
+    alias :lt_eq? :less_than_or_equal?
+
+
+    def included?(right)
+      Dry::Rules::Included.new(value, errors, build_args(right))
+    end
+
+
+    def length_equal?(right)
+      Dry::Rules::LengthEqual.new(value, errors, build_args(right))
+    end
+
+
+    def min_length?(right)
+      Dry::Rules::MinLength.new(value, errors, build_args(right))
+    end
+
+
+    def max_length?(right)
+      Dry::Rules::MaxLength.new(value, errors, build_args(right))
+    end
+
+
+    def between?(right)
+      Dry::Rules::Between.new(value, errors, build_args(right))
+    end
+
+
+    def length_between?(right)
+      Dry::Rules::LengthBetween.new(value, errors, build_args(right))
+    end
+
+
+    def format?(right)
+      Dry::Rules::Format.new(value, errors, build_args(right))
+    end
+
+
+    def each(&block)
+      return if value.blank?
+      value.inject(nil) do |rule, e|
+        _rule = self.class.new(e, errors, args).instance_exec(&block)
+        rule = rule ? rule & _rule : _rule
+        rule
+      end
+    end
+
+
+    def each_value(&block)
+      return if value.blank?
+      value.inject(nil) do |rule, (k, v)|
+        _rule = self.class.new(v, errors, args).instance_exec(&block)
+        rule = rule ? rule & _rule : _rule
+        rule
+      end
+    end
+
+
+    private
+
+
+    def build_args(right)
+      rt = right.is_a?(self.class) ? right.value : right
+      args.merge(right: rt)
+    end
+
+  end
+end

data/lib/dry/schema.rb

@@ -0,0 +1,148 @@
+module Dry
+  module Schema
+
+    attr_reader :attributes, :errors
+
+    def initialize(params)
+      @errors     = Dry::Errors.new
+      @attributes = cast({ wrap: params }.deep_symbolize_keys[:wrap], schema)
+      JSON::Validator.validate!(schema, attributes)
+    end
+
+
+    def [](key)
+      attributes[key.to_sym]
+    end
+
+
+    def valid?
+      validate_attributes(attributes, schema)
+      validate_additional
+      !errors.any?
+    end
+
+
+    def schema
+      raise NotImplemented
+    end
+
+
+    private
+
+
+    def validate_additional
+    end
+
+
+    def validate_attributes(props, schema, parents = [], key = nil)
+      case props
+        when Dry::Schema
+          errors.merge!(props.errors, (parents + [key]).compact.join('.')) unless props.valid?
+        else
+          [schema[:rule]].flatten.compact.each do |rule|
+            rule = rule.arity == 0 ? rule(key, parents, &rule) : rule.call(parents)
+            rule.valid? if rule
+          end
+      end
+
+      if schema[:properties]
+        (schema[:properties] || {}).each do |_key, data|
+          validate_attributes((props.present? ? props : {})[_key.to_sym], data, (parents + [key]).compact, _key)
+        end
+      elsif schema[:items]
+        (props.present? ? props : []).each_with_index do |e, i|
+          validate_attributes(e, schema[:items], (parents + [key]).compact, i)
+        end
+      end
+
+      if schema[:oneOf] || schema[:allOf] || schema[:anyOf]
+        [:oneOf, :allOf, :anyOf].each do |k|
+          s = schema[k]
+          case s
+            when Hash
+              validate_attributes(props, s, parents, key)
+            when Array
+              s.each { |_s| validate_attributes(props, _s, parents, key) if _s.is_a?(Hash) }
+            else
+          end
+        end
+      end
+    end
+
+
+    def cast(params, schema)
+      props = schema.is_a?(Hash) && schema[:cast] ? schema[:cast].call(params) : params
+
+      case props
+        when Hash
+          props.each_with_object({}) do |(key, value), result|
+            result[key] = find_schemas_for_attribute(key, schema).inject((value.dup rescue value)) do
+              |_value, _schema| _value = cast(_value, _schema); _value
+            end
+          end
+        when Array
+          props.map { |e| cast(e, (schema[:items] rescue nil)) }
+        else
+          props
+      end
+    end
+
+
+    def rule(attrs, parents, messages = {}, name = nil, &block)
+      if block.arity == 0
+        _attrs = [attrs].flatten.compact
+        raise 'Invalid rule' if _attrs.size > 1
+        single_rule(parents + _attrs, messages, &block)
+      else
+        multi_rule(attrs, parents, messages, name, &block)
+      end
+    end
+
+
+    def single_rule(keys, messages = {}, &block)
+      value   = attributes.dig(*keys) rescue nil
+      factory = Dry::RulesFactory.new(value, errors, key: keys.join('.'), messages: messages)
+      factory.instance_exec &block
+    end
+
+
+    def multi_rule(keys, parents, messages = {}, name = nil, &block)
+      _keys = [keys].flatten.compact
+      data  = parents.present? ? attributes.dig(*parents) : attributes
+
+      data = _keys.inject({}) do |res, key|
+        res[key.to_sym] = data[key.to_sym] rescue nil; res
+      end
+
+      factories = data.map do |key, value|
+        _key = name || key
+        _key = (parents + [_key]).join('.')
+        Dry::RulesFactory.new(value, errors, key: _key, messages: messages)
+      end
+
+      block.call *factories
+    end
+
+
+    def find_schemas_for_attribute(key, schema, schemas = [])
+      case schema
+        when Hash
+          s = schema[:properties][key] rescue nil
+          schemas << s if s
+          [:allOf, :anyOf, :oneOf].each { |k| find_schemas_for_attribute(key, schema[k], schemas) }
+        when Array
+          schema.each { |s| find_schemas_for_attribute(key, s, schemas) }
+        else
+      end
+
+
+      schemas
+    end
+
+
+    def method_missing(method)
+      attributes[method.to_sym]
+    end
+
+  end
+end