ruborg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e48935c72c444956ca0b7918efb14bd3d5b8a38273ec6843adec2fbb2da6968
+  data.tar.gz: f200cb546d62431ec1ff84544da0b96b9f84cf7877aa29627608f8c43119d2b7
+SHA512:
+  metadata.gz: 4614d7f78363f420ae4ce80355725fb84e068bfac0d94591f1cee56a6d14c7c6664dd415405462086bdf2fa7543187702f346645655b2bb32b5ffb62fea288a9
+  data.tar.gz: f70898563085b03b78cf4cf140abb5efd9bd3bd6881918aa7a77c976823a15469688e3aeafd6814c4ff880b3e5c8f949264a1c03f9b1251f3467d409ebe1f302

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--color
+--format documentation

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial gem structure
+- Borg repository initialization and management
+- Backup creation and restoration
+- YAML configuration file support
+- Passbolt CLI integration for password management
+- Command-line interface with Thor
+
+## [0.1.0] - 2025-10-04
+
+### Added
+- Initial release

data/CLAUDE.md

@@ -0,0 +1 @@
+- ruborg is a ruby gem to perform backups using borg. it reads a configuration file in yaml and instructs borg about what to do. it is a friendly fornt end of borg in ruby. it can create and access backup repositories. it can take and recall backup files or directories. it can interract with passbolt through cli to access encryption passwords.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Michail
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,186 @@
+# Ruborg
+
+> **⚠️ WARNING: This project is under heavy development and is not yet functional. Do not use in production.**
+>
+> This gem is being developed with the assistance of Claude AI.
+
+A friendly Ruby frontend for [Borg Backup](https://www.borgbackup.org/). Ruborg simplifies backup management by providing a YAML-based configuration system and seamless integration with Passbolt for encryption password management.
+
+## Features
+
+- 📦 **Repository Management** - Create and manage Borg backup repositories
+- 💾 **Backup & Restore** - Easy backup creation and archive restoration
+- 📝 **YAML Configuration** - Simple, readable configuration files
+- 🔐 **Passbolt Integration** - Secure password management via Passbolt CLI
+- 🎯 **Pattern Exclusions** - Flexible file exclusion patterns
+- 🗜️ **Compression Options** - Support for multiple compression algorithms
+
+## Prerequisites
+
+- Ruby >= 2.7.0
+- [Borg Backup](https://www.borgbackup.org/) installed and available in PATH
+- [Passbolt CLI](https://github.com/passbolt/go-passbolt-cli) (optional, for password management)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruborg'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install ruborg
+```
+
+## Configuration
+
+Create a `ruborg.yml` configuration file:
+
+```yaml
+# Repository path
+repository: /path/to/borg/repository
+
+# Paths to backup
+backup_paths:
+  - /home/user/documents
+  - /home/user/projects
+  - /etc
+
+# Exclude patterns
+exclude_patterns:
+  - "*.tmp"
+  - "*.log"
+  - "*/.cache/*"
+  - "*/node_modules/*"
+  - "*/.git/*"
+
+# Compression algorithm (lz4, zstd, zlib, lzma, none)
+compression: lz4
+
+# Encryption mode (repokey, keyfile, none)
+encryption: repokey
+
+# Passbolt integration (optional)
+passbolt:
+  resource_id: "your-passbolt-resource-uuid"
+```
+
+See `ruborg.yml.example` for a complete configuration template.
+
+## Usage
+
+### Initialize a Repository
+
+```bash
+# With passphrase
+ruborg init /path/to/repository --passphrase "your-passphrase"
+
+# With Passbolt
+ruborg init /path/to/repository --passbolt-id "resource-uuid"
+```
+
+### Create a Backup
+
+```bash
+# Using default configuration (ruborg.yml)
+ruborg backup
+
+# Using custom configuration file
+ruborg backup --config /path/to/config.yml
+
+# With custom archive name
+ruborg backup --name "my-backup-2025-10-04"
+```
+
+### List Archives
+
+```bash
+ruborg list
+```
+
+### Restore from Archive
+
+```bash
+# Restore to current directory
+ruborg restore archive-name
+
+# Restore to specific directory
+ruborg restore archive-name --destination /path/to/restore
+```
+
+### View Repository Information
+
+```bash
+ruborg info
+```
+
+## Passbolt Integration
+
+Ruborg can retrieve encryption passphrases from Passbolt using the Passbolt CLI:
+
+1. Install and configure [Passbolt CLI](https://github.com/passbolt/go-passbolt-cli)
+2. Store your Borg repository passphrase in Passbolt
+3. Add the resource ID to your `ruborg.yml`:
+
+```yaml
+passbolt:
+  resource_id: "your-passbolt-resource-uuid"
+```
+
+Ruborg will automatically retrieve the passphrase when performing backup operations.
+
+## Command Reference
+
+| Command | Description | Options |
+|---------|-------------|---------|
+| `init REPOSITORY` | Initialize a new Borg repository | `--passphrase`, `--passbolt-id` |
+| `backup` | Create a backup using config file | `--config`, `--name` |
+| `list` | List all archives in repository | `--config` |
+| `restore ARCHIVE` | Restore files from archive | `--config`, `--destination` |
+| `info` | Show repository information | `--config` |
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run:
+
+```bash
+bundle exec rake install
+```
+
+To release a new version, update the version number in `lib/ruborg/version.rb`, and then run:
+
+```bash
+bundle exec rake release
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+bundle exec rspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mpantel/ruborg.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Acknowledgments
+
+- [Borg Backup](https://www.borgbackup.org/) - The excellent backup tool this gem wraps
+- [Passbolt](https://www.passbolt.com/) - Secure password management

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/ruborg

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/ruborg"
+
+Ruborg::CLI.start(ARGV)

data/lib/ruborg/backup.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Ruborg
+  # Backup operations using Borg
+  class Backup
+    def initialize(repository, config:)
+      @repository = repository
+      @config = config
+    end
+
+    def create(name: nil)
+      raise BorgError, "Repository does not exist" unless @repository.exists?
+
+      archive_name = name || Time.now.strftime("%Y-%m-%d_%H-%M-%S")
+      cmd = build_create_command(archive_name)
+
+      execute_borg_command(cmd)
+    end
+
+    def extract(archive_name, destination: ".")
+      raise BorgError, "Repository does not exist" unless @repository.exists?
+
+      cmd = ["borg", "extract", "#{@repository.path}::#{archive_name}"]
+      cmd += ["--destination", destination] if destination != "."
+
+      execute_borg_command(cmd)
+    end
+
+    def list_archives
+      @repository.list
+    end
+
+    def delete(archive_name)
+      cmd = ["borg", "delete", "#{@repository.path}::#{archive_name}"]
+      execute_borg_command(cmd)
+    end
+
+    private
+
+    def build_create_command(archive_name)
+      cmd = ["borg", "create"]
+      cmd += ["--compression", @config.compression]
+
+      @config.exclude_patterns.each do |pattern|
+        cmd += ["--exclude", pattern]
+      end
+
+      cmd << "#{@repository.path}::#{archive_name}"
+      cmd += @config.backup_paths
+
+      cmd
+    end
+
+    def execute_borg_command(cmd)
+      result = system(*cmd)
+      raise BorgError, "Borg command failed: #{cmd.join(' ')}" unless result
+
+      result
+    end
+  end
+end

data/lib/ruborg/cli.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Ruborg
+  # Command-line interface for ruborg
+  class CLI < Thor
+    class_option :config, type: :string, default: "ruborg.yml", desc: "Path to configuration file"
+
+    desc "init REPOSITORY", "Initialize a new Borg repository"
+    option :passphrase, type: :string, desc: "Repository passphrase"
+    option :passbolt_id, type: :string, desc: "Passbolt resource ID for passphrase"
+    def init(repository_path)
+      passphrase = get_passphrase(options[:passphrase], options[:passbolt_id])
+      repo = Repository.new(repository_path, passphrase: passphrase)
+      repo.create
+      puts "Repository initialized at #{repository_path}"
+    rescue Error => e
+      error_exit(e)
+    end
+
+    desc "backup", "Create a backup using configuration file"
+    option :name, type: :string, desc: "Archive name"
+    def backup
+      config = Config.new(options[:config])
+      passphrase = fetch_passphrase_from_config(config)
+
+      repo = Repository.new(config.repository, passphrase: passphrase)
+      backup = Backup.new(repo, config: config)
+
+      backup.create(name: options[:name])
+      puts "Backup created successfully"
+    rescue Error => e
+      error_exit(e)
+    end
+
+    desc "list", "List all archives in the repository"
+    def list
+      config = Config.new(options[:config])
+      passphrase = fetch_passphrase_from_config(config)
+
+      repo = Repository.new(config.repository, passphrase: passphrase)
+      repo.list
+    rescue Error => e
+      error_exit(e)
+    end
+
+    desc "restore ARCHIVE", "Restore files from an archive"
+    option :destination, type: :string, default: ".", desc: "Destination directory"
+    def restore(archive_name)
+      config = Config.new(options[:config])
+      passphrase = fetch_passphrase_from_config(config)
+
+      repo = Repository.new(config.repository, passphrase: passphrase)
+      backup = Backup.new(repo, config: config)
+
+      backup.extract(archive_name, destination: options[:destination])
+      puts "Archive restored to #{options[:destination]}"
+    rescue Error => e
+      error_exit(e)
+    end
+
+    desc "info", "Show repository information"
+    def info
+      config = Config.new(options[:config])
+      passphrase = fetch_passphrase_from_config(config)
+
+      repo = Repository.new(config.repository, passphrase: passphrase)
+      repo.info
+    rescue Error => e
+      error_exit(e)
+    end
+
+    private
+
+    def get_passphrase(passphrase, passbolt_id)
+      return passphrase if passphrase
+      return Passbolt.new(resource_id: passbolt_id).get_password if passbolt_id
+
+      nil
+    end
+
+    def fetch_passphrase_from_config(config)
+      passbolt_config = config.passbolt_integration
+      return nil if passbolt_config.empty?
+
+      Passbolt.new(resource_id: passbolt_config["resource_id"]).get_password
+    end
+
+    def error_exit(error)
+      puts "Error: #{error.message}"
+      exit 1
+    end
+  end
+end

data/lib/ruborg/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "psych"
+
+module Ruborg
+  # Configuration management for ruborg
+  class Config
+    attr_reader :data
+
+    def initialize(config_path)
+      @config_path = config_path
+      load_config
+    end
+
+    def load_config
+      raise ConfigError, "Configuration file not found: #{@config_path}" unless File.exist?(@config_path)
+
+      @data = YAML.load_file(@config_path)
+    rescue Psych::SyntaxError => e
+      raise ConfigError, "Invalid YAML syntax: #{e.message}"
+    end
+
+    def repository
+      @data["repository"]
+    end
+
+    def backup_paths
+      @data["backup_paths"] || []
+    end
+
+    def exclude_patterns
+      @data["exclude_patterns"] || []
+    end
+
+    def compression
+      @data["compression"] || "lz4"
+    end
+
+    def encryption_mode
+      @data["encryption"] || "repokey"
+    end
+
+    def passbolt_integration
+      @data["passbolt"] || {}
+    end
+  end
+end

data/lib/ruborg/passbolt.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ruborg
+  # Passbolt CLI integration for password management
+  class Passbolt
+    def initialize(resource_id: nil)
+      @resource_id = resource_id
+      check_passbolt_cli
+    end
+
+    def get_password
+      raise PassboltError, "Resource ID not configured" unless @resource_id
+
+      cmd = ["passbolt", "get", @resource_id, "--json"]
+      output = `#{cmd.join(' ')}`
+
+      raise PassboltError, "Failed to retrieve password from Passbolt" unless $?.success?
+
+      parse_password(output)
+    end
+
+    private
+
+    def check_passbolt_cli
+      unless system("which passbolt > /dev/null 2>&1")
+        raise PassboltError, "Passbolt CLI not found. Please install it first."
+      end
+    end
+
+    def parse_password(json_output)
+      data = JSON.parse(json_output)
+      data["password"] || data["secret"]
+    rescue JSON::ParserError => e
+      raise PassboltError, "Failed to parse Passbolt response: #{e.message}"
+    end
+  end
+end

data/lib/ruborg/repository.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ruborg
+  # Borg repository management
+  class Repository
+    attr_reader :path
+
+    def initialize(path, passphrase: nil)
+      @path = path
+      @passphrase = passphrase
+    end
+
+    def exists?
+      File.directory?(@path) && File.exist?(File.join(@path, "config"))
+    end
+
+    def create
+      raise BorgError, "Repository already exists at #{@path}" if exists?
+
+      cmd = ["borg", "init", "--encryption=repokey", @path]
+      execute_borg_command(cmd)
+    end
+
+    def info
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      cmd = ["borg", "info", @path]
+      execute_borg_command(cmd)
+    end
+
+    def list
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      cmd = ["borg", "list", @path]
+      execute_borg_command(cmd)
+    end
+
+    private
+
+    def execute_borg_command(cmd)
+      env = {}
+      env["BORG_PASSPHRASE"] = @passphrase if @passphrase
+
+      result = system(env, *cmd)
+      raise BorgError, "Borg command failed: #{cmd.join(' ')}" unless result
+
+      result
+    end
+  end
+end

data/lib/ruborg/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ruborg
+  VERSION = "0.1.0"
+end

data/lib/ruborg.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "ruborg/version"
+require_relative "ruborg/config"
+require_relative "ruborg/repository"
+require_relative "ruborg/backup"
+require_relative "ruborg/passbolt"
+require_relative "ruborg/cli"
+
+module Ruborg
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class BorgError < Error; end
+  class PassboltError < Error; end
+end

data/ruborg.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/ruborg/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruborg"
+  spec.version = Ruborg::VERSION
+  spec.authors = ["Michail Pantelelis"]
+  spec.email = ["mpantel@aegean.gr"]
+
+  spec.summary = "A friendly Ruby frontend for Borg backup"
+  spec.description = "Ruborg is a Ruby gem that provides a user-friendly interface to Borg backup. It reads YAML configuration files and orchestrates backup operations, supporting repository creation, backup management, and integration with Passbolt for encryption password management."
+  spec.homepage = "https://github.com/mpantel/ruborg"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "#{spec.homepage}.git"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_dependency "thor", "~> 1.3"
+  spec.add_dependency "psych", "~> 5.0"
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+end

data/ruborg.yml.example

@@ -0,0 +1,28 @@
+# Ruborg configuration example
+
+# Repository path
+repository: /path/to/borg/repository
+
+# Paths to backup
+backup_paths:
+  - /home/user/documents
+  - /home/user/projects
+  - /etc
+
+# Exclude patterns
+exclude_patterns:
+  - "*.tmp"
+  - "*.log"
+  - "*/.cache/*"
+  - "*/node_modules/*"
+  - "*/.git/*"
+
+# Compression algorithm (lz4, zstd, zlib, lzma, none)
+compression: lz4
+
+# Encryption mode (repokey, keyfile, none)
+encryption: repokey
+
+# Passbolt integration (optional)
+passbolt:
+  resource_id: "your-passbolt-resource-uuid"

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: ruborg
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michail Pantelelis
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Ruborg is a Ruby gem that provides a user-friendly interface to Borg
+  backup. It reads YAML configuration files and orchestrates backup operations, supporting
+  repository creation, backup management, and integration with Passbolt for encryption
+  password management.
+email:
+- mpantel@aegean.gr
+executables:
+- ruborg
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- CLAUDE.md
+- LICENSE
+- README.md
+- Rakefile
+- exe/ruborg
+- lib/ruborg.rb
+- lib/ruborg/backup.rb
+- lib/ruborg/cli.rb
+- lib/ruborg/config.rb
+- lib/ruborg/passbolt.rb
+- lib/ruborg/repository.rb
+- lib/ruborg/version.rb
+- ruborg.gemspec
+- ruborg.yml.example
+homepage: https://github.com/mpantel/ruborg
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mpantel/ruborg
+  source_code_uri: https://github.com/mpantel/ruborg.git
+  changelog_uri: https://github.com/mpantel/ruborg/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: A friendly Ruby frontend for Borg backup
+test_files: []