Class: ConditionChecker

Inherits:
Object
  • Object
show all
Defined in:
lib/condition_checker.rb

Overview

The ConditionChecker supplied the DSL host environment to evaluate expressions in the Preconditions DSL language. The #is method takes a block that is evaluated in the context of the ConditionChecker instance, with access to all of the ConditionChecker methods. Typical usage will be of the form:

Preconditions.check(x).is { not_nil and responds_to(:hello)

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(arg, name = nil, &block) ⇒ ConditionChecker

Returns a new instance of ConditionChecker.



11
12
13
14
 
# File 'lib/condition_checker.rb', line 11

def initialize(arg, name=nil, &block)
  @arg = arg
  @name = name
end

Instance Attribute Details

#arg ⇒ Object (readonly)

Returns the value of attribute arg.



9
10
11
 
# File 'lib/condition_checker.rb', line 9

def arg
  @arg
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



9
10
11
 
# File 'lib/condition_checker.rb', line 9

def name
  @name
end

Instance Method Details

#can_respond_to(method_symbol) ⇒ Object

DSL call. Establishes that the checked argument can respond to the requested method, identified by symbol.

Returns:

  • true



54
55
56
57
58
59
 
# File 'lib/condition_checker.rb', line 54

def can_respond_to(method_symbol)
  if !arg.respond_to?(method_symbol)
    raise NameError, format_message("must respond to method #{method_symbol}")
  end
  true
end

#has_type(type) ⇒ Object

DSL call. Establishes that the checked argument is of the given type. nil is treated as a bottom type (i.e. it is compatible with all types)

Returns:

  • true



44
45
46
47
48
49
 
# File 'lib/condition_checker.rb', line 44

def has_type(type)
  if !arg.nil? && !arg.kind_of?(type)
    raise TypeError, format_message("must be of type #{type.name}, but is of type #{arg.class.name}")
  end
  true
end

#is_not_nil ⇒ Object

DSL call. Establishes that the checked argument is non-nil.

Returns:

  • true



33
34
35
36
37
38
 
# File 'lib/condition_checker.rb', line 33

def is_not_nil
  if arg.nil?
    raise ArgumentError, format_message("may not be nil")
  end
  true
end

#matches(regex) ⇒ Object

DSL call. Establishes that the checked argument matches the given regular expression

Returns:

  • true



64
65
66
67
68
69
 
# File 'lib/condition_checker.rb', line 64

def matches(regex)
  if arg !~ regex
    raise ArgumentError, format_message("must match the regex /#{regex.to_s}/")
  end
  true
end

#named(name, &block) ⇒ Object

Set the name of the argument being checked

Parameters:

  • name (String) —

    the name of the parameter being checked

Returns:

  • argument if a block is given to evaluate, or self if not to allow for further method chaining



20
21
22
23
24
25
26
27
28
 
# File 'lib/condition_checker.rb', line 20

def named(name, &block)
  @name = name
  if block_given?
    instance_eval(&block)
    arg
  else
    self
  end
end

#satisfies(msg = nil, &block) ⇒ Object

DSL call. Establishes that the checked argument satisfies an arbitrary condition specified in a block. If the block evaluates to true the argument passes; if it evaluates to false it fails and an [ArgumentError] is raised. An optional message may be supplied to describe what the block is checking.

If the block requests a bound variable that variable will be assigned the value of the argument we’re checking. The block may also access the argument value using the ‘arg` name. Note, also, that the block is a closure and will have natural access to variables in lexical scope at the time the DSL expression is created. Thus, one can do something like:

def sqrt(num)
   Preconditions.check(num) { satisfies { num >= 0 } }
end



82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/condition_checker.rb', line 82

def satisfies(msg = nil, &block)
  success = if block.arity > 0
              yield(arg)
            else
              instance_eval(&block)
            end
  if !success
    raise ArgumentError, msg.nil? ? format_message("must satisfy given conditions") : format_message("must be #{msg}")
  end
  true
end