dotlayer 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6153afd914718371693784c18c5be35b4f84d2b4ceddda8990efed35e54ad229
-  data.tar.gz: 192e9da8c37c20627151ee35dc415e1ac59eece7e27edb63bb8aac249e0defd7
+  metadata.gz: adde5780e85065e220d516e6f2238a63122c5a4151aea1bee55e98e272c04750
+  data.tar.gz: 693c72cb55917e957677c70b43114a6fe61968289f766662fb1198e96bcb283d
 SHA512:
-  metadata.gz: 401aa858f83b8f064b9c6fdf39e2621ce2c4ba53f6fa9ae2ba3e9922b7d74ea20a4bf8ab1b247f4515060d2c051ce4e89b9b7c26288e3a07e3fd581b7550f579
-  data.tar.gz: 6a5aa5a51170cbe973c30854f45b9e1713799cfc8d4d451e058e4a66998390f86eb656c183eda3d99baf95b2334af319cb4ae850f43e593047447e090b1115f8
+  metadata.gz: fdba914ec98999e747f9eb2b4dc547e60887206ef51b60415d412882b6be1f21ba854418f306f82f80cb1970bd83cba67d13f048235162d5140abb6903082857
+  data.tar.gz: 7692ffeb12541dcbffe01c9b3e42e9f7ff1dd39774cf0a49dc23025554c516be1be179b8c7fb745c8f316726638be785056283f658f32452f79ef497e35f8a68

data/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to dotlayer. Versions follow [Semantic Versioning](https://semver.org/).
+
+## 0.3.1 — 2026-11-05
+
+First RubyGems release since 0.2.2: it includes everything listed under 0.3.0,
+which was tagged but never published.
+
+### Changed
+
+- `doctor`'s dangling-link scan skips other git checkouts under the target
+  (any directory with a `.git`, like `~/src/*`), unless a package ships files
+  into that path. Stow only links into a checkout in that case, and checkouts
+  are most of the directories in a typical home dir: `doctor` went from 5.9s to
+  0.9s on a development machine.
+
+## 0.3.0 — 2026-11-04 (tagged, not published)
+
+### Added
+
+- Machine layers: `config-<machine>`, `config-<os>-<machine>`,
+  `config-<distro>-<machine>` and `config-<distro>-<profile>-<machine>`. The
+  machine tag comes from `$DOTLAYER_MACHINE`, then `machines.<tag>.detect`
+  commands in `dotlayer.yml`, then `hostname -s`.
+- `dotlayer diff`: shows what `install` would link, unlink or conflict on, and
+  which system files would change, without changing anything.
+- `doctor` scans the whole target dir for links into a configured repo whose
+  destination no longer exists, and prints an `rm` command for them. It never
+  deletes anything. `--depth N` limits the scan (default 6).
+
+### Changed
+
+- Stow runs with `--no-folding`: every file gets its own link, never a link to
+  a whole directory.
+- `doctor`'s broken-symlink check covers only managed `.config` and `.local`
+  paths, and the dangling-link scan skips `.local/state` (app backups).
+- System files: parent directories are created when missing, and a failed copy
+  fails the install.
+- Requires Ruby 3.3 or newer; CI tests Ruby 3.3 through 4.0 and installs Stow.
+
+### Fixed
+
+- Profile detection no longer crashes on macOS, where `hostnamectl` doesn't
+  exist.
+- `diff` conflict handling works with older Stow versions.
+
+## 0.2.2 and earlier
+
+See the [git tags](https://github.com/douglas/dotlayer/tags).

data/README.md

@@ -13,6 +13,7 @@ config-macos/               → stowed on macOS
 config-omarchy/             → stowed when Omarchy is detected
 config-omarchy-desktop/     → stowed on Omarchy + desktop profile
 config-omarchy-laptop/      → stowed on Omarchy + laptop profile
+config-omarchy-laptop-t14/  → stowed on Omarchy + laptop profile + t14 machine
 config-mycompany/            → stowed when mycompany group is detected
 ```
 
@@ -31,7 +32,7 @@ git clone https://github.com/douglas/dotlayer.git
 export PATH="$HOME/src/dotlayer/exe:$PATH"
 ```
 
-**Requirements:** Ruby >= 3.2, GNU Stow
+**Requirements:** Ruby >= 3.3, GNU Stow
 
 ## Quick start
 
@@ -42,10 +43,13 @@ dotlayer status
 # Stow all matching packages
 dotlayer install
 
+# Preview what install would change (changes nothing)
+dotlayer diff
+
 # Pull latest changes and re-stow
 dotlayer update
 
-# Check for broken symlinks and missing deps
+# Check for broken or dangling symlinks and missing deps
 dotlayer doctor
 
 # Move existing config into a stow package
@@ -57,12 +61,13 @@ dotlayer adopt --private ~/.config/lazysql config
 
 ## How it works
 
-Dotlayer auto-detects four things about your system:
+Dotlayer auto-detects five things about your system:
 
 | Detection | Method | Example |
 |-----------|--------|---------|
 | **OS** | `RbConfig::CONFIG["host_os"]` | `linux`, `macos` |
 | **Profile** | `hostnamectl chassis` or `$DOTLAYER_PROFILE` | `desktop`, `laptop` |
+| **Machine** | `$DOTLAYER_MACHINE`, configured shell commands, then `hostname -s` fallback | `t14`, `framework-desktop` |
 | **Distro** | Shell commands from config | `omarchy`, `fedora` |
 | **Group** | Shell commands from config | `work`, `mycompany` |
 
@@ -72,7 +77,11 @@ It then scans your dotfiles repo for directories matching these tags and stows t
 2. **OS layer** — `config-linux` or `config-macos`
 3. **Distro layer** — `config-omarchy`
 4. **Distro + profile** — `config-omarchy-desktop`
-5. **Group layer** — `config-mycompany`
+5. **Machine layer** — `config-t14`
+6. **OS + machine** — `config-linux-t14`
+7. **Distro + machine** — `config-omarchy-t14`
+8. **Distro + profile + machine** — `config-omarchy-laptop-t14`
+9. **Group layer** — `config-mycompany`
 
 Each layer can add files but never conflict with earlier layers (Stow constraint).
 
@@ -99,6 +108,11 @@ profiles:
   detect: hostnamectl chassis
   env: DOTLAYER_PROFILE
 
+machines:
+  env: DOTLAYER_MACHINE
+  t14:
+    detect: model="$(cat /sys/class/dmi/id/product_name /sys/class/dmi/id/product_version 2>/dev/null)"; case "$model" in *T14*) exit 0 ;; *) exit 1 ;; esac
+
 distros:
   omarchy:
     detect: test -d ~/.local/share/omarchy
@@ -162,9 +176,18 @@ repos:
     packages:
       - config
       - fonts
+    standalone_packages:
+      - claude
+      - shared
+    group_packages:
+      mycompany:
+        - work
 ```
 
 The `private: true` flag tells dotlayer which repo to use when you run `dotlayer adopt --private`.
+`standalone_packages` is an allowlist for non-layered packages in that repo.
+`group_packages` lets a group detection rule opt in exact package names like `work`
+that do not follow the `config-mycompany` suffix convention.
 
 ### What goes where?
 
@@ -176,6 +199,8 @@ The `private: true` flag tells dotlayer which repo to use when you run `dotlayer
   config-linux/                 ← Linux-specific overrides
   config-omarchy/               ← Omarchy distro overrides
   config-omarchy-desktop/       ← Omarchy + desktop profile
+  config-omarchy-laptop/        ← Omarchy + laptop profile
+  config-omarchy-laptop-t14/    ← Omarchy + laptop profile + machine model
   git/                          ← git config
   zsh/                          ← shell config
   bin/                          ← personal scripts
@@ -191,11 +216,14 @@ The `private: true` flag tells dotlayer which repo to use when you run `dotlayer
   fonts/                        ← licensed fonts
   fonts-linux/                  ← Linux-specific font config
   claude/                       ← standalone: Claude AI config
-  work/                         ← standalone: work tooling
+  work/                         ← group package: work tooling
   scripts/                      ← standalone: work automation scripts
 ```
 
-Directories that match the per-repo base packages (`config`, `fonts`) get full layer resolution. Everything else (`claude`, `work`, `scripts`) is stowed as-is in alphabetical order.
+Directories that match the per-repo base packages (`config`, `fonts`) get full layer resolution. If `standalone_packages`
+is omitted, every other top-level directory (`claude`, `scripts`) is stowed as-is in alphabetical order. If it is present,
+only those allowlisted standalone packages are stowed. Exact work packages can be gated behind detected groups with
+`group_packages`.
 
 ### Adopting files into the right repo
 
@@ -216,6 +244,7 @@ Repos are processed in order. Public packages are stowed first, then private pac
 3. `~/.public_dotfiles/config-omarchy/` — distro layer
 4. `~/.private_dotfiles/config/` — private overlays (stowed after public)
 5. `~/.private_dotfiles/config-mycompany/` — work group layer
+6. `~/.private_dotfiles/work/` — exact group package, if configured
 
 Each layer adds files — they never conflict because different layers use different file paths within the same directory structure.
 
@@ -233,19 +262,37 @@ dotlayer [options] <command>
 
 Commands:
   install     Detect system, stow all layers, install system files
+  diff        Show what install would change, without changing anything
   update      Pull repos, re-stow all layers
   status      Show detected OS, profile, distros, groups, and packages
-  doctor      Check for broken symlinks, missing repos, missing stow
+  doctor      Check for broken/dangling symlinks, missing repos, missing stow
   adopt       Move config files into a stow package and restow
   version     Print version
 
 Options:
   -c, --config PATH   Config file path
-  -n, --dry-run       Show what would be done without making changes
+  -n, --dry-run       Run stow in no-op mode to preview changes and conflicts
   -p, --private       Use private repo (for adopt command)
+      --depth N       Max depth for doctor's dangling-link scan (default: 6)
   -v, --verbose       Verbose output
 ```
 
+### diff
+
+Shows what `dotlayer install` would change, without changing anything. Packages are resolved exactly like `install`, then stow runs in simulate mode (`stow -n -v`). Output is grouped per package: `LINK` and `UNLINK` operations plus `CONFLICT` entries (stow aborts the whole package on conflicts). Links that already exist are not listed. Linux `system_files` are listed when the destination is missing, its content differs from the source, its mode differs, or it cannot be read (no sudo is used).
+
+```sh
+dotlayer diff
+```
+
+Exit status: `0` when nothing would change, `1` when changes are pending (so it can be used in scripts).
+
+### doctor
+
+Checks that stow is installed, repos and packages exist, and that managed config paths have no broken symlinks. It also scans the whole target dir (default `~`) for symlinks that point into a configured repo but whose target no longer exists. The scan skips `.cache`, `node_modules`, `.git`, `.local/share/Steam` and the repos themselves. It also skips other git checkouts (any directory with a `.git`, like `~/src/*`), unless a package ships files into that path, since stow only links there in that case. It never follows directory symlinks, and stops at `--depth` levels (default 6). It only reports: each dangling link is listed with its target, followed by a suggested `rm` command.
+
+Exit status: `0` when no issues are found, `1` otherwise.
+
 ### adopt
 
 Moves existing config files or directories into a stow package, then restows so the originals become symlinks managed by stow.
@@ -266,6 +313,16 @@ dotlayer adopt --dry-run ~/.config/lazygit config
 
 The last argument is always the package name. Dotlayer finds the first repo containing that package, or falls back to the first repo for new packages.
 
+## Development
+
+```sh
+bundle exec rake test          # run tests
+bundle exec standardrb         # lint
+bundle exec rubycritic lib/    # code quality report
+```
+
+See [Contributing](CONTRIBUTING.md) for full setup, testing, and contribution guidelines.
+
 ## Documentation
 
 - [Architecture](docs/architecture.md) — system design, data flow, and class responsibilities

data/lib/dotlayer/cli.rb

@@ -13,11 +13,12 @@ module Dotlayer
       config = Config.new(options[:config])
 
       case command
-      when "status"  then Commands::Status.new(config:).run
+      when "status" then Commands::Status.new(config:).run
       when "install" then Commands::Install.new(config:, dry_run: options[:dry_run], verbose: options[:verbose]).run
-      when "update"  then Commands::Update.new(config:, dry_run: options[:dry_run], verbose: options[:verbose]).run
-      when "doctor"  then Commands::Doctor.new(config:).run
-      when "adopt"   then run_adopt(config:, argv:, options:)
+      when "update" then Commands::Update.new(config:, dry_run: options[:dry_run], verbose: options[:verbose]).run
+      when "diff" then exit(1) unless Commands::Diff.new(config:).run
+      when "doctor" then exit(1) unless Commands::Doctor.new(config:, max_depth: options[:depth]).run
+      when "adopt" then run_adopt(config:, argv:, options:)
       when "version"
         puts "dotlayer #{VERSION}"
       else
@@ -28,13 +29,14 @@ module Dotlayer
     private
 
     def parse_global_options(argv)
-      options = { dry_run: false, verbose: false, config: nil, private: false }
+      options = {dry_run: false, verbose: false, config: nil, private: false, depth: nil}
 
       OptionParser.new do |opts|
         opts.on("-c", "--config PATH", "Config file path") { |v| options[:config] = v }
         opts.on("-n", "--dry-run", "Show what would be done") { options[:dry_run] = true }
         opts.on("-v", "--verbose", "Verbose output") { options[:verbose] = true }
         opts.on("-p", "--private", "Use private repo") { options[:private] = true }
+        opts.on("--depth N", Integer, "Max depth for doctor's dangling-link scan") { |v| options[:depth] = v }
       end.parse!(argv)
 
       options
@@ -63,7 +65,8 @@ module Dotlayer
           install   Detect system, stow all layers, install system files
           update    Pull repos, re-stow all layers
           status    Show detected OS, profile, distros, and packages
-          doctor    Check for broken symlinks, conflicts, missing deps
+          diff      Show what install would change (exit 1 if changes pending)
+          doctor    Check for broken symlinks, conflicts, missing deps (exit 1 on issues)
           adopt     Move config into a stow package and restow
           version   Print version
 
@@ -71,6 +74,7 @@ module Dotlayer
           -c, --config PATH   Config file path (default: dotlayer.yml in repo)
           -n, --dry-run       Show what would be done without making changes
           -p, --private       Use private repo (for adopt command)
+              --depth N       Max depth for doctor's dangling-link scan (default: 6)
           -v, --verbose       Verbose output
 
         Examples:

data/lib/dotlayer/commands/diff.rb

@@ -0,0 +1,108 @@
+module Dotlayer
+  module Commands
+    # Read-only preview of what `install` would change. Runs stow in
+    # simulate mode (-n -v) and compares system files byte-for-byte.
+    # #run returns true when nothing is pending, false otherwise.
+    class Diff
+      include Output
+
+      LINK_LINE = /\A(LINK|UNLINK): (.+?)(?: => .*?)?( \(reverts previous action\))?\z/
+      CONFLICT_LINE = /\A\s+\* (.+)\z/
+
+      def initialize(config:, detector: nil)
+        @config = config
+        @detector = detector || Detector.new(config: @config)
+        @pending = 0
+      end
+
+      def run
+        detection = @detector.detect
+        packages = Resolver.new(config: @config, detection: detection).resolve
+        stow = Stow.new(target: @config.target, dry_run: true, verbose: true, quiet: true)
+
+        heading "Diff (#{detection.os}/#{detection.profile}/#{detection.machine})"
+        puts
+
+        packages.each { |repo_path, package| diff_package(stow, repo_path, package) }
+        diff_system_files if detection.os == "linux"
+
+        puts
+        if @pending.zero?
+          ok "No changes pending."
+        else
+          warning "#{@pending} change(s) pending."
+        end
+        @pending.zero?
+      end
+
+      private
+
+      def diff_package(stow, repo_path, package)
+        success = stow.restow(repo_path, package)
+        plan = parse_plan(stow.last_output.to_s)
+        problems = success ? [] : plan[:conflicts]
+        problems = [stow.last_error] if !success && problems.empty?
+        return if plan[:links].empty? && plan[:unlinks].empty? && problems.empty?
+
+        puts "  #{green(package)} (#{File.basename(repo_path)})"
+        plan[:links].each { |path| puts "    #{green("LINK")}    #{path}" }
+        plan[:unlinks].each { |path| puts "    #{yellow("UNLINK")}  #{path}" }
+        problems.each { |problem| puts "    #{red("CONFLICT")} #{problem}" }
+        @pending += plan[:links].size + plan[:unlinks].size + problems.size
+      end
+
+      # Restow shows UNLINK then LINK for links that already exist; stow marks
+      # the second as "(reverts previous action)", so both cancel out.
+      def parse_plan(output)
+        links = []
+        unlinks = []
+        conflicts = []
+
+        output.each_line(chomp: true) do |line|
+          if (match = LINK_LINE.match(line))
+            kind, path, reverts = match.captures
+            if reverts
+              (kind == "LINK") ? unlinks.delete(path) : links.delete(path)
+            else
+              ((kind == "LINK") ? links : unlinks) << path
+            end
+          elsif (match = CONFLICT_LINE.match(line))
+            conflicts << match[1]
+          end
+        end
+
+        {links:, unlinks:, conflicts: conflicts.uniq}
+      end
+
+      def diff_system_files
+        entries = @config.system_files
+        first_repo = @config.repos.first
+        return if entries.empty? || first_repo.nil?
+
+        changed = entries.filter_map { |entry| system_file_change(entry, first_repo) }
+        return if changed.empty?
+
+        puts "  #{green("system files")}"
+        changed.each { |dest, reason| puts "    #{yellow("CHANGE")}  #{dest} (#{reason})" }
+        @pending += changed.size
+      end
+
+      def system_file_change(entry, repo)
+        source = File.expand_path(entry["source"], repo.path)
+        dest = entry["dest"]
+        mode = (entry["mode"] || "0644").to_s.to_i(8)
+
+        return [dest, "source missing: #{source}"] unless File.file?(source)
+        return [dest, "missing"] unless File.exist?(dest)
+
+        reasons = []
+        reasons << "content differs" unless File.binread(source) == File.binread(dest)
+        actual_mode = File.stat(dest).mode & 0o7777
+        reasons << format("mode %04o, want %04o", actual_mode, mode) unless actual_mode == mode
+        [dest, reasons.join(", ")] unless reasons.empty?
+      rescue Errno::EACCES
+        [dest, "unreadable, cannot compare"]
+      end
+    end
+  end
+end

data/lib/dotlayer/commands/doctor.rb

@@ -1,12 +1,21 @@
+require "shellwords"
+
 module Dotlayer
   module Commands
     class Doctor
       include Output
 
-      def initialize(config:, detector: nil)
+      DEFAULT_MAX_DEPTH = 6
+      SKIP_DIRS = %w[.cache node_modules .git].freeze
+      SKIP_PATHS = %w[.local/share/Steam .local/state].freeze
+
+      def initialize(config:, detector: nil, max_depth: nil)
         @config = config
+        @max_depth = max_depth || DEFAULT_MAX_DEPTH
         @detector = detector || Detector.new(config: @config)
         @issues = []
+        @reported_links = []
+        @hints = []
       end
 
       def run
@@ -21,6 +30,7 @@ module Dotlayer
         check_repos_exist
         check_packages_exist(@packages)
         check_broken_symlinks
+        check_dangling_repo_links
 
         puts
         if @issues.empty?
@@ -28,7 +38,9 @@ module Dotlayer
         else
           error "#{@issues.size} issue(s) found:"
           @issues.each { |issue| puts "  - #{issue}" }
+          @hints.each { |hint| puts "  #{hint}" }
         end
+        @issues.empty?
       end
 
       private
@@ -65,41 +77,119 @@ module Dotlayer
       end
 
       def check_broken_symlinks
-        print "  Checking for broken symlinks in #{@config.target}... "
+        print "  Checking for broken symlinks in managed config paths... "
         broken = find_broken_symlinks(@config.target)
         if broken.empty?
           ok "none"
         else
           warning "#{broken.size} found"
           broken.each do |link|
-            target = File.readlink(link) rescue "(deleted)"
+            target = begin
+              File.readlink(link)
+            rescue
+              "(deleted)"
+            end
             @issues << "Broken symlink: #{link} -> #{target}"
+            @reported_links << link
+          end
+        end
+      end
+
+      # Report-only scan of the whole target dir for links into a configured
+      # repo whose destination no longer exists. Never follows directory
+      # symlinks and never deletes anything.
+      def check_dangling_repo_links
+        print "  Checking for dangling links into repos (depth #{@max_depth})... "
+        dangling = find_dangling_repo_links(@config.target)
+        if dangling.empty?
+          ok "none"
+          return
+        end
+
+        warning "#{dangling.size} found"
+        dangling.each do |link, target|
+          @issues << "Dangling link into repo: #{link} -> #{target}"
+        end
+        @hints << "To remove dangling links: rm #{dangling.keys.map { |link| Shellwords.escape(link) }.join(" ")}"
+      end
+
+      def find_dangling_repo_links(target)
+        repo_roots = @config.repos.map(&:path)
+        @shipped_dirs = shipped_dirs(repo_roots)
+        found = {}
+        scan_dir(target, target, 0, repo_roots, found)
+        found.except(*@reported_links)
+      end
+
+      def scan_dir(dir, root, depth, repo_roots, found)
+        Dir.children(dir).sort.each do |name|
+          path = File.join(dir, name)
+          if File.symlink?(path)
+            target = File.readlink(path)
+            absolute = File.expand_path(target, dir)
+            found[path] = target if into_repo?(absolute, repo_roots) && !File.exist?(path)
+          elsif File.directory?(path) && depth < @max_depth && !skip_dir?(path, root, repo_roots)
+            scan_dir(path, root, depth + 1, repo_roots, found)
           end
         end
+      rescue SystemCallError
+        nil
+      end
+
+      def into_repo?(path, repo_roots)
+        repo_roots.any? { |repo| path.start_with?("#{repo}/") }
+      end
+
+      def skip_dir?(path, root, repo_roots)
+        relative = path.delete_prefix("#{root}/")
+        SKIP_DIRS.include?(File.basename(path)) ||
+          SKIP_PATHS.include?(relative) ||
+          repo_roots.include?(path) ||
+          foreign_checkout?(path, relative)
+      end
+
+      # Another git checkout (~/src/*, ~/work/*) holds stow links only where a
+      # package ships files into it, so skip it otherwise. Checkouts are most
+      # of the files under a home dir, and the scan is far faster without them.
+      def foreign_checkout?(path, relative)
+        File.exist?(File.join(path, ".git")) && !@shipped_dirs.include?(relative)
+      end
+
+      # Every directory any package in the repos ships, relative to the target.
+      # Covers packages that don't apply to this machine, since their old
+      # links can still dangle here.
+      def shipped_dirs(repo_roots)
+        repo_roots.flat_map { |repo|
+          Dir.glob("*/", base: repo).flat_map do |package|
+            Dir.glob("**/", File::FNM_DOTMATCH, base: File.join(repo, package)).map { |dir| dir.chomp("/") }
+          end
+        }.to_set
       end
 
       def find_broken_symlinks(target)
         broken = []
-        scan_dirs = @packages.flat_map { |repo_path, package|
+        managed_roots = [".config", ".local"]
+        scan_paths = @packages.flat_map { |repo_path, package|
           pkg_dir = File.join(repo_path, package)
           next [] unless Dir.exist?(pkg_dir)
 
-          Dir.children(pkg_dir).map { |child| File.join(target, child) }
-        }.uniq
+          managed_roots.flat_map do |root_name|
+            root_path = File.join(pkg_dir, root_name)
+            next [] unless File.exist?(root_path) || File.symlink?(root_path)
 
-        scan_dirs.each do |dir|
-          next unless File.exist?(dir) || File.symlink?(dir)
+            managed_paths = [root_path]
+            if File.directory?(root_path)
+              managed_paths.concat(Dir.glob(File.join(root_path, "**", "*"), File::FNM_DOTMATCH))
+            end
 
-          if File.symlink?(dir) && !File.exist?(dir)
-            broken << dir
-            next
+            managed_paths
+              .reject { |path| [".", ".."].include?(File.basename(path)) }
+              .map { |path| File.join(target, path.delete_prefix("#{pkg_dir}/")) }
           end
+        }.uniq
 
-          next unless File.directory?(dir)
-
-          Dir.glob(File.join(dir, "**", "*"), File::FNM_DOTMATCH).each do |path|
-            broken << path if File.symlink?(path) && !File.exist?(path)
-          end
+        scan_paths.each do |path|
+          broken << path if File.symlink?(path) && !File.exist?(path)
         end
 
         broken

data/lib/dotlayer/commands/install.rb

@@ -8,6 +8,7 @@ module Dotlayer
         @detector = detector || Detector.new(config: @config)
         @dry_run = dry_run
         @verbose = verbose
+        @system_failures = 0
       end
 
       def run
@@ -16,21 +17,29 @@ module Dotlayer
         packages = resolver.resolve
         stow = Stow.new(target: @config.target, dry_run: @dry_run, verbose: @verbose)
 
-        heading "Installing dotfiles (#{detection.os}/#{detection.profile})"
+        heading "Installing dotfiles (#{detection.os}/#{detection.profile}/#{detection.machine})"
         puts
 
-        packages.each do |repo_path, package|
-          restow_package(stow, repo_path, package)
+        failures = packages.count do |repo_path, package|
+          !restow_package(stow, repo_path, package)
         end
 
+        abort_failed_packages(failures) if failures.positive?
+
         install_system_files if detection.os == "linux"
 
         puts
+        abort "Error: #{@system_failures} system file(s) or hook(s) failed." if @system_failures.positive?
         puts "Done! #{packages.size} package(s) stowed."
       end
 
       private
 
+      def abort_failed_packages(failures)
+        puts
+        abort "Error: #{failures} package(s) failed to stow."
+      end
+
       def install_system_files
         return if @config.system_files.empty?
 
@@ -60,17 +69,13 @@ module Dotlayer
             next
           end
 
-          unless system("sudo", "cp", source, dest)
+          # install -D creates missing parent dirs (e.g. /etc/systemd/system-sleep).
+          if system("sudo", "install", "-D", "-m", mode || "0644", source, dest)
+            ok
+          else
+            @system_failures += 1
             error("failed")
-            next
           end
-
-          if mode && !system("sudo", "chmod", mode, dest)
-            error("chmod failed")
-            next
-          end
-
-          ok
         end
 
         run_hooks("after_system_files")
@@ -104,7 +109,10 @@ module Dotlayer
           if @dry_run
             warning("dry-run")
           else
-            system(cmd) ? ok : error("failed")
+            next ok if system(cmd)
+
+            @system_failures += 1
+            error("failed")
           end
         end
       end

data/lib/dotlayer/commands/status.rb

@@ -23,6 +23,7 @@ module Dotlayer
         heading "System Detection"
         puts "  OS:         #{detection.os}"
         puts "  Profile:    #{detection.profile}"
+        puts "  Machine:    #{detection.machine}"
         puts "  Distros:    #{detection.distros.empty? ? "(none)" : detection.distros.join(", ")}"
         puts "  Groups:     #{detection.groups.empty? ? "(none)" : detection.groups.join(", ")}"
         puts

data/lib/dotlayer/commands/update.rb

@@ -52,13 +52,20 @@ module Dotlayer
 
         heading "Re-stowing packages"
 
-        packages.each do |repo_path, package|
-          restow_package(stow, repo_path, package, verb: "Restowing")
+        failures = packages.count do |repo_path, package|
+          !restow_package(stow, repo_path, package, verb: "Restowing")
         end
 
+        abort_failed_packages(failures) if failures.positive?
+
         puts
         puts "Done! #{packages.size} package(s) restowed."
       end
+
+      def abort_failed_packages(failures)
+        puts
+        abort "Error: #{failures} package(s) failed to restow."
+      end
     end
   end
 end

data/lib/dotlayer/config.rb

@@ -1,7 +1,7 @@
 require "yaml"
 
 module Dotlayer
-  Repo = Data.define(:path, :private, :packages)
+  Repo = Data.define(:path, :private, :packages, :standalone_packages, :group_packages)
 
   class Config
     DEFAULT_PACKAGES = %w[stow bin git zsh config].freeze
@@ -23,14 +23,16 @@ module Dotlayer
     end
 
     def repos
-      @repos ||= @data.fetch("repos", [{ "path" => "~/.public_dotfiles" }]).filter_map do |entry|
+      @repos ||= @data.fetch("repos", [{"path" => "~/.public_dotfiles"}]).filter_map do |entry|
         path = entry["path"]&.to_s
         next if path.nil? || path.empty?
 
         Repo.new(
           path: File.expand_path(path),
           private: entry["private"] || false,
-          packages: entry["packages"]&.freeze
+          packages: entry["packages"]&.freeze,
+          standalone_packages: entry["standalone_packages"]&.freeze,
+          group_packages: entry["group_packages"] || {}
         )
       end.freeze
     end
@@ -55,6 +57,14 @@ module Dotlayer
       @data.fetch("groups", {})
     end
 
+    def machines
+      @data.fetch("machines", {})
+    end
+
+    def machine_env
+      @data.dig("machines", "env") || "DOTLAYER_MACHINE"
+    end
+
     def system_files
       @data.fetch("system_files", [])
     end

data/lib/dotlayer/detector.rb

@@ -1,7 +1,7 @@
 require "open3"
 
 module Dotlayer
-  Detection = Data.define(:os, :profile, :distros, :groups)
+  Detection = Data.define(:os, :profile, :machine, :distros, :groups)
 
   class Detector
     def initialize(config: Config.new)
@@ -9,7 +9,13 @@ module Dotlayer
     end
 
     def detect
-      Detection.new(os: detect_os, profile: detect_profile, distros: detect_distros, groups: detect_groups)
+      Detection.new(
+        os: detect_os,
+        profile: detect_profile,
+        machine: detect_machine,
+        distros: detect_distros,
+        groups: detect_groups
+      )
     end
 
     private
@@ -17,7 +23,7 @@ module Dotlayer
     def detect_os
       case RbConfig::CONFIG["host_os"]
       when /darwin/ then "macos"
-      when /linux/  then "linux"
+      when /linux/ then "linux"
       else "unknown"
       end
     end
@@ -27,13 +33,30 @@ module Dotlayer
       return from_env if from_env && !from_env.empty?
 
       if @config.profile_detect && !@config.profile_detect.empty?
-        output, status = Open3.capture2(@config.profile_detect)
+        output, status = Open3.capture2("sh", "-c", @config.profile_detect, err: File::NULL)
         return output.strip if status.success? && !output.strip.empty?
       end
 
       "desktop"
     end
 
+    def detect_machine
+      from_env = ENV[@config.machine_env]
+      return normalize_tag(from_env) if from_env && !from_env.empty?
+
+      detected = @config.machines.find do |name, entry|
+        next false if name == "env"
+
+        command_detected?(entry)
+      end
+      return normalize_tag(detected.first) if detected
+
+      output, status = Open3.capture2("hostname", "-s", err: File::NULL)
+      return normalize_tag(output) if status.success? && !output.strip.empty?
+
+      "unknown"
+    end
+
     def detect_distros
       @config.distros.select { |_name, entry| command_detected?(entry) }.keys
     end
@@ -49,5 +72,9 @@ module Dotlayer
       _, status = Open3.capture2e("sh", "-c", cmd)
       status.success?
     end
+
+    def normalize_tag(value)
+      value.to_s.strip.downcase.gsub(/[^a-z0-9_-]+/, "-").gsub(/\A-+|-+\z/, "")
+    end
   end
 end

data/lib/dotlayer/output.rb

@@ -38,12 +38,12 @@ module Dotlayer
 
     def restow_package(stow, repo_path, package, verb: "Stowing")
       print "  #{verb} #{green(package)}... "
-      if stow.dry_run?
-        warning("dry-run")
-      elsif stow.restow(repo_path, package)
-        ok
+      if stow.restow(repo_path, package)
+        stow.dry_run? ? warning("dry-run") : ok
+        true
       else
         error("failed: #{stow.last_error}")
+        false
       end
     end
   end

data/lib/dotlayer/resolver.rb

@@ -1,5 +1,3 @@
-require "set"
-
 module Dotlayer
   class Resolver
     def initialize(config:, detection:)
@@ -26,7 +24,7 @@ module Dotlayer
       # Repos with explicit packages always use layered resolution,
       # even if the directories don't exist yet
       if repo.packages || base_packages.any? { |pkg| Dir.exist?(File.join(repo.path, pkg)) }
-        resolve_layered_repo(repo.path, base_packages)
+        resolve_layered_repo(repo, base_packages)
       else
         resolve_all_packages(repo.path)
       end
@@ -34,7 +32,8 @@ module Dotlayer
 
     # Repos with base packages use layered convention matching
     # plus standalone directories that don't match any layer pattern
-    def resolve_layered_repo(repo_path, base_packages)
+    def resolve_layered_repo(repo, base_packages)
+      repo_path = repo.path
       packages = []
 
       base_packages.each do |pkg|
@@ -42,10 +41,10 @@ module Dotlayer
       end
 
       dirs = top_level_dirs(repo_path)
-      layers, matched_dirs = resolve_layers(repo_path, base_packages, dirs)
+      layers, matched_dirs = resolve_layers(repo, base_packages, dirs)
       packages.concat(layers)
 
-      standalone = resolve_standalone(repo_path, base_packages, matched_dirs, dirs)
+      standalone = resolve_standalone(repo, base_packages, matched_dirs, dirs)
       packages.concat(standalone)
     end
 
@@ -56,41 +55,82 @@ module Dotlayer
         .map { |d| [repo_path, d] }
     end
 
-    def resolve_layers(repo_path, base_packages, dirs)
+    def resolve_layers(repo, base_packages, dirs)
+      repo_path = repo.path
       os_packages = []
       distro_packages = []
       distro_profile_packages = []
+      machine_packages = []
+      os_machine_packages = []
+      distro_machine_packages = []
+      distro_profile_machine_packages = []
       group_packages = []
-      matched_dirs = Set.new(base_packages)
+      matched_dirs = base_packages.dup
 
       dirs.each do |dir|
         next if base_packages.include?(dir)
 
         case dir
-        when suffix("-#{@detection.os}")
-          os_packages << [repo_path, dir]
+        when *@detection.distros.map { |d| suffix("-#{d}-#{@detection.profile}-#{@detection.machine}") }
+          distro_profile_machine_packages << [repo_path, dir]
           matched_dirs << dir
-        when *@detection.distros.map { |d| suffix("-#{d}") }
-          distro_packages << [repo_path, dir]
+        when *@detection.distros.map { |d| suffix("-#{d}-#{@detection.machine}") }
+          distro_machine_packages << [repo_path, dir]
+          matched_dirs << dir
+        when suffix("-#{@detection.os}-#{@detection.machine}")
+          os_machine_packages << [repo_path, dir]
+          matched_dirs << dir
+        when suffix("-#{@detection.machine}")
+          machine_packages << [repo_path, dir]
           matched_dirs << dir
         when *@detection.distros.map { |d| suffix("-#{d}-#{@detection.profile}") }
           distro_profile_packages << [repo_path, dir]
           matched_dirs << dir
+        when *@detection.distros.map { |d| suffix("-#{d}") }
+          distro_packages << [repo_path, dir]
+          matched_dirs << dir
+        when suffix("-#{@detection.os}")
+          os_packages << [repo_path, dir]
+          matched_dirs << dir
         when *@detection.groups.map { |g| suffix("-#{g}") }
           group_packages << [repo_path, dir]
           matched_dirs << dir
         end
       end
 
-      layers = os_packages + distro_packages + distro_profile_packages + group_packages
+      group_packages.concat(resolve_group_packages(repo, matched_dirs))
+      layers = os_packages + distro_packages + distro_profile_packages +
+        machine_packages + os_machine_packages + distro_machine_packages +
+        distro_profile_machine_packages + group_packages
       [layers, matched_dirs]
     end
 
-    def resolve_standalone(repo_path, base_packages, matched_dirs, dirs)
+    def resolve_group_packages(repo, matched_dirs)
+      @detection.groups.flat_map do |group|
+        Array(repo.group_packages[group]).filter_map do |package|
+          next if matched_dirs.include?(package)
+          next unless Dir.exist?(File.join(repo.path, package))
+
+          matched_dirs << package
+          [repo.path, package]
+        end
+      end
+    end
+
+    def resolve_standalone(repo, base_packages, matched_dirs, dirs)
+      if repo.standalone_packages
+        return repo.standalone_packages.filter_map do |package|
+          next if matched_dirs.include?(package)
+          next unless Dir.exist?(File.join(repo.path, package))
+
+          [repo.path, package]
+        end
+      end
+
       dirs
         .reject { |d| matched_dirs.include?(d) || layer_variant?(d, base_packages) }
         .sort
-        .map { |d| [repo_path, d] }
+        .map { |d| [repo.path, d] }
     end
 
     def top_level_dirs(repo_path)

data/lib/dotlayer/stow.rb

@@ -2,30 +2,31 @@ require "open3"
 
 module Dotlayer
   class Stow
-    attr_reader :last_error
+    attr_reader :last_error, :last_output
 
-    def initialize(target: "~", dry_run: false, verbose: false)
+    def initialize(target: "~", dry_run: false, verbose: false, quiet: false)
       @target = File.expand_path(target)
       @dry_run = dry_run
       @verbose = verbose
+      @quiet = quiet
     end
 
     def dry_run? = @dry_run
 
     def restow(repo_path, package)
-      args = ["stow", "-R"]
+      args = ["stow", "-R", "--no-folding"]
+      args << "-n" if @dry_run
       args << "-v" if @verbose
       args << "-d" << repo_path
       args << "-t" << @target
       args << package
 
-      if @verbose || @dry_run
-        $stderr.puts "  #{args.join(" ")}"
+      if !@quiet && (@verbose || @dry_run)
+        warn "  #{args.join(" ")}"
       end
 
-      return true if @dry_run
-
       output, status = Open3.capture2e(*args)
+      @last_output = output
       @last_error = status.success? ? nil : output.strip
       status.success?
     rescue Errno::ENOENT

data/lib/dotlayer.rb

@@ -1,5 +1,5 @@
 module Dotlayer
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 
   autoload :CLI, "dotlayer/cli"
   autoload :Config, "dotlayer/config"
@@ -12,6 +12,7 @@ module Dotlayer
 
   module Commands
     autoload :Adopt, "dotlayer/commands/adopt"
+    autoload :Diff, "dotlayer/commands/diff"
     autoload :Doctor, "dotlayer/commands/doctor"
     autoload :Install, "dotlayer/commands/install"
     autoload :Status, "dotlayer/commands/status"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dotlayer
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Douglas Andrade
@@ -18,12 +18,14 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - exe/dotlayer
 - lib/dotlayer.rb
 - lib/dotlayer/cli.rb
 - lib/dotlayer/commands/adopt.rb
+- lib/dotlayer/commands/diff.rb
 - lib/dotlayer/commands/doctor.rb
 - lib/dotlayer/commands/install.rb
 - lib/dotlayer/commands/status.rb
@@ -39,6 +41,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/douglas/dotlayer
   source_code_uri: https://github.com/douglas/dotlayer
+  changelog_uri: https://github.com/douglas/dotlayer/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -46,14 +49,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Layered dotfiles management with GNU Stow
 test_files: []