coppertone 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70afc7cde39b4b1374dd4b0a580b9908a15b8745
-  data.tar.gz: ef5687a65195e0c2291f68bad0671b5448b35af6
+  metadata.gz: d50206e3df522c6100a46e2a6f64989d10da5774
+  data.tar.gz: 773a9709e679f5d45e5a7a6f779112ffea0e9aff
 SHA512:
-  metadata.gz: f441c6616fe2346f55fa5251c74a15c5f77701684d612441a918572da57675a89b1cb956a4c7aee006e59f496dfd33b4378a133005eb703a66dbee9f7dde0ce4
-  data.tar.gz: c9b568748213933e23c29ca8028cf96b8b179357cd02c0c7915dd05bba7adf033a5005be97f2677de9f70e6fb8afa17192765b59bb4251de1fd9410662c0b4d1
+  metadata.gz: 2752ba8667d8f7d8458cfa0429a4140f59a42af7a7ad52881b5a75f1e4881d2b4038a5fb1a8ca22dff54ca7301941da42400b94f87ddf5b6972ffb9de3900c06
+  data.tar.gz: 90cb6889a3ed66eb50663e0681ffc011641d20329c0ffb86b7d6af780d40189beb36fac80c78f4e1107295134d643a104bd7933c10ca99d265e693ff0590b90a

data/.travis.yml

@@ -5,4 +5,5 @@ rvm:
   - 2.0.0
   - 2.1.2
   - jruby-19mode
+  - rbx
 

data/README.md

@@ -17,13 +17,15 @@ One of the challenges of writing a gem that is intended to implement a specifica
 3. Coppertone defaults to using the DNS term and lookup limits defined in [RFC 7208](http://tools.ietf.org/html/rfc7208#section-4.6.4), but makes these limits configurable.
 4. Coppertone does not do TLD validation on domains encountered in SPF processing.  Domains are syntactically validated, but the TLD value is not checked against the public access list.
 
+To ensure compliance with [RFC 7208](http://tools.ietf.org/html/rfc7208), Coppertone includes the latest published version of the [OpenSPF specs](http://www.openspf.org/Test_Suite) in its RSpec test suite.
+
 If you'd like to suggest amending these guidelines, please open an issue for discussion.  Suggestions driven by real world behavior - divergences implemented by major mail server vendors or MTAs will be prioritized.
 
 ## Requirements
 
-Coppertone supports MRI 2.0 and up - earlier MRI rubies are not supported.  JRuby and Rubinius support is planned, but these VMs are not currently supported.
+Coppertone supports MRI 2.0 and up - earlier MRI rubies are not supported.  JRuby 1.7.16+ and Rubinius 2.2+ are also supported.
 
-Coppertone does not require Rails.
+Coppertone does not require Rails, although it does depend on ActiveSupport.
 
 ## Installation
 
@@ -43,7 +45,17 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+To use Coppertone as a simple SPF checker (as you might, for example, if you were bundling it in a receiving SMTP server), you may use the `Coppertone::SpfService#authenticate_email` method.
+
+For example, were you authenticating an email sent by an SMTP server with IP address 1.2.3.4, advertising a HELO domain of 'mailserver123.example.org' and sent from 'somerandomperson@example.org', you'd invoke the method as follows:
+
+    result = Coppertone::SpfService#authenticate_email('1.2.3.4',
+                                                       'somerandomperson@example.org',
+                                                       'mailserver123.example.org')
+
+which would yield an instance of Coppertone::Result with the appropriate result code, and any explanation message.  If the email was validated, then this result will also include the validating mechanism and the validated identity ('helo' or 'mailfrom').
+
+For more sophisticated use of Coppertone, please consult the code and corresponding documentation directly.
 
 ## Contributing
 

data/lib/coppertone/directive.rb

@@ -19,6 +19,10 @@ module Coppertone
       end
     end
 
+    def context_dependent?
+      mechanism.context_dependent?
+    end
+
     def all?
       mechanism.is_a?(Coppertone::Mechanism::All)
     end

data/lib/coppertone/macro_string.rb

@@ -30,6 +30,13 @@ module Coppertone
       macros.any? { |m| m.is_a?(Coppertone::MacroString::MacroExpand) }
     end
 
+    def includes_ptr?
+      expanded_macros = macros.select do |m|
+        m.is_a?(Coppertone::MacroString::MacroExpand)
+      end
+      expanded_macros.any?(&:ptr_macro?)
+    end
+
     def ==(other)
       return false unless other.instance_of? self.class
       macro_text == other.macro_text

data/lib/coppertone/mechanism/domain_spec_mechanism.rb

@@ -22,6 +22,11 @@ module Coppertone
         return true unless domain_spec
         domain_spec.context_dependent?
       end
+
+      def includes_ptr?
+        return false unless domain_spec
+        domain_spec.includes_ptr?
+      end
     end
   end
 end

data/lib/coppertone/mechanism/include.rb

@@ -21,6 +21,15 @@ 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.rb

@@ -42,6 +42,10 @@ module Coppertone
     def context_dependent?
       false
     end
+
+    def includes_ptr?
+      false
+    end
   end
 end
 

data/lib/coppertone/modifier/base.rb

@@ -16,6 +16,14 @@ module Coppertone
         Coppertone::Utils::DomainUtils.macro_expanded_domain(domain)
       end
 
+      def context_dependent?
+        domain_spec.context_dependent?
+      end
+
+      def includes_ptr?
+        domain_spec.includes_ptr?
+      end
+
       def ==(other)
         return false unless other.instance_of? self.class
         domain_spec == other.domain_spec

data/lib/coppertone/modifier/redirect.rb

@@ -12,6 +12,17 @@ module Coppertone
         target_name_from_domain_spec(macro_context, request_context)
       end
 
+      def included_record(macro_context, request_context)
+        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)
+      end
+
       def self.label
         'redirect'
       end

data/lib/coppertone/modifier/unknown.rb

@@ -12,6 +12,14 @@ module Coppertone
         raise Coppertone::InvalidModifierError
       end
 
+      def context_dependent?
+        false
+      end
+
+      def includes_ptr?
+        false
+      end
+
       def self.label
         'unknown'
       end

data/lib/coppertone/null_macro_context.rb

@@ -1,8 +1,7 @@
 module Coppertone
-  # A context used to evaluate records, directives, and modifiers that do not have
-  # contextual dependence.
+  # A context used to evaluate records, directives, and modifiers that
+  # do not have contextual dependence.
   class NullMacroContext
-
     RESERVED_REGEXP = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
     %w(s l o d i p v h c r t).each do |m|
       define_method(m.upcase) do
@@ -14,10 +13,10 @@ module Coppertone
       end
     end
 
-    def with_domain(new_domain)
+    def with_domain(_new_domain)
       self
     end
 
     NULL_CONTEXT = new
   end
-end
+end

data/lib/coppertone/record.rb

@@ -38,6 +38,15 @@ module Coppertone
       include_all?
     end
 
+    def includes
+      @includes ||=
+        begin
+          directives.select do |d|
+            d.mechanism.is_a?(Coppertone::Mechanism::Include)
+          end
+        end
+    end
+
     def modifiers
       @modifiers ||= @terms.select { |t| t.is_a?(Coppertone::Modifier) }
     end
@@ -54,6 +63,23 @@ module Coppertone
       @exp ||= find_modifier(Coppertone::Modifier::Exp)
     end
 
+    def context_dependent_result?(request_context)
+      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) }
+    end
+
+    def context_dependent_redirect_result?(request_context)
+      return false unless redirect
+      redirect.context_dependent? ||
+        redirect.context_dependent_result?(request_context)
+    end
+
+    def context_dependent_message?
+      exp && exp.context_dependent?
+    end
+
     KNOWN_MODS =
       [Coppertone::Modifier::Exp, Coppertone::Modifier::Redirect]
     def unknown_modifiers

data/lib/coppertone/record_evaluator.rb

@@ -50,14 +50,12 @@ module Coppertone
 
     def evaluate_none_result(result, macro_context, request_context)
       return result unless follow_redirect?
-      redirect_target = record.redirect.evaluate(macro_context, request_context)
-      if redirect_target
-        redirect_record =
-          RecordFinder.new(request_context.dns_client, redirect_target).record
-      end
-      fail InvalidRedirectError unless redirect_record
-      rc = macro_context.with_domain(redirect_target)
-      RecordEvaluator.new(redirect_record).evaluate(rc, request_context)
+      finder =
+        Coppertone::RedirectRecordFinder.new(record.redirect, macro_context,
+                                             request_context)
+      fail InvalidRedirectError unless finder.target && finder.record
+      rc = macro_context.with_domain(finder.target)
+      RecordEvaluator.new(finder.record).evaluate(rc, request_context)
     end
   end
 end

data/lib/coppertone/record_term_parser.rb

@@ -1,4 +1,5 @@
 module Coppertone
+  # Parses a record into terms
   class RecordTermParser
     VERSION_STR =  'v=spf1'
     RECORD_REGEXP = /\A#{VERSION_STR}(\s|\z)/i

data/lib/coppertone/redirect_record_finder.rb

@@ -0,0 +1,20 @@
+module Coppertone
+  # A helper class for finding SPF records for a redirect modifier.
+  class RedirectRecordFinder
+    attr_reader :redirect, :macro_context, :request_context
+    def initialize(redirect, macro_context, request_context)
+      @redirect = redirect
+      @macro_context = macro_context
+      @request_context = request_context
+    end
+
+    def target
+      @redirect_target ||= redirect.evaluate(macro_context, request_context)
+    end
+
+    def record
+      return unless target
+      @record ||= RecordFinder.new(request_context.dns_client, target).record
+    end
+  end
+end

data/lib/coppertone/version.rb

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

data/lib/coppertone.rb

@@ -46,5 +46,6 @@ require 'coppertone/record_term_parser'
 require 'coppertone/record'
 require 'coppertone/record_evaluator'
 require 'coppertone/record_finder'
+require 'coppertone/redirect_record_finder'
 require 'coppertone/request'
 require 'coppertone/spf_service'

data/spec/mechanism/a_spec.rb

@@ -9,6 +9,8 @@ describe Coppertone::Mechanism::A do
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
       expect(mech.to_s).to eq('a')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
     it 'should not fail if called with a blank argument' do
@@ -18,6 +20,8 @@ describe Coppertone::Mechanism::A do
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
       expect(mech.to_s).to eq('a')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
     it 'should fail if called with an invalid macrostring' do
@@ -26,7 +30,19 @@ describe Coppertone::Mechanism::A do
       end.to raise_error(Coppertone::InvalidMechanismError)
     end
 
-    it 'should parse a domain spec' do
+    it 'should parse a context independent domain spec' do
+      mech = Coppertone::Mechanism::A.new(':_spf.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.example.com'))
+      expect(mech.ip_v4_cidr_length).to eq(32)
+      expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('a:_spf.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
+    end
+
+    it 'should parse a context dependent domain spec' do
       mech = Coppertone::Mechanism::A.new(':_spf.%{d}.example.com')
       expect(mech).not_to be_nil
       expect(mech.domain_spec)
@@ -34,6 +50,20 @@ describe Coppertone::Mechanism::A do
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
       expect(mech.to_s).to eq('a:_spf.%{d}.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
+    end
+
+    it 'should parse a domain spec with a ptr' do
+      mech = Coppertone::Mechanism::A.new(':_spf.%{p}.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.%{p}.example.com'))
+      expect(mech.ip_v4_cidr_length).to eq(32)
+      expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('a:_spf.%{p}.example.com')
+      expect(mech).to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
     it 'should parse a valid IP v4 CIDR length with a domain spec' do

data/spec/mechanism/all_spec.rb

@@ -5,6 +5,8 @@ describe Coppertone::Mechanism::All do
   it 'should always return true regardless of argument' do
     expect(subject.match?(double, double)).to eq(true)
     expect(subject.to_s).to eq('all')
+    expect(subject).not_to be_includes_ptr
+    expect(subject).not_to be_context_dependent
   end
 
   it 'should not allow creation of new instances' do

data/spec/mechanism/exists_spec.rb

@@ -20,9 +20,34 @@ describe Coppertone::Mechanism::Exists do
       end.to raise_error(Coppertone::InvalidMechanismError)
     end
 
-    it 'should succeed if called with a valid macrostring' do
-      mech = Coppertone::Mechanism::Exists.new(':%{d}.example.com')
-      expect(mech.to_s).to eq('exists:%{d}.example.com')
+    it 'should parse a context independent domain spec' do
+      mech = Coppertone::Mechanism::Exists.new(':_spf.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.example.com'))
+      expect(mech.to_s).to eq('exists:_spf.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
+    end
+
+    it 'should parse a context dependent domain spec' do
+      mech = Coppertone::Mechanism::Exists.new(':_spf.%{d}.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.%{d}.example.com'))
+      expect(mech.to_s).to eq('exists:_spf.%{d}.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
+    end
+
+    it 'should parse a domain spec with a ptr' do
+      mech = Coppertone::Mechanism::Exists.new(':_spf.%{p}.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.%{p}.example.com'))
+      expect(mech.to_s).to eq('exists:_spf.%{p}.example.com')
+      expect(mech).to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
   end
 

data/spec/mechanism/include_spec.rb

@@ -20,9 +20,34 @@ describe Coppertone::Mechanism::Include do
       end.to raise_error(Coppertone::InvalidMechanismError)
     end
 
-    it 'creates a mechanism if called with a valid macrostring' do
+    it 'should parse a context independent domain spec' do
       mech = Coppertone::Mechanism::Include.new(':_spf.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.example.com'))
       expect(mech.to_s).to eq('include:_spf.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
+    end
+
+    it 'should parse a context dependent domain spec' do
+      mech = Coppertone::Mechanism::Include.new(':_spf.%{d}.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.%{d}.example.com'))
+      expect(mech.to_s).to eq('include:_spf.%{d}.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
+    end
+
+    it 'should parse a domain spec with a ptr' do
+      mech = Coppertone::Mechanism::Include.new(':_spf.%{p}.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('_spf.%{p}.example.com'))
+      expect(mech.to_s).to eq('include:_spf.%{p}.example.com')
+      expect(mech).to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
   end
 

data/spec/mechanism/ip4_spec.rb

@@ -24,18 +24,24 @@ describe Coppertone::Mechanism::IP4 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.to_s).to eq('ip4:fe80::202:b3ff:fe1e:8329')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
     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.to_s).to eq('ip4: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 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.to_s).to eq('ip4:1.2.3.4/4')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
     end
   end
 

data/spec/mechanism/ip6_spec.rb

@@ -67,18 +67,24 @@ 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).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)
         .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
     end
 
     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)
         .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329/64'))
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
     end
   end
 

data/spec/mechanism/mx_spec.rb

@@ -9,6 +9,8 @@ describe Coppertone::Mechanism::MX do
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
       expect(mech.to_s).to eq('mx')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
     it 'should not fail if called with a blank argument' do
@@ -18,6 +20,8 @@ describe Coppertone::Mechanism::MX do
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
       expect(mech.to_s).to eq('mx')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
     it 'should fail if called with an invalid macrostring' do
@@ -33,6 +37,8 @@ describe Coppertone::Mechanism::MX do
       expect(mech.ip_v4_cidr_length).to eq(24)
       expect(mech.ip_v6_cidr_length).to eq(128)
       expect(mech.to_s).to eq('mx/24')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
     it 'should process the domain spec if it includes a IP v6 CIDR' do
@@ -42,6 +48,8 @@ describe Coppertone::Mechanism::MX do
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(96)
       expect(mech.to_s).to eq('mx//96')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
     it 'should process the domain spec if it includes an IP v4 CIDR and an IP v6 CIDR' do
@@ -51,9 +59,11 @@ 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/28//96')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
     end
 
-    it 'should not fail if called with a blank argument' do
+    it 'should not fail if called with a fixed domain spec without explicit CIDRs' do
       mech = Coppertone::Mechanism::MX.new(':mx.example.com')
       expect(mech).not_to be_nil
       expect(mech.domain_spec)
@@ -61,9 +71,11 @@ describe Coppertone::Mechanism::MX do
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
       expect(mech.to_s).to eq('mx:mx.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).not_to be_context_dependent
     end
 
-    it 'should not fail if called with a blank argument' do
+    it 'should not fail if called with a fixed domain spec with explicit CIDRs' do
       mech = Coppertone::Mechanism::MX.new(':mx.example.com/28//96')
       expect(mech).not_to be_nil
       expect(mech.domain_spec)
@@ -72,6 +84,54 @@ describe Coppertone::Mechanism::MX do
       expect(mech.ip_v6_cidr_length).to eq(96)
       expect(mech.to_s).to eq('mx:mx.example.com/28//96')
     end
+
+    it 'should not fail if called with a context-dependent domain spec without explicit CIDRs' do
+      mech = Coppertone::Mechanism::MX.new(':%{d}.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{d}.example.com'))
+      expect(mech.ip_v4_cidr_length).to eq(32)
+      expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('mx:%{d}.example.com')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
+    end
+
+    it 'should not fail if called with a fixed domain spec with explicit CIDRs' do
+      mech = Coppertone::Mechanism::MX.new(':%{d}.example.com/28//96')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{d}.example.com'))
+      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:%{d}.example.com/28//96')
+      expect(mech).not_to be_includes_ptr
+      expect(mech).to be_context_dependent
+    end
+
+    it 'should not fail if called with a context-dependent domain spec without explicit CIDRs with PTR' do
+      mech = Coppertone::Mechanism::MX.new(':%{p}.example.com')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{p}.example.com'))
+      expect(mech.ip_v4_cidr_length).to eq(32)
+      expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('mx:%{p}.example.com')
+      expect(mech).to be_includes_ptr
+      expect(mech).to be_context_dependent
+    end
+
+    it 'should not fail if called with a fixed domain spec with explicit CIDRs with PTR' do
+      mech = Coppertone::Mechanism::MX.new(':%{p}.example.com/28//96')
+      expect(mech).not_to be_nil
+      expect(mech.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{p}.example.com'))
+      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:%{p}.example.com/28//96')
+      expect(mech).to be_includes_ptr
+      expect(mech).to be_context_dependent
+    end
   end
 
   context '#create' do

data/spec/mechanism/ptr_spec.rb

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

data/spec/modifier/exp_spec.rb

@@ -1,6 +1,41 @@
 require 'spec_helper'
 
 describe Coppertone::Modifier::Exp do
+  context '#new' do
+    it 'should work with a context independent domain spec' do
+      modifier = Coppertone::Modifier::Exp.new('test.example.com')
+      expect(modifier).not_to be_nil
+      expect(modifier.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('test.example.com'))
+      expect(modifier.to_s)
+        .to eq('exp=test.example.com')
+      expect(modifier).not_to be_includes_ptr
+      expect(modifier).not_to be_context_dependent
+    end
+
+    it 'should work with a context independent domain spec' do
+      modifier = Coppertone::Modifier::Exp.new('%{d}.example.com')
+      expect(modifier).not_to be_nil
+      expect(modifier.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{d}.example.com'))
+      expect(modifier.to_s)
+        .to eq('exp=%{d}.example.com')
+      expect(modifier).not_to be_includes_ptr
+      expect(modifier).to be_context_dependent
+    end
+
+    it 'should work with a context independent domain spec with a PTR' do
+      modifier = Coppertone::Modifier::Exp.new('%{p}.example.com')
+      expect(modifier).not_to be_nil
+      expect(modifier.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{p}.example.com'))
+      expect(modifier.to_s)
+        .to eq('exp=%{p}.example.com')
+      expect(modifier).to be_includes_ptr
+      expect(modifier).to be_context_dependent
+    end
+  end
+
   context 'to_s' do
     it 'should result in the expected string' do
       expect(Coppertone::Modifier::Exp.new('test.example.com').to_s)

data/spec/modifier/redirect_spec.rb

@@ -1,6 +1,41 @@
 require 'spec_helper'
 
 describe Coppertone::Modifier::Redirect do
+  context '#new' do
+    it 'should work with a context independent domain spec' do
+      modifier = Coppertone::Modifier::Redirect.new('test.example.com')
+      expect(modifier).not_to be_nil
+      expect(modifier.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('test.example.com'))
+      expect(modifier.to_s)
+        .to eq('redirect=test.example.com')
+      expect(modifier).not_to be_includes_ptr
+      expect(modifier).not_to be_context_dependent
+    end
+
+    it 'should work with a context independent domain spec' do
+      modifier = Coppertone::Modifier::Redirect.new('%{d}.example.com')
+      expect(modifier).not_to be_nil
+      expect(modifier.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{d}.example.com'))
+      expect(modifier.to_s)
+        .to eq('redirect=%{d}.example.com')
+      expect(modifier).not_to be_includes_ptr
+      expect(modifier).to be_context_dependent
+    end
+
+    it 'should work with a context independent domain spec with a PTR' do
+      modifier = Coppertone::Modifier::Redirect.new('%{p}.example.com')
+      expect(modifier).not_to be_nil
+      expect(modifier.domain_spec)
+        .to eq(Coppertone::DomainSpec.new('%{p}.example.com'))
+      expect(modifier.to_s)
+        .to eq('redirect=%{p}.example.com')
+      expect(modifier).to be_includes_ptr
+      expect(modifier).to be_context_dependent
+    end
+  end
+
   context 'to_s' do
     it 'should result in the expected string' do
       expect(Coppertone::Modifier::Redirect.new('test.example.com').to_s)

data/spec/redirect_record_finder_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Coppertone::RedirectRecordFinder do
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: coppertone
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Peter M. Goldstein
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-09-27 00:00:00.000000000 Z
+date: 2014-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -175,6 +175,7 @@ files:
 - lib/coppertone/record_evaluator.rb
 - lib/coppertone/record_finder.rb
 - lib/coppertone/record_term_parser.rb
+- lib/coppertone/redirect_record_finder.rb
 - lib/coppertone/request.rb
 - lib/coppertone/request_context.rb
 - lib/coppertone/request_count_limiter.rb
@@ -228,6 +229,7 @@ files:
 - spec/record_evaluator_spec.rb
 - spec/record_finder_spec.rb
 - spec/record_spec.rb
+- spec/redirect_record_finder_spec.rb
 - spec/request_context_spec.rb
 - spec/request_count_limiter_spec.rb
 - spec/result_spec.rb
@@ -304,6 +306,7 @@ test_files:
 - spec/record_evaluator_spec.rb
 - spec/record_finder_spec.rb
 - spec/record_spec.rb
+- spec/redirect_record_finder_spec.rb
 - spec/request_context_spec.rb
 - spec/request_count_limiter_spec.rb
 - spec/result_spec.rb