MuranoCLI 2.2.4 → 3.0.0

data/lib/MrMurano/SolutionId.rb

@@ -0,0 +1,73 @@
+# Last Modified: 2017.08.17 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
+module MrMurano
+  module SolutionId
+    INVALID_SID = '-1'
+    UNEXPECTED_TYPE_OR_ERROR_MSG = 'Unexpected result type or error: assuming empty instead'
+
+    attr_reader :sid
+    attr_reader :valid_sid
+
+    def init_sid!(sid=nil)
+      @valid_sid = false
+      unless defined?(@solntype) && @solntype
+        # Note that 'solution.id' isn't an actual config setting;
+        # see instead 'application.id' and 'product.id'. We just
+        # use 'solution.id' to indicate that the caller specified
+        # a solution ID explicitly (i.e., it's not from the $cfg).
+        raise 'Missing sid or class @solntype!?' if sid.to_s.empty?
+        @solntype = 'solution.id'
+      end
+      if sid
+        self.sid = sid
+      else
+        # Get the application.id or product.id.
+        self.sid = $cfg[@solntype]
+      end
+      # Maybe raise 'No application!' or 'No product!'.
+      return unless @sid.to_s.empty?
+      raise MrMurano::ConfigError.new("No #{/(.*).id/.match(@solntype)[1]} ID!")
+    end
+
+    def sid?
+      # The @sid should never be nil or empty, but let's at least check.
+      @sid != INVALID_SID && !@sid.to_s.empty?
+    end
+
+    def sid=(sid)
+      sid = INVALID_SID if sid.nil? || !sid.is_a?(String) || sid.empty?
+      @valid_sid = false if sid.to_s.empty? || sid == INVALID_SID || (defined?(@sid) && sid != @sid)
+      @sid = sid
+      # MAGIC_NUMBER: The 2nd element is the solution ID, e.g., solution/<sid>/...
+      raise "Unexpected @uriparts_sidex #{@uriparts_sidex}" unless @uriparts_sidex == 1
+      # We're called on initialize before @uriparts is built, so don't always do this.
+      @uriparts[@uriparts_sidex] = @sid if defined?(@uriparts)
+    end
+
+    def affirm_valid
+      @valid_sid = true
+    end
+
+    def valid_sid?
+      @valid_sid
+    end
+
+    # rubocop:disable Style/MethodName
+    def apiId
+      @sid
+    end
+
+    def endpoint(_path='')
+      # This is hopefully just a DEV error, and not something user will ever see!
+      return unless @uriparts[@uriparts_sidex] == INVALID_SID
+      error("Solution ID missing! Invalid ‘#{@solntype}’")
+      exit 2
+    end
+  end
+end
+

data/lib/MrMurano/SyncRoot.rb

@@ -0,0 +1,137 @@
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
+module MrMurano
+  ## Track what things are syncable.
+  class SyncRoot
+    include Singleton
+
+    # A thing that is syncable.
+    Syncable = Struct.new(:name, :class, :type, :desc, :bydefault, :aliases) do
+      def opt_sym
+        name.tr('-', '_').to_sym
+      end
+    end
+
+    def initialize
+      @syncset = []
+      @synctypes = {}
+    end
+
+    ##
+    # Return the @syncset
+    # @return [Array<String>] array of Syncables
+    attr_reader :syncset
+
+    ##
+    # Add a new entry to syncable things
+    # @param name [String] The name to use for the long option
+    # @param klass [Class] The class to instanciate from
+    # @param type [String] Single letter for short option and status listing
+    # @param desc [String] Summary of what this syncs.
+    # @param bydefault [Boolean] Is this part of the default sync group
+    # @param aliases [Array] List of alternative CLI option names.
+    #
+    # @return [nil]
+    def add(name, klass, type, bydefault, aliases=[])
+      # 2017-06-20: Maybe possibly enforce unique name policy for --syncset options.
+      #@syncset.each do |a|
+      #  if a.name == name.to_s
+      #    msg = %{WARNING: SyncRoot.add called more than once for name "#{a.name}"}
+      #    $stderr.puts HighLine.color(msg, :yellow)
+      #  end
+      #end
+      # We should at least enforce a unique type policy,
+      # since the type is used to define the CLI option.
+      raise "Duplicate SyncRoot type specified: '#{type}'" if @synctypes[type]
+      @synctypes[type] = true
+      @syncset << Syncable.new(name.to_s, klass, type, klass.description, bydefault, aliases)
+      nil
+    end
+
+    ##
+    # Remove all syncables.
+    def reset
+      @syncset = []
+      @synctypes = {}
+    end
+
+    ##
+    # Get the list of default syncables.
+    # @return [Array<String>] array of names
+    def bydefault
+      @syncset.select(&:bydefault).map(&:name)
+    end
+
+    ##
+    # Iterate over all syncables
+    # @param block code to run on each
+    def each
+      @syncset.each { |a| yield a.name, a.type, a.class, a.desc }
+    end
+
+    ##
+    # Iterate over all syncables with option arguments.
+    # @param block code to run on each
+    def each_option
+      #@syncset.each { |a| yield "-#{a.type.downcase}", "--[no-]#{a.name}", a.desc }
+      @syncset.each { |a| yield "-#{a.type}", "--[no-]#{a.name}", a.desc }
+    end
+
+    ##
+    # Iterate over all syncables with option argument aliases.
+    # @param block code to run on each
+    def each_alias_opt
+      @syncset.each do |syncable|
+        syncable.aliases.each do |syn|
+          yield "--[no-]#{syn}", syncable.desc
+        end
+      end
+    end
+
+    def each_alias_sym
+      @syncset.each do |syncable|
+        syncable.aliases.each do |pseudonym|
+          yield pseudonym, pseudonym.tr('-', '_').to_sym, syncable.name, syncable.opt_sym
+        end
+      end
+    end
+
+    ##
+    # Iterate over just the selected syncables.
+    # @param opt [Hash{Symbol=>Boolean}] Options hash of which to select from
+    # @param block code to run on each
+    def each_filtered(opt)
+      check_same(opt)
+      @syncset.each do |a|
+        if opt[a.opt_sym] || opt[a.type.to_sym]
+          yield a.name, a.type, a.class, a.desc
+        end
+      end
+    end
+
+    ## Adjust options based on all or none
+    # If none are selected, select the bydefault ones.
+    #
+    # @param opt [Hash{Symbol=>Boolean}] Options hash of which to select from
+    #
+    # @return [nil]
+    def check_same(opt)
+      if opt[:all]
+        @syncset.each { |a| opt[a.name.to_sym] = true }
+      else
+        any = @syncset.select { |a| opt[a.opt_sym] || opt[a.type.to_sym] }
+        if any.empty?
+          bydef = $cfg['sync.bydefault'].split
+          @syncset.select { |a| bydef.include? a.name }.each { |a| opt[a.name.to_sym] = true }
+        end
+      end
+      nil
+    end
+  end
+end
+

data/lib/MrMurano/SyncUpDown.rb

@@ -1,121 +1,60 @@
+# Last Modified: 2017.08.18 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
+# FIXME/MAYBE: Fix semicolon usage.
+# rubocop:disable Style/Semicolon
+
+require 'inflecto'
+require 'open3'
 require 'pathname'
+#require 'shellwords'
 require 'tempfile'
-require 'shellwords'
-require 'open3'
-require 'MrMurano/Config'
-require 'MrMurano/ProjectFile'
+require 'MrMurano/progress'
+require 'MrMurano/verbosing'
 require 'MrMurano/hash'
+#require 'MrMurano/Config'
+#require 'MrMurano/ProjectFile'
+##require 'MrMurano/SyncRoot'
 
 module MrMurano
-  ## Track what things are syncable.
-  class SyncRoot
-    # A thing that is syncable.
-    Syncable = Struct.new(:name, :class, :type, :desc, :bydefault) do
-    end
-
-    ##
-    # Add a new entry to syncable things
-    # @param name [String] The name to use for the long option
-    # @param klass [Class] The class to instanciate from
-    # @param type [String] Single letter for short option and status listing
-    # @param desc [String] Summary of what this syncs.
-    # @param bydefault [Boolean] Is this part of the default sync group
-    #
-    # @return [nil]
-    def self.add(name, klass, type, desc, bydefault=false)
-      @@syncset = [] unless defined?(@@syncset)
-      @@syncset << Syncable.new(name.to_s, klass, type, desc, bydefault)
-      nil
-    end
-
-    ##
-    # Remove all syncables.
-    def self.reset()
-      @@syncset = []
-    end
-
-    ##
-    # Get the list of default syncables.
-    # @return [Array<String>] array of names
-    def self.bydefault
-      @@syncset.select{|a| a.bydefault }.map{|a| a.name}
-    end
-
-    ##
-    # Iterate over all syncables
-    # @param block code to run on each
-    def self.each(&block)
-      @@syncset.each{|a| yield a.name, a.type, a.class }
-    end
-
-    ##
-    # Iterate over all syncables with option arguments.
-    # @param block code to run on each
-    def self.each_option(&block)
-      @@syncset.each{|a| yield "-#{a.type.downcase}", "--[no-]#{a.name}", a.desc}
-    end
-
-    ##
-    # Iterate over just the selected syncables.
-    # @param opt [Hash{Symbol=>Boolean}] Options hash of which to select from
-    # @param block code to run on each
-    def self.each_filtered(opt, &block)
-      self.checkSAME(opt)
-      @@syncset.each do |a|
-        if opt[a.name.to_sym] or opt[a.type.to_sym] then
-          yield a.name, a.type, a.class
-        end
-      end
-    end
-
-    ## Adjust options based on all or none
-    # If none are selected, select the bydefault ones.
-    #
-    # @param opt [Hash{Symbol=>Boolean}] Options hash of which to select from
-    #
-    # @return [nil]
-    def self.checkSAME(opt)
-      if opt[:all] then
-        @@syncset.each {|a| opt[a.name.to_sym] = true }
-      else
-        any = @@syncset.select {|a| opt[a.name.to_sym] or opt[a.type.to_sym]}
-        if any.empty? then
-          bydef = $cfg['sync.bydefault'].split
-          @@syncset.select{|a| bydef.include? a.name }.each{|a| opt[a.name.to_sym] = true}
-        end
-      end
-
-      nil
-    end
-  end
-
   ## The functionality of a Syncable thing.
   #
   # This provides the logic for computing what things have changed, and pushing and
   # pulling those things.
   #
   module SyncUpDown
-
-    # This is one item that can be synced
+    # This is one item that can be synced.
     class Item
-      # @return [String] The name of this item
+      # @return [String] The name of this item.
       attr_accessor :name
-      # @return [Pathname] Where this item lives
+      # @return [Pathname] Where this item lives.
       attr_accessor :local_path
-      # ??? what is this?
+      # FIXME/EXPLAIN: ??? what is this?
       attr_accessor :id
-      # @return [String] The lua code for this item. (not all items use this.)
+      # @return [String] The Lua code for this item. (not all items use this.)
       attr_accessor :script
-      # @return [Integer] The line in #local_path where this #script starts
+      # @return [Integer] The line in #local_path where this #script starts.
       attr_accessor :line
-      # @return [Integer] The line in #local_path where this #script ends
+      # @return [Integer] The line in #local_path where this #script ends.
       attr_accessor :line_end
-      # @return [String] If requested, the diff output
+      # @return [String] If requested, the diff output.
       attr_accessor :diff
       # @return [Boolean] When filtering, did this item pass.
       attr_accessor :selected
-      # ???? what is this?
+      # @return [String] The constructed name used to match local items to remote items.
       attr_accessor :synckey
+      # @return [String] The syncable type.
+      attr_accessor :synctype
+      # @return [String] For device2, the event type.
+      attr_accessor :type
+      # @return [String] The updated_at time from the server is used to detect changes.
+      attr_accessor :updated_at
+      # @return [Integer] Positive if multiple conflicting files found for same item.
+      attr_accessor :dup_count
 
       # Initialize a new Item with a few, or all, attributes.
       # @param hsh [Hash{Symbol=>Object}, Item] Initial values
@@ -126,17 +65,17 @@ module MrMurano
       #  item = Item.new(:name => 'get')
       #  Item.new(item)
       def initialize(hsh={})
-        hsh.each_pair{|k,v| self[k] = v}
+        hsh.each_pair { |k, v| self[k] = v }
       end
 
       def as_inst(key)
         return key if key.to_s[0] == '@'
-        return "@#{key}"
+        "@#{key}"
       end
       private :as_inst
       def as_sym(key)
         return key.to_sym if key.to_s[0] != '@'
-        return key.to_s[1..-1].to_sym
+        key.to_s[1..-1].to_sym
       end
       private :as_sym
 
@@ -150,7 +89,7 @@ module MrMurano
       # Set attribute as if this was a Hash
       # @param key [String,Symbol] attribute name
       # @param value [Object] value to set
-      def []=(key,value)
+      def []=(key, value)
         public_send("#{key}=", value)
       end
 
@@ -164,14 +103,14 @@ module MrMurano
 
       # @return [Hash{Symbol=>Object}] A hash that represents this Item
       def to_h
-        Hash[ instance_variables.map{|k| [ as_sym(k), instance_variable_get(k)]} ]
+        Hash[instance_variables.map { |k| [as_sym(k), instance_variable_get(k)] }]
       end
 
       # Adds the contents of item to self.
       # @param item [Item,Hash] Stuff to merge
       # @return [Item] ourself
       def merge!(item)
-        item.each_pair{|k,v| self[k] = v}
+        item.each_pair { |k, v| self[k] = v }
         self
       end
 
@@ -186,7 +125,7 @@ module MrMurano
       # @yieldparam key [Symbol] The name of the key
       # @yieldparam value [Object] The value for that key
       # @return [Item]
-      def each_pair(&block)
+      def each_pair
         instance_variables.each do |key|
           yield as_sym(key), instance_variable_get(key)
         end
@@ -198,7 +137,7 @@ module MrMurano
       # @yieldparam value [Object] The value for that key
       # @yieldreturn [Boolean] True to delete this key
       # @return [Item] Ourself.
-      def reject!(&block)
+      def reject!(&_block)
         instance_variables.each do |key|
           drop = yield as_sym(key), instance_variable_get(key)
           delete(key) if drop
@@ -217,10 +156,12 @@ module MrMurano
 
       # For unit testing.
       include Comparable
-      def <=>(anOther)
-        self.to_h <=> anOther.to_h
+      def <=>(other)
+        # rubocop:disable Style/RedundantSelf: Redundant self detected.
+        #   MAYBE/2017-07-18: Permanently disable Style/RedundantSelf?
+        self.to_h <=> other.to_h
       end
-    end
+    end # MrMurano::SyncUpDown::Item
 
     #######################################################################
     # Methods that must be overridden
@@ -230,8 +171,8 @@ module MrMurano
     #
     # Children objects Must override this
     #
-    # @return [Array] of Hashes of item details
-    def list()
+    # @return [Array<Item>] of item details
+    def list
       []
     end
 
@@ -240,9 +181,9 @@ module MrMurano
     # Children objects Must override this
     #
     # @param itemkey [String] The identifying key for this item
-    def remove(itemkey)
+    def remove(_itemkey)
       # :nocov:
-      raise "Forgotten implementation"
+      raise 'Forgotten implementation'
       # :nocov:
     end
 
@@ -253,9 +194,9 @@ module MrMurano
     # @param src [Pathname] Full path of where to upload from
     # @param item [Hash] The item details to upload
     # @param modify [Bool] True if item exists already and this is changing it
-    def upload(src, item, modify)
+    def upload(_src, _item, _modify)
       # :nocov:
-      raise "Forgotten implementation"
+      raise 'Forgotten implementation'
       # :nocov:
     end
 
@@ -264,7 +205,7 @@ module MrMurano
     #
     # Children objects must override this
     #
-    def docmp(itemA, itemB)
+    def docmp(_item_a, _item_b)
       true
     end
 
@@ -272,7 +213,7 @@ module MrMurano
     #######################################################################
 
     #######################################################################
-    # Methods that could be overriden
+    # Methods that could be overridden
 
     ##
     # Compute a remote item hash from the local path
@@ -282,13 +223,13 @@ module MrMurano
     # @param root [Pathname,String] Root path for this resource type from config files
     # @param path [Pathname,String] Path to local item
     # @return [Item] hash of the details for the remote item for this path
-    def toRemoteItem(root, path)
+    def to_remote_item(root, path)
       # This mess brought to you by Windows short path names.
       path = Dir.glob(path.to_s).first
       root = Dir.glob(root.to_s).first
       path = Pathname.new(path)
       root = Pathname.new(root)
-      Item.new(:name => path.realpath.relative_path_from(root.realpath).to_s)
+      Item.new(name: path.realpath.relative_path_from(root.realpath).to_s)
     end
 
     ##
@@ -318,7 +259,7 @@ module MrMurano
       itemkey = @itemkey.to_sym
       name = tolocalname(item, itemkey)
       raise "Bad key(#{itemkey}) for #{item}" if name.nil?
-      name = Pathname.new(name) unless name.kind_of? Pathname
+      name = Pathname.new(name) unless name.is_a? Pathname
       name = name.relative_path_from(Pathname.new('/')) if name.absolute?
       into + name
     end
@@ -332,7 +273,7 @@ module MrMurano
     # @param item [Item] Item to be checked
     # @param pattern [String] pattern to check with
     # @return [Bool] true or false
-    def match(item, pattern)
+    def match(_item, _pattern)
       false
     end
 
@@ -354,13 +295,13 @@ module MrMurano
     # @param local [Pathname] Full path of where to download to
     # @param item [Item] The item to download
     def download(local, item)
-#      if item[:bundled] then
+#      if item[:bundled]
 #        warning "Not downloading into bundled item #{synckey(item)}"
 #        return
 #      end
       local.dirname.mkpath
       id = item[@itemkey.to_sym]
-      if id.nil? then
+      if id.nil?
         debug "!!! Missing '#{@itemkey}', using :id instead!"
         debug ":id => #{item[:id]}"
         id = item[:id]
@@ -371,6 +312,74 @@ module MrMurano
           io.write chunk
         end
       end
+      update_mtime(local, item)
+    end
+
+    def diff_download(tmp_path, merged)
+      download(tmp_path, merged)
+    end
+
+    ## Give the local file the same timestamp as the remote, because diff.
+    #
+    # @param local [Pathname] Full path of where to download to
+    # @param item [Item] The item to download
+    def update_mtime(local, item)
+      # FIXME/MUR-XXXX: Ideally, server should use a hash we can compare.
+      #   For now, we use the sometimes set :updated_at value.
+      # FIXME/EXPLAIN/2017-06-23: Why is :updated_at sometimes not set?
+      #   (See more comments, below.)
+      return unless item[:updated_at]
+
+      mod_time = item[:updated_at]
+      mod_time = DateTime.parse(mod_time).to_time unless mod_time.is_a?(Time)
+      begin
+        FileUtils.touch([local.to_path], mtime: mod_time)
+      rescue Errno::EACCES => err
+        # This happens on Windows...
+        require 'rbconfig'
+        # Check the platform, e.g., "linux-gnu", or other.
+        is_windows = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+        unless is_windows
+          msg = 'Unexpected: touch failed on non-Windows machine'
+          $stderr.puts("#{msg} / host_os: #{RbConfig::CONFIG['host_os']} / err: #{err}")
+        end
+
+        # 2017-07-13: Nor does ctime work.
+        #   Errno::EACCES:
+        #   Permission denied @ utime_failed -
+        #     C:/Users/ADMINI~1/AppData/Local/Temp/2/one.lua_remote_20170714-1856-by2nzk.lua
+        #File.utime(mod_time, mod_time, local.to_path)
+
+        # 2017-07-14: So this probably fails, too...
+        #FileUtils.touch [local.to_path,], :ctime => mod_time
+
+        # MAYBE/2017-07-14: How to make diff work on Windows?
+        #   Would need to store timestamp in metafile?
+
+        # FIXME/EXPLAIN/2017-06-23: Why is :updated_at sometimes not set?
+        #     And why have I only triggered this from ./spec/cmd_syncdown_spec.rb ?
+        #       (Probably because nothing else makes routes or files?)
+        #     Here are the items in question:
+        #
+        # Happens to each of the MrMurano::Webservice::Endpoint::RouteItem's:
+        #
+        # <MrMurano::Webservice::Endpoint::RouteItem:0x007fe719cb6300
+        #   @id="QeRq21Cfij",
+        #   @method="delete",
+        #   @path="/api/fire/{code}",
+        #   @content_type="application/json",
+        #   @script="--#ENDPOINT delete /api/fire/{code}\nreturn 'ok'\n\n-- vim: set ai sw=2 ts=2 :\n",
+        #   @use_basic_auth=false,
+        #   @synckey="DELETE_/api/fire/{code}">
+        #
+        # Happens to each of the MrMurano::Webservice::File::FileItem's:
+        #
+        # <MrMurano::Webservice::File::FileItem:0x007fe71a44a8f0
+        #   @path="/",
+        #   @mime_type="text/html",
+        #   @checksum="da39a3ee5e6b4b0d3255bfef95601890afd80709",
+        #   @synckey="/">
+      end
     end
 
     ## Remove local reference of item
@@ -380,81 +389,152 @@ module MrMurano
     #
     # @param dest [Pathname] Full path of item to be removed
     # @param item [Item] Full details of item to be removed
-    def removelocal(dest, item)
-      dest.unlink
+    def removelocal(dest, _item)
+      dest.unlink if dest.exist?
+    end
+
+    def syncup_before
+      syncable_validate_sid
+    end
+
+    def syncup_after
+    end
+
+    def syncdown_before
+      syncable_validate_sid
+    end
+
+    def syncdown_after(_local)
+    end
+
+    def diff_item_write(io, merged, _local, _remote)
+      io << merged[:local_path].read
     end
 
     #
     #######################################################################
 
-
-    # So, for bundles this needs to look at all the places and build up the merged
-    # stack of local items.
+    # So, for bundles this needs to look at all the places
+    # and build up the merged stack of local items.
     #
-    # Which means it needs the from to be split into the base and the sub so we can
-    # inject bundle directories.
+    # Which means it needs the from to be split into the base
+    # and the sub so we can inject bundle directories.
 
     ##
     # Get a list of local items.
     #
-    # Children should never need to override this.  Instead they should override
-    # #localitems
+    # Children should never need to override this.
+    # Instead they should override #localitems.
     #
     # This collects items in the project and all bundles.
     # @return [Array<Item>] items found
-    def locallist()
-      # so. if @locationbase/bundles exists
-      #  gather and merge: @locationbase/bundles/*/@location
-      # then merge @locationbase/@location
-      #
-
-#      bundleDir = $cfg['location.bundles'] or 'bundles'
-#      bundleDir = 'bundles' if bundleDir.nil?
+    #
+    # 2017-07-02: [lb] removed this commented-out code from the locallist
+    # body. I think it's for older Solutionfiles, like 0.2.0 and 0.3.0.
+    #def locallist
+    #  # so. if @locationbase/bundles exists
+    #  #  gather and merge: @locationbase/bundles/*/@location
+    #  # then merge @locationbase/@location
+    #  #
+    #  bundleDir = $cfg['location.bundles'] or 'bundles'
+    #  bundleDir = 'bundles' if bundleDir.nil?
+    #  items = {}
+    #  if (@locationbase + bundleDir).directory?
+    #    (@locationbase + bundleDir).children.sort.each do |bndl|
+    #      if (bndl + @location).exist?
+    #        verbose("Loading from bundle #{bndl.basename}")
+    #        bitems = localitems(bndl + @location)
+    #        bitems.map!{|b| b[:bundled] = true; b} # mark items from bundles.
+    #        # use synckey for quicker merging.
+    #        bitems.each { |b| items[synckey(b)] = b }
+    #      end
+    #    end
+    #  end
+    #end
+    #
+    def locallist(skip_warn: false)
       items = {}
-#      if (@locationbase + bundleDir).directory? then
-#        (@locationbase + bundleDir).children.sort.each do |bndl|
-#          if (bndl + @location).exist? then
-#            verbose("Loading from bundle #{bndl.basename}")
-#            bitems = localitems(bndl + @location)
-#            bitems.map!{|b| b[:bundled] = true; b} # mark items from bundles.
-#
-#
-#            # use synckey for quicker merging.
-#            bitems.each { |b| items[synckey(b)] = b }
-#          end
-#        end
-#      end
-      if location.exist? then
+      if location.exist?
+        # Get a list of SyncUpDown::Item's, or a class derived thereof.
         bitems = localitems(location)
-        # use synckey for quicker merging.
-        bitems.each { |b| items[synckey(b)] = b }
-      else
-        warning "Skipping missing location #{location}"
+        # Use synckey for quicker merging.
+        # 2017-07-02: Argh. If two files have the same identity, this
+        # simple loop masks that there are two files with the same identity!
+        #bitems.each { |b| items[synckey(b)] = b }
+        warns = {}
+        bitems.each do |item|
+          skey = synckey(item)
+          if items.key? skey
+            warns[skey] = 0 unless warns.key?(skey)
+            if warns[skey].zero?
+              items[skey][:dup_count] = warns[skey]
+              # The dumb_synckey is just so we don't overwrite the
+              # original item, or other duplicates, in the hash.
+              dumb_synckey = "#{skey}-#{warns[skey]}"
+              # This just sets the alias for the output, so duplicates look unique.
+              item[@itemkey.to_sym] = dumb_synckey
+              # Don't delete the original item, so that other dupes see it.
+              #items.delete(skey)
+              msg = "Duplicate local file(s) found for ‘#{skey}’"
+              msg += " for ‘#{self.class.description}’" if self.class.description.to_s != ''
+              #msg += '!'
+              warning(msg)
+            end
+            warns[skey] += 1
+            item[:dup_count] = warns[skey]
+            dumb_synckey = "#{skey}-#{warns[skey]}"
+            item[@itemkey.to_sym] = dumb_synckey
+            items[dumb_synckey] = item
+          else
+            items[skey] = item
+          end
+        end
+      elsif !skip_warn
+        @missing_complaints = [] unless defined?(@missing_complaints)
+        unless @missing_complaints.include?(location)
+          # MEH/2017-07-31: This message is a little misleading on syncdown,
+          #   e.g., in rspec ./spec/cmd_syncdown_spec.rb, one test blows away
+          #   local directories and does a syncdown, and on stderr you'll see
+          #     Skipping missing location ‘/tmp/d20170731-3150-1f50uj4/project/specs/resources.yaml’ (Resources)
+          #   but then later in the syncdown, that directory and file gets created.
+          msg = "Skipping missing location ‘#{location}’"
+          unless self.class.description.to_s.empty?
+            msg += " (#{Inflecto.pluralize(self.class.description)})"
+          end
+          warning(msg)
+          @missing_complaints << location
+        end
       end
-
       items.values
     end
 
+    def resurrect_undeletables(localbox, _therebox)
+      # It's up to the Syncables to implement this, if they care.
+      localbox
+    end
+
     ##
     # Get the full path for the local versions
     # @return [Pathname] Location for local items
     def location
-      raise "Missing @project_section" if @project_section.nil?
+      raise 'Missing @project_section' if @project_section.nil?
       Pathname.new($cfg['location.base']) + $project["#{@project_section}.location"]
     end
 
     ##
     # Returns array of globs to search for files
     # @return [Array<String>] of Strings that are globs
+    # rubocop:disable Style/MethodName: Use snake_case for method names.
+    #  MAYBE/2017-07-18: Rename this. Beware the config has a related keyname.
     def searchFor
-      raise "Missing @project_section" if @project_section.nil?
+      raise 'Missing @project_section' if @project_section.nil?
       $project["#{@project_section}.include"]
     end
 
     ## Returns array of globs of files to ignore
     # @return [Array<String>] of Strings that are globs
     def ignoring
-      raise "Missing @project_section" if @project_section.nil?
+      raise 'Missing @project_section' if @project_section.nil?
       $project["#{@project_section}.exclude"]
     end
 
@@ -468,86 +548,141 @@ module MrMurano
     # @return [Array<Item>] Items found
     def localitems(from)
       # TODO: Profile this.
-      debug "#{self.class.to_s}: Getting local items from: #{from}"
-      searchIn = from.to_s
-      sf = searchFor.map{|i| ::File.join(searchIn, i)}
-      debug "#{self.class.to_s}: Globs: #{sf}"
-      Dir[*sf].flatten.compact.reject do |p|
-        ::File.directory?(p) or ignoring.any? do |i|
-          ::File.fnmatch(i,p)
+      debug "#{self.class}: Getting local items from:\n  #{from}"
+      search_in = from.to_s
+      sf = searchFor.map { |i| ::File.join(search_in, i) }
+      debug "#{self.class}: Globs:\n  #{sf.join("\n  ")}"
+      # 2017-07-27: Add uniq to cull duplicate entries that globbing
+      # all the ways might produce, otherwise status/sync/diff complain
+      # about duplicate resources. I [lb] think this problem has existed
+      # but was exacerbated by the change to support sub-directory scripts
+      # (Nested Lua support).
+      items = Dir[*sf].uniq.flatten.compact.reject do |path|
+        if ::File.directory?(path)
+          true
+        else
+          ignoring.any? { |pattern| self.ignore?(path, pattern) }
         end
-      end.map do |path|
-        path = Pathname.new(path).realpath
-        item = toRemoteItem(from, path)
-        if item.kind_of?(Array) then
-          item.compact.map{|i| i[:local_path] = path; i}
-        elsif not item.nil? then
-          item[:local_path] = path
+      end
+      items = items.map do |path|
+        # Do not resolve symlinks, just relative paths (. and ..),
+        # otherwise it makes nested Lua support tricky, because
+        # symlinks might be outside the root item path, and then
+        # the nested Lua path looks like ".......some_dir/some_item".
+        if $cfg['modules.no-nesting']
+          rpath = Pathname.new(path).realpath
+        else
+          rpath = Pathname.new(path).expand_path
+        end
+        item = to_remote_item(from, rpath)
+        if item.is_a?(Array)
+          item.compact.map { |i| i[:local_path] = rpath; i }
+        elsif !item.nil?
+          item[:local_path] = rpath
           item
         end
-      end.flatten.compact
+      end
+      #items = items.flatten.compact.sort_by!(&:local_path)
+      #debug "#{self.class}: items:\n  #{items.map(&:local_path).join("\n  ")}"
+      items = items.flatten.compact.sort_by { |it| it[:local_path] }
+      debug "#{self.class}: items:\n  #{items.map { |it| it[:local_path] }.join("\n  ")}"
+      sort_by_name(items)
+    end
+
+    def ignore?(path, pattern)
+      # 2017-08-18: [lb] not sure this block should be disabled for no-nesting.
+      # The block *was* added for Nested Lua support. But I think it was
+      # more necessary because modules.include is now '**/*.lua', not '*/*.lua'.
+      # Or maybe this block was because we now use expand_path, not realpath.
+      if !$cfg['modules.no-nesting'] && pattern.start_with?('**/')
+        # E.g., '**/.*' or '**/*'
+        dirname = File.dirname(path)
+        return true if ['.', ::File::ALT_SEPARATOR, ::File::SEPARATOR].include?(dirname)
+        # There's at least one ancestor directory.
+        # Remove the '**', which ::File.fnmatch doesn't recognize, and the path delimiter.
+        # 2017-08-08: Why does Rubocop not follow Style/RegexpLiteral here?
+        #pattern = pattern.gsub(/^\*\*\//, '')
+        pattern = pattern.gsub(%r{^\*\*\/}, '')
+      end
+
+      ::File.fnmatch(pattern, path)
     end
 
     #######################################################################
     # Methods that provide the core status/syncup/syncdown
 
-    ##
-    # Take a hash or something (a Commander::Command::Options) and return a hash
-    #
-    # @param hsh [Hash, Commander::Command::Options] Thing we want to be a Hash
-    # @return [Hash] an actual Hash with default value of false
-    def elevate_hash(hsh)
-      # Commander::Command::Options stripped all of the methods from parent
-      # objects. I have not nice thoughts about that.
-      begin
-        hsh = hsh.__hash__
-      rescue NoMethodError
-        # swallow this.
+    def sync_update_progress(msg)
+      if $cfg['tool.no-progress']
+        say(msg)
+      else
+        MrMurano::Verbose.verbose(msg + "\n")
       end
-      # build a hash where the default is 'false' instead of 'nil'
-      Hash.new(false).merge(Hash.transform_keys_to_symbols(hsh))
     end
-    private :elevate_hash
 
     ## Make things in Murano look like local project
     #
     # This creates, uploads, and deletes things as needed up in Murano to match
     # what is in the local project directory.
     #
-    # @param options [Hash, Commander::Command::Options] Options on opertation
+    # @param options [Hash, Commander::Command::Options] Options on operation
     # @param selected [Array<String>] Filters for _matcher
     def syncup(options={}, selected=[])
       options = elevate_hash(options)
-      itemkey = @itemkey.to_sym
       options[:asdown] = false
+
+      num_synced = 0
+
+      syncup_before
+
       dt = status(options, selected)
+
       toadd = dt[:toadd]
       todel = dt[:todel]
       tomod = dt[:tomod]
 
-      if options[:delete] then
-        todel.each do |item|
-          verbose "Removing item #{item[:synckey]}"
-          unless $cfg['tool.dry'] then
-            remove(item[itemkey])
-          end
+      itemkey = @itemkey.to_sym
+      todel.each do |item|
+        syncup_item(item, options, :delete, 'Removing') do |aitem|
+          remove(aitem[itemkey])
+          num_synced += 1
         end
       end
-      if options[:create] then
-        toadd.each do |item|
-          verbose "Adding item #{item[:synckey]}"
-          unless $cfg['tool.dry'] then
-            upload(item[:local_path], item.reject{|k,v| k==:local_path}, false)
-          end
+      toadd.each do |item|
+        syncup_item(item, options, :create, 'Adding') do |aitem|
+          upload(aitem[:local_path], aitem.reject { |k, _v| k == :local_path }, false)
+          num_synced += 1
+        end
+      end
+      tomod.each do |item|
+        syncup_item(item, options, :update, 'Updating') do |aitem|
+          upload(aitem[:local_path], aitem.reject { |k, _v| k == :local_path }, true)
+          num_synced += 1
         end
       end
-      if options[:update] then
-        tomod.each do |item|
-          verbose "Updating item #{item[:synckey]}"
-          unless $cfg['tool.dry'] then
-            upload(item[:local_path], item.reject{|k,v| k==:local_path}, true)
+
+      syncup_after
+
+      MrMurano::Verbose.whirly_stop(force: true)
+
+      num_synced
+    end
+
+    def syncup_item(item, options, action, verbage)
+      if options[action]
+        if !$cfg['tool.dry']
+          prog_msg = "#{verbage.capitalize} item #{item[:synckey]}"
+          prog_msg += " (#{item[:synctype]})" if $cfg['tool.verbose']
+          sync_update_progress(prog_msg)
+          yield item
+        else
+          MrMurano::Verbose.whirly_interject do
+            say("--dry: Not #{verbage.downcase} item #{item[:synckey]}")
           end
         end
+      elsif $cfg['tool.verbose']
+        MrMurano::Verbose.whirly_interject do
+          say("--no-#{action}: Not #{verbage.downcase} item #{item[:synckey]}")
+        end
       end
     end
 
@@ -556,43 +691,60 @@ module MrMurano
     # This creates, downloads, and deletes things as needed up in the local project
     # directory to match what is in Murano.
     #
-    # @param options [Hash, Commander::Command::Options] Options on opertation
+    # @param options [Hash, Commander::Command::Options] Options on operation
     # @param selected [Array<String>] Filters for _matcher
     def syncdown(options={}, selected=[])
       options = elevate_hash(options)
       options[:asdown] = true
+      options[:skip_missing_warning] = true
+
+      num_synced = 0
+
+      syncdown_before
+
       dt = status(options, selected)
-      into = location ###
+
       toadd = dt[:toadd]
       todel = dt[:todel]
       tomod = dt[:tomod]
 
-      if options[:delete] then
-        todel.each do |item|
-          verbose "Removing item #{item[:synckey]}"
-          unless $cfg['tool.dry'] then
-            dest = tolocalpath(into, item)
-            removelocal(dest, item)
-          end
+      into = location
+      todel.each do |item|
+        syncdown_item(item, into, options, :delete, 'Removing') do |dest, aitem|
+          removelocal(dest, aitem)
+          num_synced += 1
         end
       end
-      if options[:create] then
-        toadd.each do |item|
-          verbose "Adding item #{item[:synckey]}"
-          unless $cfg['tool.dry'] then
-            dest = tolocalpath(into, item)
-            download(dest, item)
-          end
+      toadd.each do |item|
+        syncdown_item(item, into, options, :create, 'Adding') do |dest, aitem|
+          download(dest, aitem)
+          num_synced += 1
         end
       end
-      if options[:update] then
-        tomod.each do |item|
-          verbose "Updating item #{item[:synckey]}"
-          unless $cfg['tool.dry'] then
-            dest = tolocalpath(into, item)
-            download(dest, item)
-          end
+      tomod.each do |item|
+        syncdown_item(item, into, options, :update, 'Updating') do |dest, aitem|
+          download(dest, aitem)
+          num_synced += 1
+        end
+      end
+      syncdown_after(into)
+
+      num_synced
+    end
+
+    def syncdown_item(item, into, options, action, verbage)
+      if options[action]
+        if !$cfg['tool.dry']
+          prog_msg = "#{verbage.capitalize} item #{item[:synckey]}"
+          prog_msg += " (#{item[:synctype]})" if $cfg['tool.verbose']
+          sync_update_progress(prog_msg)
+          dest = tolocalpath(into, item)
+          yield dest, item
+        else
+          say("--dry: Not #{verbage.downcase} item #{item[:synckey]}")
         end
+      elsif $cfg['tool.verbose']
+        say("--no-#{action}: Not #{verbage.downcase} item #{item[:synckey]}")
       end
     end
 
@@ -600,36 +752,75 @@ module MrMurano
     #
     # WARNING: This will download the remote item to do the diff.
     #
-    # @param item [Item] The item to get a diff of
+    # @param merged [merged] The merged item to get a diff of
+    # @local local, unadulterated (non-merged) item
     # @return [String] The diff output
-    def dodiff(item)
-      trmt = Tempfile.new([tolocalname(item, @itemkey)+'_remote_', '.lua'])
-      tlcl = Tempfile.new([tolocalname(item, @itemkey)+'_local_', '.lua'])
-      if item.has_key? :script then
-        Pathname.new(tlcl.path).open('wb') do |io|
-          io << item[:script]
-        end
-      else
-        Pathname.new(tlcl.path).open('wb') do |io|
-          io << item[:local_path].read
+    def dodiff(merged, local, _there=nil, asdown=false)
+      trmt = Tempfile.new([tolocalname(merged, @itemkey) + '_remote_', '.lua'])
+      tlcl = Tempfile.new([tolocalname(merged, @itemkey) + '_local_', '.lua'])
+      Pathname.new(tlcl.path).open('wb') do |io|
+        if merged.key?(:script)
+          io << merged[:script]
+        else
+          # For most items, read the local file.
+          # For resources, it's a bit trickier.
+          # NOTE: This class adds a :selected key to the local item that we need
+          # to remove, since it's not part of the remote items that gets downloaded.
+          local = local.reject { |k, _v| k == :selected } unless local.nil?
+          diff_item_write(io, merged, local, nil)
         end
       end
-      df = ""
+      stdout_and_stderr = ''
       begin
-        download(Pathname.new(trmt.path), item)
+        tmp_path = Pathname.new(trmt.path)
+        diff_download(tmp_path, merged)
+
+        MrMurano::Verbose.whirly_stop
 
+        # 2017-07-03: No worries, Ruby 3.0 frozen string literals, cmd is a list.
         cmd = $cfg['diff.cmd'].shellsplit
-        cmd << trmt.path.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR || ::File::SEPARATOR)
-        cmd << tlcl.path.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR || ::File::SEPARATOR)
+        # ALT_SEPARATOR is the platform specific alternative separator,
+        # for Windows support.
+        remote_path = trmt.path.gsub(
+          ::File::SEPARATOR, ::File::ALT_SEPARATOR || ::File::SEPARATOR
+        )
+        local_path = tlcl.path.gsub(
+          ::File::SEPARATOR, ::File::ALT_SEPARATOR || ::File::SEPARATOR
+        )
+        if asdown
+          cmd << local_path
+          cmd << remote_path
+        else
+          cmd << remote_path
+          cmd << local_path
+        end
 
-        df, _ = Open3.capture2e(*cmd)
+        stdout_and_stderr, _status = Open3.capture2e(*cmd)
+        # How important are the first two lines of the diff? E.g.,
+        #     --- /tmp/raw_data_remote_20170718-20183-gdyeg9.lua	2017-07-18 13:13:13.864051905 -0500
+        #     +++ /tmp/raw_data_local_20170718-20183-71o4me.lua	2017-07-18 13:13:14.520049397 -0500
+        # Seems like printing the path to a since-deleted temporary file is misleading.
+        if $cfg['diff.cmd'] == 'diff' || $cfg['diff.cmd'].start_with?('diff ')
+          lineno = 0
+          consise = stdout_and_stderr.lines.reject do |line|
+            lineno += 1
+            if lineno == 1 && line.start_with?('--- ')
+              true
+            elsif lineno == 2 && line.start_with?('+++ ')
+              true
+            else
+              false
+            end
+          end
+          stdout_and_stderr = consise.join
+        end
       ensure
         trmt.close
         trmt.unlink
         tlcl.close
         tlcl.unlink
       end
-      df
+      stdout_and_stderr
     end
 
     ##
@@ -638,13 +829,13 @@ module MrMurano
     # @param patterns [Array<String>] Filters for _matcher
     def _matcher(items, patterns)
       items.map do |item|
-        if patterns.empty? then
+        if patterns.empty?
           item[:selected] = true
         else
           item[:selected] = patterns.any? do |pattern|
-            if pattern.to_s[0] == '#' then
+            if pattern.to_s[0] == '#'
               match(item, pattern)
-            elsif item.local_path.nil? then
+            elsif !defined?(item.local_path) || item.local_path.nil?
               false
             else
               item[:local_path].fnmatch(pattern)
@@ -663,54 +854,173 @@ module MrMurano
     # @return [Hash{Symbol=>Array<Item>}] Items grouped by the action that should be taken
     def status(options={}, selected=[])
       options = elevate_hash(options)
-      itemkey = @itemkey.to_sym
 
-      there = _matcher(list(), selected)     # Array<Item>
-      here = _matcher(locallist(), selected) # Array<Item>
+      ret = filter_solution(options)
+      return ret unless ret.nil?
+
+      therebox, localbox = items_lists(options, selected)
+
+      toadd, todel = items_new_and_old(options, therebox, localbox)
+
+      tomod, unchg = items_mods_and_chgs(options, therebox, localbox)
+
+      if options[:unselected]
+        { toadd: toadd, todel: todel, tomod: tomod, unchg: unchg, skipd: [] }
+      else
+        {
+          toadd: toadd.select { |i| i[:selected] }.map { |i| i.delete(:selected); i },
+          todel: todel.select { |i| i[:selected] }.map { |i| i.delete(:selected); i },
+          tomod: tomod.select { |i| i[:selected] }.map { |i| i.delete(:selected); i },
+          unchg: unchg.select { |i| i[:selected] }.map { |i| i.delete(:selected); i },
+          skipd: [],
+        }
+      end
+    end
+
+    def filter_solution(options)
+      # Get the solution name from the config.
+      # Convert, e.g., application.id => application.name
+      soln_name = $cfg[@solntype.gsub(/(.*)\.id/, '\1.name')]
+      # Skip this syncable if the sid is not set, or if user wants to skip by solution.
+      skip_sol = false
+      if !sid? ||
+         (options[:type] == :application && @solntype != 'application.id') ||
+         (options[:type] == :product && @solntype != 'product.id')
+        skip_sol = true
+      else
+        tested = false
+        passed = false
+        if @solntype == 'application.id'
+          # elevate_hash magically makes the hash return false rather than nil
+          # on unknown keys, so preface with a key? guard.
+          if options.key?(:application) && !options[:application].to_s.empty?
+            if soln_name =~ /#{Regexp.escape(options[:application])}/i ||
+               sid =~ /#{Regexp.escape(options[:application])}/i
+              passed = true
+            end
+            tested = true
+          end
+          if options.key?(:application_id) && !options[:application_id].to_s.empty?
+            passed = true if options[:application_id] == sid
+            tested = true
+          end
+          if options.key?(:application_name) && !options[:application_name].to_s.empty?
+            passed = true if options[:application_name] == soln_name
+            tested = true
+          end
+        elsif @solntype == 'product.id'
+          if options.key?(:product) && !options[:product].to_s.empty?
+            if soln_name =~ /#{Regexp.escape(options[:product])}/i ||
+               sid =~ /#{Regexp.escape(options[:product])}/i
+              passed = true
+            end
+            tested = true
+          end
+          if options.key?(:product_id) && !options[:product_id].to_s.empty?
+            passed = true if options[:product_id] == sid
+            tested = true
+          end
+          if options.key?(:product_name) && !options[:product_name].to_s.empty?
+            passed = true if options[:product_name] == soln_name
+            tested = true
+          end
+        end
+        skip_sol = true if tested && !passed
+      end
+      return nil unless skip_sol
+      ret = { toadd: [], todel: [], tomod: [], unchg: [], skipd: [] }
+      ret[:skipd] << { synckey: self.class.description }
+      ret
+    end
+
+    def syncable_validate_sid
+      # 2017-07-02: Now that there are multiple solution types, and because
+      # SyncRoot.add is called on different classes that go with either or
+      # both products and applications, if a user only created one solution,
+      # then some syncables will have their sid set to -1, because there's
+      # not a corresponding solution in Murano.
+      raise 'Syncable missing sid or not valid_sid??!' unless sid?
+    end
+
+    def items_lists(options, selected)
+      # Fetch arrays of items there, and items here/local.
+      there = list
+      there = _matcher(there, selected)
+      local = locallist(skip_warn: options[:skip_missing_warning])
+      local = _matcher(local, selected)
 
       therebox = {}
       there.each do |item|
         item[:synckey] = synckey(item)
-        therebox[ item[:synckey] ] = item
+        item[:synctype] = self.class.description
+        therebox[item[:synckey]] = item
       end
-      herebox = {}
-      here.each do |item|
-        item[:synckey] = synckey(item)
-        herebox[ item[:synckey] ] = item
+
+      localbox = {}
+      local.each do |item|
+        skey = synckey(item)
+        # 2017-07-02: Check for local duplicates.
+        skey += "-#{item[:dup_count]}" unless item[:dup_count].nil?
+        item[:synckey] = skey
+        item[:synctype] = self.class.description
+        localbox[item[:synckey]] = item
       end
-      toadd = []
-      todel = []
+
+      # Some items are considered "undeletable", meaning if a
+      # corresponding file does not exist locally, we assume
+      # it does but is just set to the empty string.
+      localbox = resurrect_undeletables(localbox, therebox)
+
+      [therebox, localbox]
+    end
+
+    def items_new_and_old(options, therebox, localbox)
+      if options[:asdown]
+        todel = (localbox.keys - therebox.keys).map { |key| localbox[key] }
+        toadd = (therebox.keys - localbox.keys).map { |key| therebox[key] }
+      else
+        toadd = (localbox.keys - therebox.keys).map { |key| localbox[key] }
+        todel = (therebox.keys - localbox.keys).map { |key| therebox[key] }
+      end
+      [sort_by_name(toadd), sort_by_name(todel)]
+    end
+
+    def items_mods_and_chgs(options, therebox, localbox)
       tomod = []
       unchg = []
-      if options[:asdown] then
-        todel = (herebox.keys - therebox.keys).map{|key| herebox[key] }
-        toadd = (therebox.keys - herebox.keys).map{|key| therebox[key] }
-      else
-        toadd = (herebox.keys - therebox.keys).map{|key| herebox[key] }
-        todel = (therebox.keys - herebox.keys).map{|key| therebox[key] }
-      end
-      (herebox.keys & therebox.keys).each do |key|
-        # Want here to override there except for itemkey.
-        mrg = herebox[key].reject{|k,v| k==itemkey}
-        mrg = therebox[key].merge(mrg)
-        if docmp(herebox[key], therebox[key]) then
-          mrg[:diff] = dodiff(mrg.to_h) if options[:diff] and mrg[:selected]
+
+      (localbox.keys & therebox.keys).each do |key|
+        # Want 'local' to override 'there' except for itemkey.
+        if options[:asdown]
+          mrg = therebox[key].reject { |k, _v| k == @itemkey.to_sym }
+          mrg = localbox[key].merge(mrg)
+        else
+          mrg = localbox[key].reject { |k, _v| k == @itemkey.to_sym }
+          mrg = therebox[key].merge(mrg)
+        end
+
+        if docmp(localbox[key], therebox[key])
+          if options[:diff] && mrg[:selected]
+            mrg[:diff] = dodiff(mrg.to_h, localbox[key], therebox[key], options[:asdown])
+          end
           tomod << mrg
         else
           unchg << mrg
         end
       end
-      if options[:unselected] then
-        { :toadd=>toadd, :todel=>todel, :tomod=>tomod, :unchg=>unchg }
+      [sort_by_name(tomod), sort_by_name(unchg)]
+    end
+
+    def sort_by_name(list)
+      if list.any? && list.first.is_a?(Hash)
+        # AFAIK, only SyncUpDown_spec.rb comes through here, because
+        # it does not use SyncUpDown::Item but mocks its own items
+        # using hashes (see calls to and_return). [lb]
+        list.sort_by { |hsh| hsh[:name] }
       else
-        {
-          :toadd=>toadd.select{|i| i[:selected]}.map{|i| i.delete(:selected); i},
-          :todel=>todel.select{|i| i[:selected]}.map{|i| i.delete(:selected); i},
-          :tomod=>tomod.select{|i| i[:selected]}.map{|i| i.delete(:selected); i},
-          :unchg=>unchg.select{|i| i[:selected]}.map{|i| i.delete(:selected); i}
-        }
+        list.sort_by(&:name)
       end
     end
   end
 end
-#  vim: set ai et sw=2 ts=2 :
+