mini_defender 0.4.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56cc42b9b0ce4c44e30dc4bcd8dfcc31bcccc012388f52a076320ee926feec11
-  data.tar.gz: 7e5aaf99490b42b14956fda14843065d3cd906b6568da7ff4df90059f965b75b
+  metadata.gz: 36f0ca2e9d174da94e991c9eed6300ae0f0315ab57b3d9372921726261318c67
+  data.tar.gz: a4f29b8f5558008c1f5b992722a8ab9dd07dbc93d51d7ec288bd3be5e9d1d91b
 SHA512:
-  metadata.gz: f3a25a2655ed8889345d101bca863cd72a605825ae2dd99a0b6527f73c33572cf5771e8aba28fdb81b1311ac3cc22845a868c5edeb3ddcb1f9ee2572e5e91010
-  data.tar.gz: 9ee05f959b9289c6ea0d9b1f88278bc9617df76cef267a362163fef02f6056dc8443ee3700c86308b54e6608edfd3c34ad7cfabd01d6b01e86d37772d028abe5
+  metadata.gz: 885a3ff5f6a337246c9b47e6ac21b0e9dc21067a11c49d7af2d9135d66f6ab878a620b9f73cafa5b1316d5edc2d74f709f924e37309bbe74bb596500abe8348b
+  data.tar.gz: 3d6a38389f37816a4b6ebbadd7700b6c628e7011c42dfbe0a07ee907f0d354b9b7aaed18179ad97c8350ea01948966ee47182b40e5630370761a5487c58fbe97

data/Gemfile

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-# Specify your gem's dependencies in mini_defender.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
-
-gem "minitest", "~> 5.0"
+gem 'rake', '~> 13.0'
+gem 'minitest', '~> 5.0'

data/lib/mini_defender/rule.rb

@@ -61,6 +61,12 @@ class MiniDefender::Rule
     value
   end
 
+  # This method is used to change the value
+  # regardless if coercion is required
+  def force_coerce?
+    false
+  end
+
   # @param [Object] attribute
   # @param [Object] value
   # @param [MiniDefender::Validator] validator

data/lib/mini_defender/rules/array.rb

@@ -5,6 +5,22 @@ class MiniDefender::Rules::Array < MiniDefender::Rule
     'array'
   end
 
+  def initialize(data_mode = 'none')
+    @data_mode = data_mode
+  end
+
+  def self.make(args)
+    new(args[0] || 'none')
+  end
+
+  def coerce(value)
+    @data_mode == 'all' ? value : []
+  end
+
+  def force_coerce?
+    true
+  end
+
   def passes?(attribute, value, validator)
     value.is_a?(Array)
   end

data/lib/mini_defender/rules/currency.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'countries'
+require 'money'
 
 class MiniDefender::Rules::Currency < MiniDefender::Rule
   CURRENCIES = Money::Currency.map(&:iso_code).map(&:upcase).uniq

data/lib/mini_defender/rules/hash.rb

@@ -5,11 +5,60 @@ class MiniDefender::Rules::Hash < MiniDefender::Rule
     'hash'
   end
 
+  def initialize(data_mode = 'none', key_type = 'any', value_type = 'any')
+    @data_mode = data_mode
+    @key_type = key_type
+    @value_type = value_type
+  end
+
+  def self.make(args)
+    new(
+      args[0] || 'none',
+      args[1] || 'any',
+      args[2] || 'any',
+    )
+  end
+
+  def coerce(value)
+    @data_mode == 'all' ? value : {}
+  end
+
+  def force_coerce?
+    true
+  end
+
   def passes?(attribute, value, validator)
-    value.is_a?(Hash)
+    passes = value.is_a?(Hash)
+
+    if @key_type == 'string'
+      passes &= value.all? { |k, _| k.is_a?(String) }
+    end
+
+    case @value_type
+      when 'string'
+        passes &= value.all? { |_, v| v.is_a?(String) }
+      when 'integer'
+        passes &= value.all? { |_, v| v.is_a?(Integer) }
+      when 'float'
+        passes &= value.all? { |_, v| v.is_a?(Float) }
+      else
+        # None
+    end
+
+    passes
   end
 
   def message(attribute, value, validator)
-    "The field must be an object."
+    additional = ''
+
+    if @key_type != 'any'
+      additional += ", key must be #{@key_type}"
+    end
+
+    if @value_type != 'any'
+      additional += ", value must be #{@value_type}"
+    end
+
+    "The field must be an object#{additional}."
   end
 end

data/lib/mini_defender/rules_expander.rb

@@ -6,14 +6,36 @@ module MiniDefender
     # @param [Hash] flat_data
     # @return [Hash]
     def expand(rules, flat_data)
+      result = {}
+
+      rules.each do |rule_key, rule_set|
+        unless rule_key.include?('*')
+          result[rule_key] = rule_set
+          next
+        end
+
+        k_pattern = Regexp.compile('\A' + rule_key.gsub(/\*/, '\d+') + '\Z')
+        k_pattern_result = {}
+
+        flat_data.each do |value_key, _|
+          next unless k_pattern.match?(value_key)
+          k_pattern_result[value_key] = rule_set
+        end
+
+        if k_pattern_result.empty?
+          k_pattern_result[k_pattern.source.gsub(/\\[AZ]/, '').gsub('\d+', '0')] = rule_set
+        end
+
+        result.merge!(k_pattern_result)
+      end
+
+      result
+    end
+
+    def array_patterns(rules)
       rules
-        .map { |k, v| [Regexp.compile('\A' + k.gsub(/\*/, '\d+') + '\Z'), v] }.to_h
-        .map { |p, set|
-          data_rules = flat_data.filter { |k, _| p.match? k }.map { |k, _| [k, set] }
-          data_rules.length > 0 ? data_rules : [[p.source.gsub(/\\[AZ]/, '').gsub('\d+', '0'), set]]
-        }
-        .flatten(1)
-        .to_h
+        .filter { |key, _| key.include?('*') }
+        .map { |key, _| Regexp.compile('\A' + key.gsub(/\*/, '\d+') + '\Z') }
     end
   end
 end

data/lib/mini_defender/validator.rb

@@ -12,10 +12,13 @@ module MiniDefender
       @coerced = {}
       @expander = RulesExpander.new
       @factory = RulesFactory.new
+      @array_patterns = @expander.array_patterns(rules)
     end
 
     def validate
-      return unless @errors.nil?
+      unless @errors.nil?
+        return
+      end
 
       @errors = {}
 
@@ -23,6 +26,7 @@ module MiniDefender
         [k, @factory.init_set(set)]
       end
 
+      # Set default values for missing data key compared to rules
       data_rules.each do |k, set|
         if !@data.key?(k) || @data[k].blank?
           set.filter{ |r| r.defaults?(self) }.each do |r|
@@ -51,33 +55,40 @@ module MiniDefender
         end
 
         value = coerced = @data[k]
+        force_coerce = false
+
         rule_set.each do |rule|
           next unless rule.active?(self)
 
           value_included &= !rule.excluded?(self)
 
-          if rule.passes?(k, coerced, self)
+          if rule.passes?(k, value, self)
             coerced = rule.coerce(coerced)
+            force_coerce = rule.force_coerce?
           else
             @errors[k] << rule.error_message(k, value, self)
           end
         end
 
+        if force_coerce
+          value = coerced
+        end
+
         if @errors[k].empty? && value_included
           @validated[k] = value
           @coerced[k] = coerced
         end
       end
 
-      @validated = @validated.expand
-      @coerced = @coerced.expand
-
       @errors.reject! { |_, v| v.empty? }
     end
 
     def validate!
       validate if @errors.nil?
-      raise ValidationError.new('Data validation failed', @errors) unless @errors.empty?
+
+      unless @errors.empty?
+        raise ValidationError.new('Data validation failed', @errors)
+      end
     end
 
     def passes?
@@ -91,12 +102,12 @@ module MiniDefender
 
     def validated
       validate! if @errors.nil?
-      @validated
+      @validated_compacted ||= compact_expanded(@validated)
     end
 
     def coerced
       validate! if @errors.nil?
-      @coerced
+      @coerced_compacted = compact_expanded(@coerced)
     end
 
     # @return [Hash]
@@ -125,5 +136,57 @@ module MiniDefender
 
       Regexp.compile("\\A#{search_key.reverse.join('\.')}\\z")
     end
+
+    def compact_expanded(hash)
+      expanded = {}
+
+      hash.each do |k, v|
+        keys = k.split('.')
+        node = expanded
+
+        while keys.length > 1
+          next_key = keys.shift
+          next_node = (node[next_key] ||= {})
+
+          if next_node.is_a?(Array)
+            node[next_key] = next_node = next_node.each_with_index.to_h do |value, index|
+              [index.to_s, value]
+            end
+          end
+
+          node = next_node
+        end
+
+        node[keys.shift] = v
+      end
+
+      compact_keys(expanded)
+    end
+
+    def compact_keys(hash, current_key = '')
+      current_key_suffixed = if current_key == ''
+        ''
+      else
+        "#{current_key}."
+      end
+
+      result = hash.to_h do |k, v|
+        [k, v.is_a?(Hash) ? compact_keys(v, current_key_suffixed + k) : v]
+      end
+
+      if result.empty?
+        return result
+      end
+
+      unless @array_patterns.any? { |p| p.match?("#{current_key_suffixed}#{result.keys.first}") }
+        return result
+      end
+
+      if result.all? { |k, _v| k.match?(/\A\d+\z/) }
+        return result.values
+      end
+
+      result
+    end
   end
 end

data/lib/mini_defender/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniDefender
-  VERSION = "0.4.1"
+  VERSION = "0.5.1"
 end

data/lib/mini_defender.rb

@@ -13,7 +13,6 @@ require_relative 'mini_defender/validation_helpers'
 
 # Extensions to Ruby Core
 require_relative 'mini_defender/extensions/enumerable'
-require_relative 'mini_defender/extensions/hash'
 
 module MiniDefender
 end

data/mini_defender.gemspec

@@ -14,8 +14,6 @@ Gem::Specification.new do |spec|
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.6.0"
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
-
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_defender
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Ali Alhoshaiyan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
+date: 2024-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -97,7 +97,6 @@ files:
 - Rakefile
 - lib/mini_defender.rb
 - lib/mini_defender/extensions/enumerable.rb
-- lib/mini_defender/extensions/hash.rb
 - lib/mini_defender/handles_validation_errors.rb
 - lib/mini_defender/rule.rb
 - lib/mini_defender/rules.rb

data/lib/mini_defender/extensions/hash.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  def expand
-    expanded = {}
-
-    reject{ |_, v| v.is_a?(Hash) || v.is_a?(Array) }.each do |k, v|
-      keys = k.split('.')
-      node = expanded
-      node = (node[keys.shift] ||= {}) while keys.length > 1
-      node[keys.shift] = v
-    end
-
-    expanded.compact_keys
-  end
-
-  def compact_keys
-    result = to_h do |k, v|
-      [k, v.is_a?(Hash) ? v.compact_keys : v]
-    end
-
-    if !result.empty? && result.all? { |k, _v| k.match?(/\A\d+\z/) }
-      result.values
-    else
-      result
-    end
-  end
-end