mini_defender 0.1.0

data/lib/mini_defender/rules/filled.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Filled < MiniDefender::Rule
+  def self.signature
+    'filled'
+  end
+
+  def passes?(attribute, value, validator)
+    case value
+    when String
+      !value.strip.empty?
+    when Array, Hash
+      !value.empty?
+    else
+      !value.nil?
+    end
+  end
+
+  def message(attribute, value, validator)
+    'The field should not be empty.'
+  end
+end

data/lib/mini_defender/rules/greater_than.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+require_relative 'size'
+
+class MiniDefender::Rules::GreaterThan < MiniDefender::Rules::Size
+  def self.signature
+    'gt'
+  end
+
+  def passes?(attribute, value, validator)
+    case value
+    when String, Array, Hash
+      value.length > @size
+    when ActionDispatch::Http::UploadedFile
+      value.size > @size
+    when Numeric
+      value > @size
+    else
+      false
+    end
+  end
+
+  def message(attribute, value, validator)
+    case value
+    when ActionDispatch::Http::UploadedFile
+      "The file size must be greater than #{@size} bytes."
+    when Numeric
+      "The value must be greater than #{@size}."
+    else
+      "The value length must be greater than #{@size}."
+    end
+  end
+end

data/lib/mini_defender/rules/greater_than_or_equal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+require_relative 'size'
+
+class MiniDefender::Rules::GreaterThanOrEqual < MiniDefender::Rules::Size
+  def self.signature
+    'gte'
+  end
+
+  def passes?(attribute, value, validator)
+    case value
+    when String, Array, Hash
+      value.length >= @size
+    when ActionDispatch::Http::UploadedFile
+      value.size >= @size
+    when Numeric
+      value >= @size
+    else
+      false
+    end
+  end
+
+  def message(attribute, value, validator)
+    case value
+    when ActionDispatch::Http::UploadedFile
+      "The file size must be greater than or equal to #{@size} bytes."
+    when Numeric
+      "The value must be greater than or equal to #{@size}."
+    else
+      "The value length must be greater than or equal to #{@size}."
+    end
+  end
+end

data/lib/mini_defender/rules/hash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Hash < MiniDefender::Rule
+  def self.signature
+    'hash'
+  end
+
+  def passes?(attribute, value, validator)
+    value.is_a?(Hash)
+  end
+
+  def message(attribute, value, validator)
+    "The field must be an object."
+  end
+end

data/lib/mini_defender/rules/image.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+
+class MiniDefender::Rules::Image < MiniDefender::Rule
+  MIMES = %w[image/jpeg image/png image/gif image/bmp image/png image/svg+xml image/webp]
+
+  def self.signature
+    'image'
+  end
+
+  def passes?(attribute, value, validator)
+    value.is_a?(ActionDispatch::Http::UploadedFile) && MIMES.include?(value.content_type)
+  end
+
+  def message(attribute, value, validator)
+    "The field should be an image of type jpg, jpeg, png, bmp, gif, svg, or webp."
+  end
+end

data/lib/mini_defender/rules/in.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::In < MiniDefender::Rule
+  def initialize(values)
+    raise ArgumentError, 'Expected an array of values.' unless values.is_a?(Array)
+
+    @values = values
+  end
+
+  def self.signature
+    'in'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Expected at least one argument.' unless args.length > 0
+
+    new(args)
+  end
+
+  def passes?(attribute, value, validator)
+    @values.include?(value)
+  end
+
+  def message(attribute, value, validator)
+    "The value must be one of #{@values.to_sentence}."
+  end
+end

data/lib/mini_defender/rules/in_field.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::InField < MiniDefender::Rule
+  def initialize(field)
+    raise ArgumentError, 'Field must be a string.' unless field.is_a?(String)
+
+    @field = field
+  end
+
+  def self.signature
+    'in_field'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Expected one argument, target field name.' unless args.length == 1
+
+    new(args[0])
+  end
+
+  def passes?(attribute, value, validator)
+    @field_value = nil
+    return false unless validator.data.key(@field)
+
+    @field_value = validator.data[@field]
+    return false unless field.is_a?(Array)
+
+    @field_value.include?(value)
+  end
+
+  def message(attribute, value, validator)
+    case @field_value
+    when nil
+      "The field (#{@field}) is missing."
+    when Array
+      "The field (#{@field}) must be an array."
+    else
+      "The value must be one of the values found in #{@field}."
+    end
+  end
+end

data/lib/mini_defender/rules/integer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Integer < MiniDefender::Rule
+  def self.signature
+    'integer'
+  end
+
+  def coerce(value)
+    value.to_i
+  end
+
+  def passes?(attribute, value, validator)
+    value.is_a?(Integer) || value.is_a?(String) && value.match?(/^\d+$/)
+  end
+
+  def message(attribute, value, validator)
+    "The value must be an integer."
+  end
+end

data/lib/mini_defender/rules/ip.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+class MiniDefender::Rules::Ip < MiniDefender::Rule
+  MODES = %w[any public private]
+
+  def initialize(mode = 'any')
+    raise ArgumentError, 'Invalid mode' unless MODES.include?(mode)
+
+    @mode = mode
+  end
+
+  def self.signature
+    'ip'
+  end
+
+  def self.make(args)
+    new(args[0] || 'any')
+  end
+
+  def passes?(attribute, value, validator)
+    ip = IPAddr.new(value.to_s)
+    (
+      @mode == 'any' ||
+      @mode == 'private' && (ip.private? || ip.link_local? || ip.loopback?) ||
+      @mode == 'public' && !(ip.private? || ip.link_local? || ip.loopback?)
+    )
+  rescue IPAddr::InvalidAddressError
+    false
+  end
+
+  def message(attribute, value, validator)
+    case @mode
+    when 'public'
+      "The value must be a valid public IP address."
+    when 'private'
+      "The value must be a valid private IP address."
+    else
+      "The value must be a valid IP address."
+    end
+  end
+end

data/lib/mini_defender/rules/ipv4.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+class MiniDefender::Rules::Ipv4 < MiniDefender::Rule
+  MODES = %w[any public private]
+
+  def initialize(mode = 'any')
+    raise ArgumentError, 'Invalid mode' unless MODES.include?(mode)
+
+    @mode = mode
+  end
+
+  def self.signature
+    'ipv4'
+  end
+
+  def self.make(args)
+    new(args[0] || 'any')
+  end
+
+  def passes?(attribute, value, validator)
+    ip = IPAddr.new(value.to_s)
+    ip.ipv4? && (
+      @mode == 'any' ||
+      @mode == 'private' && (ip.private? || ip.link_local? || ip.loopback?) ||
+      @mode == 'public' && !(ip.private? || ip.link_local? || ip.loopback?)
+    )
+  rescue IPAddr::InvalidAddressError
+    false
+  end
+
+  def message(attribute, value, validator)
+    case @mode
+    when 'public'
+      "The value must be a valid public IPv4 address."
+    when 'private'
+      "The value must be a valid private IPv4 address."
+    else
+      "The value must be a valid IPv4 address."
+    end
+  end
+end

data/lib/mini_defender/rules/ipv6.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+class MiniDefender::Rules::Ipv6 < MiniDefender::Rule
+  MODES = %w[any public private]
+
+  def initialize(mode = 'any')
+    raise ArgumentError, 'Invalid mode' unless MODES.include?(mode)
+
+    @mode = mode
+  end
+
+  def self.signature
+    'ipv6'
+  end
+
+  def self.make(args)
+    new(args[0] || 'any')
+  end
+
+  def passes?(attribute, value, validator)
+    ip = IPAddr.new(value.to_s)
+    ip.ipv6? && (
+      @mode == 'any' ||
+      @mode == 'private' && (ip.private? || ip.link_local? || ip.loopback?) ||
+      @mode == 'public' && !(ip.private? || ip.link_local? || ip.loopback?)
+    )
+  rescue IPAddr::InvalidAddressError
+    false
+  end
+
+  def message(attribute, value, validator)
+    case @mode
+    when 'public'
+      "The value must be a valid public IPv6 address."
+    when 'private'
+      "The value must be a valid private IPv6 address."
+    else
+      "The value must be a valid IPv6 address."
+    end
+  end
+end

data/lib/mini_defender/rules/json.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class MiniDefender::Rules::Json < MiniDefender::Rule
+  def self.signature
+    'json'
+  end
+
+  def passes?(attribute, value, validator)
+    JSON.parse(value)
+  rescue JSON::ParserError
+    false
+  end
+
+  def message(attribute, value, validator)
+    "The value should be a valid JSON string."
+  end
+end

data/lib/mini_defender/rules/less_than.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+require_relative 'size'
+
+class MiniDefender::Rules::LessThan < MiniDefender::Rules::Size
+  def self.signature
+    'lt'
+  end
+
+  def passes?(attribute, value, validator)
+    case value
+    when String, Array, Hash
+      value.length < @size
+    when ActionDispatch::Http::UploadedFile
+      value.size < @size
+    when Numeric
+      value < @size
+    else
+      false
+    end
+  end
+
+  def message(attribute, value, validator)
+    case value
+    when ActionDispatch::Http::UploadedFile
+      "The file size must be less than #{@size} bytes."
+    when Numeric
+      "The value must be less than #{@size}."
+    else
+      "The value length must be less than #{@size}."
+    end
+  end
+end

data/lib/mini_defender/rules/less_than_or_equal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+require_relative 'size'
+
+class MiniDefender::Rules::LessThanOrEqual < MiniDefender::Rules::Size
+  def self.signature
+    'lte'
+  end
+
+  def passes?(attribute, value, validator)
+    case value
+    when String, Array, Hash
+      value.length <= @size
+    when ActionDispatch::Http::UploadedFile
+      value.size <= @size
+    when Numeric
+      value <= @size
+    else
+      false
+    end
+  end
+
+  def message(attribute, value, validator)
+    case value
+    when ActionDispatch::Http::UploadedFile
+      "The file size must be less than or equal to #{@size} bytes."
+    when Numeric
+      "The value must be less than or equal to #{@size}."
+    else
+      "The value length must be less than or equal to #{@size}."
+    end
+  end
+end

data/lib/mini_defender/rules/luhn.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Luhn < MiniDefender::Rule
+  def self.signature
+    'luhn'
+  end
+
+  def self.valid_luhn?(value)
+    value = value.to_s
+    return false unless value.match?(/\A\d+\z/)
+
+    double_sum = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]
+    sum = 0
+
+    value.to_i.digits.each_with_index do |digit, index|
+      sum += index.even? ? digit : double_sum[digit]
+    end
+
+    sum % 10 === 0
+  end
+
+  def coerce(value)
+    value.to_s
+  end
+
+  def passes?(attribute, value, validator)
+    value.is_a?(String) && self.class.valid_luhn?(value)
+  end
+
+  def message(attribute, value, validator)
+    'The value must be a valid Luhn string.'
+  end
+end

data/lib/mini_defender/rules/mac_address.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::MacAddress < MiniDefender::Rule
+  MODES = %w[any local universal]
+
+  def initialize(mode = 'any')
+    raise ArgumentError, 'Invalid mode' unless MODES.include?(mode)
+
+    @mode = mode
+  end
+
+  def self.signature
+    'mac'
+  end
+
+  def self.make(args)
+    new(args[0] || 'any')
+  end
+
+  def passes?(attribute, value, validator)
+    clean = value.to_s.gsub(/[-:]/)
+    clean.match?(/[0-9A-F]{12}/i) && (
+      @mode == 'any' ||
+      @mode == 'local' && (clean.hex & 0x020000000000 > 0) ||
+      @mode == 'universal' && (clean.hex & 0x020000000000 == 0)
+    )
+  end
+
+  def message(attribute, value, validator)
+    case @mode
+    when 'local'
+      "The value must be a locally administrated MAC address."
+    when 'universal'
+      "The value must be a universally administrated MAC address."
+    else
+      "The value must be a properly formatted mac address."
+    end
+  end
+end

data/lib/mini_defender/rules/max.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'less_than_or_equal'
+
+class MiniDefender::Rules::Max < MiniDefender::Rules::LessThanOrEqual
+  def self.signature
+    'max'
+  end
+end

data/lib/mini_defender/rules/max_digits.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::MaxDigits < MiniDefender::Rule
+  def initialize(limit)
+    raise ArgumentError, 'Limit must be a string.' unless limit.is_a?(Integer)
+
+    @limit = limit
+  end
+
+  def self.signature
+    'max_digits'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Expected at least one argument for max_digits.' unless args.length == 1
+
+    new(args[0].to_i)
+  end
+
+  def passes?(attribute, value, validator)
+    @integers = valid = value.is_a?(Integer) || value.is_a?(String) && value.match?(/^\d+$/)
+    valid && value.to_s.length <= @limit
+  end
+
+  def message(attribute, value, validator)
+    if @integers
+      'The field should only contain digits.'
+    else
+      "The field should have at most #{@limit} digits."
+    end
+  end
+end

data/lib/mini_defender/rules/mime_types.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+
+class MiniDefender::Rules::MimeTypes < MiniDefender::Rule
+  def initialize(types)
+    unless types.is_a?(Array) && types.all?{ |t| t.is_a?(String) }
+      raise ArgumentError, 'Expected an array of strings.'
+    end
+
+    @types = types
+    @file = false
+  end
+
+  def self.signature
+    'mime'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Expected at least one MIME type.' unless args.length > 0
+
+    new(args.split(',').map(&:downcase).map(&:strip))
+  end
+
+  def passes?(attribute, value, validator)
+    @file = value.is_a?(ActionDispatch::Http::UploadedFile)
+    @file && @types.include?(@file.content_type)
+  end
+
+  def message(attribute, value, validator)
+    if @file
+      "The file should be one of the following types #{@types.to_sentence}"
+    else
+      'The field should be a file.'
+    end
+  end
+end

data/lib/mini_defender/rules/min.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'greater_than_or_equal'
+
+class MiniDefender::Rules::Min < MiniDefender::Rules::GreaterThanOrEqual
+  def self.signature
+    'min'
+  end
+end

data/lib/mini_defender/rules/min_digits.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::MinDigits < MiniDefender::Rule
+  def initialize(limit)
+    raise ArgumentError, 'Limit must be a string.' unless limit.is_a?(Integer)
+
+    @limit = limit
+  end
+
+  def self.signature
+    'min_digits'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Expected at least one argument for min_digits.' unless args.length == 1
+
+    new(args[0].to_i)
+  end
+
+  def passes?(attribute, value, validator)
+    @integers = valid = value.is_a?(Integer) || value.is_a?(String) && value.match?(/^\d+$/)
+    valid && value.to_s.length >= @limit
+  end
+
+  def message(attribute, value, validator)
+    if @integers
+      'The field should only contain digits.'
+    else
+      "The field should have at least #{@limit} digits."
+    end
+  end
+end

data/lib/mini_defender/rules/national_id.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'luhn'
+
+class MiniDefender::Rules::NationalId < MiniDefender::Rules::Luhn
+  def self.signature
+    'national_id'
+  end
+
+  def message(attribute, value, validator)
+    'The value must be a proper national ID number.'
+  end
+end

data/lib/mini_defender/rules/not_ending_with.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::NotEndingWith < MiniDefender::Rule
+  def initialize(fragments)
+    unless fragments.is_a?(Array) && !fragments.empty? && fragments.all? { |f| f.is_a?(String) }
+      raise ArgumentError, 'Expected an array of strings.'
+    end
+
+    @fragments = fragments
+  end
+
+  def self.signature
+    'not_ending_with'
+  end
+
+  def self.make(args)
+    new(args)
+  end
+
+  def passes?(attribute, value, validator)
+    @fragments.any? { |f| !value.to_s.end_with?(f) }
+  end
+
+  def message(attribute, value, validator)
+    if @fragments.length == 1
+      "The value should not end with #{@fragments[0]}."
+    else
+      "The value should not end with one of the following #{@fragments.join(', ')}."
+    end
+  end
+end