coppertone 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d50206e3df522c6100a46e2a6f64989d10da5774
-  data.tar.gz: 773a9709e679f5d45e5a7a6f779112ffea0e9aff
+  metadata.gz: 98149a0b1ea7cda00c82becc04efa776fe05d04c
+  data.tar.gz: 4b5c342217d8ea99622fc3b7e0d75a2d49d008b5
 SHA512:
-  metadata.gz: 2752ba8667d8f7d8458cfa0429a4140f59a42af7a7ad52881b5a75f1e4881d2b4038a5fb1a8ca22dff54ca7301941da42400b94f87ddf5b6972ffb9de3900c06
-  data.tar.gz: 90cb6889a3ed66eb50663e0681ffc011641d20329c0ffb86b7d6af780d40189beb36fac80c78f4e1107295134d643a104bd7933c10ca99d265e693ff0590b90a
+  metadata.gz: 3e739ea5580ee84d251ffae5f170d1116e40a5c789b94320878727de04c4a3dc8e6ea00641e14a0454c8aba087b9579c133362b1075ca20d1a25cdbc3188e2ff
+  data.tar.gz: 89ce502d95dd1e60dafe3398d39788548f70758f3b435e3949f9fe7d62bc9356d12765b4898dd96d24eb6db76a6824dabbb74f0c5e05705c7ba015702092d9a3

data/.travis.yml

@@ -5,5 +5,7 @@ rvm:
   - 2.0.0
   - 2.1.2
   - jruby-19mode
-  - rbx
+  - rbx-2.2.10
+allow_failures:
+  - rvm: rbx-2.2.10
 

data/lib/coppertone/directive.rb

@@ -1,11 +1,15 @@
 require 'coppertone/mechanism'
 require 'coppertone/qualifier'
+require 'active_support/core_ext/module/delegation'
 
 module Coppertone
   # Instances of this class represent directive terms, as defined by the
   # SPF specification (see section 4.6.1).
   class Directive
     attr_reader :qualifier, :mechanism
+    delegate :context_dependent?, :dns_lookup_term?,
+             :includes_ptr?, to: :mechanism
+
     def initialize(qualifier, mechanism)
       @qualifier = qualifier
       @mechanism = mechanism
@@ -19,8 +23,9 @@ module Coppertone
       end
     end
 
-    def context_dependent?
-      mechanism.context_dependent?
+    def target_domain
+      fail NeedsContextError unless dns_lookup_term?
+      mechanism.target_domain
     end
 
     def all?

data/lib/coppertone/error.rb

@@ -45,4 +45,8 @@ module Coppertone
   class TermLimitExceededError < PermerrorError; end
   class VoidLimitExceededError < PermerrorError; end
   class MXLimitExceededError < PermerrorError; end
+
+  # Raised when context is required to evaluate a value, but
+  # context is not available
+  class NeedsContextError < Coppertone::Error; end
 end

data/lib/coppertone/macro_string.rb

@@ -41,5 +41,10 @@ module Coppertone
       return false unless other.instance_of? self.class
       macro_text == other.macro_text
     end
+    alias_method :eql?, :==
+
+    def hash
+      macro_text.hash
+    end
   end
 end

data/lib/coppertone/mechanism/domain_spec_mechanism.rb

@@ -27,6 +27,21 @@ module Coppertone
         return false unless domain_spec
         domain_spec.includes_ptr?
       end
+
+      def target_domain
+        fail Coppertone::NeedsContextError if context_dependent?
+        domain_spec.to_s
+      end
+
+      def ==(other)
+        return false unless other.instance_of? self.class
+        domain_spec == other.domain_spec
+      end
+      alias_method :eql?, :==
+
+      def hash
+        domain_spec.hash
+      end
     end
   end
 end

data/lib/coppertone/mechanism/domain_spec_optional.rb

@@ -37,11 +37,6 @@ module Coppertone
       def handle_invalid_domain(_macro_context, _options)
         fail RecordParsingError
       end
-
-      def ==(other)
-        return false unless other.instance_of? self.class
-        domain_spec == other.domain_spec
-      end
     end
   end
 end

data/lib/coppertone/mechanism/domain_spec_required.rb

@@ -28,11 +28,6 @@ module Coppertone
       def handle_invalid_domain(_macro_context, _options)
         fail RecordParsingError
       end
-
-      def ==(other)
-        return false unless other.instance_of? self.class
-        domain_spec == other.domain_spec
-      end
     end
   end
 end

data/lib/coppertone/mechanism/domain_spec_with_dual_cidr.rb

@@ -25,14 +25,6 @@ module Coppertone
         @ip_v6_cidr_length ||= 128
       end
 
-      def cidr_length(macro_context)
-        if macro_context.original_ip_v6?
-          ip_v6_cidr_length
-        else
-          ip_v4_cidr_length
-        end
-      end
-
       def match?(macro_context, request_context)
         request_context.register_dns_lookup_term
         target_name = generate_target_name(macro_context, request_context)
@@ -47,6 +39,7 @@ module Coppertone
       def parse_argument(attributes)
         fail InvalidMechanismError if attributes.blank?
         cidr_matches = CIDR_REGEXP.match(attributes)
+        fail InvalidMechanismError unless cidr_matches
         macro_string, raw_ip_v4_cidr_length, raw_ip_v6_cidr_length =
           clean_matches(attributes, cidr_matches)
         process_matches(macro_string, raw_ip_v4_cidr_length,
@@ -65,14 +58,10 @@ module Coppertone
       end
 
       def clean_matches(attributes, cidr_matches)
-        if cidr_matches
-          raw_ip_v4_cidr_length = cidr_matches[2] unless cidr_matches[2].blank?
-          raw_ip_v6_cidr_length = cidr_matches[4] unless cidr_matches[4].blank?
-          term = cidr_matches[0]
-          domain_spec_end = term.blank? ? -1 : (-1 - term.length)
-        else
-          domain_spec_end = -1
-        end
+        raw_ip_v4_cidr_length = cidr_matches[2] unless cidr_matches[2].blank?
+        raw_ip_v6_cidr_length = cidr_matches[4] unless cidr_matches[4].blank?
+        term = cidr_matches[0]
+        domain_spec_end = term.blank? ? -1 : (-1 - term.length)
         macro_string = parse_domain_spec(attributes, domain_spec_end)
         [macro_string, raw_ip_v4_cidr_length, raw_ip_v6_cidr_length]
       end
@@ -110,6 +99,11 @@ module Coppertone
         ip_v4_cidr_length == other.ip_v4_cidr_length &&
         ip_v6_cidr_length == other.ip_v6_cidr_length
       end
+      alias_method :eql?, :==
+
+      def hash
+        domain_spec.hash ^ ip_v4_cidr_length.hash ^ ip_v6_cidr_length.hash
+      end
     end
   end
 end

data/lib/coppertone/mechanism/include.rb

@@ -21,15 +21,6 @@ module Coppertone
         RecordFinder.new(request_context.dns_client, target_name).record
       end
 
-      def context_dependent_result?(request_context,
-                                    macro_context =
-                                      Coppertone::NullMacroContext.new)
-        target_name =
-          target_name_from_domain_spec(macro_context, request_context)
-        included_record(request_context, target_name)
-          .context_dependent_result?(request_context)
-      end
-
       def self.label
         'include'
       end

data/lib/coppertone/mechanism/ip_mechanism.rb

@@ -2,7 +2,7 @@ module Coppertone
   class Mechanism  # rubocop:disable Style/Documentation
     # Implements the ip4 mechanism.
     class IPMechanism < Mechanism
-      attr_reader :ip_network
+      attr_reader :netblock
       def self.create(attributes)
         new(attributes)
       end
@@ -11,9 +11,9 @@ module Coppertone
         super(attributes)
         unless attributes.blank?
           attributes = attributes[1..-1] if attributes[0] == ':'
-          @ip_network = parse_ip_network(attributes)
+          @netblock = parse_netblock(attributes)
         end
-        fail Coppertone::InvalidMechanismError if @ip_network.nil?
+        fail Coppertone::InvalidMechanismError if @netblock.nil?
       end
 
       LEADING_ZEROES_IN_CIDR_REGEXP = /\/0\d/
@@ -29,7 +29,7 @@ module Coppertone
         IP_PARSE_ERROR = IPAddr::Error
       end
 
-      def parse_ip_network(ip_as_s)
+      def parse_netblock(ip_as_s)
         validate_no_leading_zeroes_in_cidr(ip_as_s)
         addr, cidr_length, dual = ip_as_s.split('/')
         return nil if dual
@@ -43,13 +43,13 @@ module Coppertone
       def match?(macro_context, _request_context)
         ip = ip_for_match(macro_context)
         return false unless ip
-        return false unless ip.ipv4? == @ip_network.ipv4?
-        @ip_network.include?(ip)
+        return false unless ip.ipv4? == @netblock.ipv4?
+        @netblock.include?(ip)
       end
 
       def ==(other)
         return false unless other.instance_of? self.class
-        ip_network == other.ip_network
+        netblock == other.netblock
       end
     end
   end

data/lib/coppertone/modifier/redirect.rb

@@ -16,11 +16,9 @@ module Coppertone
         RedirectRecordFinder.new(self, macro_context, request_context).record
       end
 
-      def context_dependent_result?(request_context,
-                                    macro_context =
-                                      Coppertone::NullMacroContext.new)
-        included_record(macro_context, request_context)
-          .context_dependent_result?(request_context)
+      def target_domain
+        fail NeedsContextError if context_dependent?
+        arguments
       end
 
       def self.label

data/lib/coppertone/modifier/unknown.rb

@@ -1,12 +1,10 @@
 module Coppertone
   class Modifier  # rubocop:disable Style/Documentation
     class Unknown < Modifier
-      def self.create(attributes)
-        new(attributes)
-      end
-
-      def initialize(attributes)
+      attr_reader :label
+      def initialize(label, attributes)
         super(attributes)
+        @label = label
         @macro_string = Coppertone::MacroString.new(attributes)
       rescue Coppertone::MacroStringParsingError
         raise Coppertone::InvalidModifierError
@@ -19,11 +17,6 @@ module Coppertone
       def includes_ptr?
         false
       end
-
-      def self.label
-        'unknown'
-      end
     end
-    register(Coppertone::Modifier::Unknown)
   end
 end

data/lib/coppertone/modifier.rb

@@ -20,7 +20,11 @@ module Coppertone
       return nil unless matches
       type = matches[1]
       attributes = matches[2]
-      build(type, attributes) || build('unknown', attributes)
+      build(type, attributes) || build_unknown(type, attributes)
+    end
+
+    def self.build_unknown(type, attributes)
+      Coppertone::Modifier::Unknown.new(type, attributes)
     end
 
     attr_reader :arguments
@@ -28,8 +32,12 @@ module Coppertone
       @arguments = arguments
     end
 
+    def label
+      self.class.label
+    end
+
     def to_s
-      "#{self.class.label}=#{arguments}"
+      "#{label}=#{arguments}"
     end
   end
 end

data/lib/coppertone/record.rb

@@ -29,13 +29,12 @@ module Coppertone
       all_directive ? true : false
     end
 
-    def default_result
-      return Result.neutral unless all_directive
-      Result.from_directive(all_directive)
-    end
-
-    def safe_to_include?
-      include_all?
+    def dns_lookup_term_count
+      @dns_lookup_term_count ||=
+        begin
+          base = redirect.nil? ? 0 : 1
+          base + directives.select(&:dns_lookup_term?).size
+        end
     end
 
     def includes
@@ -51,32 +50,36 @@ module Coppertone
       @modifiers ||= @terms.select { |t| t.is_a?(Coppertone::Modifier) }
     end
 
-    def find_redirect
-      find_modifier(Coppertone::Modifier::Redirect)
-    end
-
     def redirect
       @redirect ||= find_redirect
     end
 
-    def exp
-      @exp ||= find_modifier(Coppertone::Modifier::Exp)
+    def redirect_with_directives?
+      redirect && directives.any?
     end
 
-    def context_dependent_result?(request_context)
+    def netblock_mechanisms
+      @netblock_mechanisms ||=
+        directives.select { |d| d.mechanism.is_a?(Coppertone::Mechanism::IPMechanism) }
+    end
+
+    def netblocks_only?
+      return false if redirect
+      directives.reject(&:all?).reject do |d|
+        d.mechanism.is_a?(Coppertone::Mechanism::IPMechanism)
+      end.empty?
+    end
+
+    def context_dependent_evaluation?
       return true if directives.exist?(&:context_dependent)
-      return true if context_dependent_redirect_result?(request_context)
-      return false if includes.blank?
-      includes.exists? { |i| i.context_dependent_result?(request_context) }
+      redirect && redirect.context_dependent?
     end
 
-    def context_dependent_redirect_result?(request_context)
-      return false unless redirect
-      redirect.context_dependent? ||
-        redirect.context_dependent_result?(request_context)
+    def exp
+      @exp ||= find_modifier(Coppertone::Modifier::Exp)
     end
 
-    def context_dependent_message?
+    def context_dependent_explanation?
       exp && exp.context_dependent?
     end
 
@@ -93,6 +96,10 @@ module Coppertone
       arr.first
     end
 
+    def find_redirect
+      find_modifier(Coppertone::Modifier::Redirect)
+    end
+
     def self.version_str
       Coppertone::RecordTermParser::VERSION_STR
     end

data/lib/coppertone/record_term_parser.rb

@@ -10,22 +10,16 @@ module Coppertone
       RECORD_REGEXP.match(text.strip) ? true : false
     end
 
-    attr_reader :terms
+    attr_reader :text, :terms
     def initialize(text)
       fail RecordParsingError unless self.class.record?(text)
       fail RecordParsingError unless ALLOWED_CHARACTERS.match(text)
-      @terms = term_tokens(text).map { |token| parse_token(token) }
+      @text = text
+      @terms = Coppertone::TermsParser.new(terms_segment).terms
     end
 
-    def term_tokens(text)
-      text_without_prefix = text[VERSION_STR.length..-1]
-      text_without_prefix.strip.split(/ /).select { |s| !s.blank? }
-    end
-
-    def parse_token(token)
-      term = Term.build_from_token(token)
-      fail RecordParsingError unless term
-      term
+    def terms_segment
+      text[VERSION_STR.length..-1].strip
     end
   end
 end

data/lib/coppertone/terms_parser.rb

@@ -0,0 +1,23 @@
+module Coppertone
+  # Parses a un-prefixed string into terms
+  class TermsParser
+    attr_reader :text
+    def initialize(text)
+      @text = text
+    end
+
+    def terms
+      tokens.map { |token| parse_token(token) }
+    end
+
+    def tokens
+      text.split(/ /).select { |s| !s.blank? }
+    end
+
+    def parse_token(token)
+      term = Term.build_from_token(token)
+      fail RecordParsingError unless term
+      term
+    end
+  end
+end

data/lib/coppertone/utils/domain_utils.rb

@@ -26,6 +26,11 @@ module Coppertone
         NO_DASH_REGEXP.match(l) || DASH_REGEXP.match(l)
       end
 
+      def self.valid_ldh_domain?(domain)
+        return false unless valid?(domain)
+        to_labels(domain).all? { |l| valid_hostname_label?(l) }
+      end
+
       def self.valid_label?(l)
         (l.length >= 0) && (l.length <= 63)
       end

data/lib/coppertone/version.rb

@@ -1,3 +1,3 @@
 module Coppertone  # rubocop:disable Style/Documentation
-  VERSION = '0.0.3'.freeze
+  VERSION = '0.0.4'.freeze
 end

data/lib/coppertone.rb

@@ -42,6 +42,7 @@ require 'coppertone/domain_spec'
 require 'coppertone/directive'
 require 'coppertone/modifier'
 require 'coppertone/term'
+require 'coppertone/terms_parser'
 require 'coppertone/record_term_parser'
 require 'coppertone/record'
 require 'coppertone/record_evaluator'

data/spec/directive_spec.rb

@@ -51,4 +51,37 @@ describe Coppertone::Directive do
       end
     end
   end
+
+  context '#target_domain' do
+    it 'yields the target domain when the mechanism is not context dependent' do
+      d = Coppertone::Term.build_from_token('include:_spf.example.org')
+      expect(d.target_domain).to eq('_spf.example.org')
+    end
+
+    it 'raises an error when the mechanism is context dependent' do
+      d = Coppertone::Term.build_from_token('include:_spf.%{h}.example.org')
+      expect do
+        d.target_domain
+      end.to raise_error Coppertone::NeedsContextError
+    end
+
+    it 'raises an error when the mechanism does not support a target domain' do
+      d = Coppertone::Term.build_from_token('ip4:1.2.3.4')
+      expect do
+        d.target_domain
+      end.to raise_error Coppertone::NeedsContextError
+    end
+  end
+
+  context '#to_s' do
+    it 'should hide a default qualifier' do
+      d = Coppertone::Term.build_from_token('~include:_spf.%{h}.example.org')
+      expect(d.to_s).to eq('~include:_spf.%{h}.example.org')
+    end
+
+    it 'should hide a default qualifier' do
+      d = Coppertone::Term.build_from_token('+include:_spf.%{h}.example.org')
+      expect(d.to_s).to eq('include:_spf.%{h}.example.org')
+    end
+  end
 end

data/spec/mechanism/a_spec.rb

@@ -11,6 +11,7 @@ describe Coppertone::Mechanism::A do
       expect(mech.to_s).to eq('a')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a blank argument' do
@@ -22,6 +23,7 @@ describe Coppertone::Mechanism::A do
       expect(mech.to_s).to eq('a')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should fail if called with an invalid macrostring' do
@@ -40,6 +42,7 @@ describe Coppertone::Mechanism::A do
       expect(mech.to_s).to eq('a:_spf.example.com')
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should parse a context dependent domain spec' do
@@ -52,6 +55,7 @@ describe Coppertone::Mechanism::A do
       expect(mech.to_s).to eq('a:_spf.%{d}.example.com')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should parse a domain spec with a ptr' do
@@ -64,6 +68,7 @@ describe Coppertone::Mechanism::A do
       expect(mech.to_s).to eq('a:_spf.%{p}.example.com')
       expect(mech).to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should parse a valid IP v4 CIDR length with a domain spec' do

data/spec/mechanism/all_spec.rb

@@ -7,6 +7,7 @@ describe Coppertone::Mechanism::All do
     expect(subject.to_s).to eq('all')
     expect(subject).not_to be_includes_ptr
     expect(subject).not_to be_context_dependent
+    expect(subject).not_to be_dns_lookup_term
   end
 
   it 'should not allow creation of new instances' do

data/spec/mechanism/exists_spec.rb

@@ -28,6 +28,7 @@ describe Coppertone::Mechanism::Exists do
       expect(mech.to_s).to eq('exists:_spf.example.com')
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should parse a context dependent domain spec' do
@@ -38,6 +39,7 @@ describe Coppertone::Mechanism::Exists do
       expect(mech.to_s).to eq('exists:_spf.%{d}.example.com')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should parse a domain spec with a ptr' do
@@ -48,6 +50,7 @@ describe Coppertone::Mechanism::Exists do
       expect(mech.to_s).to eq('exists:_spf.%{p}.example.com')
       expect(mech).to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
   end
 

data/spec/mechanism/include_spec.rb

@@ -28,6 +28,8 @@ describe Coppertone::Mechanism::Include do
       expect(mech.to_s).to eq('include:_spf.example.com')
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
+      expect(mech).to be_dns_lookup_term
+      expect(mech.target_domain).to eq('_spf.example.com')
     end
 
     it 'should parse a context dependent domain spec' do
@@ -38,6 +40,10 @@ describe Coppertone::Mechanism::Include do
       expect(mech.to_s).to eq('include:_spf.%{d}.example.com')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
+      expect do
+        mech.target_domain
+      end.to raise_error Coppertone::NeedsContextError
     end
 
     it 'should parse a domain spec with a ptr' do
@@ -48,6 +54,10 @@ describe Coppertone::Mechanism::Include do
       expect(mech.to_s).to eq('include:_spf.%{p}.example.com')
       expect(mech).to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
+      expect do
+        mech.target_domain
+      end.to raise_error Coppertone::NeedsContextError
     end
   end
 

data/spec/mechanism/ip4_spec.rb

@@ -22,26 +22,29 @@ describe Coppertone::Mechanism::IP4 do
 
     it 'should not fail if called with an IP v6' do
       mech = Coppertone::Mechanism::IP4.new(':fe80::202:b3ff:fe1e:8329')
-      expect(mech.ip_network).to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+      expect(mech.netblock).to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
       expect(mech.to_s).to eq('ip4:fe80::202:b3ff:fe1e:8329')
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
+      expect(mech).not_to be_dns_lookup_term
     end
 
     it 'should work if called with an IP4' do
       mech = Coppertone::Mechanism::IP4.new(':1.2.3.4')
-      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+      expect(mech.netblock).to eq(IPAddr.new('1.2.3.4'))
       expect(mech.to_s).to eq('ip4:1.2.3.4')
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
+      expect(mech).not_to be_dns_lookup_term
     end
 
     it 'should work if called with an IP4 with a pfxlen' do
       mech = Coppertone::Mechanism::IP4.new(':1.2.3.4/4')
-      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4/4'))
+      expect(mech.netblock).to eq(IPAddr.new('1.2.3.4/4'))
       expect(mech.to_s).to eq('ip4:1.2.3.4/4')
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
+      expect(mech).not_to be_dns_lookup_term
     end
   end
 
@@ -66,17 +69,17 @@ describe Coppertone::Mechanism::IP4 do
 
     it 'should not fail if called with an IP v6' do
       mech = Coppertone::Mechanism::IP4.create(':fe80::202:b3ff:fe1e:8329')
-      expect(mech.ip_network).to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+      expect(mech.netblock).to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
     end
 
     it 'should work if called with an IP4' do
       mech = Coppertone::Mechanism::IP4.create(':1.2.3.4')
-      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+      expect(mech.netblock).to eq(IPAddr.new('1.2.3.4'))
     end
 
     it 'should work if called with an IP4 with a pfxlen' do
       mech = Coppertone::Mechanism::IP4.create(':1.2.3.4/4')
-      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4/4'))
+      expect(mech.netblock).to eq(IPAddr.new('1.2.3.4/4'))
     end
 
     it 'should fail if called with an invalid pfxlen' do

data/spec/mechanism/ip6_spec.rb

@@ -22,19 +22,22 @@ describe Coppertone::Mechanism::IP6 do
 
     it 'should not fail if called with an IP v4' do
       mech = Coppertone::Mechanism::IP6.new(':1.2.3.4')
-      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+      expect(mech.netblock).to eq(IPAddr.new('1.2.3.4'))
+      expect(mech).not_to be_dns_lookup_term
     end
 
     it 'should work if called with an IP6' do
       mech = Coppertone::Mechanism::IP6.new(':fe80::202:b3ff:fe1e:8329')
-      expect(mech.ip_network)
+      expect(mech.netblock)
         .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+      expect(mech).not_to be_dns_lookup_term
     end
 
     it 'should work if called with an IP6 with a pfxlen' do
       mech = Coppertone::Mechanism::IP6.new(':fe80::202:b3ff:fe1e:8329/64')
-      expect(mech.ip_network)
+      expect(mech.netblock)
         .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329/64'))
+      expect(mech).not_to be_dns_lookup_term
     end
 
     it 'should fail if called with an invalid pfxlen' do
@@ -66,14 +69,14 @@ describe Coppertone::Mechanism::IP6 do
 
     it 'should not fail if called with an IP v4' do
       mech = Coppertone::Mechanism::IP6.create(':1.2.3.4')
-      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+      expect(mech.netblock).to eq(IPAddr.new('1.2.3.4'))
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
     end
 
     it 'should work if called with an IP6' do
       mech = Coppertone::Mechanism::IP6.create(':fe80::202:b3ff:fe1e:8329')
-      expect(mech.ip_network)
+      expect(mech.netblock)
         .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent
@@ -81,7 +84,7 @@ describe Coppertone::Mechanism::IP6 do
 
     it 'should work if called with an IP6 with a pfxlen' do
       mech = Coppertone::Mechanism::IP6.create(':fe80::202:b3ff:fe1e:8329/64')
-      expect(mech.ip_network)
+      expect(mech.netblock)
         .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329/64'))
       expect(mech).not_to be_includes_ptr
       expect(mech).not_to be_context_dependent

data/spec/mechanism/mx_spec.rb

@@ -11,6 +11,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a blank argument' do
@@ -22,6 +23,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should fail if called with an invalid macrostring' do
@@ -39,6 +41,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx/24')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should process the domain spec if it includes a IP v6 CIDR' do
@@ -61,6 +64,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx/28//96')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a fixed domain spec without explicit CIDRs' do
@@ -83,6 +87,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.ip_v4_cidr_length).to eq(28)
       expect(mech.ip_v6_cidr_length).to eq(96)
       expect(mech.to_s).to eq('mx:mx.example.com/28//96')
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a context-dependent domain spec without explicit CIDRs' do
@@ -95,6 +100,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx:%{d}.example.com')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a fixed domain spec with explicit CIDRs' do
@@ -107,6 +113,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx:%{d}.example.com/28//96')
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a context-dependent domain spec without explicit CIDRs with PTR' do
@@ -119,6 +126,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx:%{p}.example.com')
       expect(mech).to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a fixed domain spec with explicit CIDRs with PTR' do
@@ -131,6 +139,7 @@ describe Coppertone::Mechanism::MX do
       expect(mech.to_s).to eq('mx:%{p}.example.com/28//96')
       expect(mech).to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
   end
 

data/spec/mechanism/ptr_spec.rb

@@ -8,6 +8,7 @@ describe Coppertone::Mechanism::Ptr do
       expect(mech.domain_spec).to be_nil
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should not fail if called with a blank argument' do
@@ -16,6 +17,7 @@ describe Coppertone::Mechanism::Ptr do
       expect(mech.domain_spec).to be_nil
       expect(mech).not_to be_includes_ptr
       expect(mech).to be_context_dependent
+      expect(mech).to be_dns_lookup_term
     end
 
     it 'should fail if called with an invalid macrostring' do

data/spec/modifier/redirect_spec.rb

@@ -11,6 +11,7 @@ describe Coppertone::Modifier::Redirect do
         .to eq('redirect=test.example.com')
       expect(modifier).not_to be_includes_ptr
       expect(modifier).not_to be_context_dependent
+      expect(modifier.target_domain).to eq('test.example.com')
     end
 
     it 'should work with a context independent domain spec' do
@@ -22,6 +23,9 @@ describe Coppertone::Modifier::Redirect do
         .to eq('redirect=%{d}.example.com')
       expect(modifier).not_to be_includes_ptr
       expect(modifier).to be_context_dependent
+      expect do
+        modifier.target_domain
+      end.to raise_error Coppertone::NeedsContextError
     end
 
     it 'should work with a context independent domain spec with a PTR' do
@@ -33,6 +37,9 @@ describe Coppertone::Modifier::Redirect do
         .to eq('redirect=%{p}.example.com')
       expect(modifier).to be_includes_ptr
       expect(modifier).to be_context_dependent
+      expect do
+        modifier.target_domain
+      end.to raise_error Coppertone::NeedsContextError
     end
   end
 
@@ -42,4 +49,19 @@ describe Coppertone::Modifier::Redirect do
         .to eq('redirect=test.example.com')
     end
   end
+
+  context '#included_record' do
+    it 'should delegate to included_record' do
+      modifier = Coppertone::Modifier::Redirect.new('test.example.com')
+      record = double(:record)
+      finder = double(:finder)
+      expect(finder).to receive(:record).and_return(record)
+      macro_ctx = double(:macro_ctx)
+      request_ctx = double(:request_ctx)
+      expect(Coppertone::RedirectRecordFinder).to receive(:new)
+        .with(modifier, macro_ctx, request_ctx).and_return(finder)
+      expect(modifier.included_record(macro_ctx, request_ctx))
+        .to eq(record)
+    end
+  end
 end

data/spec/modifier/unknown_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Coppertone::Modifier::Unknown do
+  it 'should always be context independent and never require macro evaluation' do
+    unk = Coppertone::Modifier::Unknown.new('abcd', 'wxyz')
+    expect(unk).not_to be_context_dependent
+    expect(unk).not_to be_includes_ptr
+    expect(unk.to_s).to eq('abcd=wxyz')
+  end
+end

data/spec/null_macro_context_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Coppertone::NullMacroContext do
+  %w(s l o d i p v h c r t).each do |i|
+    it "should raise an error for #{i}" do
+      expect do
+        Coppertone::NullMacroContext::NULL_CONTEXT.send(i)
+      end.to raise_error ArgumentError
+    end
+
+    it "should raise an error for #{i.upcase}" do
+      expect do
+        Coppertone::NullMacroContext::NULL_CONTEXT.send(i.upcase)
+      end.to raise_error ArgumentError
+    end
+  end
+
+  it 'should return self for with_domain' do
+    n = Coppertone::NullMacroContext::NULL_CONTEXT
+    expect(n.with_domain('abcd')).to eq(n)
+  end
+end

data/spec/qualifier_spec.rb

@@ -11,6 +11,7 @@ describe Coppertone::Qualifier do
       it "should map from #{k} to the correct value" do
         expect(Coppertone::Qualifier.find_by_text(k)).to eq(v)
         expect(v.text).to eq(k)
+        expect(v.to_s).to eq(k)
       end
     end
   end
@@ -22,6 +23,15 @@ describe Coppertone::Qualifier do
     end
   end
 
+  context '#default?' do
+    it 'should produce the right values for default?' do
+      expect(Coppertone::Qualifier::PASS).to be_default
+      expect(Coppertone::Qualifier::FAIL).not_to be_default
+      expect(Coppertone::Qualifier::SOFTFAIL).not_to be_default
+      expect(Coppertone::Qualifier::NEUTRAL).not_to be_default
+    end
+  end
+
   context '#qualifiers' do
     it 'should have the correct contents' do
       qualifiers = Coppertone::Qualifier.qualifiers

data/spec/record_spec.rb

@@ -40,6 +40,7 @@ describe Coppertone::Record do
       expect(directive.qualifier).to eq(Coppertone::Qualifier::SOFTFAIL)
       expect(directive.mechanism).to eq(Coppertone::Mechanism::All.instance)
       expect(record.modifiers).to be_empty
+      expect(record.to_s).to eq('v=spf1 ~all')
     end
 
     it 'be case insensitive when parsing the version string' do
@@ -50,6 +51,7 @@ describe Coppertone::Record do
       expect(directive.qualifier).to eq(Coppertone::Qualifier::SOFTFAIL)
       expect(directive.mechanism).to eq(Coppertone::Mechanism::All.instance)
       expect(record.modifiers).to be_empty
+      expect(record.to_s).to eq('v=spf1 ~all')
     end
 
     it 'should parse more complex records' do
@@ -71,6 +73,7 @@ describe Coppertone::Record do
       expect(record.redirect).to be_nil
       expect(record.exp)
         .to eq(Coppertone::Modifier::Exp.new('explain._spf.%{d}'))
+      expect(record.to_s).to eq('v=spf1 mx -all exp=explain._spf.%{d}')
     end
 
     it 'should fail on more records with duplicate modifiers' do
@@ -118,4 +121,27 @@ describe Coppertone::Record do
       expect(Coppertone::Record.new('v=spf1 mx -all redirect=explain._spf.%{d}').unknown_modifiers).to be_empty
     end
   end
+
+  context '#dns_lookup_term_count' do
+    it 'should calculate correctly' do
+      expect(Coppertone::Record.new('v=spf1 -all exp=explain._spf.%{d}').dns_lookup_term_count).to eq(0)
+      expect(Coppertone::Record.new('v=spf1 a:example.test.com -exists:some.domain.com ~all').dns_lookup_term_count).to eq(2)
+      expect(Coppertone::Record.new('v=spf1 ip4:1.2.3.4 -exists:some.domain.com ~all').dns_lookup_term_count).to eq(1)
+    end
+  end
+
+  context '#includes' do
+    it 'should yield an empty array when there are no include' do
+      expect(Coppertone::Record.new('v=spf1 mx -all exp=explain._spf.%{d}').includes).to be_empty
+      expect(Coppertone::Record.new('v=spf1 ip4:1.2.3.4 ~all').includes).to be_empty
+    end
+
+    it 'should yield a set of the includes, in order' do
+      r = Coppertone::Record
+        .new('v=spf1 include:_spf.domain1.com ip4:1.2.3.4 include:_spf.domain2.com ~all exp=explain._spf.%{d}')
+      includes = r.includes
+      expect(includes.map(&:mechanism).all? {|i| i.is_a?(Coppertone::Mechanism::Include)}).to be_truthy
+      expect(includes.map(&:target_domain)).to eq(%w(_spf.domain1.com _spf.domain2.com))
+    end
+  end
 end

metadata

@@ -1,136 +1,138 @@
 --- !ruby/object:Gem::Specification
 name: coppertone
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Peter M. Goldstein
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-10 00:00:00.000000000 Z
+date: 2014-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: dns_adapter
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: dns_adapter
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: i18n
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: addressable
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-  name: activesupport
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: bundler
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-  name: rake
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-  name: rspec
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: rubocop
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Coppertone includes tools for parsing SPF DNS records, evaluating the result of SPF checks for received emails, and creating appropriate email headers from SPF results.
+description: Coppertone includes tools for parsing SPF DNS records, evaluating the
+  result of SPF checks for received emails, and creating appropriate email headers
+  from SPF results.
 email:
 - peter.m.goldstein@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -183,6 +185,7 @@ files:
 - lib/coppertone/sender_identity.rb
 - lib/coppertone/spf_service.rb
 - lib/coppertone/term.rb
+- lib/coppertone/terms_parser.rb
 - lib/coppertone/utils.rb
 - lib/coppertone/utils/domain_utils.rb
 - lib/coppertone/utils/host_utils.rb
@@ -208,7 +211,9 @@ files:
 - spec/mechanism_spec.rb
 - spec/modifier/exp_spec.rb
 - spec/modifier/redirect_spec.rb
+- spec/modifier/unknown_spec.rb
 - spec/modifier_spec.rb
+- spec/null_macro_context_spec.rb
 - spec/open_spf/ALL_mechanism_syntax_spec.rb
 - spec/open_spf/A_mechanism_syntax_spec.rb
 - spec/open_spf/EXISTS_mechanism_syntax_spec.rb
@@ -245,24 +250,24 @@ homepage: https://github.com/petergoldstein/coppertone
 licenses:
 - Apache
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.1.9
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
 specification_version: 4
 summary: A Sender Policy Framework (SPF) toolkit
 test_files:
@@ -285,7 +290,9 @@ test_files:
 - spec/mechanism_spec.rb
 - spec/modifier/exp_spec.rb
 - spec/modifier/redirect_spec.rb
+- spec/modifier/unknown_spec.rb
 - spec/modifier_spec.rb
+- spec/null_macro_context_spec.rb
 - spec/open_spf/ALL_mechanism_syntax_spec.rb
 - spec/open_spf/A_mechanism_syntax_spec.rb
 - spec/open_spf/EXISTS_mechanism_syntax_spec.rb