mini_defender 0.1.0

data/lib/mini_defender/rules/date.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'time'
+
+class MiniDefender::Rules::Date < MiniDefender::Rule
+  def self.signature
+    'date'
+  end
+
+  def passes?(attribute, value, validator)
+    parse_date(value).is_a?(Time)
+  rescue ArgumentError
+    false
+  end
+
+  def message(attribute, value, validator)
+    'The given value is not a valid date.'
+  end
+
+  protected
+
+  def parse_date(date)
+    date = date.to_time if date.is_a?(Date)
+    date = Time.parse(date) unless date.is_a?(Time)
+    date
+  end
+end

data/lib/mini_defender/rules/date_eq.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'time'
+
+class MiniDefender::Rules::DateEq < MiniDefender::Rule
+  def initialize(target_date)
+    @target_date = parse_date(target_date)
+    @valid_value = false
+  end
+
+  def self.signature
+    'date_eq'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Target date is required for date rules.' unless args == 1
+
+    self.new(args[0])
+  end
+
+  def passes?(attribute, value, validator)
+    value = parse_date(value)
+    @valid_value = true
+
+    value == @target_date
+  rescue ArgumentError
+    false
+  end
+
+  def message(attribute, value, validator)
+    return "The given value is not a valid date." unless @valid_value
+
+    "The value must be equal to #{@target_date}."
+  end
+
+  protected
+
+  def parse_date(date)
+    date = date.to_time if date.is_a?(Date)
+    date = Time.parse(date) unless date.is_a?(Time)
+    date
+  end
+end

data/lib/mini_defender/rules/date_format.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'time'
+
+class MiniDefender::Rules::DateFormat < MiniDefender::Rule
+  def initialize(format)
+    raise ArgumentError, 'Format must be a string' unless format.is_a?(String)
+    raise ArgumentError, 'Format is required for this rule' if format.empty?
+
+    @format = format
+  end
+
+  def self.signature
+    'date_format'
+  end
+
+  def self.make(args)
+    self.new(args[0])
+  end
+
+  def passes?(attribute, value, validator)
+    parse_date(value).is_a?(Time)
+  rescue ArgumentError
+    false
+  end
+
+  def message(attribute, value, validator)
+    'The given value is not a valid date.'
+  end
+
+  protected
+
+  def parse_date(date)
+    date = date.to_time if date.is_a?(Date)
+    date = Time.strptime(date, @format) unless date.is_a?(Time)
+    date
+  end
+end

data/lib/mini_defender/rules/date_gt.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'date_eq'
+
+class MiniDefender::Rules::DateGt < MiniDefender::Rules::DateEq
+  def self.signature
+    'date_gt'
+  end
+
+  def passes?(attribute, value, validator)
+    value = parse_date(value)
+    @valid_value = true
+
+    value > @target_date
+  rescue ArgumentError
+    false
+  end
+
+  def message(attribute, value, validator)
+    return "The given value is not a valid date." unless @valid_value
+
+    "The value must be greater than #{@target_date}."
+  end
+end

data/lib/mini_defender/rules/date_gte.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'date_eq'
+
+class MiniDefender::Rules::DateGte < MiniDefender::Rules::DateEq
+  def self.signature
+    'date_gte'
+  end
+
+  def passes?(attribute, value, validator)
+    value = parse_date(value)
+    @valid_value = true
+
+    value >= @target_date
+  rescue ArgumentError
+    false
+  end
+
+  def message(attribute, value, validator)
+    return "The given value is not a valid date." unless @valid_value
+
+    "The value must be greater than or equal to #{@target_date}."
+  end
+end

data/lib/mini_defender/rules/date_lt.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'date_eq'
+
+class MiniDefender::Rules::DateLt < MiniDefender::Rules::DateEq
+  def self.signature
+    'date_lt'
+  end
+
+  def passes?(attribute, value, validator)
+    value = parse_date(value)
+    @valid_value = true
+
+    value < @target_date
+  rescue ArgumentError
+    false
+  end
+
+  def message(attribute, value, validator)
+    return "The given value is not a valid date." unless @valid_value
+
+    "The value must be less than #{@target_date}."
+  end
+end

data/lib/mini_defender/rules/date_lte.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'date_eq'
+
+class MiniDefender::Rules::DateLte < MiniDefender::Rules::DateEq
+  def self.signature
+    'date_lte'
+  end
+
+  def passes?(attribute, value, validator)
+    value = parse_date(value)
+    @valid_value = true
+
+    value <= @target_date
+  rescue ArgumentError
+    false
+  end
+
+  def message(attribute, value, validator)
+    return "The given value is not a valid date." unless @valid_value
+
+    "The value must be less than or equal to #{@target_date}."
+  end
+end

data/lib/mini_defender/rules/declined.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Declined < MiniDefender::Rule
+  ALLOWED_VALUES = ['no', 'off', 0, false]
+
+  def self.signature
+    'declined'
+  end
+
+  def passes?(attribute, value, validator)
+    !value.nil? && ALLOWED_VALUES.include?(value)
+  end
+
+  def message(attribute, value, validator)
+    "Must be declined."
+  end
+end

data/lib/mini_defender/rules/declined_if.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'declined'
+
+class MiniDefender::Rules::DeclinedIf < MiniDefender::Rules::Declined
+  def initialize(target, value)
+    raise ArgumentError, 'Target must be a string' unless target.is_a?(String)
+
+    @target = target
+    @value = value
+  end
+
+  def self.signature
+    'declined_if'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Target and expected value are required.' unless args.length == 2
+
+    self.new(args[0], args[1])
+  end
+
+  def active?(validator)
+    validator.data[@target] == @value
+  end
+end

data/lib/mini_defender/rules/default.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Default < MiniDefender::Rule
+  def initialize(value)
+    @default = value
+  end
+
+  def self.signature
+    'default'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Expected exactly one argument.' unless args.length == 1
+
+    new(args[0])
+  end
+
+  def defaults?(validator)
+    true
+  end
+
+  def default_value(validator)
+    @default
+  end
+
+  def passes?(attribute, value, validator)
+    true
+  end
+
+  def message(attribute, value, validator)
+    "i can haz valuo?."
+  end
+end

data/lib/mini_defender/rules/different.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Different < MiniDefender::Rule
+  def initialize(other_field)
+    raise ArgumentError, 'Other field must be a string' unless other_field.is_a?(String)
+
+    @found = false
+    @other_field = other_field
+  end
+
+  def self.signature
+    'different'
+  end
+
+  def self.make(args)
+    self.new(args[0])
+  end
+
+  def passes?(attribute, value, validator)
+    @found, @other = validator.data.key?(@other_field), validator.data[@other_field]
+    @found && value == @other
+  end
+
+  def message(attribute, value, validator)
+    if @found
+      "The field does not match \"#{@other}\"."
+    else
+      "The field must match #{@other_field}."
+    end
+  end
+end

data/lib/mini_defender/rules/digits.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Digits < MiniDefender::Rule
+  def initialize(size)
+    raise ArgumentError, 'Size must be a positive integer' unless size.is_a?(Integer) && size > 0
+
+    @size = size
+  end
+
+  def self.signature
+    'digits'
+  end
+
+  def self.make(args)
+    self.new(args[0].to_i)
+  end
+
+  def passes?(attribute, value, validator)
+    value = value&.to_s
+    value.is_a?(String) && /\A[0-9]+\z/.match?(value) && value.length == @size
+  end
+
+  def message(attribute, value, validator)
+    "The field must contain #{size} digits."
+  end
+end

data/lib/mini_defender/rules/digits_between.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::DigitsBetween < MiniDefender::Rule
+  def initialize(min, max)
+    raise ArgumentError, 'Min must be a positive integer' unless min.is_a?(Integer) && min > 0
+    raise ArgumentError, 'Max must be a positive integer' unless max.is_a?(Integer) && max > 0
+
+    @min = min
+    @max = max
+  end
+
+  def self.signature
+    'digits_between'
+  end
+
+  def self.make(args)
+    self.new(args[0].to_i, args[1].to_i)
+  end
+
+  def passes?(attribute, value, validator)
+    value = value&.to_s
+
+    value.is_a?(String) && /\A[0-9]+\z/.match?(value) && value.length >= @min && value.length <= @max
+  end
+
+  def message(attribute, value, validator)
+    "The field must contain digits between #{min} and #{max}."
+  end
+end

data/lib/mini_defender/rules/distinct.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Distinct < MiniDefender::Rule
+  def self.signature
+    'distinct'
+  end
+
+  def passes?(attribute, value, validator)
+    validator
+      .neighbors(attribute)
+      .reject { |k, v| k == attribute }
+      .none? { |_, v| v == value }
+  end
+
+  def message(attribute, value, validator)
+    'The value should be unique.'
+  end
+end

data/lib/mini_defender/rules/email.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Email < MiniDefender::Rule
+  def self.signature
+    'email'
+  end
+
+  def coerce(value)
+    value.strip.downcase
+  end
+
+  def passes?(attribute, value, validator)
+    value.to_s.match?(URI::MailTo::EMAIL_REGEXP)
+  end
+
+  def message(attribute, value, validator)
+    "The value should be a valid email address."
+  end
+end

data/lib/mini_defender/rules/ending_with.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::EndingWith < 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
+    '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 end with #{@fragments[0]}."
+    else
+      "The value should end with one of the following #{@fragments.join(', ')}."
+    end
+  end
+end

data/lib/mini_defender/rules/equal.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'size'
+
+class MiniDefender::Rules::Equal < MiniDefender::Rules::Size
+  def self.signature
+    'equal'
+  end
+end

data/lib/mini_defender/rules/excluded.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Excluded < MiniDefender::Rule
+  def self.signature
+    'excluded'
+  end
+
+  def excluded?(validator)
+    true
+  end
+
+  def passes?(attribute, value, validator)
+    true
+  end
+end

data/lib/mini_defender/rules/excluded_if.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::ExcludedIf < MiniDefender::Rule
+  def initialize(target, value)
+    raise ArgumentError, 'Target must be a string' unless target.is_a?(String)
+
+    @target = target
+    @value = value
+  end
+
+  def self.signature
+    'excluded_if'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Target and expected value are required.' unless args.length == 2
+
+    self.new(args[0], args[1])
+  end
+
+  def excluded?(validator)
+    validator.data.key?(@target) && validator.data[@target] == @value
+  end
+
+  def passes?(attribute, value, validator)
+    true
+  end
+end

data/lib/mini_defender/rules/excluded_unless.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::ExcludedUnless < MiniDefender::Rule
+  def initialize(target, value)
+    raise ArgumentError, 'Target must be a string' unless target.is_a?(String)
+
+    @target = target
+    @value = value
+  end
+
+  def self.signature
+    'excluded_unless'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Target and expected value are required.' unless args.length == 2
+
+    self.new(args[0], args[1])
+  end
+
+  def excluded?(validator)
+    ! (validator.data.key?(@target) && validator.data[@target] == @value)
+  end
+
+  def passes?(attribute, value, validator)
+    true
+  end
+end

data/lib/mini_defender/rules/excluded_with.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::ExcludedWith < MiniDefender::Rule
+  def initialize(target)
+    raise ArgumentError, 'Target must be a string' unless target.is_a?(String)
+
+    @target = target
+  end
+
+  def self.signature
+    'excluded_with'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Target and expected value are required.' unless args.length == 1
+
+    self.new(args[0])
+  end
+
+  def excluded?(validator)
+    validator.data.key?(@target)
+  end
+
+  def passes?(attribute, value, validator)
+    true
+  end
+end

data/lib/mini_defender/rules/excluded_without.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::ExcludedWithout < MiniDefender::Rule
+  def initialize(target)
+    raise ArgumentError, 'Target must be a string' unless target.is_a?(String)
+
+    @target = target
+  end
+
+  def self.signature
+    'excluded_without'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Target and expected value are required.' unless args.length == 1
+
+    self.new(args[0])
+  end
+
+  def excluded?(validator)
+    !validator.data.key?(@target)
+  end
+
+  def passes?(attribute, value, validator)
+    true
+  end
+end

data/lib/mini_defender/rules/exists.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::Exists < MiniDefender::Rule
+  def initialize(model, column)
+    raise ArgumentError, 'model name must be a string or ActiveRecord::Base' unless model.is_a?(String)
+    raise ArgumentError, 'Column name must be a string' unless column.is_a?(String)
+
+    @model = model.camelcase.constantize
+    @column = column
+  end
+
+  def self.signature
+    'exists'
+  end
+
+  def self.make(args)
+    raise ArgumentError, 'Model and column are required.' unless args.length == 2
+
+    self.new(args[0], args[1])
+  end
+
+  def passes?(attribute, value, validator)
+    @model.where(@column => value).exists?
+  end
+
+  def message(attribute, value, validator)
+    "The value does not exists."
+  end
+end

data/lib/mini_defender/rules/expiry_date.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class MiniDefender::Rules::ExpiryDate < MiniDefender::Rule
+  def self.signature
+    'expiry_date'
+  end
+
+  def coerce(value)
+    "#{@month}/#{@year}"
+  end
+
+  def passes?(attribute, value, validator)
+    return false unless value.is_a?(String)
+
+    matches = /(\d{2})\s*\/\s*(\d{2,4})/.match(value.strip)
+    return false unless matches
+
+    @month = matches[1].to_i
+    @year = matches[2].to_i
+    @year += 2000 if year < 100
+
+    @month >= 1 && @month <= 12 && @year >= 1900
+  end
+
+  def message(attribute, value, validator)
+    'Invalid expiry date.'
+  end
+end

data/lib/mini_defender/rules/file.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+
+class MiniDefender::Rules::File < MiniDefender::Rule
+  def self.signature
+    'file'
+  end
+
+  def passes?(attribute, value, validator)
+    value.is_a?(ActionDispatch::Http::UploadedFile)
+  end
+
+  def message(attribute, value, validator)
+    "The field should be a file."
+  end
+end