zonesync 0.12.1 → 0.13.0

data/lib/zonesync/parser.rb

@@ -1,5 +1,4 @@
-# typed: true
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 require "treetop"
 Treetop.load File.join(__dir__, "zonefile")
@@ -7,7 +6,7 @@ Treetop.load File.join(__dir__, "zonefile")
 module Zonesync
   class Parser
     def self.parse(zone_string)
-      parser = T.unsafe(ZonefileParser).new
+      parser = ZonefileParser.new
       result = parser.parse(zone_string)
       if !result
         puts zone_string
@@ -90,7 +89,7 @@ module Zonesync
       attr_accessor :comment, :host
 
       def type
-        T.must(self.class.name).split("::").last
+        self.class.name.split("::").last
       end
 
       attr_reader :rdata
@@ -334,4 +333,3 @@ module Zonesync
     end
   end
 end
-

data/lib/zonesync/provider.rb

@@ -1,5 +1,4 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 require "zonesync/record"
 require "zonesync/zonefile"
@@ -9,91 +8,70 @@ require "zonesync/validator"
 
 module Zonesync
   class Provider
-    extend T::Sig
-
-    sig { params(config: T::Hash[Symbol, String]).void }
-    def initialize config
-      @config = T.let(config, T::Hash[Symbol, String])
+    def initialize(config)
+      @config = config
     end
-    sig { returns(T::Hash[Symbol, String]) }
     attr_reader :config
 
-    sig { params(config: T::Hash[Symbol, String]).returns(Provider) }
-    def self.from config
+    def self.from(config)
       Zonesync.const_get(config.fetch(:provider)).new(config)
     end
 
-    sig { params(other: Provider, force: T::Boolean).returns(T::Array[Operation]) }
-    def diff! other, force: false
+    def diff!(other, force: false)
       operations = diff(other).call
       Validator.call(operations, self, other, force: force)
       operations
     end
 
-    sig { params(other: Provider).returns(Diff) }
-    def diff other
+    def diff(other)
       Diff.new(
         from: diffable_records,
         to: other.diffable_records,
       )
     end
 
-    sig { returns(T::Array[Record]) }
     def records
       zonefile.records
     end
 
-    sig { returns(T::Array[Record]) }
     def diffable_records
       records.select do |record|
         manifest.diffable?(record)
       end.sort
     end
 
-    sig { returns(Manifest) }
     def manifest
       Manifest.new(records, zonefile)
     end
 
-    sig { returns(Zonefile) }
     private def zonefile
-      @zonefile ||= T.let(Zonefile.load(read), T.nilable(Zonefile))
+      @zonefile ||= Zonefile.load(read)
     end
 
-    sig { returns(String) }
     def read
-      Kernel.raise NotImplementedError
+      raise NotImplementedError
     end
 
-    sig { params(string: String).void }
-    def write string
-      Kernel.raise NotImplementedError
+    def write(string)
+      raise NotImplementedError
     end
 
-    sig { params(record: Record).void }
-    def remove record
-      Kernel.raise NotImplementedError
+    def remove(record)
+      raise NotImplementedError
     end
 
-    sig { params(old_record: Record, new_record: Record).void }
-    def change old_record, new_record
-      Kernel.raise NotImplementedError
+    def change(old_record, new_record)
+      raise NotImplementedError
     end
 
-    sig { params(record: Record).void }
-    def add record
-      Kernel.raise NotImplementedError
+    def add(record)
+      raise NotImplementedError
     end
 
-    # Helper method for graceful duplicate record handling
-    # Child classes can use this in their add method implementations
-    sig { params(record: Record, block: T.proc.void).void }
-    def add_with_duplicate_handling record, &block
+    def add_with_duplicate_handling(record, &block)
       begin
         block.call
       rescue DuplicateRecordError => e
-        # Gracefully handle duplicate records - this means the record
-        # already exists and we just want to start tracking it
         puts "Record already exists in #{self.class.name}: #{e.record.name} #{e.record.type} - will start tracking it"
         return
       end
@@ -101,7 +79,6 @@ module Zonesync
 
     private
 
-    sig { params(remote_records: T::Array[Record], expected_hashes: T::Array[String]).returns(T::Array[Record]) }
     def hash_based_diffable_records(remote_records, expected_hashes)
       require 'set'
       expected_set = Set.new(expected_hashes)
@@ -129,33 +106,24 @@ module Zonesync
   require "zonesync/route53"
 
   class Memory < Provider
-    extend T::Sig
-
-    sig { returns(String) }
     def read
       config.fetch(:string)
     end
 
-    sig { params(string: String).void }
-    def write string
+    def write(string)
       config[:string] = string
       nil
     end
   end
 
   class Filesystem < Provider
-    extend T::Sig
-
-    sig { returns(String) }
     def read
       File.read(config.fetch(:path))
     end
 
-    sig { params(string: String).void }
-    def write string
+    def write(string)
       File.write(config.fetch(:path), string)
       nil
     end
   end
 end
-

data/lib/zonesync/record.rb

@@ -1,12 +1,11 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 module Zonesync
   Record = Struct.new(:name, :type, :ttl, :rdata, :comment, keyword_init: true) do
-    extend T::Sig
+    # Make Record immutable by removing setters
+    undef_method :name=, :type=, :ttl=, :rdata=, :comment=, :[]=
 
-    sig { params(record: Zonesync::Parser::Record).returns(Record) }
-    def self.from_dns_zonefile_record record
+    def self.from_dns_zonefile_record(record)
       new(
         name: record.host,
         type: record.type,
@@ -16,50 +15,42 @@ module Zonesync
       )
     end
 
-    sig { params(origin: String).returns(String) }
-    def short_name origin
+    def short_name(origin)
       ret = name.sub(origin, "")
       ret = ret.sub(/\.$/, "")
       ret = "@" if ret == ""
       ret
     end
 
-    sig { returns(T::Boolean) }
     def manifest?
       type == "TXT" &&
         name.match?(/^zonesync_manifest\./)
     end
 
-    sig { returns(T::Boolean) }
     def checksum?
       type == "TXT" &&
         name.match?(/^zonesync_checksum\./)
     end
 
-    sig { params(other: Record).returns(Integer) }
-    def <=> other
+    def <=>(other)
       to_sortable <=> other.to_sortable
     end
 
-    sig { returns([Integer, String, String, String, Integer]) }
     def to_sortable
       is_soa = type == "SOA" ? 0 : 1
       [is_soa, type, name, rdata, ttl.to_i]
     end
 
-    sig { returns(String) }
     def to_s
       string = [name, ttl, type, rdata].join(" ")
       string << " ; #{comment}" if comment
       string
     end
 
-    sig { params(other: Record).returns(T::Boolean) }
     def identical_to?(other)
       name == other.name && type == other.type && ttl == other.ttl && rdata == other.rdata
     end
 
-    sig { params(other: Record).returns(T::Boolean) }
     def conflicts_with?(other)
       return false unless name == other.name && type == other.type
 
@@ -75,15 +66,12 @@ module Zonesync
       end
     end
 
-    sig { params(type: String).returns(T::Boolean) }
     def self.single_record_per_name?(type)
       type == "CNAME" || type == "SOA"
     end
 
-    sig { params(records: T::Array[Record]).returns(T::Array[Record]) }
     def self.non_meta(records)
       records.reject { |r| r.manifest? || r.checksum? }
     end
   end
 end
-

data/lib/zonesync/record_hash.rb

@@ -1,15 +1,12 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
+
 require "zlib"
 
 module Zonesync
   module RecordHash
-    extend T::Sig
-
-    sig { params(record: Record).returns(String) }
     def self.generate(record)
       identity = "#{record.name}:#{record.type}:#{record.ttl}:#{record.rdata}"
       Zlib.crc32(identity).to_s(36)
     end
   end
-end
+end

data/lib/zonesync/route53.rb

@@ -1,5 +1,4 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 require "zonesync/record"
 require "zonesync/http"
@@ -8,9 +7,7 @@ require "erb"
 
 module Zonesync
   class Route53 < Provider
-    sig { returns(String) }
     def read
-      @read = T.let(@read, T.nilable(String))
       @read ||= begin
         doc = REXML::Document.new(http.get(""))
         records = doc.elements.collect("*/ResourceRecordSets/ResourceRecordSet") do |record_set|
@@ -20,7 +17,6 @@ module Zonesync
       end
     end
 
-    sig { params(record: Record).void }
     def remove(record)
       if record.type == "TXT"
         # Route53 requires all TXT records with the same name to be managed together
@@ -76,13 +72,11 @@ module Zonesync
       end
     end
 
-    sig { params(old_record: Record, new_record: Record).void }
     def change(old_record, new_record)
       remove(old_record)
       add(new_record)
     end
 
-    sig { params(record: Record).void }
     def add(record)
       add_with_duplicate_handling(record) do
         begin
@@ -113,7 +107,6 @@ module Zonesync
 
     private
 
-    sig { params(action: String, record: Record).void }
     def change_record(action, record)
       http.post("", <<~XML)
         <?xml version="1.0" encoding="UTF-8"?>
@@ -139,7 +132,6 @@ module Zonesync
       XML
     end
 
-    sig { params(action: String, records_list: T::Array[Record]).void }
     def change_records(action, records_list)
       # Group records by name and type to handle multiple values
       grouped = records_list.group_by { |r| [r.name, r.type, r.ttl] }
@@ -172,7 +164,6 @@ module Zonesync
       XML
     end
 
-    sig { params(el: REXML::Element).returns(T::Array[Record]) }
     def to_records(el)
       el.elements.collect("ResourceRecords/ResourceRecord") do |rr|
         name = normalize_trailing_period(get_value(el, "Name"))
@@ -181,38 +172,34 @@ module Zonesync
         rdata = get_value(rr, "Value")
 
         record = Record.new(
-          name:,
-          type:,
-          ttl:,
-          rdata:,
+          name: name,
+          type: type,
+          ttl: ttl,
+          rdata: rdata,
           comment: nil, # Route 53 does not have a direct comment field
         )
       end
     end
 
-    sig { params(el: REXML::Element, field: String).returns(String) }
-    def get_value el, field
+    def get_value(el, field)
       el.elements[field].text.gsub(/\\(\d{3})/) { $1.to_i(8).chr } # unescape octal
     end
 
-    sig { params(value: String).returns(String) }
     def normalize_trailing_period(value)
       value =~ /\.$/ ? value : value + "."
     end
 
-    sig { returns(HTTP) }
     def http
       return @http if @http
-      @http = T.let(HTTP.new("https://route53.amazonaws.com/2013-04-01/hostedzone/#{config.fetch(:hosted_zone_id)}/rrset"), T.nilable(Zonesync::HTTP))
-      T.must(@http).before_request do |request, uri, body|
+      @http = HTTP.new("https://route53.amazonaws.com/2013-04-01/hostedzone/#{config.fetch(:hosted_zone_id)}/rrset")
+      @http.before_request do |request, uri, body|
         request["Content-Type"] = "application/xml"
         request["X-Amz-Date"] = Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
         request["Authorization"] = sign_request(request.method, uri, body)
       end
-      T.must(@http)
+      @http
     end
 
-    sig { params(method: String, uri: URI::HTTPS, body: T.nilable(String)).returns(String) }
     def sign_request(method, uri, body)
       service = "route53"
       date = Time.now.utc.strftime("%Y%m%d")
@@ -246,7 +233,6 @@ module Zonesync
       "#{algorithm} Credential=#{config.fetch(:aws_access_key_id)}/#{credential_scope}, SignedHeaders=#{signed_headers}, Signature=#{signature}"
     end
 
-    sig { params(key: String, date_stamp: String, region_name: String, service_name: String).returns(String) }
     def get_signature_key(key, date_stamp, region_name, service_name)
       k_date = OpenSSL::HMAC.digest("SHA256", "AWS4" + key, date_stamp)
       k_region = OpenSSL::HMAC.digest("SHA256", k_date, region_name)
@@ -255,4 +241,3 @@ module Zonesync
     end
   end
 end
-

data/lib/zonesync/sync.rb

@@ -1,14 +1,10 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 require "zonesync/logger"
 
 module Zonesync
   Sync = Struct.new(:source, :destination) do
-    extend T::Sig
-
-    sig { params(dry_run: T::Boolean, force: T::Boolean).void }
-    def call dry_run: false, force: false
+    def call(dry_run: false, force: false)
       operations = destination.diff!(source, force: force)
 
       smanifest = source.manifest.generate

data/lib/zonesync/validator.rb

@@ -1,17 +1,13 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
+
 require "zonesync/record_hash"
 
 module Zonesync
   Validator = Struct.new(:operations, :destination, :source) do
-    extend T::Sig
-
-    sig { params(operations: T::Array[Operation], destination: Provider, source: T.nilable(Provider), force: T::Boolean).void }
     def self.call(operations, destination, source = nil, force: false)
       new(operations, destination, source).call(force: force)
     end
 
-    sig { params(force: T::Boolean).void }
     def call(force: false)
       validation_error = ValidationError.new
 
@@ -44,14 +40,12 @@ module Zonesync
 
     private
 
-    sig { returns(Manifest) }
     def manifest
       destination.manifest
     end
 
-    sig { returns(T.nilable(ChecksumMismatchError)) }
     def validate_v2_manifest_integrity
-      manifest_data = T.must(manifest.existing).rdata[1..-2]
+      manifest_data = manifest.existing.rdata[1..-2]
       expected_hashes = manifest_data.split(",")
       actual_records = Record.non_meta(destination.records)
       actual_hash_to_record = actual_records.map { |r| [RecordHash.generate(r), r] }.to_h
@@ -69,7 +63,6 @@ module Zonesync
       )
     end
 
-    sig { params(missing_hash: String).returns(T.nilable(Record)) }
     def find_expected_record(missing_hash)
       return nil unless source
 
@@ -77,7 +70,6 @@ module Zonesync
       source_records.find { |r| RecordHash.generate(r) == missing_hash }
     end
 
-    sig { params(expected_record: T.nilable(Record), actual_records: T::Array[Record]).returns(T.nilable(Record)) }
     def find_modified_record(expected_record, actual_records)
       return nil unless expected_record
 
@@ -96,8 +88,7 @@ module Zonesync
       end
     end
 
-    sig { params(record: Record, force: T::Boolean).returns(T.nilable([T.nilable(Record), Record])) }
-    def validate_addition record, force: false
+    def validate_addition(record, force: false)
       return nil if manifest.matches?(record)
       return nil if force
 
@@ -115,7 +106,6 @@ module Zonesync
       [conflicting_record, record]
     end
 
-    sig { params(record: Record, expected_hashes: T::Array[String]).returns(T.nilable(Record)) }
     def find_v2_conflict(record, expected_hashes)
       destination.records.find do |r|
         next if r.manifest? || r.checksum?
@@ -126,7 +116,6 @@ module Zonesync
       end
     end
 
-    sig { params(record: Record).returns(T.nilable(Record)) }
     def find_v1_conflict(record)
       shorthand = manifest.shorthand_for(record, with_type: true)
       destination.records.find do |r|
@@ -134,7 +123,6 @@ module Zonesync
       end
     end
 
-    sig { params(record: Record).returns(T.nilable(Record)) }
     def find_unmanaged_conflict(record)
       destination.records.find do |r|
         r.identical_to?(record)
@@ -142,4 +130,3 @@ module Zonesync
     end
   end
 end
-

data/lib/zonesync/version.rb

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

data/lib/zonesync/zonefile.rb

@@ -1,13 +1,9 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 require "zonesync/parser"
 
 module Zonesync
   class Zonefile
-    extend T::Sig
-
-    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")
@@ -19,16 +15,12 @@ module Zonesync
       new(records, origin: zone.origin)
     end
 
-    sig { params(records: T::Array[Zonesync::Record], origin: String).void }
-    def initialize records, origin:
+    def initialize(records, origin:)
       @records = records
       @origin = origin
     end
 
-    sig { returns(T::Array[Zonesync::Record]) }
     attr_reader :records
-
-    sig { returns(String) }
     attr_reader :origin
   end
 end

data/lib/zonesync.rb

@@ -1,5 +1,4 @@
-# typed: strict
-require "sorbet-runtime"
+# frozen_string_literal: true
 
 require "zonesync/sync"
 require "zonesync/generate"
@@ -16,29 +15,21 @@ begin # optional active_support dependency
 rescue LoadError; end
 
 module Zonesync
-  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
+  def self.call(source: "Zonefile", destination: "zonesync", dry_run: false, force: false)
     Sync.new(
       Provider.from({ provider: "Filesystem", path: source }),
-      Provider.from(credentials(destination)),
+      Provider.from(credentials(destination.to_sym)),
     ).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
+  def self.generate(source: "zonesync", destination: "Zonefile")
     Generate.new(
-      Provider.from(credentials(source)),
-      Provider.from({ provider: "Filesystem", path: T.must(destination) }),
+      Provider.from(credentials(source.to_sym)),
+      Provider.from({ provider: "Filesystem", path: destination }),
     ).call
   end
 
-  sig { params(key: Symbol).returns(T::Hash[Symbol, String]) }
-  def self.credentials key
+  def self.credentials(key)
     ActiveSupport::EncryptedConfiguration.new(
       config_path: "config/credentials.yml.enc",
       key_path: "config/master.key",
@@ -47,4 +38,3 @@ module Zonesync
     ).config[key]
   end
 end
-

data/zonesync.gemspec

@@ -29,11 +29,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "thor", "~>1.0"
   spec.add_dependency "treetop", "~>1.6"
-  spec.add_dependency "sorbet-runtime"
 
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "webmock"
-  spec.add_development_dependency "sorbet"
-  spec.add_development_dependency "tapioca"
 end