diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b251477f8..3e819163b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,4 +19,4 @@ jobs:
       - name: Run ShellCheck bin top level
         run: |
             shellcheck bin/support/bash_functions.sh bin/support/download_ruby -x &&
-            shellcheck bin/build bin/compile bin/detect bin/release bin/test bin/test-compile -x
+            shellcheck bin/compile bin/detect bin/release bin/test bin/test-compile -x
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e45aeab8..32d4b2a43 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@
 
 ## [Unreleased]
 
+- Remove experimental CNB support. For official CNB support use [heroku/buildpacks-ruby](https://github.com/heroku/buildpacks-ruby) instead. (https://github.com/heroku/heroku-buildpack-ruby/pull/1464)
 
 ## [v271] - 2024-06-03
 
diff --git a/bin/build b/bin/build
deleted file mode 100755
index 5a6d0f4ec..000000000
--- a/bin/build
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-
-LAYERS_DIR=$1
-PLATFORM_DIR=$2
-_ENV_DIR="$PLATFORM_DIR/env"
-PLAN=$3
-APP_DIR=$(pwd)
-BIN_DIR=$(cd "$(dirname "$0")" || exit; pwd) # absolute path
-BUILDPACK_DIR=$(dirname "$BIN_DIR")
-
-# legacy buildpack uses $STACK
-export STACK=$CNB_STACK_ID
-
-# shellcheck source=bin/support/bash_functions.sh
-source "$BIN_DIR/support/bash_functions.sh"
-
-cat<<EOF 1>&2
-    The CNB implementation in this buildpack is no longer maintained
-
-    The heroku/heroku-ruby-buildpack previously implemented the Cloud Native Buildpack \(CNB\) spec beta support, however this functionality is no longer supported or maintained.
-
-    The Heroku Ruby CNB is now at https://github.com/heroku/buildpacks-ruby. See https://github.com/heroku/buildpacks for more information on using the Heroku CNB builder. To avoid interruptions switch to the new CNB as soon as possible.
-EOF
-
-bootstrap_ruby_dir=$(install_bootstrap_ruby "$BIN_DIR" "$BUILDPACK_DIR")
-export PATH="$bootstrap_ruby_dir/bin/:$PATH"
-unset GEM_PATH
-
-"$bootstrap_ruby_dir"/bin/ruby "$BIN_DIR/support/ruby_build" "$APP_DIR" "$LAYERS_DIR" "$PLATFORM_DIR" "$PLAN"
diff --git a/bin/detect b/bin/detect
index 83ad9437c..e25db8c44 100755
--- a/bin/detect
+++ b/bin/detect
@@ -1,18 +1,10 @@
 #!/bin/sh
 
-if [ -z "$CNB_STACK_ID" ]; then
-  # v2 API
-  APP_DIR=$1
-else
-  _PLATFORM_DIR=$1
-  _PLAN=$2
-  # v3 API
-  APP_DIR=$(pwd)
-fi
+APP_DIR=$1
 
 if [ -f "$APP_DIR/Gemfile" ]; then
   echo "Ruby"
   exit 0
 else
-  exit 100
+  exit 1
 fi
diff --git a/bin/support/ruby_build b/bin/support/ruby_build
deleted file mode 100755
index ddcb77edf..000000000
--- a/bin/support/ruby_build
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-
-# This script compiles an application so it can run on Heroku.
-# It will install the application's specified version of Ruby, it's dependencies
-# and certain framework specific requirements (such as calling `rake assets:precompile`
-# for rails apps). You can see all features described in the devcenter
-# https://devcenter.heroku.com/articles/ruby-support
-$stdout.sync = true
-
-$:.unshift File.expand_path("../../../lib", __FILE__)
-require "language_pack"
-require "language_pack/shell_helpers"
-
-APP_DIR=ARGV[0]
-LAYER_DIR=ARGV[1]
-PLATFORM_DIR=ARGV[2]
-ENV_DIR="#{PLATFORM_DIR}/env"
-PLAN=ARGV[3]
-
-begin
-  LanguagePack::ShellHelpers.initialize_env(ENV_DIR)
-  if pack = LanguagePack.detect(ARGV[0], nil, LAYER_DIR)
-    pack.topic("Compiling #{pack.name}")
-    pack.log("compile") do
-      pack.build
-    end
-  end
-rescue Exception => e
-  LanguagePack::ShellHelpers.display_error_and_exit(e)
-end
-
diff --git a/buildpack.toml b/buildpack.toml
index 7c72034f4..0bcaf7851 100644
--- a/buildpack.toml
+++ b/buildpack.toml
@@ -1,10 +1,5 @@
-api = "0.2"
-
 [buildpack]
-id = "heroku/ruby"
-version = "0.1.4"
 name = "Ruby"
-homepage = "https://github.com/heroku/heroku-buildpack-ruby"
 ruby_version = "3.1.4"
 
 [publish]
@@ -19,7 +14,6 @@ files = [
   "app.json",
   "hatchet.json",
   "hatchet.lock",
-  "package.toml",
 ]
 
 [[publish.Vendor]]
@@ -33,16 +27,3 @@ dir = "vendor/ruby/heroku-22"
 [[publish.Vendor]]
 url = "https://heroku-buildpack-ruby.s3.us-east-1.amazonaws.com/heroku-24/amd64/ruby-3.1.4.tgz"
 dir = "vendor/ruby/amd64/heroku-24"
-
-[[stacks]]
-id = "heroku-20"
-
-[[stacks]]
-id = "heroku-22"
-
-[metadata]
-
-[metadata.release]
-
-[metadata.release.docker]
-repository = "public.ecr.aws/heroku-buildpacks/heroku-ruby-buildpack"
diff --git a/lib/language_pack/base.rb b/lib/language_pack/base.rb
index 82187e162..c57ae0324 100644
--- a/lib/language_pack/base.rb
+++ b/lib/language_pack/base.rb
@@ -5,7 +5,6 @@
 require "language_pack/shell_helpers"
 require "language_pack/cache"
 require "language_pack/helpers/bundler_cache"
-require "language_pack/helpers/layer"
 require "language_pack/metadata"
 require "language_pack/fetcher"
 
@@ -28,7 +27,7 @@ class LanguagePack::Base
   # changes directory to the build_path
   # @param [String] the path of the build dir
   # @param [String] the path of the cache dir this is nil during detect and release
-  def initialize(build_path, cache_path = nil, layer_dir=nil)
+  def initialize(build_path, cache_path = nil)
     @build_path    = build_path
     @stack         = ENV.fetch("STACK")
     @cache         = LanguagePack::Cache.new(cache_path)
@@ -36,7 +35,6 @@ def initialize(build_path, cache_path = nil, layer_dir=nil)
     @bundler_cache = LanguagePack::BundlerCache.new(@cache, @stack)
     @id            = Digest::SHA1.hexdigest("#{Time.now.to_f}-#{rand(1000000)}")[0..10]
     @fetchers      = {:buildpack => LanguagePack::Fetcher.new(VENDOR_URL) }
-    @layer_dir     = layer_dir
     @arch = get_arch
 
     Dir.chdir build_path
@@ -103,24 +101,6 @@ def compile
     mcount "success"
   end
 
-  def build
-    write_release_toml
-    Kernel.puts ""
-    warnings.each do |warning|
-      Kernel.puts "\e[1m\e[33m###### WARNING:\e[0m"# Bold yellow
-      Kernel.puts ""
-      puts warning
-      Kernel.puts ""
-      Kernel.puts ""
-    end
-    if deprecations.any?
-      topic "DEPRECATIONS:"
-      puts @deprecations.join("\n")
-    end
-    Kernel.puts ""
-    mcount "success"
-  end
-
   def build_release
     release = {}
     release["addons"]                = default_addons
@@ -130,29 +110,6 @@ def build_release
     release
   end
 
-  def write_release_toml
-    release = build_release
-
-    layer = LanguagePack::Helpers::Layer.new(@layer_dir, "env", launch: true)
-    FileUtils.mkdir_p("#{layer.path}/env.launch")
-    release["config_vars"].each do |key, value|
-      File.open("#{layer.path}/env.launch/#{key.upcase}.override", 'w') do |f|
-        f.write(value)
-      end
-    end
-
-    release_toml = release["default_process_types"].map do |type, command|
-      <<PROCESSES
-[[processes]]
-type = "#{type}"
-command = "#{command}"
-PROCESSES
-    end
-    File.open("#{@layer_dir}/launch.toml", 'a') do |f|
-      f.write(release_toml.join("\n"))
-    end
-  end
-
   def write_release_yaml
     release = build_release
     FileUtils.mkdir("tmp") unless File.exists?("tmp")
@@ -163,11 +120,6 @@ def write_release_yaml
     warn_webserver
   end
 
-  # write out the release. Pick v2a or v3 release format
-  def write_release
-    @layer_dir ? write_release_toml : write_release_yaml
-  end
-
   def warn_webserver
     return if File.exist?("Procfile")
     msg =  "No Procfile detected, using the default web server.\n"
@@ -209,7 +161,7 @@ def setup_language_pack_environment
   end
 
   def add_to_profiled(string, filename: "ruby.sh", mode: "a")
-    profiled_path = @layer_dir ? "#{@layer_dir}/ruby/profile.d/" : "#{build_path}/.profile.d/"
+    profiled_path = "#{build_path}/.profile.d/"
 
     FileUtils.mkdir_p profiled_path
     File.open("#{profiled_path}/#{filename}", mode) do |file|
@@ -234,51 +186,32 @@ def add_to_export(string)
 
   # option can be :path, :default, :override
   # https://github.com/buildpacks/spec/blob/366ac1aa0be59d11010cc21aa06c16d81d8d43e7/buildpack.md#environment-variable-modification-rules
-  def export(key, val, layer: nil, option: nil)
-    if layer
-      # don't replace if the key is already set
-      return if ENV[key] && option == :default
-
-      filename =
-        if option.nil? || option == :path
-          key
-        elsif option == :default
-          "#{key}.override"
-        else
-          "#{key}.#{option}"
-        end
-
-      FileUtils.mkdir_p("#{layer.path}/env.build")
-      File.open("#{layer.path}/env.build/#{filename}", "w") do |f|
-        f.write(val)
-      end
-    else
-      string =
-        if option == :default
-          %{export #{key}="${#{key}:-#{val}}"}
-        elsif option == :path
-          %{export #{key}="#{val}:$#{key}"}
-        else
-          %{export #{key}="#{val.gsub('"','\"')}"}
-        end
-
-      export = File.join(ROOT_DIR, "export")
-      File.open(export, "a") do |file|
-        file.puts string
+  def export(key, val, option: nil)
+    string =
+      if option == :default
+        %{export #{key}="${#{key}:-#{val}}"}
+      elsif option == :path
+        %{export #{key}="#{val}:$#{key}"}
+      else
+        %{export #{key}="#{val.gsub('"','\"')}"}
       end
+
+    export = File.join(ROOT_DIR, "export")
+    File.open(export, "a") do |file|
+      file.puts string
     end
   end
 
-  def set_export_default(key, val, layer = nil)
-    export key, val, layer: layer, option: :default
+  def set_export_default(key, val)
+    export key, val, option: :default
   end
 
-  def set_export_override(key, val, layer = nil)
-    export key, val, layer: layer, option: :override
+  def set_export_override(key, val)
+    export key, val, option: :override
   end
 
-  def set_export_path(key, val, layer = nil)
-    export key, val, layer: layer, option: :path
+  def set_export_path(key, val)
+    export key, val, option: :path
   end
 
   def log_internal(*args)
diff --git a/lib/language_pack/helpers/layer.rb b/lib/language_pack/helpers/layer.rb
deleted file mode 100644
index 3e36df101..000000000
--- a/lib/language_pack/helpers/layer.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-require 'fileutils'
-require 'toml'
-
-class LanguagePack::Helpers::Layer
-  attr_reader :path
-
-  # Launch: True if you want the layer to exist in the final image, for example
-  # if you want maven for building an app but don't want it to boot the image.
-  # Build: True if you want to make the results of this buildpack available to other
-  # buildpacks in the compilation process.
-  # Cache: True if you want the layer to be pulled back in on the next build. False
-  # means the layer dir for this component will be empty on the next time.
-  def initialize(layer_dir, name, launch: false, build: false, cache: false)
-    @layer_dir = layer_dir
-    @name = name
-    @path = Pathname.new "#{@layer_dir}/#{@name}"
-    @toml = if File.exist?(toml_file)
-              TOML.load(File.read(toml_file))
-            else
-              Hash.new
-            end
-
-    @toml[:launch] = launch
-    @toml[:build] = build
-    @toml[:cache] = cache
-    if File.exist?(toml_file)
-      @toml[:metadata] = TOML.load(File.read(toml_file))[:metadata]
-    end
-    @toml[:metadata] ||= Hash.new
-
-    FileUtils.mkdir_p(@path)
-    write
-  end
-
-  # Key value store per layer
-  def metadata
-    @toml[:metadata]
-  end
-
-  def toml_file
-    @toml_file ||= "#{@layer_dir}/#{@name}.toml"
-  end
-
-  def write
-    File.open(toml_file, "w") do |file|
-      file.write TOML::Dumper.new(@toml).to_s
-    end
-  end
-
-  def validate!
-    valid, messages = yield metadata
-    unless valid
-      if messages.class.included_modules.include?(Enumerable)
-        messages.each {|message| puts message }
-      else
-        puts messages
-      end
-      @path.rmtree
-    end
-  end
-end
diff --git a/lib/language_pack/rails2.rb b/lib/language_pack/rails2.rb
index 1cf7322f8..ae0291bbb 100644
--- a/lib/language_pack/rails2.rb
+++ b/lib/language_pack/rails2.rb
@@ -55,12 +55,6 @@ def compile
     super
   end
 
-  def build
-    # TODO install plugins into separate layer
-    install_plugins
-    super
-  end
-
   def best_practice_warnings
     if env("RAILS_ENV") != "production"
       warn(<<-WARNING)
diff --git a/lib/language_pack/ruby.rb b/lib/language_pack/ruby.rb
index 4a3009b7e..1991ea5d2 100644
--- a/lib/language_pack/ruby.rb
+++ b/lib/language_pack/ruby.rb
@@ -8,7 +8,6 @@
 require "language_pack/helpers/nodebin"
 require "language_pack/helpers/node_installer"
 require "language_pack/helpers/yarn_installer"
-require "language_pack/helpers/layer"
 require "language_pack/helpers/binstub_check"
 require "language_pack/version"
 
@@ -19,8 +18,6 @@ class LanguagePack::Ruby < LanguagePack::Base
   LIBYAML_PATH         = "libyaml-#{LIBYAML_VERSION}"
   NODE_BP_PATH         = "vendor/node/bin"
 
-  Layer = LanguagePack::Helpers::Layer
-
   # detects if this is a valid Ruby app
   # @return [Boolean] true if it's a Ruby app
   def self.use?
@@ -111,57 +108,6 @@ def compile
     raise e
   end
 
-
-  def build
-    new_app?
-    remove_vendor_bundle
-    warn_bad_binstubs
-    ruby_layer = Layer.new(@layer_dir, "ruby", launch: true)
-    install_ruby("#{ruby_layer.path}/#{slug_vendor_ruby}")
-    ruby_layer.metadata[:version] = ruby_version.version
-    ruby_layer.metadata[:patchlevel] = ruby_version.patchlevel if ruby_version.patchlevel
-    ruby_layer.metadata[:engine] = ruby_version.engine.to_s
-    ruby_layer.metadata[:engine_version] = ruby_version.engine_version
-    ruby_layer.write
-
-    gem_layer = Layer.new(@layer_dir, "gems", launch: true, cache: true, build: true)
-    setup_language_pack_environment(
-      ruby_layer_path: ruby_layer.path,
-      gem_layer_path: gem_layer.path,
-      bundle_path: "#{gem_layer.path}/vendor/bundle",
-      bundle_default_without: "development:test"
-    )
-    allow_git do
-      # TODO install bundler in separate layer
-      topic "Loading Bundler Cache"
-      gem_layer.validate! do |metadata|
-        valid_bundler_cache?(gem_layer.path, gem_layer.metadata)
-      end
-      install_bundler_in_app("#{gem_layer.path}/#{slug_vendor_base}")
-      build_bundler
-      # TODO post_bundler might need to be done in a new layer
-      bundler.clean
-      gem_layer.metadata[:gems] = Digest::SHA2.hexdigest(File.read("Gemfile.lock"))
-      gem_layer.metadata[:stack] = @stack
-      gem_layer.metadata[:ruby_version] = run_stdout(%q(ruby -v)).strip
-      gem_layer.metadata[:rubygems_version] = run_stdout(%q(gem -v)).strip
-      gem_layer.metadata[:buildpack_version] = BUILDPACK_VERSION
-      gem_layer.write
-
-      create_database_yml
-      # TODO replace this with multibuildpack stuff? put binaries in their own layer?
-      install_binaries
-      run_assets_precompile_rake_task
-    end
-    setup_profiled(ruby_layer_path: ruby_layer.path, gem_layer_path: gem_layer.path)
-    setup_export(gem_layer)
-    config_detect
-    best_practice_warnings
-    cleanup
-
-    super
-  end
-
   def cleanup
   end
 
@@ -344,36 +290,28 @@ def setup_language_pack_environment(ruby_layer_path:, gem_layer_path:, bundle_pa
 
   # Sets up the environment variables for subsequent processes run by
   # muiltibuildpack. We can't use profile.d because $HOME isn't set up
-  def setup_export(layer = nil)
-    if layer
-      paths = ENV["PATH"]
-    else
-      paths = ENV["PATH"].split(":").map do |path|
-        /^\/.*/ !~ path ? "#{build_path}/#{path}" : path
-      end.join(":")
-    end
+  def setup_export
+    paths = ENV["PATH"].split(":").map do |path|
+      /^\/.*/ !~ path ? "#{build_path}/#{path}" : path
+    end.join(":")
 
     # TODO ensure path exported is correct
-    set_export_path "PATH", paths, layer
+    set_export_path "PATH", paths
 
-    if layer
-      gem_path = "#{layer.path}/#{slug_vendor_base}"
-    else
-      gem_path = "#{build_path}/#{slug_vendor_base}"
-    end
-    set_export_path "GEM_PATH", gem_path, layer
-    set_export_default "LANG", "en_US.UTF-8", layer
+    gem_path = "#{build_path}/#{slug_vendor_base}"
+    set_export_path "GEM_PATH", gem_path
+    set_export_default "LANG", "en_US.UTF-8"
 
     # TODO handle jruby
     if ruby_version.jruby?
       set_export_default "JRUBY_OPTS", default_jruby_opts
     end
 
-    set_export_default "BUNDLE_PATH", ENV["BUNDLE_PATH"], layer
-    set_export_default "BUNDLE_WITHOUT", ENV["BUNDLE_WITHOUT"], layer
-    set_export_default "BUNDLE_BIN", ENV["BUNDLE_BIN"], layer
-    set_export_default "BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE", ENV["BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE"], layer if bundler.needs_ruby_global_append_path?
-    set_export_default "BUNDLE_DEPLOYMENT", ENV["BUNDLE_DEPLOYMENT"], layer if ENV["BUNDLE_DEPLOYMENT"] # Unset on windows since we delete the Gemfile.lock
+    set_export_default "BUNDLE_PATH", ENV["BUNDLE_PATH"]
+    set_export_default "BUNDLE_WITHOUT", ENV["BUNDLE_WITHOUT"]
+    set_export_default "BUNDLE_BIN", ENV["BUNDLE_BIN"]
+    set_export_default "BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE", ENV["BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE"]
+    set_export_default "BUNDLE_DEPLOYMENT", ENV["BUNDLE_DEPLOYMENT"] # Unset on windows since we delete the Gemfile.lock
   end
 
   # sets up the profile.d script for this buildpack
@@ -607,7 +545,6 @@ def install_ruby(install_path)
     error message
   end
 
-  # TODO make this compatible with CNB
   def new_app?
     @new_app ||= !File.exist?("vendor/heroku")
   end
diff --git a/package.toml b/package.toml
deleted file mode 100644
index 54b0d2e45..000000000
--- a/package.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[buildpack]
-uri = "."
diff --git a/vendor/toml.rb b/vendor/toml.rb
deleted file mode 100644
index aaae10de5..000000000
--- a/vendor/toml.rb
+++ /dev/null
@@ -1,159 +0,0 @@
-require "ostruct"
-require "date"
-
-# From charlie Somerville
-# https://github.com/charliesome/toml2
-# https://github.com/hone/toml2
-#
-# Cloned and patched
-module TOML
-  def self.safe_load
-    raise NotImplementedError, "whoops"
-  end
-
-  def self.load(__toml)
-    __b = binding
-    __b.eval(to_ruby(__toml))
-    hashize(binding_vars(__b))
-  end
-
-  class << self
-  private
-    def _section(mergee)
-      b = nil
-      c = Object.new
-      c.singleton_class.send(:define_method, :[]) { |b_| b = b_ }
-      yield c
-      mergee.merge! binding_vars(b)
-    end
-
-    def binding_vars(b)
-      Hash[b.eval("local_variables").reject{|v|v[0,2]=="__"}.map{|l| [l, b.eval("#{l}")] }]
-    end
-
-    def hashize(obj, seen = {}.compare_by_identity)
-      return if seen[obj]
-      seen[obj] = true
-      case obj
-      when OpenStruct; hashize(obj.instance_variable_get(:@table), seen)
-      when Hash; Hash[obj.reject{|k,_|k[0, 2] == "__"}.map { |k,v| v = hashize(v, seen); v.nil? ? nil : [k, v] }.compact]
-      when Array; obj.map { |v| hashize(v, seen) }.compact
-      when Integer, Float, true, false, nil; seen[obj] = false; obj
-      else obj
-      end
-    end
-
-    def to_ruby(toml)
-      "if true\n#{toml.gsub(/^\s*\[([a-z0-9_.]+)\]\s*$/i){|sec|" end; #{1.
-      upto($1.split(".").length-1).map { |i| "#{$1.split(".")[0...i].join(
-      ".")}||=OpenStruct.new"}.join";"}; #{$1} = OpenStruct.new; _section(
-      #{$1}.instance_variable_get(:@table)) do |__| __[binding]; " }.gsub(
-      /\d{4}(-\d{2}){2}T(\d{2}:){2}\d{2}Z/){|x|"Date.parse(%{#{x}})"}}end"
-    end
-  end
-
-  # pulled from https://github.com/emancu/toml-rb/blob/master/lib/toml-rb/dumper.rb
-  class Dumper
-    def initialize(hash)
-      @toml_str = ''
-
-      visit(hash, [])
-    end
-
-    def to_s
-      @toml_str
-    end
-
-    private
-
-    def visit(hash, prefix, extra_brackets = false)
-      simple_pairs, nested_pairs, table_array_pairs = sort_pairs hash
-
-      if prefix.any? && (simple_pairs.any? || hash.empty?)
-        print_prefix prefix, extra_brackets
-      end
-
-      dump_pairs simple_pairs, nested_pairs, table_array_pairs, prefix
-    end
-
-    def sort_pairs(hash)
-      nested_pairs = []
-      simple_pairs = []
-      table_array_pairs = []
-
-      hash.keys.sort.each do |key|
-        val = hash[key]
-        element = [key, val]
-
-        if val.is_a? Hash
-          nested_pairs << element
-        elsif val.is_a?(Array) && val.first.is_a?(Hash)
-          table_array_pairs << element
-        else
-          simple_pairs << element
-        end
-      end
-
-      [simple_pairs, nested_pairs, table_array_pairs]
-    end
-
-    def dump_pairs(simple, nested, table_array, prefix = [])
-      # First add simple pairs, under the prefix
-      dump_simple_pairs simple
-      dump_nested_pairs nested, prefix
-      dump_table_array_pairs table_array, prefix
-    end
-
-    def dump_simple_pairs(simple_pairs)
-      simple_pairs.each do |key, val|
-        key = quote_key(key) unless bare_key? key
-        @toml_str << "#{key} = #{to_toml(val)}\n"
-      end
-    end
-
-    def dump_nested_pairs(nested_pairs, prefix)
-      nested_pairs.each do |key, val|
-        key = quote_key(key) unless bare_key? key
-
-        visit val, prefix + [key], false
-      end
-    end
-
-    def dump_table_array_pairs(table_array_pairs, prefix)
-      table_array_pairs.each do |key, val|
-        key = quote_key(key) unless bare_key? key
-        aux_prefix = prefix + [key]
-
-        val.each do |child|
-          print_prefix aux_prefix, true
-          args = sort_pairs(child) << aux_prefix
-
-          dump_pairs(*args)
-        end
-      end
-    end
-
-    def print_prefix(prefix, extra_brackets = false)
-      new_prefix = prefix.join('.')
-      new_prefix = '[' + new_prefix + ']' if extra_brackets
-
-      @toml_str += "[" + new_prefix + "]\n"
-    end
-
-    def to_toml(obj)
-      if obj.is_a? Time
-        obj.strftime('%Y-%m-%dT%H:%M:%SZ')
-      else
-        obj.inspect
-      end
-    end
-
-    def bare_key?(key)
-      !!key.to_s.match(/^[a-zA-Z0-9_-]*$/)
-    end
-
-    def quote_key(key)
-      '"' + key.gsub('"', '\\"') + '"'
-    end
-  end
-end