class SPF::Query::Record

Represents a parsed SPF record.

Attributes

a[R]

Selects all `a:` mechanisms.

@return [Array<Mechanism>]

all[R]

The right-most `all:` mechanism.

@return [Mechanism, nil]

exists[R]

Selects all `exists:` mechanisms.

@return [Array<Mechanism>]

exp[R]

The `exp=` modifier.

@return [Modifier, nil]

include[R]

Selects all `include:` mechanisms.

@return [Array<Mechanism>]

ip4[R]

Selects all `ip4:` mechanisms.

@return [Array<Mechanism>]

ip6[R]

Selects all `ip6:` mechanisms.

@return [Array<Mechanism>]

mechanisms[R]

All mechanisms within the record.

@return [Array<Mechanism>]

modifiers[R]

All modifiers within the record.

@return [Array<Modifier>]

mx[R]

Selects all `mx:` mechanisms.

@return [Array<Mechanism>]

ptr[R]

Selects all `ptr:` mechanisms.

@return [Array<Mechanism>]

redirect[R]

The `redirect=` modifier.

@return [Modifier, nil]

rules[R]

The SPF rules.

@return [Array<Mechanism, Modifier>]

v[R]

The SPF version of the record.

@return [:spf1]

version[R]

The SPF version of the record.

@return [:spf1]

Public Class Methods

new(version,rules=[]) click to toggle source

Initializes the SPF record.

@param [:spf1] version

The SPF version.

@param [Array<Mechanism, Modifier>] rules

SPF rules.
# File lib/spf/query/record.rb, line 96
def initialize(version,rules=[])
  @version = version
  @rules   = rules

  @mechanisms = @rules.select { |term| term.kind_of?(Mechanism) }
  @modifiers  = @rules.select { |term| term.kind_of?(Modifier)  }

  # prefer the last `all:` mechanism
  @all = @mechanisms.reverse_each.find do |mechanism|
    mechanism.name == :all
  end

  mechanisms_by_name = lambda { |name|
    @mechanisms.select { |mechanism| mechanism.name == name }
  }

  @include = mechanisms_by_name[:include]
  @a       = mechanisms_by_name[:a]
  @mx      = mechanisms_by_name[:mx]
  @ptr     = mechanisms_by_name[:ptr]
  @ip4     = mechanisms_by_name[:ip4]
  @ip6     = mechanisms_by_name[:ip6]
  @exists  = mechanisms_by_name[:exists]

  modifier_by_name = lambda { |name|
    @modifiers.find { |modifier| modifier.name == name }
  }

  @redirect = modifier_by_name[:redirect]
  @exp      = modifier_by_name[:exp]
end
parse(spf) click to toggle source

Parses an SPF record.

@param [String] spf

The raw SPF record.

@return [Record]

The parsed SPF record.

@raise [InvalidRecord]

The SPF record could not be parsed.

@raise [SenderIDFound]

@see Parser.parse

@api public

# File lib/spf/query/record.rb, line 146
def self.parse(spf)
  if spf.include?('spf2.0')
    raise(SenderIDFound,"Sender ID was found in place of SPF")
  end

  begin
    Parser.parse(spf)
  rescue Parslet::ParseFailed => error
    raise(InvalidRecord.new(error.message,error.cause))
  end
end
query(domain,resolver=Resolv::DNS.new) click to toggle source

Queries the domain for it's SPF record.

@param [String] domain

The domain to query.

@param [Resolv::DNS] resolver

The optional resolver to use.

@return [Record, nil]

The parsed SPF record. If no SPF record could be found,
`nil` will be returned.

@api public

# File lib/spf/query/record.rb, line 173
def self.query(domain,resolver=Resolv::DNS.new)
  if (spf = Query.query(domain,resolver))
    parse(spf)
  end
end

Public Instance Methods

each(&block) click to toggle source

Enumerates over the rules.

@yield [rule]

The given block will be passed each rule.

@yieldparam [Mechanism, Modifier] rule

A directive or modifier rule.

@return [Enumerator]

If no block is given, an Enumerator will be returned.
# File lib/spf/query/record.rb, line 191
def each(&block)
  @rules.each(&block)
end
inspect() click to toggle source

Inspects the record.

@return [String]

# File lib/spf/query/record.rb, line 209
def inspect
  "#<#{self.class}: #{self}>"
end
to_s() click to toggle source

Converts the record back to a String.

@return [String]

# File lib/spf/query/record.rb, line 200
def to_s
  "v=#{@version} #{@rules.join(' ')}"
end