module Validation::Adjustment - validation-0.4.1 Documentation

INJECT(adjuster1, adjuster2, *adjusters) click to toggle source

Sequential apply all adjusters. @param adjuster1 [Proc, to_proc] @param adjuster2 [Proc, to_proc] @param adjusters [Proc, to_proc] @return [lambda]

# File lib/validation/adjustment.rb, line 47
def INJECT(adjuster1, adjuster2, *adjusters)
  adjusters = [adjuster1, adjuster2, *adjusters]

  unless adjusters.all? { |f| adjustable?(f) }
    raise TypeError, 'wrong object for adjuster'
  end

  ->v {
    adjusters.reduce(v) { |ret, adjuster| adjuster.call(ret) }
  }
end

PARSE(parser) click to toggle source

Accept any parser when that respond to parse method. @param parser [#parse] @return [lambda]

# File lib/validation/adjustment.rb, line 62
def PARSE(parser)
  if !::Integer.equal?(parser) && !parser.respond_to?(:parse)
    raise TypeError, 'wrong object for parser'
  end

  ->v {
    if ::Integer.equal?(parser)
      ::Kernel.Integer(v)
    else
      parser.parse(
        case v
        when String
          v
        when ->_ { v.respond_to?(:to_str) }
          v.to_str
        when ->_ { v.respond_to?(:read) }
          v.read
        else
          raise TypeError, 'wrong object for parsing source'
        end
      )
    end
  }
end

WHEN(pattern, adjuster) click to toggle source

Adjuster Builders Apply adjuster when passed pattern. @param pattern [Proc, Method, ===] @param adjuster [Proc, to_proc] @return [lambda]

# File lib/validation/adjustment.rb, line 30
def WHEN(pattern, adjuster)
  unless Eqq.pattern?(pattern)
    raise TypeError, 'wrong object for pattern'
  end

  unless Validation.adjustable?(adjuster)
    raise TypeError, 'wrong object for adjuster'
  end

  ->v { _valid?(pattern, v) ? adjuster.call(v) : v }
end

adjustable?(object) click to toggle source

true if argument is sufficient for adjuster. A adjuster have to be arity equal 1.

# File lib/validation/adjustment.rb, line 12
def adjustable?(object)
  case object
  when Proc
    object.arity == 1
  else
    if object.respond_to?(:to_proc)
      object.to_proc.arity == 1
    else
      false
    end
  end
end