mealib 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59fe9fdc843f31b1f435c4810c1712f5d947fbcec6e7fd3c4d8800ce7df9f10e
-  data.tar.gz: 284d947973a7cd84471535d1e54fb52cbb498bfe9279e04c1082d0c278de84ca
+  metadata.gz: 7ff7ddd718879b0d25a984ffb27775b4fe75801d6d798e404cf5241a6fe727cf
+  data.tar.gz: a49286f7887760301878f98be9fe7100518c1e14236bddfeba656b90b65a4344
 SHA512:
-  metadata.gz: 7223f57b7ae359591689621f082a009b44b1d9899ee365ffd0ede6858e3ae33ad7d4cd63c22ca58832462c2d158040f1c6fe8ac8a479a9229db76781e204b0de
-  data.tar.gz: 9dbebed80e16a562ee93f0346f833287f2023b342584bf53abbecbde3bb54480cf46cd46de6fa35ebf3f6e8d11ce0099133525a533fb66ff6e376a1eab6429ac
+  metadata.gz: 77979d02e2257d148278949318598ff9a318e84a76111496ddb7c02be611c977db2c94f0066d2e3be7b2d847cf7a19604b65ae48c1a18f8668e47002235119cc
+  data.tar.gz: 4231c29c6bf5eb36045d0366a3fd17622f5ba13593bdd9d9d83ad367aea60ac610fcc2c202e6648553e5913fb7442900d13d18a8bc50b7659e5ed26534fc3528

data/config/initializers/core_ext/hash.rb

@@ -0,0 +1,55 @@
+class Hash
+
+  def camelcase_keys(type: :symbol, first: :lower)
+    transform_keys &camelcase_proc(type: type, first: first)
+  end
+
+
+  def camelcase_keys!(type: :symbol, first: :lower)
+    transform_keys! &camelcase_proc(type: type, first: first)
+  end
+
+
+  def deep_camelcase_keys(type: :symbol, first: :lower)
+    deep_transform_keys &camelcase_proc(type: type, first: first)
+  end
+
+
+  def deep_camelcase_keys!(type: :symbol, first: :lower)
+    deep_transform_keys! &camelcase_proc(type: type, first: first)
+  end
+
+
+  def underscore_keys!(symbol = false)
+    transform_keys! &underscore_proc(symbol)
+  end
+
+
+  def underscore_keys(symbol = false)
+    self.dup.underscore_keys(symbol)
+  end
+
+
+  def deep_underscore_keys!(symbol = false)
+    deep_transform_keys! &underscore_proc(symbol)
+  end
+
+
+  def deep_underscore_keys(symbol = false)
+    self.dup.deep_underscore_keys!(symbol)
+  end
+
+
+  private
+
+
+  def camelcase_proc(type: :symbol, first: :lower)
+    proc { |key| type == :symbol ? key.to_s.camelcase(first).to_sym : key.to_s.camelcase(first) }
+  end
+
+
+  def underscore_proc(symbol)
+    proc { |key| new_key = key.to_s.underscore; symbol ? new_key.to_sym : new_key }
+  end
+
+end

data/lib/mealib.rb

@@ -3,33 +3,6 @@ lambda do
   lib_path  = '%s/**/*.rb' % File.expand_path('../mealib', __FILE__)
   # noinspection RubyResolve
   Dir[lib_path].each { |f| require_relative f }
-
-  require_relative 'dry/errors'
-  require_relative 'dry/schema'
-  require_relative 'dry/rule'
-
-  require_relative 'dry/rules/binary'
-  require_relative 'dry/rules/composite'
-  require_relative 'dry/rules/between'
-  require_relative 'dry/rules/min_length'
-  require_relative 'dry/rules/greater_than'
-  require_relative 'dry/rules/not_equal'
-  require_relative 'dry/rules/less_than'
-  require_relative 'dry/rules/greater_than_or_equal'
-  require_relative 'dry/rules/collection'
-  require_relative 'dry/rules/length_between'
-  require_relative 'dry/rules/or'
-  require_relative 'dry/rules/and'
-  require_relative 'dry/rules/less_than_or_equal'
-  require_relative 'dry/rules/then'
-  require_relative 'dry/rules/format'
-  require_relative 'dry/rules/present'
-  require_relative 'dry/rules/length_equal'
-  require_relative 'dry/rules/included'
-  require_relative 'dry/rules/equal'
-  require_relative 'dry/rules/max_length'
-
-  require_relative 'dry/rules_factory'
 end.call
 
 # загружаем все классы из директории app

data/lib/mealib/version.rb

@@ -1,3 +1,3 @@
 module Mealib
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mealib
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - C80609A
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-26 00:00:00.000000000 Z
+date: 2020-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -54,31 +54,8 @@ files:
 - bin/console
 - bin/rails
 - bin/setup
+- config/initializers/core_ext/hash.rb
 - config/initializers/core_ext/string.rb
-- lib/dry/errors.rb
-- lib/dry/rule.rb
-- lib/dry/rules/and.rb
-- lib/dry/rules/between.rb
-- lib/dry/rules/binary.rb
-- lib/dry/rules/collection.rb
-- lib/dry/rules/composite.rb
-- lib/dry/rules/equal.rb
-- lib/dry/rules/format.rb
-- lib/dry/rules/greater_than.rb
-- lib/dry/rules/greater_than_or_equal.rb
-- lib/dry/rules/included.rb
-- lib/dry/rules/length_between.rb
-- lib/dry/rules/length_equal.rb
-- lib/dry/rules/less_than.rb
-- lib/dry/rules/less_than_or_equal.rb
-- lib/dry/rules/max_length.rb
-- lib/dry/rules/min_length.rb
-- lib/dry/rules/not_equal.rb
-- lib/dry/rules/or.rb
-- lib/dry/rules/present.rb
-- lib/dry/rules/then.rb
-- lib/dry/rules_factory.rb
-- lib/dry/schema.rb
 - lib/mealib.rb
 - lib/mealib/abstract_serializer.rb
 - lib/mealib/dict.rb

data/lib/dry/errors.rb

@@ -1,77 +0,0 @@
-module Dry
-  class Errors
-
-    attr_reader :messages
-
-    def initialize(messages = {})
-      @messages = messages
-    end
-
-
-    def add(key, message)
-      keys = key.to_s.split('.').map!(&:to_sym)
-      old  = messages.dig(*keys[0...-1]) rescue {}
-      old  = {} unless old.is_a?(Hash)
-      new  = keys[0...-1].inject(messages) { |h, k| h[k] ||= {} rescue h = {}; h[k] = {} }
-      new[keys.last] = [] unless new.is_a?(Array)
-      new[keys.last] << message
-      new.merge!(old)
-    end
-
-
-    def merge!(error, parent_key = nil)
-      hash_to_dots(error.messages, {}, parent_key).each do |key, messages|
-        messages.each { |message| add(key, message) }
-      end
-      messages
-    end
-
-
-    def any?
-      messages.any?
-    end
-
-
-    def has_key?(key)
-      keys = key.to_s.split('.').map!(&:to_sym)
-      keys.size == 1 ? messages[keys.first].present? : (messages.dig(*keys[0...-1])[keys.last].present? rescue false)
-    end
-
-
-    def first_message
-      fetch_messages(messages.values.first).first
-    end
-
-
-    def clone
-      self.class.new(messages.clone)
-    end
-
-
-    private
-
-
-    def hash_to_dots(hash, results = {}, start_key = '')
-      hash.each do |key, value|
-        key = key.to_s
-        key_value = start_key.present? ? sprintf('%s.%s', start_key, key) : key
-        if value.is_a?(Hash)
-          results.merge!(hash_to_dots(value, results, key_value))
-        else
-          results[key_value] = value
-        end
-      end
-      results
-    end
-
-
-    def fetch_messages(value)
-      if value.is_a?(Hash)
-        fetch_messages(value.values.first)
-      else
-        value
-      end
-    end
-
-  end
-end

data/lib/dry/rule.rb

@@ -1,69 +0,0 @@
-module Dry
-  class Rule
-
-    attr_reader :value, :errors, :args
-
-    def initialize(value, errors = Dry::Errors.new, **args)
-      @value  = value
-      @errors = errors
-      @args   = args.symbolize_keys
-    end
-
-
-    def name
-      args[:name]
-    end
-
-
-    def add_error
-      errors.add(key, messages[name.to_s] || 'invalid')
-    end
-
-
-    def clone
-      self.class.new(value, errors.clone, args)
-    end
-
-
-    def and(right)
-      Dry::Rules::And.new(self, errors, args.merge(right: right))
-    end
-    alias :& :and
-
-
-    def then(right)
-      Dry::Rules::Then.new(self, errors, args.merge(right: right))
-    end
-    alias :> :then
-
-
-    def or(right)
-      Dry::Rules::Or.new(self, errors, args.merge(right: right))
-    end
-    alias :| :or
-
-
-    def +(right)
-      Dry::Rules::Collection.new(self, errors, args.merge(right: right))
-    end
-
-
-    def valid?
-      raise NotImplementedError
-    end
-
-
-    private
-
-
-    def messages
-      @messages ||= (args[:messages] || {}).deep_stringify_keys
-    end
-
-
-    def key
-      @key ||= args[:key] || (raise 'Missing required param "key"')
-    end
-
-  end
-end

data/lib/dry/rules/and.rb

@@ -1,11 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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