bunbun 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2baeb841135209850e6ce3f030cb5751024fae83144edb11ada150534f86f3e0
+  data.tar.gz: af7fe28e6bd0dccb06d43ab23e85514b9a1e94975af9951d0b474492dca19615
+SHA512:
+  metadata.gz: b1d0081d994305b6db4882f03d8d13e8e8d6401a07cb167ed5d174ba18ac805e7abbd6a4bc5c8aea74a90b0720533a2edc9ccae5014c82dbc4a1a38f066b0c67
+  data.tar.gz: 10bbc9a3d6d1918c16a902d30f1254b868d4658d493c565f904de1530369988f7916c913394f4aca1d38f811bb2d7d5b29e676bd036b0b42c1e61eb5bc0f7056

data/LICENSE.txt

@@ -0,0 +1,4 @@
+Copyright (c) 2025 TIMCRAFT
+
+This is an Open Source project licensed under the terms of the LGPLv3 license.
+Please see <http://www.gnu.org/licenses/lgpl-3.0.html> for license text.

data/README.md

@@ -0,0 +1,76 @@
+# bunbun
+
+Ruby client for the [bunny.net](https://bunny.net) [API](https://docs.bunny.net/reference/bunnynet-api-overview).
+
+
+## Installation
+
+Using Bundler:
+
+    $ bundle add bunbun
+
+Using RubyGems:
+
+    $ gem install bunbun
+
+
+## Usage
+
+For accessing the bunny.net API:
+
+```ruby
+require 'bunbun'
+
+client = BunBun::Client.new(access_key: access_key)
+
+client.storage_zone.list.each do |zone|
+  puts zone.values_at('Id', 'Name', 'FilesStored').join(' )
+end
+```
+
+For accessing files on edge storage:
+
+```ruby
+require 'bunbun'
+
+file = 'image.jpg'
+
+zone = 'zone-name'
+
+host = 'storage.bunnycdn.com'
+
+client = BunBun::Client.new(access_key: access_key, host: host)
+
+client.download("/#{zone}/#{file}", file)
+```
+
+You can store your access key in a `BUNNY_ACCESS_KEY` environment variable,
+and the storage host in a `BUNNY_HOST` environment variable.
+
+
+## CLI
+
+The gem also includes a command line tool.
+
+Store your access keys in your .netrc file, for example:
+
+```
+machine api.bunny.net
+  login user
+  password xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+machine storage.bunnycdn.com
+  login zone-name
+  password xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx-xxxx-xxxx
+```
+
+Specify the access key for the bunny.net API, and any additional keys for
+accessing edge storage. The login for the api.bunny.net entry can be anything,
+the login for each storage entry should be the name of the storage zone.
+
+You can then use the `bunny` command line tool like this:
+
+```
+$ bunny storage zones
+```
+
+Run the tool without any arguments to see a list of available commands.

data/bin/bunny

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'bunbun', '~> 1'
+  gem 'netrc'
+  gem 'tabulo', '~> 3'
+end
+
+cli = BunBun::CLI.new
+cli.call(ARGV)

data/bunbun.gemspec

@@ -0,0 +1,26 @@
+require_relative './lib/bunbun'
+
+Gem::Specification.new do |s|
+  s.name = 'bunbun'
+  s.version = BunBun::VERSION
+  s.license = 'LGPL-3.0'
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Tim Craft']
+  s.email = ['email@timcraft.com']
+  s.homepage = 'https://github.com/readysteady/bunbun'
+  s.description = 'Ruby client for bunny.net'
+  s.summary = 'Ruby client for bunny.net'
+  s.files = Dir.glob('lib/**/*.rb') + %w[LICENSE.txt README.md bunbun.gemspec]
+  s.required_ruby_version = '>= 3.3.0'
+  s.require_path = 'lib'
+  s.executables = ['bunny']
+  s.metadata = {
+    'homepage' => 'https://github.com/readysteady/bunbun',
+    'source_code_uri' => 'https://github.com/readysteady/bunbun',
+    'bug_tracker_uri' => 'https://github.com/readysteady/bunbun/issues'
+  }
+  s.add_dependency 'base64'
+  s.add_dependency 'digest', '~> 3'
+  s.add_dependency 'net-http'
+  s.add_dependency 'json', '~> 2'
+end

data/lib/bunbun/body.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module BunBun::Body
+  def self.transform_keys(object)
+    if object.is_a?(Hash)
+      hash = {}
+      object.each { |key, value| hash[transform(key)] = transform_keys(value) }
+      hash
+    elsif object.is_a?(Array)
+      object.map { transform_keys(_1) }
+    else
+      object
+    end
+  end
+
+  def self.transform(key)
+    key = key.to_s
+
+    return key if key.chars.first.between?('A', 'Z')
+
+    transforms[key] ||= key.split('_').map(&:capitalize).join
+  end
+
+  def self.transforms
+    @transforms ||= {}
+  end
+
+  transforms['aws_signing_enabled'] = 'AWSSigningEnabled'
+  transforms['aws_signing_key'] = 'AWSSigningKey'
+  transforms['aws_signing_region_name'] = 'AWSSigningRegionName'
+  transforms['aws_signing_secret'] = 'AWSSigningSecret'
+  transforms['connection_limit_per_ip_count'] = 'ConnectionLimitPerIPCount'
+  transforms['enable_auto_ssl'] = 'EnableAutoSSL'
+  transforms['enable_geo_zone_af'] = 'EnableGeoZoneAF'
+  transforms['enable_geo_zone_asia'] = 'EnableGeoZoneASIA'
+  transforms['enable_geo_zone_eu'] = 'EnableGeoZoneEU'
+  transforms['enable_geo_zone_sa'] = 'EnableGeoZoneSA'
+  transforms['enable_geo_zone_us'] = 'EnableGeoZoneUS'
+  transforms['enable_tls1'] = 'EnableTLS1'
+  transforms['enable_tls1_1'] = 'EnableTLS1_1'
+  transforms['logging_ip_anonymization_enabled'] = 'LoggingIPAnonymizationEnabled'
+  transforms['optimizer_enable_webp'] = 'OptimizerEnableWebP'
+  transforms['optimizer_minify_css'] = 'OptimizerMinifyCSS'
+  transforms['origin_retry_5xx_responses'] = 'OriginRetry5XXResponses'
+  transforms['shield_ddos_protection_enabled'] = 'ShieldDDosProtectionEnabled'
+  transforms['shield_ddos_protection_type'] = 'ShieldDDosProtectionType'
+  transforms['verify_origin_ssl'] = 'VerifyOriginSSL'
+  transforms['waf_disabled_rules'] = 'WAFDisabledRules'
+  transforms['waf_disabled_rule_groups'] = 'WAFDisabledRuleGroups'
+  transforms['waf_enabled'] = 'WAFEnabled'
+  transforms['waf_enable_request_header_logging'] = 'WAFEnableRequestHeaderLogging'
+  transforms['waf_request_header_ignores'] = 'WAFRequestHeaderIgnores'
+end

data/lib/bunbun/cli/command.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+require 'optparse'
+require 'tabulo'
+require 'json'
+
+class BunBun::CLI::Command
+  def self.options
+    @options ||= []
+  end
+
+  def self.option(name)
+    options << name
+  end
+
+  def self.argument_names
+    @argument_names ||= instance_method(:call).parameters.select { _1[0] == :req || _1[0] == :opt }.map { _1[1] }
+  end
+
+  def self.argument_count
+    argument_names.length
+  end
+
+  def option_parser
+    OptionParser.new do |opts|
+      self.class.options.each do |name|
+        opts.on("--#{name}=VALUE")
+      end
+    end
+  end
+
+  attr_accessor :options
+
+  def call
+  end
+
+  private
+
+  NETRC = Netrc.read
+
+  def get_access_key(host, zone_name = nil)
+    if zone_name.nil?
+      netrc_entry = NETRC[host]
+      raise BunBun::CLI::Error, "no netrc entry for #{host}" if netrc_entry.nil?
+      netrc_entry.password
+    else
+      netrc_entry = NETRC.each.find { _1[1] == host && _1[3] == zone_name }
+      raise BunBun::CLI::Error, "no netrc entry for #{host} (#{zone_name})" if netrc_entry.nil?
+      netrc_entry[5]
+    end
+  end
+
+  def read_body_params(file)
+    JSON.parse(File.read(file))
+  rescue Errno::ENOENT
+    raise BunBun::CLI::Error, 'file does not exist'
+  rescue JSON::ParserError
+    raise BunBun::CLI::Error, 'file must be valid json'
+  end
+
+  def client
+    @client ||= BunBun::Client.new(access_key: get_access_key('api.bunny.net'))
+  end
+
+  BYTESIZE_UNITS = {
+    GB: 1_000_000_000,
+    MB: 1_000_000,
+    KB: 1_000
+  }
+
+  def format_bytesize(integer)
+    BYTESIZE_UNITS.each do |suffix, size|
+      if integer >= size
+        return "#{(integer.to_f / size).round(2)} #{suffix}"
+      end
+    end
+  
+    "#{integer} bytes"
+  end
+
+  def format_timestamp(string)
+    string.split('.').first.tr('T', ' ')
+  end
+
+  def print_json(object, io: STDOUT)
+    io.puts JSON.pretty_generate(object)
+  end
+
+  def print_table(array, io: STDOUT)
+    return if array.empty?
+
+    table = Tabulo::Table.new(array, border: :modern)
+
+    yield table
+
+    io.puts table.pack
+  end
+end

data/lib/bunbun/cli/countries.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::Countries < BunBun::CLI::Command
+  def call
+    items = client.country.list
+
+    print_table(items) do |t|
+      t.add_column('Name', align_header: :left) { _1['Name'] }
+      t.add_column('Code', align_header: :left) { _1['IsoCode'] }
+    end
+  end
+end

data/lib/bunbun/cli/keys.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::Keys < BunBun::CLI::Command
+  def call
+    items = client.api_key.list
+
+    print_table(items.fetch('Items')) do |t|
+      t.add_column('ID', align_header: :left) { _1['Id'] }
+      t.add_column('Key', align_header: :left) { _1['Key'] }
+      t.add_column('Roles', align_header: :left) { _1['Roles'].join(', ') }
+    end
+  end
+end

data/lib/bunbun/cli/purge.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::Purge < BunBun::CLI::Command
+  def call(url)
+    client.purge(url)
+  end
+end

data/lib/bunbun/cli/regions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::Regions < BunBun::CLI::Command
+  def call
+    items = client.region.list
+
+    print_table(items) do |t|
+      t.add_column('ID', align_header: :right) { _1['Id'] }
+      t.add_column('Name', align_header: :left) { _1['Name'] }
+      t.add_column('Region', align_header: :left) { _1['RegionCode'] }
+      t.add_column('Country', align_header: :left) { _1['CountryCode'] }
+      t.add_column('Latitude', align_header: :right) { _1['Latitude'] }
+      t.add_column('Longitude', align_header: :right) { _1['Longitude'] }
+    end
+  end
+end

data/lib/bunbun/cli/storage_command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::StorageCommand < BunBun::CLI::Command
+  attr_accessor :storage_zone
+  attr_accessor :storage_host
+  attr_accessor :storage_access_key
+
+  def call(path)
+    unless path =~ /\A\/([\w\-]+)\//
+      raise BunBun::CLI::Error, 'path must start with a zone name'
+    end
+
+    self.storage_zone = $1
+
+    self.storage_host = options[:host] || 'storage.bunnycdn.com'
+
+    self.storage_access_key = get_access_key(storage_host, storage_zone)
+
+    @client = BunBun::Client.new(host: storage_host, access_key: storage_access_key)
+  end
+end

data/lib/bunbun/cli/storage_delete.rb

@@ -0,0 +1,9 @@
+class BunBun::CLI::StorageDelete < BunBun::CLI::StorageCommand
+  option :host
+
+  def call(path)
+    super
+
+    client.delete(path)
+  end
+end

data/lib/bunbun/cli/storage_download.rb

@@ -0,0 +1,9 @@
+class BunBun::CLI::StorageDownload < BunBun::CLI::StorageCommand
+  option :host
+
+  def call(path)
+    super
+
+    client.download(path, File.basename(path))
+  end
+end

data/lib/bunbun/cli/storage_edit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::StorageEdit < BunBun::CLI::StorageCommand
+  option :host
+
+  def call(path)
+    super
+
+    response = client.download(path)
+
+    unless response.content_type.start_with?('text/') || response.content_type == 'application/json'
+      raise BunBun::CLI::Error, "cannot edit #{response.content_type} files"
+    end
+
+    text = response.body
+
+    pipe = IO.popen(ENV.fetch('EDITOR'), 'w+')
+    pipe.puts(text)
+    pipe.close_write
+
+    edited_text = pipe.read
+
+    pipe.close
+
+    unless edited_text.empty? || edited_text == text
+      client.upload(path, edited_text, content_type: response.content_type)
+    end
+  end
+end

data/lib/bunbun/cli/storage_files.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::StorageFiles < BunBun::CLI::StorageCommand
+  option :host
+
+  def call(path)
+    unless path.end_with?('/')
+      raise BunBun::CLI::Error, 'path must end with a trailing slash'
+    end
+
+    super
+
+    items = client.get(path)
+
+    print_table(items) do |t|
+      t.add_column('Name', align_header: :left) { _1['ObjectName'] }
+      t.add_column('Size') { format_bytesize(_1['Length']) unless _1['Length'].zero? }
+      t.add_column('Created', align_header: :right) { format_timestamp(_1['DateCreated']) }
+      t.add_column('Modified', align_header: :right) { format_timestamp(_1['LastChanged']) }
+    end
+  end
+end

data/lib/bunbun/cli/storage_upload.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'shellwords'
+
+class BunBun::CLI::StorageUpload < BunBun::CLI::StorageCommand
+  option :host
+
+  def call(path, file)
+    unless path.end_with?('/')
+      raise BunBun::CLI::Error, 'path must end with a trailing slash'
+    end
+
+    super
+
+    content_type = `file -b --mime-type #{Shellwords.escape(file)}`.chomp
+
+    File.open(file, 'rb') do |io|
+      client.upload(path + File.basename(file), io, content_type: content_type)
+    end
+  end
+end

data/lib/bunbun/cli/storage_zone.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::StorageZone < BunBun::CLI::Command
+  def call(id)
+    print_json client.storage_zone.get(id)
+  end
+end

data/lib/bunbun/cli/storage_zone_create.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::StorageZoneCreate < BunBun::CLI::Command
+  def call(file)
+    client.storage_zone.create(read_body_params(file))
+  end
+end

data/lib/bunbun/cli/storage_zones.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::StorageZones < BunBun::CLI::Command
+  def call
+    items = client.storage_zone.list
+
+    print_table(items.sort_by { _1['Name'] }) do |t|
+      t.add_column('ID', align_header: :right) { _1['Id'] }
+      t.add_column('Name', align_header: :left) { _1['Name'] }
+      t.add_column('Region', align_header: :left) { _1['Region'] }
+      t.add_column('Hostname', align_header: :left) { _1['StorageHostname'] }
+      t.add_column('Size', align_header: :left) { format_bytesize(_1['StorageUsed']) }
+      t.add_column('Files', align_header: :right) { _1['FilesStored'] }
+      t.add_column('Modified', align_header: :right) { format_timestamp(_1['DateModified']) }
+    end
+  end
+end

data/lib/bunbun/cli/zone.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::Zone < BunBun::CLI::Command
+  def call(id)
+    print_json client.pull_zone.get(id)
+  end
+end

data/lib/bunbun/cli/zone_create.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::ZoneCreate < BunBun::CLI::Command
+  def call(file)
+    client.pull_zone.create(read_body_params(file))
+  end
+end

data/lib/bunbun/cli/zone_purge.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::ZonePurge < BunBun::CLI::Command
+  def call(id)
+    client.pull_zone.purge(id)
+  end
+end

data/lib/bunbun/cli/zone_rules_delete.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::ZoneRulesDelete < BunBun::CLI::Command
+  def call(zone_id, rule_id)
+    client.pull_zone.edge_rules.delete(zone_id, rule_id)
+  end
+end

data/lib/bunbun/cli/zone_rules_disenable.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::ZoneRulesDisenable < BunBun::CLI::Command
+  def call(zone_id, rule_id)
+    client.pull_zone.edge_rules.disenable(zone_id, rule_id)
+  end
+end

data/lib/bunbun/cli/zone_rules_enable.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::ZoneRulesEnable < BunBun::CLI::Command
+  def call(zone_id, rule_id)
+    client.pull_zone.edge_rules.enable(zone_id, rule_id)
+  end
+end

data/lib/bunbun/cli/zone_rules_post.rb

@@ -0,0 +1,5 @@
+class BunBun::CLI::ZoneRulesPost < BunBun::CLI::Command
+  def call(zone_id, file)
+    client.pull_zone.edge_rules.post(zone_id, read_body_params(file))
+  end
+end

data/lib/bunbun/cli/zones.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class BunBun::CLI::Zones < BunBun::CLI::Command
+  def call
+    items = client.pull_zone.list
+
+    print_table(items) do |t|
+      t.add_column('ID', align_header: :right) { _1['Id'] }
+      t.add_column('Name', align_header: :left) { _1['Name'] }
+      t.add_column('Storage Zone', align_header: :right) { _1['StorageZoneId'] }
+      t.add_column('Bandwidth') { format_bytesize(_1['MonthlyBandwidthUsed']) }
+      t.add_column('Domain', align_header: :left) { |zone|
+        hostnames = zone['Hostnames'].reject { _1['IsSystemHostname'] || _1['IsManagedHostname'] }
+        hostnames.map { _1['Value'] }.first
+      }
+    end
+  end
+end

data/lib/bunbun/cli.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+require 'netrc'
+require 'optparse'
+
+class BunBun::CLI
+  Error = Class.new(StandardError)
+
+  autoload :Command, 'bunbun/cli/command'
+  autoload :StorageCommand, 'bunbun/cli/storage_command'
+
+  def self.commands
+    @commands ||= []
+  end
+
+  def self.command(key)
+    autoload_path = 'bunbun/cli/' + key.join('_')
+
+    autoload command_class_name(key), autoload_path
+
+    commands << key
+  end
+
+  def self.command_class_name(key)
+    key.map(&:capitalize).join.to_sym
+  end
+
+  command %w[countries]
+  command %w[keys]
+  command %w[purge]
+  command %w[regions]
+  command %w[storage delete]
+  command %w[storage download]
+  command %w[storage edit]
+  command %w[storage files]
+  command %w[storage upload]
+  command %w[storage zone create]
+  command %w[storage zone]
+  command %w[storage zones]
+  command %w[zone create]
+  command %w[zone purge]
+  command %w[zone rules delete]
+  command %w[zone rules disenable]
+  command %w[zone rules enable]
+  command %w[zone rules post]
+  command %w[zone]
+  command %w[zones]
+
+  def call(args)
+    if args.empty? || args.size == 1 && args.first == '--help'
+      print_usage
+
+      return
+    end
+
+    option_args, command_args = args.partition { _1.start_with?('-') }
+
+    key = self.class.commands.find { command_args.first(_1.length) == _1 }
+
+    if key.nil?
+      error "#{command_args.join(' ')} is not a valid command"
+    end
+
+    command_class = get_command_class(key)
+
+    command = command_class.new
+
+    if option_parser = command.option_parser
+      command.options = {}
+
+      option_parser.parse(option_args, into: command.options)
+    end
+
+    command_args = command_args.drop(key.length)
+
+    if command_args.length < command_class.argument_count
+      error "not enough arguments (expected #{command_class.argument_count})"
+    elsif command_args.length > command_class.argument_count
+      error "too many arguments (expected #{command_class.argument_count})"
+    end
+
+    command.call(*command_args)
+  rescue OptionParser::InvalidOption
+    error 'invalid option'
+  rescue OptionParser::MissingArgument
+    error 'missing option argument'
+  rescue BunBun::Error, BunBun::CLI::Error => exception
+    error exception.message
+  end
+
+  private
+
+  def get_command_class(key)
+    BunBun::CLI.const_get(self.class.command_class_name(key))
+  end
+
+  def print_usage(io: STDOUT, program_name: File.basename($0))
+    io.puts "Usage: #{program_name} COMMAND"
+    io.puts
+
+    self.class.commands.each do |key|
+      command_class = get_command_class(key)
+
+      arguments = command_class.argument_names.map { ' ' + _1.to_s.upcase }.join
+
+      options = command_class.options.map { " [--#{_1}=#{_1.upcase}]" }.join
+
+      io.puts "  #{program_name} #{key.join(' ')}#{arguments}#{options}"
+    end
+
+    io.puts
+  end
+
+  def error(message)
+    message = 'ERROR: ' + message
+    message = color_red(message) if STDERR.isatty
+
+    Kernel::abort(message)
+  end
+
+  def color_red(text)
+    "\e[#{31}m#{text}\e[m"
+  end
+end

data/lib/bunbun/client/api_key.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class BunBun::Client::ApiKey < BunBun::Client::Namespace
+  def list
+    @client.get('/apikey')
+  end
+end

data/lib/bunbun/client/country.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class BunBun::Client::Country < BunBun::Client::Namespace
+  def list
+    @client.get('/country')
+  end
+end

data/lib/bunbun/client/namespace.rb

@@ -0,0 +1,9 @@
+class BunBun::Client::Namespace
+  def initialize(client)
+    @client = client
+  end
+
+  def inspect
+    "<#{self.class.name}>"
+  end
+end

data/lib/bunbun/client/pull_zone/edge_rules.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class BunBun::Client::PullZone::EdgeRules < BunBun::Client::Namespace
+  def post(zone_id, body_params)
+    @client.post("/pullzone/#{zone_id}/edgerules/addOrUpdate", BunBun::Body.transform_keys(body_params))
+  end
+
+  alias_method :create, :post
+
+  def delete(zone_id, rule_id)
+    @client.delete("/pullzone/#{zone_id}/edgerules/#{rule_id}")
+  end
+
+  def disenable(zone_id, rule_id)
+    body_params = {
+      Id: Integer(zone_id),
+      Value: false
+    }
+
+    @client.post("/pullzone/#{zone_id}/edgerules/#{rule_id}/setEdgeRuleEnabled", body_params)
+  end
+
+  def enable(zone_id, rule_id)
+    body_params = {
+      Id: Integer(zone_id),
+      Value: true
+    }
+
+    @client.post("/pullzone/#{zone_id}/edgerules/#{rule_id}/setEdgeRuleEnabled", body_params)
+  end
+
+  alias_method :update, :post
+end

data/lib/bunbun/client/pull_zone.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class BunBun::Client::PullZone < BunBun::Client::Namespace
+  autoload :EdgeRules, 'bunbun/client/pull_zone/edge_rules'
+
+  def initialize(client)
+    super
+
+    @edge_rules = EdgeRules.new(client)
+  end
+
+  def create(body_params)
+    @client.post('/pullzone', BunBun::Body.transform_keys(body_params))
+  end
+
+  def delete(id)
+    @client.delete("/pullzone/#{id}")
+  end
+
+  attr_reader :edge_rules
+
+  def get(id)
+    @client.get("/pullzone/#{id}")
+  end
+
+  def list
+    @client.get('/pullzone')
+  end
+
+  def purge(id)
+    @client.post("/pullzone/#{id}/purgeCache")
+  end
+
+  def update(id, body_params)
+    @client.post("/pullzone/#{id}", BunBun::Body.transform_keys(body_params))
+  end
+end

data/lib/bunbun/client/region.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class BunBun::Client::Region < BunBun::Client::Namespace
+  def list
+    @client.get('/region')
+  end
+end

data/lib/bunbun/client/statistics.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class BunBun::Client::Statistics < BunBun::Client::Namespace
+  def get(date_from: nil, date_to: nil, pull_zone: nil, server_zone_id: nil, load_errors: nil, hourly: nil)
+    params = {
+      dateFrom: date_from,
+      dateTo: date_to,
+      pullZone: pull_zone,
+      serverZoneId: server_zone_id,
+      loadErrors: load_errors,
+      hourly: hourly
+    }
+
+    @client.get(BunBun::URI.join('/statistics', params))
+  end
+end

data/lib/bunbun/client/storage_zone/statistics.rb

@@ -0,0 +1,10 @@
+class BunBun::Client::StorageZone::Statistics < BunBun::Client::Namespace
+  def get(id, date_from: nil, date_to: nil)
+    params = {
+      dateFrom: date_from,
+      dateTo: date_to
+    }
+
+    @client.get(BunBun::URI.join("/storagezone/#{id}/statistics", params))
+  end
+end

data/lib/bunbun/client/storage_zone.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class BunBun::Client::StorageZone < BunBun::Client::Namespace
+  autoload :Statistics, 'bunbun/client/storage_zone/statistics'
+
+  def initialize(client)
+    super
+
+    @statistics = Statistics.new(client)
+  end
+
+  def create(body_params)
+    @client.post('/storagezone', BunBun::Body.transform_keys(body_params))
+  end
+
+  def delete(id)
+    @client.delete("/storagezone/#{id}")
+  end
+
+  def get(id)
+    @client.get("/storagezone/#{id}")
+  end
+
+  def list(page: nil, per_page: nil, include_deleted: nil, search: nil)
+    params = {
+      page: page,
+      perPage: per_page,
+      includeDeleted: include_deleted,
+      search: search
+    }
+
+    @client.get(BunBun::URI.join('/storagezone', params))
+  end
+
+  attr_reader :statistics
+
+  def update(id, body_params)
+    @client.post("/storagezone/#{id}", BunBun::Body.transform_keys(body_params))
+  end
+end

data/lib/bunbun/client.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+require 'net/http'
+require 'json'
+
+class BunBun::Client
+  autoload :ApiKey, 'bunbun/client/api_key'
+  autoload :Country, 'bunbun/client/country'
+  autoload :Namespace, 'bunbun/client/namespace'
+  autoload :PullZone, 'bunbun/client/pull_zone'
+  autoload :Region, 'bunbun/client/region'
+  autoload :Statistics, 'bunbun/client/statistics'
+  autoload :StorageZone, 'bunbun/client/storage_zone'
+
+  def initialize(access_key: nil, host: nil, open_timeout: 2, read_timeout: 2)
+    @access_key = access_key || ENV.fetch('BUNNY_ACCESS_KEY')
+    @host = host || ENV['BUNNY_HOST'] || 'api.bunny.net'
+    @port = Net::HTTP.https_default_port
+    @opts = {
+      use_ssl: true,
+      open_timeout: open_timeout,
+      read_timeout: read_timeout
+    }
+    @user_agent = "ruby/#{RUBY_VERSION} bunbun/#{BunBun::VERSION}"
+    @api_key = BunBun::Client::ApiKey.new(self)
+    @country = BunBun::Client::Country.new(self)
+    @pull_zone = BunBun::Client::PullZone.new(self)
+    @region = BunBun::Client::Region.new(self)
+    @statistics = BunBun::Client::Statistics.new(self)
+    @storage_zone = BunBun::Client::StorageZone.new(self)
+  end
+
+  attr_reader :api_key
+
+  attr_reader :country
+
+  def delete(path)
+    start do |http|
+      message = Net::HTTP::Delete.new(path)
+      message['AccessKey'] = @access_key
+      message['User-Agent'] = @user_agent
+
+      BunBun::Response.parse(http.request(message))
+    end
+  end
+
+  def download(path, destination = nil)
+    start do |http|
+      message = Net::HTTP::Get.new(path)
+      message['Accept'] = '*/*'
+      message['AccessKey'] = @access_key
+      message['User-Agent'] = @user_agent
+
+      http.request(message) do |response|
+        unless response.is_a?(Net::HTTPSuccess)
+          raise BunBun::Response.error(response)
+        end
+
+        if destination
+          File.open(destination, 'wb') do |file|
+            response.read_body do |chunk|
+              file.write(chunk)
+            end
+          end
+        end
+
+        response
+      end
+    end
+  end
+
+  def get(path)
+    start do |http|
+      message = Net::HTTP::Get.new(path)
+      message['Accept'] = 'application/json'
+      message['AccessKey'] = @access_key
+      message['User-Agent'] = @user_agent
+
+      BunBun::Response.parse(http.request(message))
+    end
+  end
+
+  def inspect
+    "<#{self.class.name}: host=#{@host}>"
+  end
+
+  def post(path, params = nil)
+    start do |http|
+      message = Net::HTTP::Post.new(path)
+      message['AccessKey'] = @access_key
+      message['User-Agent'] = @user_agent
+
+      unless params.nil?
+        message['Content-Type'] = 'application/json'
+        message.body = JSON.generate(params)
+      end
+
+      BunBun::Response.parse(http.request(message))
+    end
+  end
+
+  attr_reader :pull_zone
+
+  def purge(url:, async: nil)
+    params = {url: url, async: async}
+
+    post(BunBun::URI.join('/purge', params))
+  end
+
+  attr_reader :region
+
+  attr_reader :statistics
+
+  attr_reader :storage_zone
+
+  def upload(path, content, content_type: 'application/octet-stream')
+    start do |http|
+      message = Net::HTTP::Put.new(path)
+      message['AccessKey'] = @access_key
+      message['Content-Type'] = content_type
+      message['User-Agent'] = @user_agent
+
+      if content.respond_to?(:read)
+        size = content.respond_to?(:path) ? File.size(content.path) : content.size
+
+        message['Content-Length'] = size
+        message.body_stream = content
+      else
+        message.body = content
+      end
+
+      http.request(message)
+    end
+  end
+
+  private
+
+  def start(&block)
+    Net::HTTP.start(@host, @port, @opts, &block)
+  end
+end

data/lib/bunbun/response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'json'
+
+module BunBun::Response
+  def self.parse(response)
+    unless response.is_a?(Net::HTTPSuccess)
+      raise error(response)
+    end
+
+    body = response.body
+
+    unless response.content_type == 'application/json'
+      return body
+    end
+
+    JSON.parse(body)
+  end
+
+  def self.error(response)
+    error_class(response).new(error_message(response))
+  end
+
+  def self.error_class(response)
+    case response
+    when Net::HTTPClientError then BunBun::ClientError
+    when Net::HTTPServerError then BunBun::ServerError
+    else
+      BunBun::Error
+    end
+  end
+
+  def self.error_message(response)
+    if response.content_type == 'application/json'
+      JSON.parse(response.body).fetch('Message')
+    else
+      "unexpected #{response.code} #{response.content_type} response"
+    end
+  end
+end

data/lib/bunbun/uri.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'base64'
+require 'digest'
+require 'uri'
+
+module BunBun::URI
+  def self.join(path, params = nil)
+    return path if params.nil? || params.empty? || params.all? { |_, value| value.nil? }
+
+    encoded = []
+
+    params.each do |name, value|
+      next if value.nil?
+
+      encoded << ::URI.encode_uri_component(name) + '=' + ::URI.encode_uri_component(value)
+    end
+
+    path + '?' + encoded.join('&')
+  end
+
+  def self.sign(path, expires: Time.now + 3600, host: ENV.fetch('BUNNY_CDN_HOST'), security_key: ENV.fetch('BUNNY_CDN_KEY'))
+    uri = 'https://' + host + path
+
+    expires = expires.to_i.to_s
+
+    string = security_key + path + expires
+
+    token = Base64.urlsafe_encode64(Digest::SHA256.digest(string)).delete("=\n")
+
+    uri + "?token=#{token}&expires=#{expires}"
+  end
+end

data/lib/bunbun.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BunBun
+  VERSION = '1.0.0'
+
+  Error = Class.new(StandardError)
+  ClientError = Class.new(Error)
+  ServerError = Class.new(Error)
+
+  autoload :Body, 'bunbun/body'
+  autoload :CLI, 'bunbun/cli'
+  autoload :Client, 'bunbun/client'
+  autoload :Response, 'bunbun/response'
+  autoload :URI, 'bunbun/uri'
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: bunbun
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tim Craft
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  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'
+- !ruby/object:Gem::Dependency
+  name: digest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  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'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Ruby client for bunny.net
+email:
+- email@timcraft.com
+executables:
+- bunny
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/bunny
+- bunbun.gemspec
+- lib/bunbun.rb
+- lib/bunbun/body.rb
+- lib/bunbun/cli.rb
+- lib/bunbun/cli/command.rb
+- lib/bunbun/cli/countries.rb
+- lib/bunbun/cli/keys.rb
+- lib/bunbun/cli/purge.rb
+- lib/bunbun/cli/regions.rb
+- lib/bunbun/cli/storage_command.rb
+- lib/bunbun/cli/storage_delete.rb
+- lib/bunbun/cli/storage_download.rb
+- lib/bunbun/cli/storage_edit.rb
+- lib/bunbun/cli/storage_files.rb
+- lib/bunbun/cli/storage_upload.rb
+- lib/bunbun/cli/storage_zone.rb
+- lib/bunbun/cli/storage_zone_create.rb
+- lib/bunbun/cli/storage_zones.rb
+- lib/bunbun/cli/zone.rb
+- lib/bunbun/cli/zone_create.rb
+- lib/bunbun/cli/zone_purge.rb
+- lib/bunbun/cli/zone_rules_delete.rb
+- lib/bunbun/cli/zone_rules_disenable.rb
+- lib/bunbun/cli/zone_rules_enable.rb
+- lib/bunbun/cli/zone_rules_post.rb
+- lib/bunbun/cli/zones.rb
+- lib/bunbun/client.rb
+- lib/bunbun/client/api_key.rb
+- lib/bunbun/client/country.rb
+- lib/bunbun/client/namespace.rb
+- lib/bunbun/client/pull_zone.rb
+- lib/bunbun/client/pull_zone/edge_rules.rb
+- lib/bunbun/client/region.rb
+- lib/bunbun/client/statistics.rb
+- lib/bunbun/client/storage_zone.rb
+- lib/bunbun/client/storage_zone/statistics.rb
+- lib/bunbun/response.rb
+- lib/bunbun/uri.rb
+homepage: https://github.com/readysteady/bunbun
+licenses:
+- LGPL-3.0
+metadata:
+  homepage: https://github.com/readysteady/bunbun
+  source_code_uri: https://github.com/readysteady/bunbun
+  bug_tracker_uri: https://github.com/readysteady/bunbun/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Ruby client for bunny.net
+test_files: []