class Sfn::Lint::Rule

Composition of definitions

Attributes

definitions[R]

@return [Array<Definition>] definitions composing rule

fail_message[R]

@return [String] message describing failure

name[R]

@return [Symbol] name of rule

provider[R]

@return [Symbol] target provider

Public Class Methods

new(name, definitions, fail_message, provider = :aws) click to toggle source

Create a new rule

@param name [String, Symbol] name of rule @param definitions [Array<Definition>] definitions composing rule @param fail_message [String] message to describe failure @param provider [String, Symbol] target provider @return [self]

# File lib/sfn/lint/rule.rb, line 24
def initialize(name, definitions, fail_message, provider = :aws)
  @name = name.to_sym
  @definitions = definitions.dup.uniq.freeze
  @fail_message = fail_message
  @provider = Bogo::Utility.snake(provider).to_sym
  validate_definitions!
end

Public Instance Methods

add_definition(definition) click to toggle source

Add a new definition to the collection

@param definition [Definition] new definition to add @return [self]

# File lib/sfn/lint/rule.rb, line 86
def add_definition(definition)
  new_defs = definitions.dup
  new_defs << definition
  @definitions = new_defs.uniq.freeze
  validate_definitions!
  self
end
apply(template) click to toggle source

Apply all definitions to template

@param template [Hash] @return [TrueClass, Array<Smash[:definition, :failures]>] true if passed. Definition failures if failed.

# File lib/sfn/lint/rule.rb, line 53
def apply(template)
  results = definitions.map do |definition|
    result = definition.apply(template)
    result == true ? result : Smash.new(:definition => definition, :failures => result)
  end
  if results.all? { |item| item == true }
    true
  else
    results.delete_if { |item| item == true }
    results
  end
end
fail?(template) click to toggle source

Check if template fails this rule

@param template [Hash] @return [TrueClass, FalseClass]

# File lib/sfn/lint/rule.rb, line 78
def fail?(template)
  !pass?(template)
end
generate_fail_message(results) click to toggle source

Generate the failure message for this rule with given failure result set.

# File lib/sfn/lint/rule.rb, line 34
def generate_fail_message(results)
  msg = fail_message.dup
  unless results.empty?
    failed_items = results.map do |item|
      f_item = item[:failures]
      next if f_item.nil? || f_item == true || f_item == false
      f_item
    end.flatten.compact.map(&:to_s)
    unless failed_items.empty?
      msg = "#{msg} (failures: `#{failed_items.join("`, `")}`)"
    end
  end
  msg
end
pass?(template) click to toggle source

Check if template passes this rule

@param template [Hash] @return [TrueClass, FalseClass]

# File lib/sfn/lint/rule.rb, line 70
def pass?(template)
  apply(template) == true
end
remove_definition(definition) click to toggle source

Remove a definition from the collection

@param definition [Definition] definition to remove @return [self]

# File lib/sfn/lint/rule.rb, line 98
def remove_definition(definition)
  new_defs = definitions.dup
  new_defs.delete(definition)
  @definitions = new_defs.uniq.freeze
  self
end
validate_definitions!() click to toggle source

Check that provided definitions provider match rule defined provider

# File lib/sfn/lint/rule.rb, line 106
def validate_definitions!
  non_match = definitions.find_all do |definition|
    definition.provider != provider
  end
  unless non_match.empty?
    raise ArgumentError.new "Rule defines `#{provider}` as provider but includes definitions for " \
                            "non matching providers. (#{non_match.map(&:provider).map(&:to_s).uniq.sort.join(", ")})"
  end
end