Class: Anodator::Rule

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

Overview

Check rule

Rule has target expressions, prerequisite, validator and message. “Prerequisite” is represented by the Validator.

Constant Summary collapse

ERROR_LEVELS =

Check levels

default levels are error and warning. You can add any levels.

{
  :error   => 2, # ERROR
  :warning => 1, # WARNING
}
ERROR_LEVEL_NAMES =

Check level names

Check level name labels

{
  :error   => "ERROR",
  :warning => "WARNING",
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(target_expressions, message, validator, prerequisite = nil, level = ERROR_LEVELS.values.sort.last, description = nil) ⇒ Rule

Returns a new instance of Rule.



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/anodator/rule.rb', line 58

def initialize(target_expressions, message, validator, prerequisite = nil, level = ERROR_LEVELS.values.sort.last, description = nil)
  @target_expressions = target_expressions.to_a
  @message            = message
  @validator          = validator
  @prerequisite       = prerequisite
  @level              = level
  @description        = description

  if @target_expressions.size.zero?
    raise ArgumentError.new("target expressions cannot be blank")
  end
  if @message.nil?
    raise ArgumentError.new("message cannot be blank")
  end
  if @validator.nil?
    raise ArgumentError.new("validator cannot be blank")
  end
  unless ERROR_LEVELS.values.include?(@level)
    raise ArgumentError.new("level must be #{ERROR_LEVEL_NAMES.join(", ")}.")
  end
  if @prerequisite.is_a? Array
    @prerequisite = Validator::ComplexValidator.new(:validators => @prerequisite)
  end
end

Instance Attribute Details

#description ⇒ Object (readonly)

Returns the value of attribute description.



28
29
30
 
# File 'lib/anodator/rule.rb', line 28

def description
  @description
end

#level ⇒ Object (readonly)

Returns the value of attribute level.



28
29
30
 
# File 'lib/anodator/rule.rb', line 28

def level
  @level
end

#message ⇒ Object (readonly)

Returns the value of attribute message.



28
29
30
 
# File 'lib/anodator/rule.rb', line 28

def message
  @message
end

#prerequisite ⇒ Object (readonly)

Returns the value of attribute prerequisite.



28
29
30
 
# File 'lib/anodator/rule.rb', line 28

def prerequisite
  @prerequisite
end

#target_expressions ⇒ Object (readonly)

Returns the value of attribute target_expressions.



28
29
30
 
# File 'lib/anodator/rule.rb', line 28

def target_expressions
  @target_expressions
end

#validator ⇒ Object (readonly)

Returns the value of attribute validator.



28
29
30
 
# File 'lib/anodator/rule.rb', line 28

def validator
  @validator
end

Class Method Details

.add_error_level(value, symbol, label) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/anodator/rule.rb', line 30

def self.add_error_level(value, symbol, label)
  # value check
  raise "Error level value must be Integer" unless value.is_a? Integer
  raise "Error level value must be greater than zero" unless value > 0
  raise "Error level value #{value} already exists" if ERROR_LEVELS.values.include?(value)
  # symbol check
  raise "Error level symbol must be symbol" unless symbol.is_a? Symbol
  raise "Error level symbol #{symbol} already exists" if ERROR_LEVELS.keys.include?(symbol)
  # label check
  raise "Error level label must be string" unless label.is_a? String
  raise "Error level label #{label} already exists" if ERROR_LEVEL_NAMES.values.include?(label)

  # check OK
  ERROR_LEVELS[symbol] = value
  ERROR_LEVEL_NAMES[symbol] = label
end

.level_expression(level) ⇒ Object 



122
123
124
125
126
127
128
 
# File 'lib/anodator/rule.rb', line 122

def self.level_expression(level)
  if ERROR_LEVELS.values.include?(level)
    return ERROR_LEVEL_NAMES[ERROR_LEVELS.index(level)]
  end

  return nil
end

.remove_error_level(symbol) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
 
# File 'lib/anodator/rule.rb', line 47

def self.remove_error_level(symbol)
  # symbol check
  raise "Unknown rror level symbol #{symbol}" unless ERROR_LEVELS.keys.include?(symbol)
  # count check
  raise "Error levels must be atleast one value" if ERROR_LEVELS.size == 1

  # check OK
  ERROR_LEVELS.delete(symbol)
  ERROR_LEVEL_NAMES.delete(symbol)
end

Instance Method Details

#check ⇒ Object

check values depend on prerequisite and validator

When invalid, return CheckResult object, but when valid return nil.



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/anodator/rule.rb', line 87

def check
  unless @prerequisite.nil?
    unless @prerequisite.valid?
      return nil
    end
  end

  if @validator.valid?
    return nil
  else
    numbers = @target_expressions.map do |target_expression|
      Validator::Base.values.spec_item_by_expression(target_expression).number
    end

    CheckResult.new(numbers,
                    @message.expand(Validator::Base.values),
                    @level)
  end
end

#level_expression ⇒ Object 



118
119
120
 
# File 'lib/anodator/rule.rb', line 118

def level_expression
  return Rule.level_expression(@level)
end

#to_s ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/anodator/rule.rb', line 130

def to_s
  target_names = @target_expressions.map { |te| Validator::Base.values.spec_item_by_expression(te).name }.join(",")
  buf =<<_EOD_
Description: #{@description.nil? ? "None." : @description}
  Targets: #{target_names}
  Message: #{@message.template}
  Level: #{level_expression}
  Validator:
#{@validator.to_s}
  Prerequisite:
#{@prerequisite.nil? ? "    - (None)" : @prerequisite.to_s}
_EOD_
end

#validate_configuration ⇒ Object 



107
108
109
110
111
112
113
114
115
116
 
# File 'lib/anodator/rule.rb', line 107

def validate_configuration
  @target_expressions.each do |target_expression|
    Validator::Base.values.spec_item_by_expression(target_expression)
  end
  @message.validate_configuration
  @validator.validate_configuration
  @prerequisite.validate_configuration unless @prerequisite.nil?
rescue UnknownTargetExpressionError => e
  raise InvalidConfiguration.new(e.to_s)
end