zonesync 0.9.0 → 0.11.0

data/lib/zonesync/zonefile.rb

@@ -1,323 +1,34 @@
-require "treetop"
-Treetop.load File.join(__dir__, "zonefile")
+# typed: strict
+require "sorbet-runtime"
 
-module Zonesync
-  module Zonefile
-    class << self
-      def parse(zone_string)
-        parser = ZonefileParser.new
-        result = parser.parse(zone_string)
-        return result if result
-        puts zone_string
-        raise ParsingError, parser.failure_reason
-      end
-
-      def load(zone_string)
-        parsed = parse(zone_string)
-        Zone.new(parsed.entries,
-          origin: parsed.variables["ORIGIN"],
-        )
-      end
-    end
-
-    class ParsingError < RuntimeError; end
-    class UnknownRecordType < RuntimeError; end
-    class Zone
-      attr_reader :origin
-      attr_reader :records
-
-      def initialize(entries, origin: nil, alternate_origin: ".")
-        @origin = 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
-        @origin ||= soa.origin
-      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
+require "zonesync/parser"
 
-      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
+module Zonesync
+  class Zonefile
+    extend T::Sig
 
-      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
+    sig { params(zone_string: String).returns(Zonefile) }
+    def self.load(zone_string)
+      if zone_string !~ /\sSOA\s/ # insert dummy SOA to trick parser if needed
+        zone_string.sub!(/\n([^$])/, "\n@ 1 SOA example.com example.com ( 2000010101 1 1 1 1 )\n\\1")
       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
+      zone = Parser.parse(zone_string)
+      records = zone.records.map do |dns_zonefile_record|
+        Zonesync::Record.from_dns_zonefile_record(dns_zonefile_record)
       end
-
-      alias target domainname
+      new(records, origin: zone.origin)
     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
+    sig { params(records: T::Array[Zonesync::Record], origin: String).void }
+    def initialize records, origin:
+      @records = records
+      @origin = origin
     end
 
-    class SSHFP < Record
-      attr_accessor :host, :alg, :fptype, :fp
+    sig { returns(T::Array[Zonesync::Record]) }
+    attr_reader :records
 
-      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
+    sig { returns(String) }
+    attr_reader :origin
   end
 end

data/lib/zonesync.rb

@@ -1,82 +1,50 @@
+# typed: strict
+require "sorbet-runtime"
+
+require "zonesync/sync"
+require "zonesync/generate"
 require "zonesync/provider"
-require "zonesync/diff"
-require "zonesync/validator"
-require "zonesync/logger"
 require "zonesync/cli"
 require "zonesync/rake"
 require "zonesync/errors"
+require "zonesync/record_hash"
+
+begin # optional active_support dependency
+  require "active_support"
+  require "active_support/encrypted_configuration"
+  require "active_support/core_ext/hash/keys"
+rescue LoadError; end
 
 module Zonesync
-  def self.call source: "Zonefile", destination: "zonesync", dry_run: false
+  extend T::Sig
+
+  sig { params(source: T.nilable(String), destination: T.nilable(String), dry_run: T::Boolean, force: T::Boolean).void }
+  def self.call source: "Zonefile", destination: "zonesync", dry_run: false, force: false
+    source = T.must(source)
+    destination = T.must(destination).to_sym
     Sync.new(
-      { provider: "Filesystem", path: source },
-      credentials[destination]
-    ).call(dry_run: dry_run)
+      Provider.from({ provider: "Filesystem", path: source }),
+      Provider.from(credentials(destination)),
+    ).call(dry_run: dry_run, force: force)
   end
 
+  sig { params(source: T.nilable(String), destination: T.nilable(String)).void }
   def self.generate source: "zonesync", destination: "Zonefile"
+    source = T.must(source).to_sym
     Generate.new(
-      credentials[source],
-      { provider: "Filesystem", path: destination }
+      Provider.from(credentials(source)),
+      Provider.from({ provider: "Filesystem", path: T.must(destination) }),
     ).call
   end
 
-  def self.credentials
-    require "active_support"
-    require "active_support/encrypted_configuration"
-    require "active_support/core_ext/hash/keys"
+  sig { params(key: Symbol).returns(T::Hash[Symbol, String]) }
+  def self.credentials key
     ActiveSupport::EncryptedConfiguration.new(
       config_path: "config/credentials.yml.enc",
       key_path: "config/master.key",
       env_key: "RAILS_MASTER_KEY",
       raise_if_missing_key: true,
-    )
-  end
-
-  class Sync < Struct.new(:source, :destination)
-    def call dry_run: false
-      source = Provider.from(self.source)
-      destination = Provider.from(self.destination)
-      operations = Diff.call(
-        from: destination.diffable_records,
-        to: source.diffable_records,
-      )
-
-      Validator.call(operations, destination)
-
-      smanifest = source.manifest.generate
-      dmanifest = destination.manifest.existing
-      if smanifest != dmanifest
-        if dmanifest
-          operations << [:change, [dmanifest, smanifest]]
-        else
-          operations << [:add, [smanifest]]
-        end
-      end
-
-      schecksum = source.manifest.generate_checksum
-      dchecksum = destination.manifest.existing_checksum
-      if schecksum != dchecksum
-        if dchecksum
-          operations << [:change, [dchecksum, schecksum]]
-        else
-          operations << [:add, [schecksum]]
-        end
-      end
-
-      operations.each do |method, args|
-        Logger.log(method, args, dry_run: dry_run)
-        destination.send(method, *args) unless dry_run
-      end
-    end
-  end
-
-  class Generate < Struct.new(:source, :destination)
-    def call
-      source = Provider.from(self.source)
-      destination = Provider.from(self.destination)
-      destination.write(source.read)
-    end
+    ).config[key]
   end
 end
 

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true