zonesync 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da2a32c21af6c64a37bdb9a998089318ba12cbf3e20e0699a757adafe23d6e29
-  data.tar.gz: 6614061b9bc864e1f5a6219d25ac96d93f45cf5a98a9234c75bc7241e51eb909
+  metadata.gz: 9f636466fb4175eab983daffca93a4f3e09447bd49a4b50944078034c9067b46
+  data.tar.gz: 462dcac524149c882e25e8f1962c9b29cc376177448b5a8320241cb135a83b01
 SHA512:
-  metadata.gz: c79134908c21f775a9aa58eccadd072684d0657b3e23bf9b953a050ef4c558cd557f9bbed9c57a522c7ab3e0521bd0a3254c19c8b2415a36c25e236be242a74c
-  data.tar.gz: 17d1e8928f168ea9bd4e93a9add850c2c5e7e7c168d3982d133817bdef63a9c085ae4d2b108aa8b51f1d5cab692f597d8d035aece15c7b44fa2547ad7baa0f91
+  metadata.gz: '0628bc131c08e8432e82c7b1f9a94587224871434df282ad52adc3cc1fe04b755c2b73ba849ee707a4c9c3ab6dfb69cd99b1289e6cfde41df9c72b1ccc874485'
+  data.tar.gz: 4f55bace0450c64863dccbe394d160b00197db1294cc227e2fa119310c89415c5b6bf4ee52a9bd2d1e68a9aa362376e3079552947cc9703df3ee4e562d8e5fff

data/.rspec

@@ -1,2 +1,2 @@
 --color
---require debug
+--require spec_helper

data/Gemfile

@@ -4,3 +4,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem "debug"
+gem "dns-zonefile", path: "../dns-zonefile"

data/README.md

@@ -48,8 +48,11 @@ wwwtest       CNAME www
 mail          A     192.0.2.3
 mail2         A     192.0.2.4
 mail3         A     192.0.2.5
+ignore        A     192.0.2.6 ; zonesync: ignore
 ```
 
+Note that records with a comment containing "zonesync: ignore" will not be touched during the sync. I'm considering inverting this from a blacklist to a whitelist in a future version, to avoid stomping on collaborators' records.
+
 ### DNS Host
 
 We need to tell `zonesync` about our DNS host by building a small YAML file. The structure of this file will depend on your DNS host, so here are some examples:

data/lib/zonesync/cloudflare.rb

@@ -19,6 +19,7 @@ module Zonesync
         type: new_record[:type],
         ttl: new_record[:ttl],
         content: new_record[:rdata],
+        comment: new_record[:comment],
       })
     end
 
@@ -28,6 +29,7 @@ module Zonesync
         type: record[:type],
         ttl: record[:ttl],
         content: record[:rdata],
+        comment: record[:comment],
       })
     end
 
@@ -55,6 +57,7 @@ module Zonesync
         attrs["type"],
         attrs["ttl"].to_i,
         rdata,
+        attrs["comment"],
       ).to_h
     end
 

data/lib/zonesync/provider.rb

@@ -1,5 +1,5 @@
-require "dns/zonefile"
 require "zonesync/record"
+require "zonesync/zonefile"
 
 module Zonesync
   class Provider < Struct.new(:credentials)
@@ -13,6 +13,8 @@ module Zonesync
         Record.from_dns_zonefile_record(record)
       end.select do |record|
         %w[A AAAA CNAME MX TXT SPF NAPTR PTR].include?(record.type)
+      end.reject do |record|
+        record.comment.to_s.downcase.include? "zonesync: ignore"
       end.sort
     end
 
@@ -21,7 +23,7 @@ module Zonesync
       if body !~ /\sSOA\s/ # insert dummy SOA to trick parser if needed
         body.sub!(/\n([^$])/, "\n@ 1 SOA example.com example.com ( 2000010101 1 1 1 1 )\n\\1")
       end
-      DNS::Zonefile.load(body)
+      Zonefile.load(body)
     end
 
     def read record

data/lib/zonesync/record.rb

@@ -1,5 +1,5 @@
 module Zonesync
-  class Record < Struct.new(:name, :type, :ttl, :rdata)
+  class Record < Struct.new(:name, :type, :ttl, :rdata, :comment)
     def self.from_dns_zonefile_record record
       type = record.class.name.split("::").last
       rdata = case type
@@ -23,6 +23,7 @@ module Zonesync
         type,
         record.ttl,
         rdata,
+        record.comment,
       )
     end
 
@@ -35,7 +36,9 @@ module Zonesync
     end
 
     def to_s
-      values.join(" ")
+      string = [name, type, ttl, rdata].join(" ")
+      string << " ; #{comment}" if comment
+      string
     end
   end
 end

data/lib/zonesync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zonesync
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/lib/zonesync/zonefile.rb

@@ -0,0 +1,318 @@
+require "treetop"
+Treetop.load File.join(__dir__, "zonefile")
+
+module Zonesync
+  module Zonefile
+    class << self
+      def parse(zone_string)
+        parser = ZonefileParser.new
+        result = parser.parse(zone_string)
+        return result if result
+        raise ParsingError, parser.failure_reason
+      end
+
+      def load(zone_string, alternate_origin = nil)
+        Zone.new(parse(zone_string).entries, alternate_origin)
+      end
+    end
+
+    class ParsingError < RuntimeError; end
+    class UnknownRecordType < RuntimeError; end
+    class Zone
+      attr_reader :origin
+      attr_reader :records
+
+      def initialize(entries, alternate_origin = nil)
+        alternate_origin ||= "."
+        @records = []
+        @vars = {"origin" => alternate_origin, :last_host => "."}
+        entries.each do |e|
+          case e.parse_type
+          when :variable
+            key = e.name.text_value.downcase
+            @vars[key] = case key
+            when "ttl"
+              e.value.text_value.to_i
+            else
+              e.value.text_value
+            end
+          when :soa
+            @records << SOA.new(@vars, e)
+          when :record
+            case e.record_type
+            when "A" then @records << A.new(@vars, e)
+            when "AAAA" then @records << AAAA.new(@vars, e)
+            when "CAA" then @records << CAA.new(@vars, e)
+            when "CNAME" then @records << CNAME.new(@vars, e)
+            when "MX" then @records << MX.new(@vars, e)
+            when "NAPTR" then @records << NAPTR.new(@vars, e)
+            when "NS" then @records << NS.new(@vars, e)
+            when "PTR" then @records << PTR.new(@vars, e)
+            when "SRV" then @records << SRV.new(@vars, e)
+            when "SPF" then @records << SPF.new(@vars, e)
+            when "SSHFP" then @records << SSHFP.new(@vars, e)
+            when "TXT" then @records << TXT.new(@vars, e)
+            when "SOA" then
+              # No-op
+            else
+              raise UnknownRecordType, "Unknown record type: #{e.record_type}"
+            end
+          end
+        end
+      end
+
+      def soa
+        records_of(SOA).first
+      end
+
+      def records_of(kl)
+        @records.select { |r| r.instance_of? kl }
+      end
+    end
+
+    class Record
+      # assign, with handling for global TTL
+      def self.writer_for_ttl(*attribs)
+        attribs.each do |attrib|
+          define_method "#{attrib}=" do |val|
+            instance_variable_set("@#{attrib}", val || @vars["ttl"])
+          end
+        end
+      end
+
+      attr_reader :ttl
+      attr_writer :klass
+      writer_for_ttl :ttl
+
+      def klass
+        @klass = nil if @klass == ""
+        @klass ||= "IN"
+      end
+
+      attr_accessor :comment
+
+      private
+
+      def qualify_host(host)
+        origin = vars["origin"]
+        host = vars[:last_host] if /^\s*$/.match?(host)
+        host = host.gsub(/@/, origin)
+        if /\.$/.match?(host)
+          host
+        elsif /^\./.match?(origin)
+          host + origin
+        else
+          host + "." + origin
+        end
+      end
+      attr_accessor :vars
+    end
+
+    class SOA < Record
+      attr_accessor :origin, :nameserver, :responsible_party, :serial, :refresh_time, :retry_time, :expiry_time, :nxttl
+
+      def initialize(vars, zonefile_soa = nil)
+        @vars = vars
+        if zonefile_soa
+          self.origin = qualify_host(zonefile_soa.origin.to_s)
+          @vars[:last_host] = origin
+          self.ttl = zonefile_soa.ttl.to_i
+          self.klass = zonefile_soa.klass.to_s
+          self.nameserver = qualify_host(zonefile_soa.ns.to_s)
+          self.responsible_party = qualify_host(zonefile_soa.rp.to_s)
+          self.serial = zonefile_soa.serial.to_i
+          self.refresh_time = zonefile_soa.refresh.to_i
+          self.retry_time = zonefile_soa.reretry.to_i
+          self.expiry_time = zonefile_soa.expiry.to_i
+          self.nxttl = zonefile_soa.nxttl.to_i
+        end
+      end
+    end
+
+    class A < Record
+      attr_accessor :host, :address
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.address = zonefile_record.ip_address.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+    end
+
+    class AAAA < A
+    end
+
+    class CAA < Record
+      attr_accessor :host, :flags, :tag, :value
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.flags = zonefile_record.flags.to_i
+          self.tag = zonefile_record.tag.to_s
+          self.value = zonefile_record.value.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+    end
+
+    class CNAME < Record
+      attr_accessor :host, :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.domainname = qualify_host(zonefile_record.target.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias target domainname
+      alias alias host
+    end
+
+    class MX < Record
+      attr_accessor :host, :priority, :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.priority = zonefile_record.priority.to_i
+          self.domainname = qualify_host(zonefile_record.exchanger.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias exchange domainname
+      alias exchanger domainname
+    end
+
+    class NAPTR < Record
+      attr_accessor :host, :data
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.data = zonefile_record.data.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+    end
+
+    class NS < Record
+      attr_accessor :host, :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.domainname = qualify_host(zonefile_record.nameserver.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias nameserver domainname
+    end
+
+    class PTR < Record
+      attr_accessor :host, :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.domainname = qualify_host(zonefile_record.target.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias target domainname
+    end
+
+    class SRV < Record
+      attr_accessor :host, :priority, :weight, :port, :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.priority = zonefile_record.priority.to_i
+          self.weight = zonefile_record.weight.to_i
+          self.port = zonefile_record.port.to_i
+          self.domainname = qualify_host(zonefile_record.target.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias target domainname
+    end
+
+    class SSHFP < Record
+      attr_accessor :host, :alg, :fptype, :fp
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.alg = zonefile_record.alg.to_i
+          self.fptype = zonefile_record.fptype.to_i
+          self.fp = zonefile_record.fp.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+    end
+
+    class TXT < Record
+      attr_accessor :host, :data
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.data = zonefile_record.data.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+    end
+
+    class SPF < TXT
+    end
+  end
+end

data/lib/zonesync/zonefile.treetop

@@ -0,0 +1,586 @@
+grammar Zonefile
+  rule zone
+    (variable / space_or_break / comment)* soa (resource_record / variable / comment / space / linebreak)* {
+      def variables
+        @variables ||= begin
+          raw = elements[0].elements.select { |e| e.to_s =~ /^\$/ }
+          variables = {}
+          raw.each do |e|
+            variables[e.name.text_value.to_s] = e.value.text_value.to_s
+          end
+          variables
+        end
+      end
+
+      def origin
+        soa.origin.host.to_s
+      end
+
+      def to_s
+        text_value
+      end
+
+      def rr
+        elements[-1].elements.select { |e| e.to_s !~ /\A\s*([;$].*)?\z|\A\z/; }
+      end
+      
+      def entries
+        elements[0].elements.select { |e| e.to_s !~ /\A\s*(;.*)?\z|\A\z/; } +
+          [soa] +
+          elements[-1].elements.select { |e| e.to_s !~ /\A\s*(;.*)?\z|\A\z/; }
+      end
+    }
+  end
+
+  rule variable
+    "$" name:([a-zA-Z0-9]+) space value:([a-zA-Z0-9\.\-_]+) space? comment? {
+      def to_s
+        "$#{name.text_value.to_s} #{value.text_value.to_s}"
+      end
+
+      def parse_type ; :variable ; end
+    }
+  end
+
+  rule soa
+    (
+     origin space ttl klass "SOA" space ns space "("? multiline_comment* space_or_break* rp multiline_comment* space_or_break* "("?  multiline_comment* space_or_break* serial multiline_comment* space_or_break refresh multiline_comment* space_or_break reretry multiline_comment* space_or_break expiry multiline_comment* space_or_break nxttl multiline_comment* space_or_break* ")"? /
+     origin space klass ttl "SOA" space ns space "("? multiline_comment* space_or_break* rp multiline_comment* space_or_break* "("?  multiline_comment* space_or_break* serial multiline_comment* space_or_break refresh multiline_comment* space_or_break reretry multiline_comment* space_or_break expiry multiline_comment* space_or_break nxttl multiline_comment* space_or_break* ")"?
+    ) {
+      def to_s
+        "#{origin} #{ttl} #{klass} SOA #{ns} #{rp} (#{serial} #{refresh} #{reretry} #{expiry} #{nxttl})"
+      end
+      
+      def parse_type ; :soa ; end
+    }
+  end
+
+  rule resource_record
+    record:(a_record / aaaa_record / caa_record / cname_record / mx_record / naptr_record / ns_record / ptr_record / srv_record / spf_record / sshfp_record / txt_record / soa_record) space* comment:comment? linebreak {
+      def zone
+        p = parent
+        while p.respond_to?(:parent) && p.parent
+          p = p.parent
+        end
+        p
+      end
+      
+      def to_s
+        text_value
+      end
+
+      def record_type
+        record.record_type
+      end
+
+      def ttl
+        record.ttl || zone.variables['TTL'].to_i
+      end
+
+      def comment
+        return if super.empty?
+        super
+      end
+
+      def method_missing(method_name, *args)
+        if record.respond_to?(method_name)
+          record.send(method_name, *args)
+        end
+      end
+
+      def respond_to?(method_name)
+        super || record.respond_to?(method_name)
+      end
+
+      def parse_type ; :record ; end
+    }
+  end
+
+  rule a_record
+    (
+     host space ms_age ttl klass "A" space ip_address /
+     host space ms_age klass ttl "A" space ip_address
+    ) {
+      def to_s
+        "#{host} #{ms_age} #{ttl} #{klass} A #{ip_address}"
+      end
+
+      def record_type
+        "A"
+      end
+    }
+  end
+
+  rule ip_address
+    [\d]+ "." [\d]+ "." [\d]+ "." [\d]+ {
+      def to_s
+        text_value
+      end
+    }
+  end
+  
+  rule aaaa_record
+    (
+     host space ms_age ttl klass "AAAA" space ip_address:ip6_address /
+     host space ms_age klass ttl "AAAA" space ip_address:ip6_address
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} AAAA #{ip_address}"
+      end
+
+      def record_type
+        "AAAA"
+      end
+    }
+  end
+  
+  rule ip6_address
+    [\da-fA-F:.] 2..39 {
+      def to_s
+        text_value.downcase
+      end
+    }
+  end
+
+  rule caa_record
+    (
+      host space ms_age ttl klass "CAA" space flags:integer space tag:unquoted_string space value:caa_value /
+      host space ms_age klass ttl "CAA" space flags:integer space tag:unquoted_string space value:caa_value
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} CAA #{flags} #{tag} #{value}"
+      end
+
+      def record_type
+        "CAA"
+      end
+    }
+  end
+
+  rule caa_value
+    (quoted_string / unquoted_string) {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule cname_record
+    (
+     host space ms_age ttl klass "CNAME" space target:host /
+     host space klass ms_age ttl "CNAME" space target:host /
+     host space ms_age ttl "CNAME" space target:host /
+     host space klass "CNAME" space target:host 
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} CNAME #{target}"
+      end
+
+      def record_type
+        "CNAME"
+      end
+    }
+  end
+
+  rule mx_record
+    (
+     host space ttl klass "MX" space priority:integer space exchanger:host /
+     host space klass ttl "MX" space priority:integer space exchanger:host
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} MX #{priority} #{exchanger}"
+      end
+
+      def record_type
+        "MX"
+      end
+    }
+  end
+  
+  rule naptr_record
+    (
+     host space ms_age ttl klass "NAPTR" space data /
+     host space ms_age klass ttl "NAPTR" space data
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} NAPTR #{data}"
+      end
+
+      def record_type
+        "NAPTR"
+      end
+    }
+  end
+
+  rule ns_record
+    (
+     host space ms_age ttl klass "NS" space nameserver:host /
+     host space ms_age klass ttl "NS" space nameserver:host
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} NS #{nameserver}"
+      end
+
+      def record_type
+        "NS"
+      end
+    }
+  end
+
+  rule ptr_record
+    (
+     host space ms_age ttl klass "PTR" space target:host /
+     host space ms_age klass ttl "PTR" space target:host
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} PTR #{target}"
+      end
+
+      def record_type
+        "PTR"
+      end
+    }
+  end
+
+  rule soa_record
+    (
+     origin space ms_age ttl klass "SOA" space ns space rp space data /
+     origin space ms_age klass ttl "SOA" space ns space rp space data
+    ) {
+      def to_s
+        "#{origin} #{ttl} #{klass} SOA #{ns} #{rp} (#{space})"
+      end
+
+      def record_type
+        "SOA"
+      end
+    }
+  end
+
+  rule srv_record
+    (
+     host space ms_age ttl klass "SRV" space priority:integer space weight:integer space port:integer space target:host /
+     host space klass ms_age ttl "SRV" space priority:integer space weight:integer space port:integer space target:host /
+     host space ms_age ttl "SRV" space priority:integer space weight:integer space port:integer space target:host /
+     host space klass "SRV" space priority:integer space weight:integer space port:integer space target:host
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} SRV #{priority} #{weight} #{port} #{target}"
+      end
+
+      def record_type
+        "SRV"
+      end
+    }
+  end
+
+  rule spf_record
+    (
+     host space ms_age ttl klass "SPF" space data:txt_data /
+     host space ms_age klass ttl "SPF" space data:txt_data 
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} SPF #{data}"
+      end
+
+      def record_type
+        "SPF"
+      end
+    }
+  end
+
+  rule sshfp_record
+    (
+     host space ms_age ttl klass "SSHFP" space alg:integer space fptype:integer space fp:fingerprint / 
+     host space ms_age klass ttl "SSHFP" space alg:integer space fptype:integer space fp:fingerprint 
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} SSHFP #{alg} #{fptype} #{fp}"
+      end
+
+      def record_type
+        "SSHFP"
+      end
+    }
+  end
+
+  rule txt_record
+    (
+     host space ms_age ttl klass "TXT" space data:ms_txt_data /
+     host space ms_age klass ttl "TXT" space data:ms_txt_data
+    ) {
+      def to_s
+        "#{host} #{ttl} #{klass} TXT #{data}"
+      end
+
+      def record_type
+        "TXT"
+      end
+    }
+  end
+
+  rule origin
+    host comment* {
+      def to_s
+        "#{host}"
+      end
+    }
+  end
+
+  rule multiline_comment
+     linebreak+ comment* {
+      def to_s
+        text_value.strip
+      end
+    }
+  end
+
+  rule space
+    [ \t]+ {
+      def to_s
+        text_value
+      end
+    }
+  end
+  
+  rule linebreak
+    [\n\r]+ {
+      def to_s
+        ''
+      end
+    }
+  end
+  
+  rule space_or_break
+    [\s]+ {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule klass
+    (("IN" space) / '') {
+      def to_s
+        text_value.strip
+      end
+    }
+  end
+  
+  rule comment
+    space* ";" [^\n\r]* {
+      def to_s
+        text_value[2..].to_s.strip
+      end
+
+      def parse_type ; :comment ; end
+    }
+  end
+
+  rule ns
+    host comment* {
+      def to_s
+        "#{host}"
+      end
+    }
+  end
+
+  rule rp
+    rp_value comment* {
+      def to_s
+       "#{rp_value}"
+      end
+    }
+  end
+
+  rule rp_value
+    ("." / (("\\." / [a-zA-Z0-9\-)])+ "."?)+) {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule serial
+    integer comment* {
+      def to_i
+        integer.to_i
+      end
+      def to_s
+        "#{to_i}"
+      end
+    }
+  end
+
+  rule time_interval
+    integer time_multiplier {
+      def to_s
+        text_value
+      end
+
+      def to_i
+        time_multiplier.to_i * integer.to_i
+      end
+    }
+  end
+
+  rule refresh
+    time_interval comment* {
+      def to_i
+        time_interval.to_i
+      end
+      def to_s
+        time_interval.to_s
+      end
+    }
+  end
+
+  rule integer
+    [0-9]+ {
+      def to_i
+        text_value.to_i
+      end
+      def to_s
+        "#{to_i}"
+      end
+    }
+  end
+
+  rule time_multiplier
+    ( 's' / 'S' / 'm' / 'M' / 'h' / 'H' / 'd' / 'D' / 'w' / 'W' / '' ) {
+      def to_s
+        text_value
+      end
+      def to_i
+        case text_value.downcase
+          when 'm' then 60
+          when 'h' then 60 * 60
+          when 'd' then 60 * 60 * 24
+          when 'w' then 60 * 60 * 24 * 7
+          else
+            1
+        end
+      end
+    }
+  end
+
+  rule reretry
+    time_interval comment* {
+      def to_i
+        time_interval.to_i
+      end
+      def to_s
+        time_interval.to_s
+      end
+    }
+  end
+
+  rule expiry
+    time_interval comment* {
+      def to_i
+        time_interval.to_i
+      end
+      def to_s
+        time_interval.to_s
+      end
+    }
+  end
+
+  rule nxttl
+    time_interval comment* {
+      def to_i
+        time_interval.to_i
+      end
+      def to_s
+        time_interval.to_s
+      end
+    }
+  end
+
+  rule ms_age
+    ( "[AGE:" [\d]+ "]" space / '' ) {
+      def to_s
+        text_value
+      end
+    }
+  end
+  
+  rule ttl
+    ((time_interval space) / '') {
+      def to_i
+        respond_to?(:time_interval) ? time_interval.to_i : nil
+      end
+      def to_s
+        respond_to?(:time_interval) ? time_interval.to_s : ''
+      end
+    }
+  end
+
+  rule host
+    ( ([*a-zA-Z0-9\-\._]+) / "@" / ' ' / "\t" ) {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule fingerprint
+    [a-fA-Z0-9:]+ {
+      def to_s
+        text_value.strip
+      end
+    }
+  end
+
+  rule data
+    [^;\n\r]+ {
+      def to_s
+        text_value.strip
+      end
+    }
+  end
+
+  rule ms_txt_data
+    (
+      "(" space* data:txt_data space* ")" /
+      data:txt_data
+    ) {
+      def to_s
+        data.to_s
+      end
+    }
+  end
+  
+  rule txt_data
+    txt_string (space txt_data)* {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule txt_string
+    (quoted_string / unquoted_string) {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule quoted_string
+    ( '"' ( '\"' / [^"] )* '"') {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule unquoted_string
+    '[a-zA-Z0-9=_\.\-\@\:\~]+'r {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+end

data/zonesync.gemspec

@@ -27,9 +27,9 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "dns-zonefile", "~>1.0"
   spec.add_dependency "diff-lcs", "~>1.4"
   spec.add_dependency "thor", "~>1.0"
+  spec.add_dependency "treetop", "~>1.6"
 
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zonesync
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Micah Geisel
@@ -9,50 +9,50 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-17 00:00:00.000000000 Z
+date: 2024-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: dns-zonefile
+  name: diff-lcs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: diff-lcs
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: treetop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -121,6 +121,8 @@ files:
 - lib/zonesync/rake.rb
 - lib/zonesync/record.rb
 - lib/zonesync/version.rb
+- lib/zonesync/zonefile.rb
+- lib/zonesync/zonefile.treetop
 - log/.keep
 - zonesync.gemspec
 homepage: https://github.com/botandrose/zonesync