multisync 0.3.6 → 0.4.0

data/lib/multisync/definition/null.rb

@@ -1,14 +1,13 @@
-
 class Multisync::Definition::Null < Multisync::Definition::Entity
-  
   def initialize
+    @level = -1
   end
-  
+
   def register member
   end
 
   def fullname
-    nil
+    ""
   end
 
   def rsync_options
@@ -19,34 +18,33 @@ class Multisync::Definition::Null < Multisync::Definition::Entity
   def source
     raise "no source (from) defined"
   end
-  
+
   def source_description
-    ''
+    ""
   end
-  
+
   # to (destination) is a required option and should be set at least at root level
   def destination
     raise "no destination (to) defined"
   end
-  
+
   def destination_description
-    ''
+    ""
   end
-  
+
   def default?
     false
   end
-  
+
   def checks
     []
   end
 
   def check_source?
     false
-  end  
+  end
 
   def check_destination?
     false
   end
 end
-

data/lib/multisync/definition/template.rb

@@ -1,26 +1,25 @@
-
 class Multisync::Definition::Template
   include Multisync::Definition::Dsl
-  
+
   @registered = []
-  
+
   def self.register instance
     @registered << instance
   end
-  
+
   def self.lookup name
-    @registered.find {|instance| instance.name == name }
+    @registered.find { _1.name == name }
   end
-  
+
   # The name of the template
   attr_reader :name
-  
+
   # The block the template holds
   attr_reader :block
-  
+
   def initialize name, &block
     @name = name
     self.class.register self
     @block = block
   end
-end
+end

data/lib/multisync/definition.rb

@@ -1,7 +1,6 @@
-
 class Multisync::Definition
-  autoload :Dsl, 'multisync/definition/dsl'
-  autoload :Entity, 'multisync/definition/entity'
-  autoload :Null, 'multisync/definition/null'
-  autoload :Template, 'multisync/definition/template'
-end
+  autoload :Dsl, "multisync/definition/dsl"
+  autoload :Entity, "multisync/definition/entity"
+  autoload :Null, "multisync/definition/null"
+  autoload :Template, "multisync/definition/template"
+end

data/lib/multisync/list.rb

@@ -1,44 +1,47 @@
-
-require 'rainbow/ext/string'
-
 class Multisync::List
-  
+  include Multisync::Colors
+
   # Given catalog
   attr_reader :catalog
-  
+
   # Tasks
   attr_reader :tasks
 
-  def initialize catalog
-    @catalog = catalog
-    @tasks = []
+  def initialize tasks
+    @tasks = tasks
   end
-  
+
   def to_s
-    catalog.traverse self
-    table.to_s
+    "\n" + table.to_s
   end
-  
+
   def table
-    Terminal::Table.new(rows: tasks, style: table_style)
+    Terminal::Table.new(rows: rows, style: table_style)
   end
-  
-  def visit subject, level
-    if level > 0
-      tab = ''.ljust(2*(level-1), ' ')
-      default = subject.default? ? ' *' : ''
-      name = "#{tab}#{subject.name}#{default}"
-      tasks << [name, *description(subject).map(&:faint)]
-      # puts "#{name.ljust(32, ' ')}#{description(subject)}"
+
+  def rows
+    tasks.map do |task|
+      next unless task.level > 0
+
+      indent = "".ljust(2 * (task.level - 1), " ")
+      name = task.executeable? ? task.name : "#{task.name}#{as_note("/")}"
+      default = task.default? ? as_note(" *") : ""
+      [
+        [indent, name, default].join,
+        *descriptions(task)
+      ]
     end
   end
-  
-  def description subject
-    desc = [subject.source_description, subject.destination_description]
-    desc.any?(&:empty?) ? [] : [desc.first, ['--> ', desc.last].join]
+
+  def descriptions task
+    if [task.source_description, task.destination_description].any?(&:empty?)
+      ["", "", ""]
+    else
+      [task.source_description, "-->", task.destination_description].map(&method(:as_note))
+    end
   end
 
   def table_style
-    { border_top: false,  border_bottom: false, border_x: '–', border_y: '', border_i: '', padding_left: 0, padding_right: 3 }
+    {border_x: as_note("─"), border_y: "", border_i: "", border_top: false, border_bottom: false, padding_left: 0, padding_right: 3}
   end
 end

data/lib/multisync/rsync_stat.rb

@@ -1,58 +1,99 @@
-
-require 'filesize'
+require "filesize"
 
 class Multisync::RsyncStat
-  
+  # Keep track of totals
+  def self.total
+    @total ||= Hash.new 0
+  end
+
+  # Sample output
+  #   ...
+  #   Number of files: 89,633 (reg: 59,322, dir: 30,311)
+  #   Number of created files: 356 (reg: 281, dir: 75)
+  #   Number of deleted files: 114 (reg: 101, dir: 13)
+  #   Number of regular files transferred: 344
+  #   Total file size: 546,410,522,192 bytes
+  #   Total transferred file size: 7,991,491,676 bytes
+  #   Literal data: 7,952,503,842 bytes
+  #   Matched data: 38,987,834 bytes
+  #   File list size: 3,063,808
+  #   File list generation time: 2.414 seconds
+  #   File list transfer time: 0.000 seconds
+  #   Total bytes sent: 7,957,645,803
+  #   Total bytes received: 101,299
+  #
+  #   sent 7,957,645,803 bytes  received 101,299 bytes  23,719,067.37 bytes/sec
+  #   total size is 546,410,522,192  speedup is 68.66
   def initialize output
     @output = output
   end
 
-  # Build an internal hash with normalized stats  
-  def parse
-    @stats = definitions.each_with_object({}) do |definition, stats|
-      value = scan[definition[:match]]
-      stats[definition[:key]] = value ? (definition[:coerce] ? definition[:coerce].call(value) : value) : definition[:default]
-    end
-    self
-  end
-  
-  # Scan output and return a hash
+  # extracted returns a hash with labels as keys and extracted strings as values
   #   {
   #     "Number of files" => "35,648",
-  #     "Number of created files" => "0",
-  #     "Number of deleted files" => "0",
-  #     "Number of regular files transferred"=>"0",
+  #     "Number of created files" => "2,120",
   #     ...
   #   }
-  def scan
-    @scan ||= @output.scan(/(#{definitions.map{|d| d[:match] }.join('|')}):\s+([,0-9]+)/).each_with_object({}) {|(k,v), o| o[k] = v }
-  end
-  
-  def to_a
-    [
-      @stats[:files],
-      @stats[:created],
-      @stats[:deleted],
-      @stats[:transferred],
-      @stats[:file_size],
-      @stats[:transferred_size],
-    ]
-  end
-  
-  def method_missing name
-    key = name.to_sym
-    return @stats[key] if @stats.keys.include? key
-    super
-  end
-  
-  def definitions
-    [
-      { key: :files, match: 'Number of files', coerce: ->(x) { x.gsub(',',"'") }, default: '0' },
-      { key: :created, match: 'Number of created files', coerce: ->(x) { x.gsub(',',"'") }, default: '0' },
-      { key: :deleted, match: 'Number of deleted files', coerce: ->(x) { x.gsub(',',"'") }, default: '0' },
-      { key: :transferred, match: 'Number of regular files transferred', coerce: ->(x) { x.gsub(',',"'") }, default: '0' },
-      { key: :file_size, match: 'Total file size', coerce: ->(x) { Filesize.new(x.gsub(',','').to_i).pretty }, default: '0 B' },
-      { key: :transferred_size, match: 'Total transferred file size', coerce: ->(x) { Filesize.new(x.gsub(',','').to_i).pretty }, default: '0 B' },
-    ]
-  end
-end
+  def extracted
+    @extraced ||= @output.scan(/(#{labels.join("|")}):\s+([,0-9]+)/).to_h
+  end
+
+  # stats returns a hash with the follwing keys (and updates class total)
+  #   {
+  #     "Number of files" => 35648,
+  #     "Number of created files" => 2120,
+  #     "Number of deleted files" => 37,
+  #     "Number of regular files transferred" => 394,
+  #     "Total file size" => 204936349,
+  #     "Total transferred file size" => 49239,
+  #   }
+  def stats
+    @stats ||= labels.each_with_object({}) do |label, h|
+      value = extracted[label]&.delete(",").to_i
+
+      self.class.total[label] += value # update total
+      h[label] = value
+    end
+  end
+
+  def labels
+    self.class.format_map.keys
+  end
+
+  def formatted_values
+    self.class.format_values do |label|
+      stats[label]
+    end
+  end
+
+  def self.formatted_totals
+    format_values do |label|
+      total[label]
+    end
+  end
+
+  def self.format_values
+    format_map.map do |label, format|
+      format.call(yield label)
+    end
+  end
+
+  def self.format_map
+    {
+      "Number of files" => to_numbers,
+      "Number of created files" => to_numbers,
+      "Number of deleted files" => to_numbers,
+      "Number of regular files transferred" => to_numbers,
+      "Total file size" => to_filesize,
+      "Total transferred file size" => to_filesize
+    }
+  end
+
+  def self.to_numbers
+    ->(x) { x.to_s.gsub(/\B(?=(...)*\b)/, "'") }
+  end
+
+  def self.to_filesize
+    ->(x) { Filesize.new(x).pretty }
+  end
+end

data/lib/multisync/runtime.rb

@@ -1,82 +1,77 @@
-
-require 'mixlib/shellout'
+require "mixlib/shellout"
 
 class Multisync::Runtime
+  include Multisync::Colors
 
   # Runtime options
   #   dryrun: true|false
   #   show: true|false
   attr_reader :options
-  
+
   def initialize options
     @options = options
   end
-  
-  def dryrun?
-    options[:dryrun]
-  end
-  
-  def show_only?
-    options[:print]
-  end
-  
-  def quiet?
-    options[:quiet]
-  end
-  
-  def timeout
-    options[:timeout]
-  end
-  
+
+  def dryrun? = options[:dryrun]
+
+  def show_only? = options[:print]
+
+  def quiet? = options[:quiet]
+
+  def timeout = options[:timeout]
+
   def run sync
     rsync_options = sync.rsync_options.dup
-    rsync_options.unshift '--stats'
-    rsync_options.unshift '--verbose' unless quiet?
-    rsync_options.unshift '--dry-run' if dryrun?
+    rsync_options.unshift "--stats"
+    rsync_options.unshift "--verbose" unless quiet?
+    rsync_options.unshift "--dry-run" if dryrun?
 
     # escape path by hand, shellescape escapes also ~, but we want to keep its
     # special meaning for home, instead of passing it as literal char
-    source, destination = [sync.source, sync.destination].map {|path| path.gsub(/\s+/, '\\ ') }
-    cmd = "rsync #{rsync_options.join(' ')} #{source} #{destination}"
-    cmd_options = { timeout: timeout }
-    cmd_options.merge!({live_stdout: $stdout, live_stderr: $stderr}) unless quiet?
+    source, destination = [sync.source, sync.destination].map { _1.gsub(/\s+/, "\\ ") }
+    cmd = "rsync #{rsync_options.join(" ")} #{source} #{destination}"
+    cmd_options = {timeout: timeout}
+    unless quiet?
+      cmd_options[:live_stdout] = $stdout
+      cmd_options[:live_stderr] = $stderr
+    end
     rsync = Mixlib::ShellOut.new(cmd, cmd_options)
     sync.result[:cmd] = rsync.command
 
     unless quiet?
       puts
-      puts [sync.source_description, sync.destination_description].join(' --> ').color(:cyan)
+      puts as_main([sync.source_description, sync.destination_description].join(" --> "))
     end
-    
+
     # Perform all only_if checks, from top to bottom
     sync.checks.each do |check|
       next unless Mixlib::ShellOut.new(check[:cmd]).run_command.error?
 
-      puts check[:cmd] + ' (failed)'
-      puts "Skip: ".color(:yellow) + rsync.command
+      puts as_skipped("#{check[:cmd]} (failed)")
+      puts as_note("Skip: #{rsync.command}")
       sync.result[:action] = :skip
       sync.result[:skip_message] = check[:message]
-      return
+      return false
     end
-    
+
     # source check
-    if sync.check_source? && ! check_path(sync.source, :source)
-      puts "Source #{sync.source} is not accessible"
-      puts "Skip: ".color(:yellow) + rsync.command
+    if sync.check_source? && !check_path(sync.source, :source)
+      puts as_skipped("Source #{sync.source} is not accessible")
+      puts as_note("Skip: #{rsync.command}")
       sync.result[:action] = :skip
       sync.result[:skip_message] = "Source is not accessible"
       return
     end
-    
+
     # target check
-    if sync.check_destination? && ! check_path(sync.destination, :destination)
-      puts "Destination #{sync.destination} is not accessible"
-      puts "Skip: ".color(:yellow) + rsync.command
+    if sync.check_destination? && !check_path(sync.destination, :destination)
+      puts as_skipped("Destination #{sync.destination} is not accessible")
+      puts as_note("Skip: #{rsync.command}")
       sync.result[:action] = :skip
       sync.result[:skip_message] = "Destination is not accessible"
       return
     end
-      
+
     if show_only?
       puts rsync.command
     else
@@ -88,20 +83,20 @@ class Multisync::Runtime
       sync.result[:stderr] = rsync.stderr
     end
   end
-  
+
   # checks a path
   # if path includes a host, the reachability of the host will be checked
   # the existence of the remote path will not be checked
   # if path is a local source path, its existence will be checked
   # if path is a local destination path, the existence of the parent will be checked
   def check_path path, type = :source
-    if path.include? ':'
-      host = path.split(':').first.split('@').last
+    if path.include? ":"
+      host = path.split(":").first.split("@").last
       Mixlib::ShellOut.new("ping -o -t 1 #{host}").run_command.status.success?
     else
-      abs_path = File.expand_path path
-      abs_path = File.dirname abs_path if type == :destination
-      File.exist? abs_path
+      File.expand_path(path)
+        .then { (type == :destination) ? File.dirname(_1) : _1 }
+        .then { File.exist? _1 }
     end
   end
-end
+end

data/lib/multisync/selector.rb

@@ -1,36 +1,58 @@
-
 class Multisync::Selector
-  
   # Given catalog
   attr_reader :catalog
-  
-  # Given set names
-  attr_reader :sets
-  
+
+  # Given queries
+  attr_reader :queries
+
   # Selected tasks
-  attr_reader :result
+  attr_reader :results
 
-  def initialize catalog, sets
+  def initialize catalog, queries
     @catalog = catalog
-    @sets = sets
-    @result = []
+    @queries = queries
+    @results = []
+    @all_subjects = []
+    @subjects_by_name = []
   end
-  
-  def tasks
+
+  def tasks parents: false
     catalog.traverse self
-    result
+    parents ? selected_with_parents : selected
   end
-  
-  def visit subject, _level
-    result << subject if selected?(subject)
+
+  def visit subject
+    results << subject
+  end
+
+  def selected_with_parents
+    @selected_with_parents ||= results.select { selected_or_parent_of_selected? _1 }
+  end
+
+  def selected_or_parent_of_selected? subject
+    !subject.fullname.empty? &&
+      selected_fullnames.any? { %r{^#{subject.fullname}(?:/|$)}.match _1 }
   end
-  
+
+  def selected_fullnames
+    @selected_fullnames ||= selected.map(&:fullname)
+  end
+
+  def selected
+    @selected ||= results.select { selected? _1 }
+  end
+
   def selected? subject
+    # return only subjects with a fullname
+    return false if subject.fullname.empty?
+
+    # no queries defined, but subject is in the default set
+    return true if queries.empty? && subject.default?
+
     # only return the leaves of the definition tree
-    return false unless subject.members.empty?
-    # no sets defined, but subject is in the default set
-    return true if sets.empty? && subject.default?
-    # subject matches any of the given sets
-    sets.any? {|set| /\b#{set}\b/.match subject.fullname }
+    # return false unless subject.members.any?
+
+    # subject matches any of the given queries
+    queries.any? { /\b#{_1}\b/.match subject.fullname }
   end
 end

data/lib/multisync/summary.rb

@@ -1,55 +1,90 @@
-
 class Multisync::Summary
-  
+  include Multisync::Colors
+
   # All tasks to include in the summary
   attr_reader :tasks
-  
+
   def initialize tasks
     @tasks = tasks
   end
-  
+
   def to_s
-    table.to_s
+    ["", as_main("Summary"), table.to_s, failures].compact.join("\n")
   end
-  
+
   def table
     Terminal::Table.new(headings: headings, rows: data, style: table_style)
   end
-  
+
   def headings
-    %w( Source Destination Files + - → ∑ ↑ ).zip(%i( left left right right right right right right )).map{|v,a| {value: v, alignment: a} }
+    %w[SOURCE DESTINATION FILES + - → ∑ ↑]
+      .map(&method(:as_note))
+      .zip(%i[left left right right right right right right])
+      .map { |v, a| {value: v, alignment: a} }
   end
-  
+
   def data
-    # Exclude tasks with an empty result (> not run) first
     tasks.map do |task|
       result = task.result
-      desc = [task.source_description, "--> #{task.destination_description}"]
+      desc = [task.source_description, task.destination_description]
 
       case result[:action]
       when :run
-        if result[:status] && result[:status].success?
+        if result[:status]&.success?
           # successfull run
-          stat = Multisync::RsyncStat.new(result[:stdout]).parse
-          [*desc, *stat.to_a.map{|e| {value: e.color(:green), alignment: :right} } ]
+          stats = Multisync::RsyncStat.new(result[:stdout])
+          [*desc, *stats.formatted_values.map { {value: as_success(_1), alignment: :right} }]
         else
           # failed or interrupted run
-          [*desc, { value: (result[:stderr] || 'n/a').strip.color(:red), colspan: 6 } ]
+          [*desc, as_message(as_fail("Failed, for more information see details below"))]
+          # [*desc, as_message(as_fail(result[:stderr] || "n/a").strip)]
         end
 
       when :skip
         # skiped sync
-        [*desc, { value: result[:skip_message].color(:yellow), colspan: 6 } ]
+        [*desc, as_message(as_skipped(result[:skip_message]))]
 
       else
         # not executed
-        [*desc, { value: 'not executed'.faint, colspan: 6 } ]
+        [*desc, as_message(as_note("not executed"))]
       end
-    end
+    end.push(
+      [
+        as_note("Total"),
+        "",
+        *Multisync::RsyncStat
+          .formatted_totals
+          .map { {value: as_note(_1), alignment: :right} }
+      ]
+    )
   end
-  
-  def table_style
-    { border_top: false,  border_bottom: false, border_x: '–', border_y: '', border_i: '', padding_left: 0, padding_right: 3 }
+
+  def failures
+    tasks
+      .select { _1.result[:action] == :run && !_1.result[:status]&.success? }
+      .flat_map do |task|
+        [
+          as_fail([task.source_description, task.destination_description].join(" --> ")),
+          message_or_nil(task.result[:stdout]),
+          message_or_nil(task.result[:stderr]),
+          ""
+        ].compact
+      end
+      # Add title if any failures
+      .tap { _1.unshift "\n#{as_main("Failures")}" if _1.any? }
+      # Return failures as string or nil
+      .then { _1.any? ? _1.join("\n") : nil }
+  end
+
+  def as_message message
+    {value: message, colspan: 6}
   end
 
+  def message_or_nil message
+    (message.nil? || message.empty?) ? nil : message
+  end
+
+  def table_style
+    {border_x: as_note("─"), border_y: "", border_i: "", border_top: false, border_bottom: false, padding_left: 0, padding_right: 3}
+  end
 end

data/lib/multisync/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Multisync
-  VERSION = "0.3.6"
+  VERSION = "0.4.0"
 end