castled 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b32ade60008579e7327153766c0cb2863380e65676f74333ddefdfaf576d496a
+  data.tar.gz: d130e839828dd6b38a40317698f4f6eda5f974b68a99d009792f70a581201bdc
+SHA512:
+  metadata.gz: bef65346414a4945081b6f11fd961576b42a890a184be7cb35d3a1dd992c852f3ae92e4e3792933888366c889efa63fe3f6303310dbcbb8edc9a9b3b09fb2580
+  data.tar.gz: dc0d75e763b14b13bd3f7838cb5bb713fc71dd89179a7b95b6b7f7bfe51ea27c63faeb37ca8442dcc8f16572beea3ea5c3882afa3f4d37c8e14395eb3ec8795f

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "rake"
+end
+
+gem "minitest", "~> 6.0", group: :development

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    castled (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    drb (2.2.3)
+    minitest (6.0.6)
+      drb (~> 2.0)
+      prism (~> 1.5)
+    prism (1.9.0)
+    rake (13.4.2)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  castled!
+  minitest (~> 6.0)
+  rake (>= 13.0, >= 0)
+
+CHECKSUMS
+  castled (0.1.1)
+  drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
+  minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
+  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+
+BUNDLED WITH
+  4.0.6

data/README.md

@@ -0,0 +1,109 @@
+# Castled
+
+**Simple backups for Omarchy. Opinionated defaults, zero ceremony.**
+
+Omarchy gives you a beautiful, modern, fully configured Linux system in one shot — the omakase menu, chef's choice. Castled applies the same spirit to backups: a tiny, plain-text tool that saves the dotfiles you care about without turning disaster recovery into another configuration hobby.
+
+No bespoke backup framework. No paradox of choice. Just `init`, `backup`, and `restore`.
+
+## Why Castled?
+
+- **Curated from the start** — `simple-backup init` writes a sensible Omarchy-oriented `config.yml` you can edit in seconds.
+- **Plain text, terminal-first** — one YAML file lists what to save and where; everything else stays out of your way.
+- **Restore when it matters** — list backups, pick one, preview with `--dry-run`, diff with `--diff`.
+- **Substitutions welcome** — change paths, add folders, point `destination` at your USB drive. The defaults are a starting point, not a contract.
+
+## Installation
+
+```bash
+gem build castled.gemspec
+gem install castled-*.gem
+```
+
+Or from the project directory:
+
+```bash
+bundle install
+bundle exec rake install
+```
+
+## Quick start
+
+### Initialize
+
+Create a `config.yml` in the current directory:
+
+```bash
+simple-backup init
+```
+
+Example `config.yml` (also what `init` generates):
+
+```yaml
+backup_name: omarchy
+backup_paths:
+  - ~/.bash_logout
+  - ~/.bash_profile
+  - ~/.bashrc
+  - ~/.gemrc
+  - ~/.XCompose
+destination: /run/media/leonid/250GB/backups
+```
+
+Adjust `backup_paths` and `destination` to match your machine. Plug in an external drive, point `destination` at its mount path, and you're done.
+
+### Backup
+
+Copy configured paths to a timestamped folder under `destination`:
+
+```bash
+simple-backup backup
+```
+
+Backups are stored as `backup_name_YYYYMMDD_HHMMSS` (e.g. `omarchy_20260519_112300`).
+
+### Schedule with cron
+
+Run backups automatically from the directory that holds your `config.yml`:
+
+```bash
+crontab -e
+```
+
+Example — backup every day at 9:00 AM:
+
+```cron
+0 9 * * * cd /path/to/backup-config && /usr/bin/env simple-backup backup
+```
+
+Use full paths in cron jobs when possible; cron runs with a smaller environment than your interactive shell.
+
+### Restore
+
+List available backups and restore one interactively:
+
+```bash
+simple-backup restore
+```
+
+Restore copies files back to their original locations (overwriting existing files).
+
+Preview without writing:
+
+```bash
+simple-backup restore --dry-run
+simple-backup restore 1 --dry-run --diff
+```
+
+Dry run reports:
+
+- files that would be copied to new paths
+- files that would overwrite existing paths
+- optional unified diffs for overwritten text files (`--diff`, requires `--dry-run`)
+
+## Development
+
+```bash
+bundle install
+bundle exec ruby -Ilib:test test/test_*.rb
+```

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.verbose = true
+end
+
+task default: :test

data/castled.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "lib/castled/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "castled"
+  spec.version       = Castled::VERSION
+  spec.authors       = ["Castled"]
+  spec.email         = ["castled@example.com"]
+
+  spec.summary       = "Simple backups via simple-backup CLI"
+  spec.description   = "Initialize, backup, and restore files with a YAML config"
+  spec.homepage      = "https://github.com/example/castled"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.start_with?("test/", ".git")
+    end
+  rescue StandardError
+    %w[
+      castled.gemspec
+      Gemfile
+      README.md
+      exe/simple-backup
+      lib/castled.rb
+      lib/castled/version.rb
+      lib/castled/cli.rb
+      lib/castled/config.rb
+      lib/castled/backup.rb
+      test/test_helper.rb
+      test/test_config.rb
+      test/test_backup.rb
+      test/test_cli.rb
+    ]
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = ["simple-backup"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", ">= 13.0"
+end

data/docs/index.html

@@ -0,0 +1,152 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Castled — Simple backups for Omarchy</title>
+  <meta name="description" content="A tiny, opinionated backup tool for Omarchy users. Initialize once, back up your dotfiles, restore when you need them.">
+  <style>
+    :root {
+      --bg: #0f1114;
+      --surface: #1a1d23;
+      --border: #2a3038;
+      --text: #e8eaed;
+      --muted: #9aa0a6;
+      --accent: #7eb8da;
+      --accent-dim: #5a8fad;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      line-height: 1.6;
+      min-height: 100vh;
+    }
+    .wrap {
+      max-width: 42rem;
+      margin: 0 auto;
+      padding: 3rem 1.5rem 4rem;
+    }
+    h1 {
+      font-size: 1.75rem;
+      font-weight: 600;
+      letter-spacing: -0.02em;
+      margin-bottom: 0.5rem;
+    }
+    .tagline {
+      font-size: 1.125rem;
+      color: var(--muted);
+      margin-bottom: 2rem;
+    }
+    .pitch {
+      margin-bottom: 2.5rem;
+      color: var(--muted);
+    }
+    .pitch strong { color: var(--text); font-weight: 500; }
+    h2 {
+      font-size: 0.75rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--accent-dim);
+      margin: 2rem 0 0.75rem;
+    }
+    pre, code {
+      font-family: ui-monospace, "Cascadia Code", "SF Mono", Menlo, Consolas, monospace;
+      font-size: 0.8125rem;
+    }
+    pre {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 1rem 1.25rem;
+      overflow-x: auto;
+      margin-bottom: 0.5rem;
+    }
+    .cmd { color: var(--accent); }
+    .comment { color: var(--muted); }
+    ul.features {
+      list-style: none;
+      margin: 1.5rem 0;
+    }
+    ul.features li {
+      padding: 0.35rem 0;
+      padding-left: 1.25rem;
+      position: relative;
+      color: var(--muted);
+    }
+    ul.features li::before {
+      content: "→";
+      position: absolute;
+      left: 0;
+      color: var(--accent-dim);
+    }
+    footer {
+      margin-top: 3rem;
+      padding-top: 1.5rem;
+      border-top: 1px solid var(--border);
+      font-size: 0.875rem;
+      color: var(--muted);
+    }
+    footer a { color: var(--accent); text-decoration: none; }
+    footer a:hover { text-decoration: underline; }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <h1>Castled</h1>
+    <p class="tagline">Simple backups for Omarchy. Opinionated defaults, zero ceremony.</p>
+
+    <p class="pitch">
+      Omarchy is <strong>beautiful, modern &amp; opinionated Linux</strong> — omakase computing,
+      chef's choice. Castled brings the same spirit to your personal dotfiles: one command to
+      initialize, one to back up, one to restore. No backup framework to learn. Substitutions
+      welcome.
+    </p>
+
+    <ul class="features">
+      <li>Curated <code>config.yml</code> from <code>simple-backup init</code></li>
+      <li>Timestamped copies to any destination (USB, NAS, local disk)</li>
+      <li>Interactive restore with dry-run and diff preview</li>
+    </ul>
+
+    <h2>Install</h2>
+    <pre><code><span class="cmd">gem build castled.gemspec</span>
+<span class="cmd">gem install castled-*.gem</span></code></pre>
+
+    <h2>Initialize</h2>
+    <pre><code><span class="cmd">simple-backup init</span>
+<span class="comment"># creates config.yml with Omarchy-friendly defaults</span></code></pre>
+
+    <h2>Example config</h2>
+    <pre><code>backup_name: omarchy
+backup_paths:
+  - ~/.bash_logout
+  - ~/.bash_profile
+  - ~/.bashrc
+  - ~/.gemrc
+  - ~/.XCompose
+destination: /run/media/leonid/250GB/backups</code></pre>
+
+    <h2>Backup &amp; restore</h2>
+    <pre><code><span class="cmd">simple-backup backup</span>
+<span class="comment"># → omarchy_YYYYMMDD_HHMMSS/</span>
+
+<span class="cmd">simple-backup restore</span>
+<span class="cmd">simple-backup restore --dry-run --diff</span></code></pre>
+
+    <h2>Schedule (optional)</h2>
+    <pre><code><span class="comment"># crontab — daily at 9:00</span>
+0 9 * * * cd /path/to/config &amp;&amp; simple-backup backup</code></pre>
+
+    <footer>
+      <a href="https://github.com/example/castled">GitHub</a>
+      ·
+      <a href="https://omarchy.org">Omarchy</a>
+      ·
+      MIT License
+    </footer>
+  </div>
+</body>
+</html>

data/exe/simple-backup

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "castled"
+
+Castled::CLI.run(ARGV)

data/lib/castled/backup.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require "time"
+require "yaml"
+
+module Castled
+  class Backup
+    MANIFEST_FILENAME = ".castled_manifest.yml"
+
+    class Error < StandardError; end
+
+    def initialize(config)
+      @config = config
+    end
+
+    def run!
+      timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+      backup_dir = @config.destination_path.join("#{@config.backup_name}_#{timestamp}")
+      FileUtils.mkdir_p(backup_dir)
+
+      entries = []
+      @config.backup_paths.each do |source_path|
+        source = Pathname.new(source_path).expand_path
+        raise Error, "Path not found: #{source}" unless source.exist?
+
+        dest_name = source.basename.to_s
+        dest = backup_dir.join(dest_name)
+        copy_entry(source, dest)
+        entries << { "source" => source.to_s, "backup_entry" => dest_name }
+      end
+
+      write_manifest(backup_dir, entries)
+      backup_dir.to_s
+    end
+
+    def restore!(selection: nil, dry_run: false, diff: false, io: $stdout)
+      backups = list_backups
+      raise Error, "No backups found for '#{@config.backup_name}'" if backups.empty?
+
+      chosen = select_backup(backups, selection: selection)
+      manifest = load_manifest(chosen)
+      plan = restore_plan(chosen, manifest)
+
+      if dry_run
+        print_dry_run(chosen, plan, diff: diff, io: io)
+        return chosen.to_s
+      end
+
+      plan.each do |operation|
+        restore_operation(operation)
+      end
+
+      chosen.to_s
+    end
+
+    def list_backups
+      dest = @config.destination_path
+      return [] unless dest.directory?
+
+      prefix = "#{@config.backup_name}_"
+      dest.children
+          .select(&:directory?)
+          .select { |d| d.basename.to_s.start_with?(prefix) }
+          .sort_by { |d| d.basename.to_s }
+          .reverse
+    end
+
+    private
+
+    def restore_plan(backup_dir, manifest)
+      manifest.fetch("entries").flat_map do |entry|
+        source = Pathname.new(entry.fetch("source"))
+        backup_entry = backup_dir.join(entry.fetch("backup_entry"))
+        raise Error, "Backup entry missing: #{backup_entry}" unless backup_entry.exist?
+
+        if backup_entry.directory?
+          directory_restore_plan(backup_entry, source)
+        else
+          [file_restore_operation(backup_entry, source)]
+        end
+      end
+    end
+
+    def directory_restore_plan(backup_entry, source)
+      operations = []
+      operations << { action: :mkdir, backup: backup_entry, target: source } unless source.directory?
+
+      backup_entry.find.each do |path|
+        next if path == backup_entry
+
+        relative_path = path.relative_path_from(backup_entry)
+        target = source.join(relative_path)
+
+        if path.directory?
+          operations << { action: :mkdir, backup: path, target: target } unless target.directory?
+        else
+          operations << file_restore_operation(path, target)
+        end
+      end
+
+      operations
+    end
+
+    def file_restore_operation(backup_entry, target)
+      action = target.exist? ? :overwrite : :copy
+      { action: action, backup: backup_entry, target: target }
+    end
+
+    def restore_operation(operation)
+      case operation[:action]
+      when :mkdir
+        FileUtils.mkdir_p(operation[:target])
+      when :copy, :overwrite
+        FileUtils.mkdir_p(operation[:target].dirname)
+        FileUtils.cp(operation[:backup].to_s, operation[:target].to_s)
+      end
+    end
+
+    def print_dry_run(backup_dir, plan, diff:, io:)
+      io.puts "Dry run: restoring #{backup_dir.basename}"
+
+      if plan.empty?
+        io.puts "No files would be copied."
+        return
+      end
+
+      plan.each do |operation|
+        case operation[:action]
+        when :mkdir
+          io.puts "Would create directory: #{operation[:target]}"
+        when :copy
+          io.puts "Would copy: #{operation[:backup]} -> #{operation[:target]}"
+        when :overwrite
+          io.puts "Would overwrite: #{operation[:target]} with #{operation[:backup]}"
+          print_diff(operation, io: io) if diff
+        end
+      end
+    end
+
+    def print_diff(operation, io:)
+      current = operation[:target].read
+      restored = operation[:backup].read
+      return if current == restored
+
+      io.puts "Diff for #{operation[:target]}:"
+      io.puts "--- current"
+      io.puts "+++ restored"
+      io.puts unified_line_diff(current, restored)
+    rescue ArgumentError
+      io.puts "Diff skipped for #{operation[:target]}: file is not valid text"
+    end
+
+    def unified_line_diff(current, restored)
+      current_lines = current.lines
+      restored_lines = restored.lines
+      max = [current_lines.length, restored_lines.length].max
+      output = []
+
+      max.times do |index|
+        old_line = current_lines[index]
+        new_line = restored_lines[index]
+        next if old_line == new_line
+
+        output << "-#{old_line}" if old_line
+        output << "+#{new_line}" if new_line
+      end
+
+      output.join
+    end
+
+    def copy_entry(source, dest)
+      if source.directory?
+        FileUtils.mkdir_p(dest)
+        source.children.each do |child|
+          FileUtils.cp_r(child.to_s, dest.to_s)
+        end
+      else
+        FileUtils.mkdir_p(dest.dirname)
+        FileUtils.cp(source.to_s, dest.to_s)
+      end
+    end
+
+    def write_manifest(backup_dir, entries)
+      manifest = {
+        "backup_name" => @config.backup_name,
+        "created_at" => Time.now.iso8601,
+        "entries" => entries
+      }
+      backup_dir.join(MANIFEST_FILENAME).write(YAML.dump(manifest))
+    end
+
+    def load_manifest(backup_dir)
+      path = backup_dir.join(MANIFEST_FILENAME)
+      raise Error, "Manifest not found in #{backup_dir}" unless path.exist?
+
+      YAML.safe_load(path.read) || {}
+    end
+
+    def select_backup(backups, selection: nil)
+      return backups[selection.to_i - 1] if selection
+
+      puts "Available backups:"
+      backups.each_with_index do |backup, index|
+        puts "  #{index + 1}. #{backup.basename}"
+      end
+      print "Select backup (1-#{backups.size}): "
+      choice = $stdin.gets&.strip
+      index = choice.to_i
+      raise Error, "Invalid selection" if index < 1 || index > backups.size
+
+      backups[index - 1]
+    end
+  end
+end

data/lib/castled/cli.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Castled
+  class CLI
+    COMMANDS = %w[init backup restore].freeze
+
+    def self.run(argv)
+      new.run(argv)
+    end
+
+    def run(argv)
+      command = argv.first
+      if command.nil? || command == "--help" || command == "-h"
+        print_usage
+        exit command.nil? ? 1 : 0
+      end
+
+      unless COMMANDS.include?(command)
+        $stderr.puts "Unknown command: #{command}"
+        print_usage
+        exit 1
+      end
+
+      send(command, argv[1..])
+    rescue Config::Error, Backup::Error => e
+      $stderr.puts "Error: #{e.message}"
+      exit 1
+    end
+
+    private
+
+    def init(_args)
+      path = Config.init!
+      puts "Created #{path}"
+    end
+
+    def backup(_args)
+      config = Config.load!
+      backup_dir = Backup.new(config).run!
+      puts "Backup created at #{backup_dir}"
+    end
+
+    def restore(args)
+      options = parse_restore_options(args)
+      config = Config.load!
+      restored = Backup.new(config).restore!(
+        selection: options[:selection],
+        dry_run: options[:dry_run],
+        diff: options[:diff]
+      )
+
+      if options[:dry_run]
+        puts "Dry run complete for #{restored}"
+      else
+        puts "Restored from #{restored}"
+      end
+    end
+
+    def parse_restore_options(args)
+      dry_run = false
+      diff = false
+      selection = nil
+      unknown = []
+
+      args.each do |arg|
+        case arg
+        when "--dry-run", "-n"
+          dry_run = true
+        when "--diff"
+          diff = true
+        when /\A\d+\z/
+          selection ||= arg
+        else
+          unknown << arg
+        end
+      end
+
+      raise Backup::Error, "Unknown restore options: #{unknown.join(', ')}" unless unknown.empty?
+      raise Backup::Error, "--diff requires --dry-run" if diff && !dry_run
+
+      { dry_run: dry_run, diff: diff, selection: selection }
+    end
+
+    def print_usage
+      puts <<~USAGE
+        Usage: simple-backup <command>
+
+        Commands:
+          init     Create config.yml in the current directory
+          backup   Copy configured paths to a timestamped backup folder
+          restore  List backups and restore one interactively
+
+        Restore options:
+          --dry-run, -n   Preview files that would be copied or overwritten
+          --diff          Show unified diffs for files that would be overwritten
+      USAGE
+    end
+  end
+end

data/lib/castled/config.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Castled
+  class Config
+    CONFIG_FILENAME = "config.yml"
+
+    DEFAULT_TEMPLATE = <<~YAML
+      backup_name: omarchy
+      backup_paths:
+        - ~/.bash_logout
+        - ~/.bash_profile
+        - ~/.bashrc
+        - ~/.gemrc
+        - ~/.XCompose
+      destination: /run/media/leonid/250GB/backups
+    YAML
+
+    class Error < StandardError; end
+
+    attr_reader :backup_name, :backup_paths, :destination
+
+    def self.init!(dir: Dir.pwd)
+      path = Pathname.new(dir).join(CONFIG_FILENAME)
+      raise Error, "#{CONFIG_FILENAME} already exists" if path.exist?
+
+      path.write(DEFAULT_TEMPLATE)
+      path.to_s
+    end
+
+    def self.load!(dir: Dir.pwd)
+      path = Pathname.new(dir).join(CONFIG_FILENAME)
+      raise Error, "#{CONFIG_FILENAME} not found. Run `simple-backup init` first." unless path.exist?
+
+      new(path)
+    end
+
+    def initialize(path)
+      @path = Pathname.new(path)
+      data = YAML.safe_load(@path.read, permitted_classes: [Symbol], aliases: true) || {}
+      @backup_name = data["backup_name"] || data[:backup_name]
+      @backup_paths = Array(data["backup_paths"] || data[:backup_paths])
+      @destination = data["destination"] || data[:destination]
+      validate!
+    end
+
+    def destination_path
+      Pathname.new(@destination).expand_path
+    end
+
+    private
+
+    def validate!
+      raise Error, "backup_name is required" if @backup_name.nil? || @backup_name.to_s.strip.empty?
+
+      if @backup_paths.empty?
+        raise Error, "backup_paths must list at least one file or folder"
+      end
+
+      if @destination.nil? || @destination.to_s.strip.empty?
+        raise Error, "destination is required"
+      end
+    end
+  end
+end

data/lib/castled/version.rb

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

data/lib/castled.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "castled/version"
+require_relative "castled/config"
+require_relative "castled/backup"
+require_relative "castled/cli"
+
+module Castled
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: castled
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Castled
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !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'
+description: Initialize, backup, and restore files with a YAML config
+email:
+- castled@example.com
+executables:
+- simple-backup
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- castled.gemspec
+- docs/index.html
+- exe/simple-backup
+- lib/castled.rb
+- lib/castled/backup.rb
+- lib/castled/cli.rb
+- lib/castled/config.rb
+- lib/castled/version.rb
+homepage: https://github.com/example/castled
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Simple backups via simple-backup CLI
+test_files: []