mark-twin 0.2.0 → 0.4.0

data/lib/twin/picker.rb

@@ -17,6 +17,7 @@ module Twin
       missing_target: "!",
       missing_source: "!",
       both_missing:   "✗",
+      unreachable:    "?",
       disabled:       "·",
     }.freeze
 
@@ -27,6 +28,7 @@ module Twin
       missing_target: "\e[31m",   # red
       missing_source: "\e[31m",   # red
       both_missing:   "\e[31m",   # red
+      unreachable:    "\e[31m",   # red
       disabled:       "\e[2m",    # dim
     }.freeze
 

data/lib/twin/remote.rb

@@ -0,0 +1,72 @@
+require "open3"
+
+module Twin
+  # Remote (ssh) targets, written exactly as rsync understands them:
+  # "user@host:/path" or "host:/path". A target counts as remote when a colon
+  # appears before the first slash. Sources stay local — twin pushes.
+  module Remote
+    module_function
+
+    SSH_OPTS = ["-o", "BatchMode=yes", "-o", "ConnectTimeout=5"].freeze
+
+    def remote?(target)
+      %r{\A[^/]+:}.match?(target.to_s)
+    end
+
+    # "user@host:/path" → ["user@host", "/path"]
+    def split(target)
+      host, path = target.to_s.split(":", 2)
+      [host, path.to_s]
+    end
+
+    # Non-interactive reachability probe (BatchMode: never asks for a password).
+    def reachable?(host)
+      system("ssh", *SSH_OPTS, host, "true", out: File::NULL, err: File::NULL)
+    end
+
+    # Stat many paths in one ssh round-trip. Paths go over stdin (one per
+    # line), the remote loop answers "path<TAB>epoch" or "path<TAB>-" for
+    # missing ones. Tries BSD stat first, then GNU — covers macOS and Linux.
+    # Returns {path => Time or nil-if-missing}, or nil when ssh itself failed.
+    STAT_SCRIPT = <<~SH.freeze
+      while IFS= read -r p; do
+        if [ -e "$p" ]; then
+          printf '%s\t%s\n' "$p" "$(stat -f %m -- "$p" 2>/dev/null || stat -c %Y -- "$p")"
+        else
+          printf '%s\t-\n' "$p"
+        fi
+      done
+    SH
+
+    def stat_paths(host, paths)
+      return {} if paths.empty?
+      out, _err, status = Open3.capture3(
+        "ssh", *SSH_OPTS, host, STAT_SCRIPT,
+        stdin_data: paths.join("\n") + "\n"
+      )
+      return nil unless status.success?
+
+      result = {}
+      out.each_line do |line|
+        path, mtime = line.chomp.split("\t", 2)
+        next unless path && mtime
+        result[path] = mtime == "-" ? nil : Time.at(mtime.to_i)
+      end
+      result
+    rescue Errno::ENOENT
+      nil # ssh not installed
+    end
+
+    # Create a directory on the remote side (mkdir -p equivalent).
+    def mkdir_p(host, dir)
+      _out, _err, status = Open3.capture3("ssh", *SSH_OPTS, host, "mkdir", "-p", shellesc(dir))
+      status.success?
+    end
+
+    # Escape one argument for the remote shell (ssh joins args with spaces and
+    # hands the string to a shell — local exec-style arrays don't protect it).
+    def shellesc(s)
+      "'" + s.gsub("'", "'\\\\''") + "'"
+    end
+  end
+end

data/lib/twin/scanner.rb

@@ -1,19 +1,28 @@
 require "json"
 require "open3"
 
+require_relative "remote"
+
 module Twin
   # One YAML block from a sync-file, enriched with live filesystem state.
   Job = Struct.new(
-    :program, :path, :description, :active, :excludes, :label,
+    :program, :path, :description, :active, :excludes, :owned, :label,
     :source, :target, :cmd, :delete, :render, :render_outdated, :target_path_field, :sync_file,
     :source_exists, :target_exists, :source_mtime, :target_mtime, :conflict,
+    :target_unreachable,
     keyword_init: true,
   ) do
     def source_path = File.join(source, path)
     def target_path = File.join(target, target_path_field || path)
+    def remote?     = Twin::Remote.remote?(target)
+
+    # Everything rsync must not touch: Exclude (not part of the sync at all)
+    # plus Own (part of the scope, but the target owns it).
+    def all_excludes = excludes + (owned || [])
 
     def status
       return :disabled if active != 1
+      return :unreachable if target_unreachable
       return :both_missing if !source_exists && !target_exists
       return :missing_source unless source_exists
       return :missing_target unless target_exists
@@ -41,7 +50,7 @@ module Twin
     # Aggregate status across jobs — worst first.
     def status
       states = jobs.map(&:status)
-      %i[both_missing missing_source missing_target target_newer source_newer disabled in_sync]
+      %i[unreachable both_missing missing_source missing_target target_newer source_newer disabled in_sync]
         .find { |s| states.include?(s) } || :in_sync
     end
 
@@ -69,10 +78,35 @@ module Twin
         raise "grubber returned invalid JSON: #{e.message}"
       end
       vars = cfg.var_map
-      records.filter_map do |r|
+      jobs = records.filter_map do |r|
         context = "#{r["Program"]} in #{File.basename(r["_note_file"].to_s)}"
         build_job(Twin::Template.substitute_record(r, vars, context: context), vars)
       end
+      fill_remote_stats(jobs)
+      jobs
+    end
+
+    # Remote targets can't be stat'ed locally — batch them into one ssh
+    # round-trip per host. A failed ssh marks the jobs unreachable instead
+    # of aborting the scan (local jobs stay usable).
+    def fill_remote_stats(jobs)
+      jobs.select { |j| j.remote? && j.active == 1 }
+          .group_by { |j| Twin::Remote.split(j.target).first }
+          .each do |host, host_jobs|
+        stats = Twin::Remote.stat_paths(host, host_jobs.map { |j| Twin::Remote.split(j.target_path).last })
+        host_jobs.each do |j|
+          rpath = Twin::Remote.split(j.target_path).last
+          if stats.nil?
+            j.target_unreachable = true
+            next
+          end
+          mtime = stats[rpath]
+          j.target_exists = !mtime.nil?
+          j.target_mtime  = mtime
+          j.conflict      = j.source_exists && mtime && j.source_mtime &&
+                            mtime - j.source_mtime >= 60
+        end
+      end
     end
 
     def load_programs(cfg, file: nil, label: nil, show_all: false)
@@ -113,12 +147,24 @@ module Twin
       return nil if path.empty? || source.empty? || target.empty?
 
       render   = r["Render"] == true
-      excludes = (r["Exclude"] || "").split(",").map(&:strip).reject(&:empty?)
+      excludes = split_list(r["Exclude"])
+      # Own: paths inside the sync scope that the TARGET owns — machine-specific
+      # config the source must never clobber. Same rsync effect as Exclude, but
+      # kept apart so `status` can name the intent instead of hiding it among
+      # build artefacts and .DS_Store.
+      owned    = split_list(r["Own"])
+      remote   = Twin::Remote.remote?(target)
+
+      if render && remote
+        raise "#{r["Program"]}: Render is not supported for remote targets (#{target})"
+      end
 
       src_full = File.join(source, path)
       tgt_full = File.join(target, target_path_field || path)
       src_exists, src_mtime = stat(src_full)
-      tgt_exists, tgt_mtime = stat(tgt_full)
+      # Remote targets are stat'ed in one batched ssh call after all jobs are
+      # built (fill_remote_stats) — until then they read as missing.
+      tgt_exists, tgt_mtime = remote ? [false, nil] : stat(tgt_full)
 
       # Render jobs: status is content-based (mtime is meaningless for a rendered
       # target). conflict stays false so the mtime conflict-warning skips them.
@@ -134,6 +180,7 @@ module Twin
         description:      r["Description"].to_s,
         active:           (r["Active"] || 0).to_i,
         excludes:         excludes,
+        owned:            owned,
         label:            r["Label"].to_s,
         source:           source,
         target:           target,
@@ -148,6 +195,7 @@ module Twin
         source_mtime:     src_mtime,
         target_mtime:     tgt_mtime,
         conflict:         !!conflict,
+        target_unreachable: false,
       )
     end
 
@@ -158,6 +206,11 @@ module Twin
       [false, nil]
     end
 
+    # Comma-separated block field → array of trimmed, non-empty entries.
+    def split_list(value)
+      (value || "").split(",").map(&:strip).reject(&:empty?)
+    end
+
     # For a render job: is the target out of date with the rendered template?
     # nil when source is missing/a directory (status falls through to those).
     # True when target is absent or content differs, or the template can't be

data/lib/twin/sync.rb

@@ -1,5 +1,7 @@
 require "fileutils"
 
+require_relative "remote"
+
 module Twin
   module Sync
     module_function
@@ -35,6 +37,8 @@ module Twin
     # Render a template Job: read source, substitute {{vars}}, write if changed.
     # Returns [success, output, changed].
     def render_job(cfg, job, dry_run: false)
+      return [false, "render: remote targets are not supported", false] if job.remote?
+
       src = job.source_path
       tgt = job.target_path
 
@@ -81,7 +85,7 @@ module Twin
 
     # Sync one Job. Returns [success, combined_output, transferred].
     # transferred is true when rsync actually moved bytes (false on no-op or dry_run).
-    def run_job(cfg, job, dry_run: false)
+    def run_job(cfg, job, dry_run: false, force: false)
       return render_job(cfg, job, dry_run: dry_run) if job.render
 
       src = job.source_path
@@ -89,26 +93,21 @@ module Twin
 
       return [false, "source not found: #{src}", false] unless File.exist?(src)
 
-      FileUtils.mkdir_p(File.dirname(tgt))
-
-      args = ["rsync", "-av", "--itemize-changes", "--update"]
-      args << "--delete" if job.delete
-      args << "--dry-run" if dry_run
-      cfg.global_excludes.each { |ex| args << "--exclude=#{ex}" }
-      job.excludes.each       { |ex| args << "--exclude=#{ex}" }
-
-      if File.directory?(src)
-        args << "#{src}/" << "#{tgt}/"
+      if job.remote?
+        host, rpath = Twin::Remote.split(tgt)
+        unless dry_run || Twin::Remote.mkdir_p(host, File.dirname(rpath))
+          return [false, "ssh: could not create #{File.dirname(rpath)} on #{host}", false]
+        end
       else
-        args << src << tgt
+        FileUtils.mkdir_p(File.dirname(tgt))
       end
 
-      output, status = run(args)
+      output, status = run(rsync_args(cfg, job, dry_run: dry_run, force: force))
       return [false, output, false] unless status.success?
 
       xfr = !dry_run && transferred?(output)
 
-      if job.conflict && !xfr && !dry_run
+      if job.conflict && !xfr && !dry_run && !force
         output += "\nskipped: target is newer, source not synced"
       end
 
@@ -128,9 +127,52 @@ module Twin
       [true, output, xfr]
     end
 
+    # Full rsync argument vector for a job.
+    #
+    # force: drop --update, so a file that is newer on the target is overwritten
+    # anyway. Only ever set after the user agreed to it (see Twin::Conflict), or
+    # via `twin sync --force`.
+    def rsync_args(cfg, job, dry_run: false, force: false)
+      src = job.source_path
+      tgt = job.target_path
+
+      args = ["rsync", "-av", "--itemize-changes"]
+      args << "--update" unless force
+      if job.delete
+        args << "--delete"
+        args.concat(backup_args(job))
+      end
+      args << "--dry-run" if dry_run
+      cfg.global_excludes.each { |ex| args << "--exclude=#{ex}" }
+      job.all_excludes.each   { |ex| args << "--exclude=#{ex}" }
+
+      if File.directory?(src)
+        args << "#{src}/" << "#{tgt}/"
+      else
+        args << src << tgt
+      end
+      args
+    end
+
+    # Safety net for --delete: deleted and overwritten files land in a
+    # per-run backup dir on the target side (<target>/.twin-backup/<stamp>).
+    # rsync only creates the dir when it actually backs something up.
+    # The exclude keeps a backup dir inside the transfer root (Path: ".")
+    # from being deleted by the very sync it protects against.
+    def backup_args(job)
+      root = job.remote? ? Twin::Remote.split(job.target).last : job.target
+      dir  = File.join(root, ".twin-backup", run_stamp)
+      ["--backup", "--backup-dir=#{dir}", "--exclude=.twin-backup/"]
+    end
+
+    # One timestamp per twin process, so a multi-job run shares a backup dir.
+    def run_stamp
+      @run_stamp ||= Time.now.strftime("%Y-%m-%d_%H%M%S")
+    end
+
     # Sync all jobs in a Program. Returns array of [job, success, output].
-    def run_program(cfg, program, dry_run: false)
-      program.active_jobs.map { |job| [job, *run_job(cfg, job, dry_run: dry_run)] }
+    def run_program(cfg, program, dry_run: false, force: false)
+      program.active_jobs.map { |job| [job, *run_job(cfg, job, dry_run: dry_run, force: force)] }
     end
 
     def run(args)

data/lib/twin/version.rb

@@ -1,3 +1,3 @@
 module Twin
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/twin.rb

@@ -1,8 +1,12 @@
 require_relative "twin/version"
+require_relative "twin/remote"
 require_relative "twin/template"
 require_relative "twin/config"
 require_relative "twin/scanner"
 require_relative "twin/sync"
+require_relative "twin/conflict"
+require_relative "twin/journal"
+require_relative "twin/add"
 require_relative "twin/preview"
 require_relative "twin/picker"
 require_relative "twin/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mark-twin
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Ralf Hülsmann
@@ -37,10 +37,14 @@ files:
 - README.md
 - bin/twin
 - lib/twin.rb
+- lib/twin/add.rb
 - lib/twin/cli.rb
 - lib/twin/config.rb
+- lib/twin/conflict.rb
+- lib/twin/journal.rb
 - lib/twin/picker.rb
 - lib/twin/preview.rb
+- lib/twin/remote.rb
 - lib/twin/scanner.rb
 - lib/twin/sync.rb
 - lib/twin/template.rb
@@ -78,7 +82,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.4
 specification_version: 4
-summary: Sync configuration folders between two Macs from self-documenting Markdown
-  files
+summary: Sync configuration between machines, from self-documenting Markdown files
 test_files: []
 ...