s3-tar-backup 1.1.2 → 1.1.3

data/lib/s3_tar_backup/backend/backend_object.rb

@@ -0,0 +1,3 @@
+module S3TarBackup::Backend
+  BackendObject = Struct.new(:path, :size)
+end

data/lib/s3_tar_backup/backend/file_backend.rb

@@ -0,0 +1,52 @@
+require 'fileutils'
+require 'pathname'
+
+require_relative 'upload_item_failed_error'
+require_relative 'backend_object'
+
+module S3TarBackup::Backend
+  class FileBackend
+    attr_reader :prefix
+
+    def initialize(path)
+      @prefix = Pathname.new(path).absolute? ? path : File.expand_path(File.join('~', path))
+    end
+
+    def name
+      "File"
+    end
+
+    def remove_item(relative_path)
+      File.delete(File.join(@prefix, relative_path))
+    end
+
+    def item_exists?(relative_path)
+      File.exists?(File.join(@prefix, relative_path))
+    end
+
+    def download_item(relative_path, local_path)
+      FileUtils.cp(File.join(@prefix, relative_path), local_path)
+    end
+
+    def upload_item(relative_path, local_path, remove_original)
+      path = File.join(@prefix, relative_path)
+      FileUtils.mkdir_p(File.dirname(path)) unless File.directory?(File.dirname(path))
+      if remove_original
+        FileUtils.mv(local_path, path)
+      else
+        FileUtils.cp(local_path, path)
+      end
+    end
+
+    def list_items(relative_path='')
+      return [] unless File.directory?(File.join(@prefix, relative_path))
+      relative_path = '.' if relative_path.nil? || relative_path.empty?
+      Dir.chdir(@prefix) do
+        Dir.entries(relative_path).select{ |x| File.file?(x) }.map do |x|
+          path = File.join(relative_path, x)
+          BackendObject.new(path, File.size?(path))
+        end
+      end
+    end
+  end
+end

data/lib/s3_tar_backup/backend/s3_backend.rb

@@ -0,0 +1,62 @@
+require 'aws-sdk'
+
+require_relative 'upload_item_failed_error'
+require_relative 'backend_object'
+
+module S3TarBackup::Backend
+  class S3Backend
+    attr_reader :prefix
+
+    @s3
+
+    def initialize(access_key, secret_key, region, dest_prefix)
+      warn "No AWS region specified (config key settings.s3_region). Assuming eu-west-1" unless region
+      @s3 = AWS::S3.new(access_key_id: access_key, secret_access_key: secret_key, region: region || 'eu-west-1')
+      @prefix = dest_prefix
+    end
+
+    def name
+      "S3"
+    end
+
+    def remove_item(relative_path)
+      bucket, path = parse_bucket_object("#{@prefix}/#{relative_path}")
+      @s3.buckets[bucket].objects[path].delete
+    end
+
+    def item_exists?(relative_path)
+      bucket, path = parse_bucket_object("#{@prefix}/#{relative_path}")
+      @s3.buckets[bucket].objects[path].exists?
+    end
+
+    def download_item(relative_path, local_path)
+      bucket, path = parse_bucket_object("#{@prefix}/#{relative_path}")
+      object = @s3.buckets[bucket].objects[path]
+      open(local_path, 'wb') do |f|
+        object.read do |chunk|
+          f.write(chunk)
+        end
+      end
+    end
+
+    def upload_item(relative_path, local_path, remove_original)
+      bucket, path = parse_bucket_object("#{@prefix}/#{relative_path}")
+      @s3.buckets[bucket].objects.create(path, Pathname.new(local_path))
+      File.delete(local_path) if remove_original
+    rescue Errno::ECONNRESET => e
+      raise UploadItemFailedError.new, e.message
+    end
+
+    def list_items(relative_path='')
+      bucket, path = parse_bucket_object("#{@prefix}/#{relative_path}")
+      @s3.buckets[bucket].objects.with_prefix(path).map do |x|
+        BackendObject.new(x.key, x.content_length)
+      end
+    end
+
+  private
+    def parse_bucket_object(path)
+      path.split('/', 2)
+    end
+  end
+end

data/lib/s3_tar_backup/backend/upload_item_failed_error.rb

@@ -0,0 +1,4 @@
+module S3TarBackup::Backend
+  class UploadItemFailedError < StandardError
+  end
+end

data/lib/s3_tar_backup/backup.rb

@@ -1,91 +1,118 @@
-require 'aws-sdk'
+require 'fileutils'
+require 'pathname'
 
 module S3TarBackup
-	class Backup
-		@backup_dir
-		@name
-		@sources
-		@exclude
-		@time # Here to avoid any sort of race conditions
-		@archive
-		@compression_flag
-		@compression_ext
-		@gpg_key
-
-		COMPRESSIONS = {
-			:gzip => {:flag => '-z', :ext => 'tar.gz'},
-			:bzip2 => {:flag => '-j', :ext => 'tar.bz2'},
-			:lzma => {:flag => '--lzma', :ext => 'tar.lzma'},
-			:lzma2 => {:flag => '-J', :ext => 'tar.xz'}
-		}
-
-		ENCRYPTED_EXTENSION = 'asc'
-
-
-		def initialize(backup_dir, name, sources, exclude, compression=:bzip2, gpg_key=nil)
-			@backup_dir, @name, @sources, @exclude = backup_dir, name, [*sources], [*exclude]
-			raise "Unknown compression #{compression}. Valid options are #{COMPRESSIONS.keys.join(', ')}" unless COMPRESSIONS.has_key?(compression)
-			@compression_flag = COMPRESSIONS[compression][:flag]
-			@compression_ext = COMPRESSIONS[compression][:ext]
-			@time = Time.now
-			@gpg_key = gpg_key
-
-			Dir.mkdir(@backup_dir) unless File.directory?(@backup_dir)
-		end
-
-		def snar
-			"backup-#{@name}.snar"
-		end
-
-		def snar_path
-			File.join(@backup_dir, snar)
-		end
-
-		def snar_exists?
-			File.exists?(snar_path)
-		end
-
-		def archive
-			return @archive if @archive
-			type = snar_exists? ? 'incr' : 'full'
-			encrypted_bit = @gpg_key ? ".#{ENCRYPTED_EXTENSION}" : ''
-			File.join(@backup_dir, "backup-#{@name}-#{@time.strftime('%Y%m%d_%H%M%S')}-#{type}.#{@compression_ext}#{encrypted_bit}")
-		end
-
-		def backup_cmd(verbose=false)
-			exclude = @exclude.map{ |e| " --exclude \"#{e}\""}.join
-			sources = @sources.map{ |s| "\"#{s}\""}.join(' ')
-			@archive = archive
-			tar_archive = @gpg_key ? '' : "f \"#{@archive}\""
-			gpg_cmd = @gpg_key ? " | gpg -r #{@gpg_key} -o \"#{@archive}\" --always-trust --yes --batch --no-tty -e" : ''
-			"tar c#{verbose ? 'v' : ''}#{tar_archive} #{@compression_flag} -g \"#{snar_path}\"#{exclude} --no-check-device #{sources}#{gpg_cmd}"
-		end
-
-		def self.parse_object(object, profile)
-			name = File.basename(object.key)
-			match = name.match(/^backup-([\w\-]+)-(\d\d\d\d)(\d\d)(\d\d)_(\d\d)(\d\d)(\d\d)-(\w+)\.(.*?)(\.#{ENCRYPTED_EXTENSION})?$/)
-			return nil unless match && match[1] == profile
-
-			return {
-				:type => match[8].to_sym,
-				:date => Time.new(match[2].to_i, match[3].to_i, match[4].to_i, match[5].to_i, match[6].to_i, match[7].to_i),
-				:name => name,
-				:ext => match[9],
-				:size => object.content_length,
-				:profile => match[1],
-				:compression => COMPRESSIONS.find{ |k,v| v[:ext] == match[9] }[0],
-				:encryption => !match[10].nil?
-			}
-		end
-
-		# No real point in creating a whole new class for this one
-		def self.restore_cmd(restore_into, restore_from, verbose=false)
-			ext, encrypted = restore_from.match(/[^\.\\\/]+\.(.*?)(\.#{ENCRYPTED_EXTENSION})?$/)[1..2]
-			compression_flag = COMPRESSIONS.find{ |k,v| v[:ext] == ext }[1][:flag]
-			tar_archive = encrypted ? '' : "f \"#{restore_from}\""
-			gpg_cmd = encrypted ? "gpg --yes --batch --no-tty -d \"#{restore_from}\" | " : ''
-			"#{gpg_cmd}tar xp#{verbose ? 'v' : ''}#{tar_archive} #{compression_flag} -G -C #{restore_into}"
-		end
-
-	end
+  class Backup
+    @backup_dir
+    @name
+    @sources
+    @exclude
+    @time # Here to avoid any sort of race conditions
+    @archive
+    @compression_flag
+    @compression_ext
+    @encryption
+
+    COMPRESSIONS = {
+      :none => {:flag => '', :ext => 'tar'},
+      :gzip => {:flag => '-z', :ext => 'tar.gz'},
+      :bzip2 => {:flag => '-j', :ext => 'tar.bz2'},
+      :lzma => {:flag => '--lzma', :ext => 'tar.lzma'},
+      :lzma2 => {:flag => '-J', :ext => 'tar.xz'}
+    }
+
+    ENCRYPTED_EXTENSIONS = { :gpg_key => 'asc', :password_file => 'gpg' }
+    PASSPHRASE_CIPHER_ALGO = 'AES256'
+
+
+    def initialize(backup_dir, name, sources, exclude, compression=:bzip2, encryption=nil)
+      @backup_dir, @name = backup_dir, name
+      raise "Unknown compression #{compression}. Valid options are #{COMPRESSIONS.keys.join(', ')}" unless COMPRESSIONS.has_key?(compression)
+      @compression_flag = COMPRESSIONS[compression][:flag]
+      @compression_ext = COMPRESSIONS[compression][:ext]
+      @time = Time.now
+      @encryption = encryption
+
+      @sources = [*sources].map{ |x| x.gsub('\\', '/') }
+      @exclude = [*exclude].map{ |x| x.gsub('\\', '/') }
+
+      # If the backup dir is inside any of the sources, exclude it
+      absolute_backup_dir = File.absolute_path(backup_dir)
+      # I cannot for the life of me get tar to accept absolute paths to directories. Passing a path relative to the CWD seems to work though
+      @exclude.push(*@sources.select{ |x| absolute_backup_dir.start_with?(File.absolute_path(x)) }.map{ |x| Pathname.new(absolute_backup_dir).relative_path_from(Pathname.new(Dir.pwd)).to_s })
+
+      FileUtils.mkdir_p(@backup_dir) unless File.directory?(@backup_dir)
+    end
+
+    def snar
+      "backup-#{@name}.snar"
+    end
+
+    def snar_path
+      File.join(@backup_dir, snar)
+    end
+
+    def tmp_snar_path
+      snar_path + '.tmp'
+    end
+
+    def snar_exists?
+      File.exists?(snar_path)
+    end
+
+    def archive
+      return @archive if @archive
+      type = snar_exists? ? 'incr' : 'full'
+      encrypted_bit = @encryption ? ".#{ENCRYPTED_EXTENSIONS[@encryption[:type]]}" : ''
+      File.join(@backup_dir, "backup-#{@name}-#{@time.strftime('%Y%m%d_%H%M%S')}-#{type}.#{@compression_ext}#{encrypted_bit}")
+    end
+
+    def backup_cmd(verbose=false)
+      exclude = @exclude.map{ |e| " --exclude \"#{e}\""}.join
+      sources = @sources.map{ |s| "\"#{s}\""}.join(' ')
+      @archive = archive
+      tar_archive = @encryption ? '' : "f \"#{@archive}\""
+      gpg_cmd = @encryption.nil? ? '' : case @encryption[:type]
+      when :gpg_key
+        " | gpg -r #{@encryption[:gpg_key]} -o \"#{@archive}\" --always-trust --yes --batch --no-tty -e"
+      when :password_file
+        " | gpg -c --passphrase-file \"#{@encryption[:password_file]}\" --cipher-algo #{PASSPHRASE_CIPHER_ALGO} -o \"#{@archive}\" --batch --yes --no-tty"
+      end
+      "tar c#{verbose ? 'v' : ''}#{tar_archive} #{@compression_flag} -g \"#{tmp_snar_path}\"#{exclude} --no-check-device #{sources}#{gpg_cmd}"
+    end
+
+    def self.parse_object(object, profile)
+      name = File.basename(object.path)
+      match = name.match(/^backup-([\w\-]+)-(\d\d\d\d)(\d\d)(\d\d)_(\d\d)(\d\d)(\d\d)-(\w+)\.(.*?)(?:\.(#{ENCRYPTED_EXTENSIONS.values.join('|')}))?$/)
+      return nil unless match && match[1] == profile
+
+      return {
+        :type => match[8].to_sym,
+        :date => Time.new(match[2].to_i, match[3].to_i, match[4].to_i, match[5].to_i, match[6].to_i, match[7].to_i),
+        :name => name,
+        :ext => match[9],
+        :size => object.size,
+        :profile => match[1],
+        :compression => COMPRESSIONS.find{ |k,v| v[:ext] == match[9] }[0],
+        :encryption => match[10].nil? ? nil : ENCRYPTED_EXTENSIONS.key(match[10])
+      }
+    end
+
+    # No real point in creating a whole new class for this one
+    def self.restore_cmd(restore_into, restore_from, verbose=false, password_file=nil)
+      ext, encryption_ext = restore_from.match(/[^\.\\\/]+\.(.*?)(?:\.(#{ENCRYPTED_EXTENSIONS.values.join('|')}))?$/)[1..2]
+      encryption = ENCRYPTED_EXTENSIONS.key(encryption_ext)
+      compression_flag = COMPRESSIONS.find{ |k,v| v[:ext] == ext }[1][:flag]
+      tar_archive = encryption ? '' : "f \"#{restore_from}\""
+      gpg_cmd = encryption.nil? ? '' : case encryption
+      when :gpg_key
+        "gpg --yes -d \"#{restore_from}\" | "
+      when :password_file
+        flag = password_file && !password_file.empty? ? " --passphrase-file \"#{password_file}\"" : ''
+        "gpg --yes#{flag} -d \"#{restore_from}\" | "
+      end
+      "#{gpg_cmd}tar xp#{verbose ? 'v' : ''}#{tar_archive} #{compression_flag} -G -C #{restore_into}"
+    end
+
+  end
 end

data/lib/s3_tar_backup/ini_parser.rb

@@ -1,207 +1,208 @@
 module S3TarBackup
-	class IniParser
-		@config
-		@comments
-		@file_path
-		@defaults
-
-		def initialize(file_path, defaults={})
-			@file_path, @defaults = file_path, defaults
-		end
-
-		# Loads the config from file, and parses it
-		def load
-			if File.exists?(@file_path) && !File.directory?(@file_path)
-				File.open(@file_path) do |f|
-					@config, @comments = parse_config(f.readlines)
-				end
-			else
-				@config, @comments = {}, {}
-			end
-			apply_defaults(@defaults)
-			self # Allow chaining
-		end
-
-		# Saves the config to file
-		def save
-			File.open(@file_path, 'w') do |f|
-				f.write(render_config)
-			end
-		end
-
-		# Parses a set of lines in a config file, turning them into sections and comments
-		def parse_config(config_lines)
-			# TODO get rid of all the {:before => [], :after => nil}
-			config, comments = {}, {}
-			section = nil
-			next_comment = {:before => [], :after => nil}
-
-			config_lines.each do |line|
-				case line.chomp
-				# Section
-				when /^\[([\w\-]+)(?: "([\w\-]+)")?\]$/
-					section = $1.chomp
-					section << ".#{$2.chomp}" if $2
-					section = section.to_sym
-					config[section] = {} unless config.has_key?(section)
-					comments[section] = {} unless comments.has_key?(section)
-					next_comment = {:before => [], :after => nil}
-					# key line
-				when /^([\w\-]+)\s*=\s*([^;]*?)\s*(?:;\s+(.*))?$/
-					raise "Config key before section" unless section
-					key = $1.chomp.to_sym
-					if config[section].has_key?(key)
-						config[section][key] = [config[section][key]] unless config[section][key].is_a?(Array)
-						config[section][key] << $2.chomp
-					else
-						config[section][key] = $2.chomp
-					end
-					# If we found a comment at the end of the line
-					next_comment[:after] = $3 if $3
-					comments[section][key] = next_comment unless next_comment == {:before => [], :after => nil}
-					next_comment = {:before => [], :after => nil}
-				when /;\s?(.*)/
-					next_comment[:before] << $1
-				end
-			end
-
-			[config, comments]
-		end
-
-		# Applies the defaults passed to the constructor
-		def apply_defaults(defaults)
-			defaults.each do |key, default|
-				section, key = key.match(/(.*)\.(.*)/)[1..2]
-
-				if default.is_a?(Array)
-					default_val, comment = default
-				else
-					default_val, comment = default, nil
-				end
-
-				@config[section] = {} unless @config.has_key?(section)
-				set("#{section}.#{key}", default_val, comment)
-			end
-		end
-
-		# Takes the current config, and renders it
-		def render_config(comments=true)
-			r = ''
-			@config.each do |section_key, section|
-				section_key_parts = section_key.to_s.split('.')
-				if section_key_parts.count > 1
-					r << "\n[#{section_key_parts.shift} \"#{section_key_parts.join(' ')}\"]\n\n"
-				else
-					r << "\n[#{section_key}]\n\n"
-				end
-				section.each do |key, values|
-					values = [*values]
-					comments_before, comments_after = '', ''
-					if comments && @comments.include?(section_key) && @comments[section_key].include?(key)
-						comments_before = @comments[section_key][key][:before].inject(''){ |s,v| s << "; #{v}\n" }
-						comments_after = " ; #{@comments[section_key][key][:after]}" if @comments[section_key][key][:after]
-					end
-					r << comments_before
-					r << values.map{ |value| "#{key} = #{value}" }.join("\n")
-					r << comments_after << "\n\n"
-				end
-			end
-			r.lstrip.rstrip
-		end
-
-		def [](arg)
-			get(arg)
-		end
-
-		# Used to retrieve a config value, with an optional default.
-		# arg: The config key to get, in the form <section>.<key>
-		# default: The value to return if the key doesn't exist.
-		# This function will use type information from self.defaults / default, if available.
-		# Example: config_object.get('section.key', 'default_value')
-		def get(arg, default=nil)
-			section, key = arg.match(/(.*)\.(.*)/)[1..2]
-			section = section.to_sym
-			key = key.to_sym
-
-			unless @config.has_key?(section) && @config[section].has_key?(key)
-				raise "Tried to access config key #{section}.#{key} which doesn't exist" if default.nil?
-				return default
-			end
-
-			val = @config[section][key]
-			# Is it one of the reserved keywords...?
-			case val
-			when 'True' then return true
-			when 'False' then return false
-			when 'None' then return nil
-			end
-
-			# Attempt to case... Is there a default?
-			if default
-				type = default.class
-			elsif @defaults.has_key?("#{section}.#{key}")
-				type = @defaults["#{section}.#{key}"].class
-				# If default is of the form (value, comment)
-				type = @defaults["#{section}.#{key}"][0].class if type.is_a?(Array)
-			else
-				type = nil
-			end
-
-			case type
-			when Integer
-				return val.to_i
-			when Float
-				return val.to_f
-			else
-				return val
-			end
-		end
-
-		def []=(arg, value)
-			set(arg, value)
-		end
-
-		# Used to set a config value, with optional comments.
-		# arg; The config key to set, in the form <section>.<key>
-		# comments: The comments to set, if any. If multiple lines are desired, they should be separated by "\n"
-		# Example: config_object.set('section.key', 'value', 'This is the comment\nExplaining section.key')
-		def set(arg, value, comments=nil)
-			section, key = arg.match(/(.*)\.(.*)/)[1..2]
-			section = section.to_sym
-			key = key.to_sym
-
-			# Is it one of our special values?
-			case value
-			when true then value = 'True'
-			when false then value = 'False'
-			when nil then value = 'None'
-			end
-
-			@config[section] = {} unless @config.has_key?(section)
-			@config[section][key] = value
-
-			if comments
-				comments = comments.split("\n")
-				@comments[section] = {} unless @comments.has_key?(section)
-				@comments[section][key] = {:before => comments, :after => nil}
-			end
-		end
-
-		def has_section?(section)
-			@config.has_key?(section.to_sym)
-		end
-
-		def find_sections(pattern=/.*/)
-			@config.select{ |k,v| k =~ pattern }
-		end
-
-		def each
-			@config.each_with_index do |section_key, section|
-				section.each_with_index do |key, value|
-					key_str = "#{section_key}#{key}"
-					yield key_str, get(key_str)
-				end
-			end
-		end
-	end
+  class IniParser
+    attr_reader :file_path
+
+    @config
+    @comments
+    @defaults
+
+    def initialize(file_path, defaults={})
+      @file_path, @defaults = file_path, defaults
+    end
+
+    # Loads the config from file, and parses it
+    def load
+      if File.exists?(@file_path) && !File.directory?(@file_path)
+        File.open(@file_path) do |f|
+          @config, @comments = parse_config(f.readlines)
+        end
+      else
+        @config, @comments = {}, {}
+      end
+      apply_defaults(@defaults)
+      self # Allow chaining
+    end
+
+    # Saves the config to file
+    def save
+      File.open(@file_path, 'w') do |f|
+        f.write(render_config)
+      end
+    end
+
+    # Parses a set of lines in a config file, turning them into sections and comments
+    def parse_config(config_lines)
+      # TODO get rid of all the {:before => [], :after => nil}
+      config, comments = {}, {}
+      section = nil
+      next_comment = {:before => [], :after => nil}
+
+      config_lines.each do |line|
+        case line.chomp
+        # Section
+        when /^\[([\w\-]+)(?: "([\w\-]+)")?\]$/
+          section = $1.chomp
+          section << ".#{$2.chomp}" if $2
+          section = section.to_sym
+          config[section] = {} unless config.has_key?(section)
+          comments[section] = {} unless comments.has_key?(section)
+          next_comment = {:before => [], :after => nil}
+          # key line
+        when /^([\w\-]+)\s*=\s*([^;]*?)\s*(?:;\s+(.*))?$/
+          raise "Config key before section" unless section
+          key = $1.chomp.to_sym
+          if config[section].has_key?(key)
+            config[section][key] = [config[section][key]] unless config[section][key].is_a?(Array)
+            config[section][key] << $2.chomp
+          else
+            config[section][key] = $2.chomp
+          end
+          # If we found a comment at the end of the line
+          next_comment[:after] = $3 if $3
+          comments[section][key] = next_comment unless next_comment == {:before => [], :after => nil}
+          next_comment = {:before => [], :after => nil}
+        when /;\s?(.*)/
+          next_comment[:before] << $1
+        end
+      end
+
+      [config, comments]
+    end
+
+    # Applies the defaults passed to the constructor
+    def apply_defaults(defaults)
+      defaults.each do |key, default|
+        section, key = key.match(/(.*)\.(.*)/)[1..2]
+
+        if default.is_a?(Array)
+          default_val, comment = default
+        else
+          default_val, comment = default, nil
+        end
+
+        @config[section] = {} unless @config.has_key?(section)
+        set("#{section}.#{key}", default_val, comment)
+      end
+    end
+
+    # Takes the current config, and renders it
+    def render_config(comments=true)
+      r = ''
+      @config.each do |section_key, section|
+        section_key_parts = section_key.to_s.split('.')
+        if section_key_parts.count > 1
+          r << "\n[#{section_key_parts.shift} \"#{section_key_parts.join(' ')}\"]\n\n"
+        else
+          r << "\n[#{section_key}]\n\n"
+        end
+        section.each do |key, values|
+          values = [*values]
+          comments_before, comments_after = '', ''
+          if comments && @comments.include?(section_key) && @comments[section_key].include?(key)
+            comments_before = @comments[section_key][key][:before].inject(''){ |s,v| s << "; #{v}\n" }
+            comments_after = " ; #{@comments[section_key][key][:after]}" if @comments[section_key][key][:after]
+          end
+          r << comments_before
+          r << values.map{ |value| "#{key} = #{value}" }.join("\n")
+          r << comments_after << "\n\n"
+        end
+      end
+      r.lstrip.rstrip
+    end
+
+    def [](arg)
+      get(arg)
+    end
+
+    # Used to retrieve a config value, with an optional default.
+    # arg: The config key to get, in the form <section>.<key>
+    # default: The value to return if the key doesn't exist.
+    # This function will use type information from self.defaults / default, if available.
+    # Example: config_object.get('section.key', 'default_value')
+    def get(arg, default=nil)
+      section, key = arg.match(/(.*)\.(.*)/)[1..2]
+      section = section.to_sym
+      key = key.to_sym
+
+      unless @config.has_key?(section) && @config[section].has_key?(key)
+        raise "Tried to access config key #{section}.#{key} which doesn't exist" if default.nil?
+        return default
+      end
+
+      val = @config[section][key]
+      # Is it one of the reserved keywords...?
+      case val
+      when 'True' then return true
+      when 'False' then return false
+      when 'None' then return nil
+      end
+
+      # Attempt to case... Is there a default?
+      if default
+        type = default.class
+      elsif @defaults.has_key?("#{section}.#{key}")
+        type = @defaults["#{section}.#{key}"].class
+        # If default is of the form (value, comment)
+        type = @defaults["#{section}.#{key}"][0].class if type.is_a?(Array)
+      else
+        type = nil
+      end
+
+      case type
+      when Integer
+        return val.to_i
+      when Float
+        return val.to_f
+      else
+        return val
+      end
+    end
+
+    def []=(arg, value)
+      set(arg, value)
+    end
+
+    # Used to set a config value, with optional comments.
+    # arg; The config key to set, in the form <section>.<key>
+    # comments: The comments to set, if any. If multiple lines are desired, they should be separated by "\n"
+    # Example: config_object.set('section.key', 'value', 'This is the comment\nExplaining section.key')
+    def set(arg, value, comments=nil)
+      section, key = arg.match(/(.*)\.(.*)/)[1..2]
+      section = section.to_sym
+      key = key.to_sym
+
+      # Is it one of our special values?
+      case value
+      when true then value = 'True'
+      when false then value = 'False'
+      when nil then value = 'None'
+      end
+
+      @config[section] = {} unless @config.has_key?(section)
+      @config[section][key] = value
+
+      if comments
+        comments = comments.split("\n")
+        @comments[section] = {} unless @comments.has_key?(section)
+        @comments[section][key] = {:before => comments, :after => nil}
+      end
+    end
+
+    def has_section?(section)
+      @config.has_key?(section.to_sym)
+    end
+
+    def find_sections(pattern=/.*/)
+      @config.select{ |k,v| k =~ pattern }
+    end
+
+    def each
+      @config.each_with_index do |section_key, section|
+        section.each_with_index do |key, value|
+          key_str = "#{section_key}#{key}"
+          yield key_str, get(key_str)
+        end
+      end
+    end
+  end
 end