dennis-client 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a1f20fe7792d9b35ebd46ef5534abce7aa58e95e0c6d426b8999d88a39d9080
+  data.tar.gz: 26fb26887882aed7c9572e508267a48f9cf62179e3bfbe2c5d26a834f54d3ac8
+SHA512:
+  metadata.gz: 94e51088eb391d0cbe4d0837fe95da4eafb601c9fd42ff0fa2db58727927094868dcab1bdaaa17b68f9f025a1fc5e0b043ca5b12d0d21933a45ce05181957544
+  data.tar.gz: e28bc9ea027f5d667ba87a786b0a986595a20d31c064ccb12c6e870f009c51facbffa445b5fb65f911cab473af29fbd6cdff5521eba6356b4265cb9c531c095f

data/VERSION

@@ -0,0 +1 @@
+1.1.1

data/lib/dennis/client.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'apia_client'
+require 'dennis/group'
+require 'dennis/zone'
+require 'dennis/nameserver'
+require 'dennis/record'
+require 'dennis/record_type'
+
+module Dennis
+  class Client
+
+    attr_reader :hostname
+    attr_reader :api_key
+    attr_reader :api
+
+    def initialize(hostname, api_key, **options)
+      @hostname = hostname
+      @api_key = api_key
+
+      @api = ApiaClient.load(hostname, namespace: 'api/v1', **options)
+      @api.headers['Authorization'] = "Bearer #{api_key}"
+    end
+
+    def record_types
+      RecordType.all(self)
+    end
+
+    def groups(**opts)
+      Group.all(self, **opts)
+    end
+
+    def group(id, field: :id)
+      Group.find_by(self, field, id)
+    end
+
+    def create_group(**opts)
+      Group.create(self, **opts)
+    end
+
+    def zones(**opts)
+      Zone.all(self, **opts)
+    end
+
+    def zone(id, field: :id)
+      Zone.find_by(self, field, id)
+    end
+
+    def record(id, field: :id)
+      Record.find_by(self, field, id)
+    end
+
+    def tagged_records(tags, group: nil)
+      Record.all_by_tag(self, tags, group: group)
+    end
+
+    def nameservers
+      Nameserver.all(self)
+    end
+
+    def nameserver(id, field: :id)
+      Nameserver.find_by(self, field, id)
+    end
+
+    def create_nameserver(**opts)
+      Nameserver.create(self, **opts)
+    end
+
+  end
+end

data/lib/dennis/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dennis
+
+  class Error < StandardError
+  end
+
+  class ExternalReferenceRequiredError < Error
+  end
+
+end

data/lib/dennis/group.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'dennis/nameserver'
+require 'dennis/validation_error'
+
+module Dennis
+  class Group
+
+    class << self
+
+      def all(client, page: nil, per_page: nil)
+        request = client.api.create_request(:get, 'groups')
+        request.arguments[:page] = page if page
+        request.arguments[:per_page] = per_page if per_page
+        PaginatedArray.create(request.perform.hash, 'groups') do |hash|
+          new(client, hash)
+        end
+      end
+
+      def find_by(client, field, value)
+        request = client.api.create_request(:get, 'groups/:group')
+        request.arguments[:group] = { field => value }
+        Group.new(client, request.perform.hash['group'])
+      rescue ApiaClient::RequestError => e
+        e.code == 'group_not_found' ? nil : raise
+      end
+
+      def create(client, name:, external_reference: nil)
+        request = client.api.create_request(:post, 'groups')
+        request.arguments[:properties] = { name: name, external_reference: external_reference }
+        Group.new(client, request.perform.hash['group'])
+      rescue ApiaClient::RequestError => e
+        raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+        raise
+      end
+
+    end
+
+    def initialize(client, hash)
+      @client = client
+      @hash = hash
+    end
+
+    def id
+      @hash['id']
+    end
+
+    def name
+      @hash['name']
+    end
+
+    def external_reference
+      @hash['external_reference']
+    end
+
+    def created_at
+      return nil if @hash['created_at'].nil?
+      return @hash['created_at'] if @hash['created_at'].is_a?(Time)
+
+      Time.at(@hash['created_at'])
+    end
+
+    def updated_at
+      return nil if @hash['updated_at'].nil?
+      return @hash['updated_at'] if @hash['updated_at'].is_a?(Time)
+
+      Time.at(@hash['updated_at'])
+    end
+
+    def nameservers
+      @nameservers ||= @hash['nameservers'].map do |hash|
+        Nameserver.new(@client, hash)
+      end
+    end
+
+    def create_zone(**properties)
+      Zone.create(@client, group: { id: id }, **properties)
+    end
+
+    def create_or_update_zone(**properties)
+      Zone.create_or_update(@client, group: { id: id }, **properties)
+    end
+
+    def zones(**options)
+      Zone.all_for_group(@client, { id: id }, **options)
+    end
+
+    def zone(id, field: :id)
+      zone = Zone.find_by(@client, field, id)
+      return nil if zone.nil?
+      return nil if zone.group.id != self.id
+
+      zone
+    end
+
+    def tagged_records(tags)
+      Record.all_by_tag(@client, tags, group: { id: id })
+    end
+
+    def update(properties)
+      req = @client.api.create_request(:patch, 'groups/:group')
+      req.arguments['group'] = { id: id }
+      req.arguments['properties'] = properties
+      @hash = req.perform.hash['group']
+      true
+    rescue ApiaClient::RequestError => e
+      raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+      raise
+    end
+
+    def delete
+      req = @client.api.create_request(:delete, 'groups/:group')
+      req.arguments['group'] = { id: id }
+      req.perform
+      true
+    end
+
+  end
+end

data/lib/dennis/group_not_found_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'dennis/error'
+
+module Dennis
+  class GroupNotFoundError < Error
+  end
+end

data/lib/dennis/nameserver.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Dennis
+  class Nameserver
+
+    class << self
+
+      def all(client)
+        nameservers = client.api.perform(:get, 'nameservers')
+        nameservers.hash['nameservers'].map { |hash| new(client, hash) }
+      end
+
+      def find_by(client, field, value)
+        request = client.api.create_request(:get, 'nameservers/:nameserver')
+        request.arguments[:nameserver] = { field => value }
+        new(client, request.perform.hash['nameserver'])
+      rescue ApiaClient::RequestError => e
+        e.code == 'nameserver_not_found' ? nil : raise
+      end
+
+      def create(client, name:, server: nil)
+        request = client.api.create_request(:post, 'nameservers')
+        request.arguments[:properties] = { name: name, server: server }
+        new(client, request.perform.hash['nameserver'])
+      rescue ApiaClient::RequestError => e
+        raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+        raise
+      end
+
+    end
+
+    def initialize(client, hash)
+      @client = client
+      @hash = hash
+    end
+
+    def id
+      @hash['id']
+    end
+
+    def name
+      @hash['name']
+    end
+
+    def server
+      @hash['server']
+    end
+
+    def created_at
+      return nil if @hash['created_at'].nil?
+      return @hash['created_at'] if @hash['created_at'].is_a?(Time)
+
+      Time.at(@hash['created_at'])
+    end
+
+    def updated_at
+      return nil if @hash['updated_at'].nil?
+      return @hash['updated_at'] if @hash['updated_at'].is_a?(Time)
+
+      Time.at(@hash['updated_at'])
+    end
+
+    def update(properties)
+      req = @client.api.create_request(:patch, 'nameservers/:nameserver')
+      req.arguments['nameserver'] = { id: id }
+      req.arguments['properties'] = properties
+      @hash = req.perform.hash['nameserver']
+      true
+    rescue ApiaClient::RequestError => e
+      raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+      raise
+    end
+
+    def delete
+      req = @client.api.create_request(:delete, 'nameservers/:nameserver')
+      req.arguments['nameserver'] = { id: id }
+      req.perform
+      true
+    end
+
+  end
+end

data/lib/dennis/paginated_array.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'dennis/pagination'
+
+module Dennis
+  class PaginatedArray < Array
+
+    attr_accessor :pagination
+
+    class << self
+
+      def create(result, key, &block)
+        result_hash = result[key]
+        array = new(result_hash.map(&block))
+        array.pagination = Pagination.new(result['pagination'])
+        array
+      end
+
+    end
+
+  end
+end

data/lib/dennis/pagination.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dennis
+  class Pagination
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def current_page
+      @hash['current_page']
+    end
+
+    def total_pages
+      @hash['total_pages']
+    end
+
+    def total
+      @hash['total']
+    end
+
+    def per_page
+      @hash['per_page']
+    end
+
+    def large_set?
+      @hash['large_set']
+    end
+
+  end
+end

data/lib/dennis/record.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'dennis/error'
+require 'dennis/validation_error'
+require 'dennis/zone_not_found_error'
+
+module Dennis
+  class Record
+
+    class << self
+
+      def all(client, zone, **options)
+        request = client.api.create_request(:get, 'zones/:zone/records')
+        request.arguments[:zone] = zone
+        options.each do |field, value|
+          request.arguments[field] = value
+        end
+        request.perform.hash['records'].map { |hash| new(client, hash) }
+      end
+
+      def all_by_tag(client, tags, group: nil)
+        request = client.api.create_request(:get, 'records/tagged')
+        request.arguments[:tags] = tags
+        request.arguments[:group] = group if group
+        request.perform.hash['records'].map { |hash| new(client, hash) }
+      end
+
+      def find_by(client, field, value)
+        request = client.api.create_request(:get, 'records/:record')
+        request.arguments[:record] = { field => value }
+        new(client, request.perform.hash['record'])
+      rescue ApiaClient::RequestError => e
+        e.code == 'record_not_found' ? nil : raise
+      end
+
+      def create(client, zone:, **properties)
+        request = client.api.create_request(:post, 'records')
+        request.arguments[:zone] = zone
+        request.arguments[:properties] = properties_to_argument(properties)
+        new(client, request.perform.hash['record'])
+      rescue ApiaClient::RequestError => e
+        raise ZoneNotFoundError if e.code == 'zone_not_found'
+        raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+        raise
+      end
+
+      def create_or_update(client, zone_id, **properties)
+        if properties[:external_reference].nil?
+          raise Dennis::ExternalReferenceRequiredError, 'An external_reference must be provided to use create_or_update'
+        end
+
+        record = find_by(client, :external_reference, properties[:external_reference])
+        if record.nil?
+          create(client, zone: { id: zone_id }, **properties)
+        else
+          record.update(properties)
+          record
+        end
+      end
+
+      def properties_to_argument(hash, type: nil)
+        arguments = {}
+        [:name, :type, :ttl, :priority, :external_reference, :tags].each do |field_name|
+          arguments[field_name] = hash[field_name] if hash.key?(field_name)
+
+          type = hash[field_name] if field_name == :type && hash.key?(field_name)
+        end
+
+        if hash.key?(:content)
+          if type.nil?
+            raise Error, 'Cannot generate record properties without a type'
+          end
+
+          arguments[:content] = { type.to_s.upcase => hash[:content] }
+        end
+        arguments
+      end
+
+    end
+
+    def initialize(client, hash)
+      @client = client
+      @hash = hash
+    end
+
+    def id
+      @hash['id']
+    end
+
+    def name
+      @hash['name']
+    end
+
+    def full_name
+      @hash['full_name']
+    end
+
+    def type
+      @hash['type']
+    end
+
+    def ttl
+      @hash['ttl']
+    end
+
+    def priority
+      @hash['priority']
+    end
+
+    def external_reference
+      @hash['external_reference']
+    end
+
+    def managed?
+      @hash['managed']
+    end
+
+    def tags
+      @hash['tags']
+    end
+
+    def created_at
+      return nil if @hash['created_at'].nil?
+      return @hash['created_at'] if @hash['created_at'].is_a?(Time)
+
+      Time.at(@hash['created_at'])
+    end
+
+    def updated_at
+      return nil if @hash['updated_at'].nil?
+      return @hash['updated_at'] if @hash['updated_at'].is_a?(Time)
+
+      Time.at(@hash['updated_at'])
+    end
+
+    def zone
+      return @zone if @zone
+      return nil unless @hash['zone']
+
+      @zone = Zone.new(@client, @hash['zone'])
+    end
+
+    def raw_content
+      @hash['raw_content']
+    end
+
+    def display_content
+      @hash['display_content']
+    end
+
+    def content
+      return nil if type.nil?
+
+      @hash.dig('content', type.to_s.upcase)&.transform_keys(&:to_sym)
+    end
+
+    def update(properties)
+      req = @client.api.create_request(:patch, 'records/:record')
+      req.arguments['record'] = { id: id }
+      req.arguments['properties'] = self.class.properties_to_argument(properties, type: type)
+      @hash = req.perform.hash['record']
+      true
+    rescue ApiaClient::RequestError => e
+      raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+      raise
+    end
+
+    def delete
+      req = @client.api.create_request(:delete, 'records/:record')
+      req.arguments['record'] = { id: id }
+      req.perform
+      true
+    end
+
+  end
+end

data/lib/dennis/record_type.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Dennis
+  class RecordType
+
+    class << self
+
+      def all(client)
+        request = client.api.create_request(:get, 'record_types')
+        request.perform.hash['record_types'].each_with_object({}) do |rt, hash|
+          type = new(rt)
+          hash[type.name] = type
+        end
+      end
+
+    end
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def name
+      @hash['name']
+    end
+
+    def requires_priority?
+      @hash['requires_priority'] == true
+    end
+
+    def managed_only?
+      @hash['managed_only'] == true
+    end
+
+    def exposed?
+      @hash['exposed'] == true
+    end
+
+    def content_attributes
+      @hash['content_attributes'].map do |hash|
+        ContentAttribute.new(hash)
+      end
+    end
+
+    class ContentAttribute
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def name
+        @hash['name']
+      end
+
+      def label
+        @hash['label']
+      end
+
+      def type
+        @hash['type']
+      end
+
+      def options
+        return [] if @hash['options'].nil?
+
+        @hash['options'].map do |hash|
+          ContentAttributeOption.new(hash)
+        end
+      end
+
+    end
+
+    class ContentAttributeOption
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def label
+        @hash['label']
+      end
+
+      def value
+        @hash['value']
+      end
+
+    end
+
+  end
+end

data/lib/dennis/validation_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dennis/error'
+require 'dennis/validation_error_detail'
+
+module Dennis
+  class ValidationError < Error
+
+    attr_reader :errors
+
+    def initialize(errors)
+      super
+      @errors = errors.map { |e| ValidationErrorDetail.new(e) }
+    end
+
+    def to_s
+      "Validation error: #{errors.map(&:message).join(', ')}"
+    end
+
+  end
+end

data/lib/dennis/validation_error_detail.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Dennis
+  class ValidationErrorDetail
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def attribute
+      @hash['attribute']
+    end
+
+    def type
+      @hash['type']
+    end
+
+    def message
+      @hash['message']
+    end
+
+  end
+end

data/lib/dennis/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Dennis
+
+  VERSION_FILE_ROOT = File.expand_path('../../VERSION', __dir__)
+  if File.file?(VERSION_FILE_ROOT)
+    VERSION = File.read(VERSION_FILE_ROOT).strip.sub(/\Av/, '')
+  else
+    VERSION = '0.0.0.dev'
+  end
+
+end

data/lib/dennis/zone.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'dennis/validation_error'
+require 'dennis/group_not_found_error'
+require 'dennis/record'
+require 'dennis/paginated_array'
+
+module Dennis
+  class Zone
+
+    class << self
+
+      def all(client, query: nil, view: nil, tags: nil, page: nil, per_page: nil)
+        request = client.api.create_request(:get, 'zones')
+        request.arguments[:query] = query if query
+        request.arguments[:view] = view if view
+        request.arguments[:tags] = tags if tags
+        request.arguments[:page] = page if page
+        request.arguments[:per_page] = per_page if per_page
+        PaginatedArray.create(request.perform.hash, 'zones') do |hash|
+          new(client, hash)
+        end
+      end
+
+      def all_for_group(client, group, query: nil, view: nil, tags: nil, page: nil, per_page: nil)
+        request = client.api.create_request(:get, 'groups/:group/zones')
+        request.arguments[:group] = group
+        request.arguments[:query] = query if query
+        request.arguments[:view] = view if view
+        request.arguments[:tags] = tags if tags
+        request.arguments[:page] = page if page
+        request.arguments[:per_page] = per_page if per_page
+        PaginatedArray.create(request.perform.hash, 'zones') do |hash|
+          new(client, hash)
+        end
+      end
+
+      def find_by(client, field, value)
+        request = client.api.create_request(:get, 'zones/:zone')
+        request.arguments[:zone] = { field => value }
+        new(client, request.perform.hash['zone'])
+      rescue ApiaClient::RequestError => e
+        e.code == 'zone_not_found' ? nil : raise
+      end
+
+      def create(client,
+                 group:,
+                 allow_sub_domains_of_zones_in_other_groups: nil,
+                 **properties)
+        request = client.api.create_request(:post, 'zones')
+        request.arguments[:group] = group
+        request.arguments[:properties] = properties
+        unless allow_sub_domains_of_zones_in_other_groups.nil?
+          request.arguments[:allow_sub_domains_of_zones_in_other_groups] = allow_sub_domains_of_zones_in_other_groups
+        end
+        new(client, request.perform.hash['zone'])
+      rescue ApiaClient::RequestError => e
+        raise GroupNotFoundError if e.code == 'group_not_found'
+        raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+        raise
+      end
+
+      def create_or_update(client, group:, **properties)
+        if properties[:external_reference].nil?
+          raise Dennis::ExternalReferenceRequiredError, 'An external_reference must be provided to use create_or_update'
+        end
+
+        zone = find_by(client, :external_reference, properties[:external_reference])
+        if zone.nil?
+          create(client, group: group, **properties)
+        else
+          zone.update(properties)
+          zone
+        end
+      end
+
+    end
+
+    def initialize(client, hash)
+      @client = client
+      @hash = hash
+    end
+
+    def id
+      @hash['id']
+    end
+
+    def name
+      @hash['name']
+    end
+
+    def external_reference
+      @hash['external_reference']
+    end
+
+    def nameservers_verified_at
+      parse_time(@hash['nameservers_verified_at'])
+    end
+
+    def nameservers_checked_at
+      parse_time(@hash['nameservers_checked_at'])
+    end
+
+    def nameservers_verified?
+      @hash['nameservers_verified']
+    end
+
+    def verified?
+      @hash['verified']
+    end
+
+    def always_verified?
+      @hash['always_verified']
+    end
+
+    def reverse_dns?
+      @hash['reverse_dns']
+    end
+
+    def stale_verification?
+      @hash['stale_verification']
+    end
+
+    def default_ttl
+      @hash['default_ttl']
+    end
+
+    def tags
+      @hash['tags']
+    end
+
+    def group
+      return @group if @group
+      return nil unless @hash['group']
+
+      @group = Group.new(@client, @hash['group'])
+    end
+
+    def created_at
+      return nil if @hash['created_at'].nil?
+      return @hash['created_at'] if @hash['created_at'].is_a?(Time)
+
+      Time.at(@hash['created_at'])
+    end
+
+    def updated_at
+      return nil if @hash['updated_at'].nil?
+      return @hash['updated_at'] if @hash['updated_at'].is_a?(Time)
+
+      Time.at(@hash['updated_at'])
+    end
+
+    def create_record(**properties)
+      Record.create(@client, zone: { id: id }, **properties)
+    end
+
+    def create_or_update_record(**properties)
+      Record.create_or_update(@client, id, **properties)
+    end
+
+    def records(**options)
+      Record.all(@client, { id: id }, **options)
+    end
+
+    def record(value, field: :id)
+      record = Record.find_by(@client, field, value)
+      return nil if record.nil?
+      return nil if record.zone.id != id
+
+      record
+    end
+
+    def update(properties)
+      req = @client.api.create_request(:patch, 'zones/:zone')
+      req.arguments['zone'] = { id: id }
+      req.arguments['properties'] = properties
+      @hash = req.perform.hash['zone']
+      true
+    rescue ApiaClient::RequestError => e
+      raise ValidationError, e.detail['errors'] if e.code == 'validation_error'
+
+      raise
+    end
+
+    def delete
+      req = @client.api.create_request(:delete, 'zones/:zone')
+      req.arguments['zone'] = { id: id }
+      req.perform
+      true
+    end
+
+    def verify_nameservers
+      req = @client.api.create_request(:post, 'zones/:zone/verify_nameservers')
+      req.arguments['zone'] = { id: id }
+      @hash = req.perform.hash['zone']
+      verified?
+    rescue ApiaClient::RequestError => e
+      raise unless e.code == 'nameservers_already_verified'
+
+      true
+    end
+
+    private
+
+    def parse_time(time)
+      return nil if time.nil?
+      return time if time.is_a?(Time)
+
+      Time.at(time.to_i)
+    end
+
+  end
+end

data/lib/dennis/zone_not_found_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'dennis/error'
+
+module Dennis
+  class ZoneNotFoundError < Error
+  end
+end

data/lib/dennis-client.rb

@@ -0,0 +1,5 @@
+# rubocop:disable Naming/FileName
+# frozen_string_literal: true
+
+require 'dennis'
+# rubocop:enable Naming/FileName

data/lib/dennis.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'dennis/client'
+
+module Dennis
+
+  class << self
+
+    def new(hostname, api_key)
+      Client.new(hostname, api_key)
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: dennis-client
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: apia-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A client library for talking to the Dennis DNS API.
+email:
+- adam@krystal.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- lib/dennis-client.rb
+- lib/dennis.rb
+- lib/dennis/client.rb
+- lib/dennis/error.rb
+- lib/dennis/group.rb
+- lib/dennis/group_not_found_error.rb
+- lib/dennis/nameserver.rb
+- lib/dennis/paginated_array.rb
+- lib/dennis/pagination.rb
+- lib/dennis/record.rb
+- lib/dennis/record_type.rb
+- lib/dennis/validation_error.rb
+- lib/dennis/validation_error_detail.rb
+- lib/dennis/version.rb
+- lib/dennis/zone.rb
+- lib/dennis/zone_not_found_error.rb
+homepage: https://github.com/krystal/dennis-client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: A client library for talking to the Dennis DNS API.
+test_files: []