porkbun 0.5.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cf1f7fe28b5a9b974cf289160cd9f7c8b12bd4547e2814ba6d50e99a6d1feb3
-  data.tar.gz: 5e3514fa7eecd74e9572d34c123af1953d6daaba34359184c2934adc62e20f22
+  metadata.gz: 0d5e8faabfe0bc6179bdb965bb3d2150e40a8ef4be37d70e16ea625b6ed1d653
+  data.tar.gz: 1044c9005c5ebbe24ac2c2478e70d87638ff68d034c05b78baa26913de8b15a8
 SHA512:
-  metadata.gz: a11ad716a955f544a22c59f3c2bcad9bdb44bd310aee0d7c53427457c051ee5fb48ae6867e41db2e82c85abe2ee16e1a8a7f8659d23fa541db8a0ca920b024e7
-  data.tar.gz: 802ccbc80c9082e90f357e83cd54da76e90aac3cffb28eb09857875c2bad71081f9b43d0815a547b003abec470c30fd43c476841c685f2c611bd543f68e57c76
+  metadata.gz: 352e4fe4edb99376d3965018027d4b06e6881d0bb9f20b2e34f0d41c210b2239fa79807692d3a554ebcab03f24d223299da1cf1acd140c64ff0dfdfbfdb56b43
+  data.tar.gz: bae37bcc7ee6640c7e3bab4576abfa1d97b092dea3041677cb70414e47b472ec193db9033c85dd1a5d4151a7785c391c07e3aa26c9310fbe6014237cf156885a

data/AGENTS.md

@@ -0,0 +1,41 @@
+# Porkbun Ruby Agent Guide
+
+This repository contains a Ruby gem and CLI for the Porkbun API. The project is a partial implementation focused on the author's needs.
+
+## Rules
+
+- Read the relevant Ruby source and tests before changing behavior.
+- Implement behavior in the local library API (`lib/`), not in the CLI. Keep CLI commands as thin argument and output adapters.
+- Keep changes focused. Do not add speculative features or refactors.
+- Add or update RSpec coverage for behavior changes.
+- Run the test suite after every code modification and before every commit. Report the result.
+- Update `README.md` every time you change code. Keep it in sync with the current API, CLI, and usage after every code modification; do not defer documentation updates. Update `CHANGELOG.md` with every user-facing change.
+- Before bumping any dependency or project version, actually check the current latest release in an authoritative package registry. Do not rely on memory, an old lockfile, or an assumed version.
+- Treat API and CLI renames as breaking changes. Update the major version when they remove or rename public behavior.
+- Absolutely never commit, push, or change shared Git state unless the user explicitly instructs you to do so.
+
+## Structure
+
+- `lib/` — gem implementation.
+- `bin/` — executable scripts, including the CLI.
+- `spec/` — RSpec tests.
+- `README.md` — usage, API, CLI, and development documentation.
+- `.github/workflows/` — CI configuration.
+
+## Commands
+
+- Install dependencies: `bin/setup`
+- Run tests: `bundle exec rake` or `bundle exec rspec`
+- Open a console: `bin/console`
+- Install the gem locally: `bundle exec rake install`
+- Release the gem: `bundle exec rake release`
+
+## Documentation routing
+
+| Topic | Document |
+| --- | --- |
+| Usage, API, CLI, development, and contributing | [README.md](README.md) |
+
+## Documentation and changelog
+
+Update the relevant documentation and `CHANGELOG.md` with each user-facing change. Keep entries short and factual. If a change needs a design note, explain the decision and its impact in the relevant documentation.

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+## [2.0.0] - 2026-09-18
+
+- Removed the CLI `list` and `retrieve` commands and replaced them with the single `ls` command for listing domains or retrieving records for a domain and optional record ID.
+- Renamed the CLI `create` command to `add` and `delete_all` to `rm_rf`.
+- Added the `rm` CLI command for deleting one unambiguous record by hostname, with or without a trailing dot.
+- Added the `update` CLI command, with `up` as an alias, to change record content or TTL.
+- Replaced the public `Porkbun::DNS.retrieve` API with `Porkbun::Domain.list`.
+- Added `Porkbun.new(domain)` domain objects and `Porkbun::Record` objects for record retrieval, creation, update, and deletion.
+- Added `Porkbun::Domain#zone_file`, `Porkbun::Domain.import`, and explicit `get_record` naming.
+- Added RSpec coverage for `Porkbun::Domain.list`.
+- Updated Thor to `1.5.0`.
+- Fixed `--help` handling for CLI commands.
+- Added project guidance in `AGENTS.md` and `CLAUDE.md`.
+- Removed the external `http` dependency in favor of Ruby's standard library.
+- Raised the minimum supported Ruby version to `3.2.0`.
+- Updated development dependencies to their latest compatible releases.

data/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

data/Gemfile

@@ -5,11 +5,9 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in porkbun.gemspec
 gemspec
 
-group :development do
-  # gem "rake", "~> 13.0", :group => :test
-  gem 'pry', '~> 0.14.2', group: :test
-  gem 'rspec', '~> 3.12', group: :test
-  gem 'webmock', '~> 3.19', group: :test
+group :development, :test do
+  gem 'rake', '~> 13.4'
+  gem 'pry', '~> 0.16'
+  gem 'rspec', '~> 3.13'
+  gem 'webmock', '~> 3.26'
 end
-
-gem 'thor', '~> 1.2'

data/Gemfile.lock

@@ -1,76 +1,60 @@
 PATH
   remote: .
   specs:
-    porkbun (0.4.0)
-      http (~> 5.1.1)
-      thor (~> 1.2)
+    porkbun (2.0.0)
+      thor (~> 1.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.8.5)
-      public_suffix (>= 2.0.2, < 6.0)
+    addressable (2.9.0)
+      public_suffix (>= 2.0.2, < 8.0)
+    bigdecimal (4.1.3)
     coderay (1.1.3)
-    crack (0.4.5)
+    crack (1.0.1)
+      bigdecimal
       rexml
-    diff-lcs (1.5.0)
-    domain_name (0.5.20190701)
-      unf (>= 0.0.5, < 1.0.0)
-    ffi (1.15.5)
-    ffi-compiler (1.0.1)
-      ffi (>= 1.0.0)
-      rake
-    hashdiff (1.0.1)
-    http (5.1.1)
-      addressable (~> 2.8)
-      http-cookie (~> 1.0)
-      http-form_data (~> 2.2)
-      llhttp-ffi (~> 0.4.0)
-    http-cookie (1.0.5)
-      domain_name (~> 0.5)
-    http-form_data (2.3.0)
-    llhttp-ffi (0.4.0)
-      ffi-compiler (~> 1.0)
-      rake (~> 13.0)
-    method_source (1.0.0)
-    pry (0.14.2)
+    diff-lcs (1.6.2)
+    hashdiff (1.2.1)
+    io-console (0.9.4)
+    method_source (1.1.0)
+    pry (0.16.0)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    public_suffix (5.0.3)
-    rake (13.0.6)
-    rexml (3.2.6)
-    rspec (3.12.0)
-      rspec-core (~> 3.12.0)
-      rspec-expectations (~> 3.12.0)
-      rspec-mocks (~> 3.12.0)
-    rspec-core (3.12.2)
-      rspec-support (~> 3.12.0)
-    rspec-expectations (3.12.3)
+      reline (>= 0.6.0)
+    public_suffix (7.0.5)
+    rake (13.4.2)
+    reline (0.7.0)
+      io-console (~> 0.5)
+    rexml (3.4.4)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.6)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-support (3.12.1)
-    thor (1.2.2)
-    unf (0.1.4)
-      unf_ext
-    unf_ext (0.0.8.2)
-    webmock (3.19.1)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    thor (1.5.0)
+    webmock (3.26.4)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
-  arm64-darwin-22
-  arm64-darwin-23
+  ruby
 
 DEPENDENCIES
   porkbun!
-  pry (~> 0.14.2)
-  rspec (~> 3.12)
-  thor (~> 1.2)
-  webmock (~> 3.19)
+  pry (~> 0.16)
+  rake (~> 13.4)
+  rspec (~> 3.13)
+  webmock (~> 3.26)
 
 BUNDLED WITH
    2.4.12

data/README.md

@@ -14,11 +14,18 @@ need a specific call to be implemented, let me know, or submit a PR
 ```ruby
 ENV['PORKBUN_API_KEY'] = 'YOUR_API_KEY'
 ENV['PORKBUN_SECRET_API_KEY'] = 'YOUR_SECRET_API_KEY'
-record = Porkbun::DNS.create(name: 'test',
+domain = Porkbun.new('domain.org')
+
+domain.records.each { |record| puts record.to_s }
+
+record = domain.create_record('test',
   type: 'A',
   content: '1.1.1.1',
   ttl: 300
 )
+record.update(content: '8.8.8.8')
+record.delete
+
 ```
 
 ## API
@@ -27,22 +34,60 @@ record = Porkbun::DNS.create(name: 'test',
 
 Make sure your keys are good.
 
-### `Porkbun::DNS.retrieve(domain, id)`
+## Classes
+
+### `Porkbun::Domain`
+
+#### class methods
 
-Retrive all or specific record for a domain
+- `all` - returns an array of `Porkbun::Domain` objects for each domain in the account.
+- `create_record(hostname, options)` - returns a `Porkbun::Record` created from a full hostname.
+- `get_record(hostname)` - returns one unambiguous `Porkbun::Record`.
+- `import(file)` - returns an array of `Porkbun::Record` objects created from a zone file.
+- `update_dynamic(hostname, ip)` - returns a hash describing the created or updated record.
 
-### `Porkbun::DNS.create(options)`
+```ruby
+Porkbun::Domain.all.each { |domain| puts domain }
+record = Porkbun::Domain.get_record('www.domain.org')
+record.update(content: '8.8.8.8')
+```
+
+#### instance methods
 
-Create record for a domain
+`Porkbun.new('domain.org')` returns a `Porkbun::Domain` object.
 
-options:
-- `name` - name of record. example `www`
-- `type` - record type. example: CNAME
-- `content` - content of record. example '1.1.1.1',
-- `ttl` - time to live. example: 600. porkbun seems to have this as a minimum
-- `prio` - record priority. mainly for MX records. example 10.
+- `records` - returns an array of `Porkbun::Record` objects for the domain.
+- `get_record(name)` - returns one unambiguous `Porkbun::Record`; `name` can be relative or fully qualified.
+- `create_record(name, options)` - returns a new `Porkbun::Record`.
+- `delete_all_records` - returns an array of `Porkbun::Record` objects after deleting all non-NS records.
+- `zone_file` - returns a string that can be passed to `import`.
+
+```ruby
+domain = Porkbun.new('domain.org')
+record = domain.get_record('www')
+record.update(content: '8.8.8.8')
+record.delete
+
+domain.delete_all_records
+```
+
+### `Porkbun::Record`
+
+A `Porkbun::Record` represents one DNS record and owns its mutations.
+
+#### instance methods
+
+- `update(content:, ttl:)` - returns the updated `Porkbun::Record`.
+- `delete` - returns the deleted `Porkbun::Record`.
+- `to_s` - returns a string containing the BIND zone entry.
+
+```ruby
+record = domain.get_record('www')
+puts record.to_s
+record.update(ttl: 700)
+record.delete
+```
 
-returns instance of DNS which can be used to delete
 
 ## CLI
 
@@ -50,12 +95,15 @@ The gem also comes with a CLI
 
     $ porkbun
     Commands:
-      porkbun delete_all <domain>              # deletes all records for a domain. this is destructive. use with caution
-      porkbun dyndns <hostname.domain> [<ip>]  # Update a dynamic dns record. example: porkbun dyndns home.example.com
-      porkbun help [COMMAND]                   # Describe available commands or one specific command
-      porkbun import <file>                    # Import BIND zone file
-      porkbun list                             # List all domains
-      porkbun retrieve <domain> [<id>]         # List all records for a domain
+      porkbun add RECORD --content=CONTENT --type=TYPE                         # Add a new record
+      porkbun update RECORD [--content=CONTENT] [--ttl=TTL]                    # Update a record (alias: up)
+      porkbun rm_rf DOMAIN                                                      # deletes all records for a domain. this is destructive. use with caution
+      porkbun rm RECORD                                                       # Delete one record for a hostname
+      porkbun dyndns HOSTNAME [IP]                                              # Update a dynamic dns record. example: porkbun dyndns home.example.com
+      porkbun env                                                               # Print environment variables
+      porkbun help [COMMAND]                                                    # Describe available commands or one specific command
+      porkbun import FILE                                                       # Import BIND zone file
+      porkbun ls [DOMAIN] [ID]                                                  # List all domains or records for a domain
 
 
 be sure to set the environmental variables for it to work
@@ -67,7 +115,7 @@ export PORKBUN_SECRET_API_KEY = YOUR_SECRET_API_KEY
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Run the test suite with `just test`. To publish a release, update the version number, then run `just publish`. This runs the tests and then calls the supported release task, which creates a git tag, pushes git commits and the tag, and publishes the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/Rakefile

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-task default: %i[]
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task default: %i[spec]

data/bin/porkbun

@@ -5,109 +5,101 @@ require 'porkbun'
 require 'thor'
 
 class CLI < Thor
-  desc 'import <file>', 'Import BIND zone file'
+  remove_command :tree
+  map 'up' => 'update'
+
+  def self.basename
+    'porkbun'
+  end
+
+  desc 'import FILE', 'Import BIND zone file'
   def import(file)
-    record_regex = /^(?<hostname>[^\s]+)\.\s+(?<ttl>\d+)\s+IN\s+(?<type>[^\s]+)\s*(?<priority>\d+)?\s+(?<content>.+)$/
-    IO.readlines(file).each do |line|
-      match_data = line.match(record_regex)
-      next unless match_data
-
-      domain = match_data[:hostname].split('.')[-2..].join('.').chomp '.'
-      name = match_data[:hostname].split('.')[0..-3].join('.')
-
-      options = {
-        domain:,
-        name:,
-        ttl: match_data[:ttl],
-        type: match_data[:type],
-        prio: match_data[:priority],
-        content: match_data[:content].chomp('.').gsub(/^"|"$/, '')
-      }.compact
-
-      record = Porkbun::DNS.create options
-      pp record
-    end
+    Porkbun::Domain.import(file).each { |record| puts record }
   end
 
-  desc 'list', 'List all domains'
-  def list
-    Porkbun::Domain.list_all[:domains].each do |domain|
-      puts domain[:domain]
+  desc 'ls [DOMAIN] [ID]', 'List all domains or records for a domain'
+  def ls(domain = nil, id = '')
+    if domain
+      puts Porkbun.new(domain).records
+    else
+      Porkbun::Domain.all.each do |domain|
+        puts domain
+      end
     end
   end
 
+
   desc 'env', 'Print environment variables'
   def env
     puts 'PORKBUN_API_KEY: ' + ENV['PORKBUN_API_KEY'].to_s
-    puts 'BUN_SECRET_API_KEY: ' + ENV['PORKBUN_SECRET_API_KEY'].to_s
+    puts 'PORKBUN_SECRET_API_KEY: ' + ENV['PORKBUN_SECRET_API_KEY'].to_s
   end
 
-  desc 'delete_all <domain>', 'deletes all records for a domain. this is destructive. use with caution'
-  def delete_all(domain, id = '')
-    records = get_all(domain, id)
-    records.each do |record|
-      next if record.type == 'NS'
-
+  desc 'rm_rf DOMAIN', 'deletes all records for a domain. this is destructive. use with caution'
+  def rm_rf(domain, id = '')
+    Porkbun.new(domain).delete_all_records.each do |record|
       puts "DELETE #{record}"
-      record.delete
     end
   end
 
-  desc 'create', 'Create a new record'
+  desc 'rm RECORD', 'Delete one record for a hostname'
+  def rm(hostname)
+    record = Porkbun::Domain.get_record(hostname)
+    record.delete
+    puts "DELETE #{record}"
+  end
+
+  desc 'update RECORD', 'Update a record (alias: up)'
+  option :content, desc: 'The new record content'
+  option :ttl, type: :numeric, desc: 'The new TTL in seconds'
+  def update(hostname)
+    raise Thor::Error, 'Specify --content or --ttl' unless options[:content] || options[:ttl]
+
+    record = Porkbun::Domain.get_record(hostname)
+    puts "UPDATE #{record}"
+    record.update(options)
+    puts record.message
+  end
+
+
+  desc 'add RECORD', 'Add a new record'
   option :type, required: true, desc: 'The record type: A, AAAA, CNAME, MX, TXT, SRV, NS, SOA'
-  option :domain, required: true, desc: 'The domain name: google.com'
-  option :name, required: true, desc: 'The hostname: www'
   option :content, required: true, desc: 'The content: hostname, or IP address'
   option :ttl, default: 600, type: :numeric, desc: 'The TTL in seconds'
   option :prio, default: 0, type: :numeric, desc: 'The priority for MX records'
-  def create
-    record = Porkbun::DNS.create(options)
+  def add(hostname)
+    record = Porkbun::Domain.create_record(hostname, options)
     puts record
     puts record.message
   end
 
-  desc 'dyndns <hostname.domain> [<ip>]', 'Update a dynamic dns record. example: porkbun dyndns home.example.com'
+  desc 'dyndns HOSTNAME [IP]', 'Update a dynamic dns record. example: porkbun dyndns home.example.com'
   long_desc 'If no IP is provided, the current public IP is used.'
   def dyndns(hostname, ip = nil)
-    ip ||= HTTP.get('https://canhazip.com').to_s.chomp
-    domain = hostname.split('.')[-2..].join('.').chomp '.'
-    name = hostname.split('.')[0..-3].join('.')
-    records = get_all(domain)
-    record = records.find { |r| r.name == hostname }
-    if record
-      record.content = ip
-      record.name = name
-      puts "UPDATE #{record}"
-      record.save
-      puts record.message
-    else
+    ip ||= Porkbun::Domain.public_ip
+    result = Porkbun::Domain.update_dynamic(hostname, ip)
+    if result[:created]
       print 'CREATE '
-      record = Porkbun::DNS.create(domain:, name:, type: 'A', content: ip)
-      puts record
-      puts record.message
+      puts result[:record]
+      puts result[:record].message
+    else
+      puts "UPDATE #{result[:display]}"
+      puts result[:record].message
     end
   end
 
-  desc 'retrieve <domain> [<id>]', 'List all records for a domain'
-  def retrieve(domain, id = '')
-    records = get_all(domain, id)
-    puts records
-  end
 
   def self.exit_on_failure?
     exit 1
   end
 
-  private
+end
 
-  def get_all(domain, id = '')
-    records = Porkbun::DNS.retrieve(domain, id)
-    if records.instance_of?(Porkbun::Error)
-      puts records.message
-      exit 1
-    end
-    records
+if $PROGRAM_NAME == __FILE__
+  if ARGV.include?('--help')
+    command = ARGV.find { |arg| !arg.start_with?('-') }
+    CLI.start(command ? ['help', command] : ['help'])
+  else
+    CLI.start(ARGV)
   end
 end
-
-CLI.start(ARGV)

data/justfile

@@ -0,0 +1,8 @@
+_default:
+    @just -l
+
+test:
+    mise exec -- env BUNDLE_PATH=.bundle bundle exec rake
+
+publish: test
+    mise exec -- env BUNDLE_PATH=.bundle bundle exec rake release

data/lib/porkbun/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Porkbun
-  VERSION = "0.5.1"
+  VERSION = "2.0.0"
 end

data/lib/porkbun.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require 'http'
+require 'json'
+require 'net/http'
+require 'uri'
 require_relative 'porkbun/version'
 
 module Porkbun
@@ -10,10 +12,16 @@ module Porkbun
     if ENV.fetch('PORKBUN_API_KEY', nil).nil? || ENV.fetch('PORKBUN_SECRET_API_KEY', nil).nil?
       abort 'PORKBUN_API_KEY and PORKBUN_SECRET_API_KEY must be set'
     end
-    res = HTTP.post File.join('https://porkbun.com/api/json/v3', path), json: {
+    uri = URI(File.join('https://api.porkbun.com/api/json/v3', path))
+    request = Net::HTTP::Post.new(uri)
+    request['Content-Type'] = 'application/json'
+    request.body = {
       secretapikey: ENV.fetch('PORKBUN_SECRET_API_KEY', nil),
       apikey: ENV.fetch('PORKBUN_API_KEY', nil)
-    }.merge(options)
+    }.merge(options).to_json
+    res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      http.request(request)
+    end
 
     JSON.parse(res.body, symbolize_names: true)
   end
@@ -41,7 +49,11 @@ module Porkbun
     porkbun 'ping'
   end
 
-  class DNS < Abstract
+  def self.new(domain)
+    Domain.new(domain)
+  end
+
+  class Record < Abstract
     attr_accessor :name, :content, :type, :ttl, :prio, :domain, :id, :notes
 
     def initialize(options)
@@ -55,7 +67,7 @@ module Porkbun
     end
 
     def self.create(options)
-      record = DNS.new options
+      record = Record.new options
       record.create
     end
 
@@ -72,17 +84,124 @@ module Porkbun
       edit
     end
 
-    def self.retrieve(domain, id = nil)
+    def update(options = {})
+      self.name = Record.relative_record_name(self)
+      self.content = options[:content] if options.key?(:content)
+      self.ttl = options[:ttl] if options.key?(:ttl)
+      save
+    end
+
+    def self.list(domain, id = nil)
       raise Error, 'need domain' unless domain
 
       res = Porkbun.porkbun File.join('dns/retrieve', domain, id || '').chomp('/')
       return Error.new(res[:message]) if res[:status] == 'ERROR'
 
       res[:records].map do |record|
-        DNS.new record.merge(domain:)
+        Record.new record.merge(domain:)
+      end
+    end
+
+    def self.domain_for(hostname)
+      fqdn = hostname.to_s.chomp('.')
+      domains = Porkbun::Domain.list_all[:domains].map { |item| item[:domain] }
+      domains.sort_by(&:length).reverse.find do |domain|
+        fqdn == domain || fqdn.end_with?(".#{domain}")
+      end
+    end
+
+    def self.records_for(target, id = nil)
+      requested = target.to_s.chomp('.')
+      owner = domain_for(requested) || requested.split('.').last(2).join('.')
+      records = list(owner, id)
+      raise records if records.is_a?(Error)
+      return records if owner == requested
+
+      records.select { |record| record_hostname(record, owner) == requested }
+    end
+
+    def self.find_record(hostname)
+      records = records_for(hostname)
+      raise Error, 'No record found for hostname' if records.empty?
+      raise Error, 'Multiple records found for hostname' if records.length > 1
+
+      records.first
+    end
+
+    def self.create_record(record, options)
+      fqdn = record.chomp('.')
+      domain = domain_for(fqdn) || fqdn.split('.').last(2).join('.')
+      name = fqdn == domain ? '' : fqdn.delete_suffix(".#{domain}")
+      create(options.merge(domain:, name:))
+    end
+
+    def self.update_record(record, options)
+      record.name = relative_record_name(record)
+      record.content = options[:content] if options[:content]
+      record.ttl = options[:ttl] if options[:ttl]
+      record.save
+      record
+    end
+
+    def self.delete_record(hostname)
+      record = find_record(hostname)
+      record.delete
+      record
+    end
+
+    def self.delete_all(domain, id = '')
+      list(domain, id).reject { |record| record.type == 'NS' }.each(&:delete)
+    end
+
+    def self.import_zone(file)
+      record_regex = /^(?<hostname>[^\s]+)\.\s+(?<ttl>\d+)\s+IN\s+(?<type>[^\s]+)\s*(?<priority>\d+)?\s+(?<content>.+)$/
+      IO.readlines(file).filter_map do |line|
+        match_data = line.match(record_regex)
+        next unless match_data
+
+        labels = match_data[:hostname].split('.')
+        options = {
+          domain: labels[-2..].join('.'),
+          name: labels[0..-3].join('.'),
+          ttl: match_data[:ttl],
+          type: match_data[:type],
+          prio: match_data[:priority],
+          content: match_data[:content].chomp('.').gsub(/^"|"$/, '')
+        }.compact
+        create(options)
       end
     end
 
+    def self.public_ip
+      Net::HTTP.get(URI('https://canhazip.com')).chomp
+    end
+
+    def self.update_dynamic(hostname, ip)
+      records = records_for(hostname)
+      return { created: true, record: create_record(hostname, type: 'A', content: ip) } if records.empty?
+
+      record = records.first
+      display = record.to_s
+      update_record(record, content: ip)
+      { created: false, display:, record: }
+    end
+
+    def self.record_hostname(record, domain)
+      name = record.name.to_s.chomp('.')
+      return domain if name.empty? || name == '@'
+
+      name.end_with?(".#{domain}") ? name : "#{name}.#{domain}"
+    end
+
+    def self.relative_record_name(record)
+      name = record.name.to_s.chomp('.')
+      domain = record.domain.to_s.chomp('.')
+      return '' if name == domain
+      return name.delete_suffix(".#{domain}") if name.end_with?(".#{domain}")
+
+      name
+    end
+
     def delete
       raise Error, 'Need ID to delete record' unless id
 
@@ -105,6 +224,7 @@ module Porkbun
       "#{name}. #{ttl} IN #{type} #{prio_str} #{content_str}".tr_s(' ', ' ')
     end
 
+
     def to_h
       {
         name: name,
@@ -137,4 +257,111 @@ module Porkbun
       options
     end
   end
+
+
+  class Domain
+    attr_reader :domain
+
+    def initialize(domain)
+      @domain = domain.to_s.chomp('.')
+    end
+
+    def self.all
+      list_all[:domains].map { |item| new(item[:domain]) }
+    end
+
+    def to_s
+      domain
+    end
+
+    def records
+      Record.list(domain)
+    end
+
+    def records_for(target)
+      requested = normalize_hostname(target)
+      records = Record.list(domain)
+      raise records if records.is_a?(Error)
+      return records if requested == domain
+
+      records.select { |record| Record.record_hostname(record, domain) == requested }
+    end
+
+    def get_record(name)
+      matches = records_for(name)
+      raise Error, 'No record found for hostname' if matches.empty?
+      raise Error, 'Multiple records found for hostname' if matches.length > 1
+
+      matches.first
+    end
+
+    def create_record(name, options)
+      hostname = normalize_hostname(name)
+      relative_name = hostname == domain ? '' : hostname.delete_suffix(".#{domain}")
+      Record.create(options.merge(domain:, name: relative_name))
+    end
+
+
+    def delete_all_records
+      Record.delete_all(domain)
+    end
+
+    def zone_file
+      records.map(&:to_s).join("\n") + "\n"
+    end
+
+    def self.get_record(hostname)
+      Record.find_record(hostname)
+    end
+
+
+    def self.update_dynamic(hostname, ip)
+      Record.update_dynamic(hostname, ip)
+    end
+
+    def update_dynamic(name, ip)
+      matches = records_for(name)
+      return { created: true, record: create_record(name, type: 'A', content: ip) } if matches.empty?
+
+      record = get_record(name)
+      display = record.to_s
+      record.update(content: ip)
+      { created: false, display:, record: }
+    end
+
+    private
+
+    def normalize_hostname(name)
+      hostname = name.to_s.chomp('.')
+      return hostname if hostname == domain || hostname.end_with?(".#{domain}")
+
+      "#{hostname}.#{domain}"
+    end
+
+    class << self
+      def get_record(hostname)
+        Record.find_record(hostname)
+      end
+
+
+
+
+      def create_record(hostname, options)
+        Record.create_record(hostname, options)
+      end
+
+
+      def import(file)
+        Record.import_zone(file)
+      end
+
+      def public_ip
+        Record.public_ip
+      end
+
+      def update_dynamic(hostname, ip)
+        Record.update_dynamic(hostname, ip)
+      end
+    end
+  end
 end

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = { version = "4.0.4", postinstall = "gem install pry amazing_print slop http sqlite3 thor colorize" }

metadata

@@ -1,43 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: porkbun
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Daniel Bretoi
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 5.1.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 5.1.1
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.5'
 description: Porkbun API wrapper for Ruby.
 email:
 - daniel@otherware.org
@@ -47,19 +32,23 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- AGENTS.md
+- CHANGELOG.md
+- CLAUDE.md
 - Gemfile
 - Gemfile.lock
 - README.md
 - Rakefile
 - bin/porkbun
+- justfile
 - lib/porkbun.rb
 - lib/porkbun/version.rb
+- mise.toml
 homepage: https://github.com/danielb2/porkbun-ruby
 licenses: []
 metadata:
   homepage_uri: https://github.com/danielb2/porkbun-ruby
   source_code_uri: https://github.com/danielb2/porkbun-ruby
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -67,15 +56,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Porkbun API wrapper for Ruby.
 test_files: []