bug#22300: 25.1.50; Dired -- renaming folders/files to CamelCase/UPPERCASE/lowercase.

[Keith David Bershatsky]

Thank you, John, for helping me answer Eli's question about situations when OSX 
uses case-insensitive versus case-sensitive.  I didn't have the knowledge to be 
able to respond properly.

Here is an unsophisticated workaround that bypasses `dired-create-files' when 
dealing with renaming when (1) 'darwin; (2) just one file; and, (3) the file 
names of to/from are equal if both are lower-cased.  It doesn't do the fancy 
cutting/pasting of the new line in dired-mode and instead just reverts the 
entire buffer.

    (require 'dired-aux)

    (require 'cl) ;; for `lexical-let*'
    
    (defun dired-do-create-files (op-symbol file-creator operation arg
                                        &optional marker-char op1
                                        how-to)
      "Create a new file for each marked file.
    Prompt user for a target directory in which to create the new
      files.  The target may also be a non-directory file, if only
      one file is marked.  The initial suggestion for target is the
      Dired buffer's current directory (or, if `dired-dwim-target' is
      non-nil, the current directory of a neighboring Dired window).
    OP-SYMBOL is the symbol for the operation.  Function `dired-mark-pop-up'
      will determine whether pop-ups are appropriate for this OP-SYMBOL.
    FILE-CREATOR and OPERATION as in `dired-create-files'.
    ARG as in `dired-get-marked-files'.
    Optional arg MARKER-CHAR as in `dired-create-files'.
    Optional arg OP1 is an alternate form for OPERATION if there is
      only one file.
    Optional arg HOW-TO determines how to treat the target.
      If HOW-TO is nil, use `file-directory-p' to determine if the
       target is a directory.  If so, the marked file(s) are created
       inside that directory.  Otherwise, the target is a plain file;
       an error is raised unless there is exactly one marked file.
      If HOW-TO is t, target is always treated as a plain file.
      Otherwise, HOW-TO should be a function of one argument, TARGET.
       If its return value is nil, TARGET is regarded as a plain file.
       If it return value is a list, TARGET is a generalized
        directory (e.g. some sort of archive).  The first element of
        this list must be a function with at least four arguments:
          operation - as OPERATION above.
          rfn-list  - list of the relative names for the marked files.
          fn-list   - list of the absolute names for the marked files.
          target    - the name of the target itself.
          The rest of into-dir are optional arguments.
       For any other return value, TARGET is treated as a directory."
      (or op1 (setq op1 operation))
      (let* ((fn-list (dired-get-marked-files nil arg))
         (rfn-list (mapcar (function dired-make-relative) fn-list))
         (dired-one-file        ; fluid variable inside dired-create-files
          (and (consp fn-list) (null (cdr fn-list)) (car fn-list)))
         (target-dir (dired-dwim-target-directory))
         (default (and dired-one-file
                       (expand-file-name (file-name-nondirectory (car fn-list))
                                         target-dir)))
         (defaults (dired-dwim-target-defaults fn-list target-dir))
         (target (expand-file-name ; fluid variable inside dired-create-files
                  (minibuffer-with-setup-hook
                      (lambda ()
                        (set (make-local-variable 
'minibuffer-default-add-function) nil)
                        (setq minibuffer-default defaults))
                    (dired-mark-read-file-name
                     (concat (if dired-one-file op1 operation) " %s to: ")
                     target-dir op-symbol arg rfn-list default))))
         (into-dir (cond ((null how-to)
                          ;; Allow DOS/Windows users to change the letter
                          ;; case of a directory.  If we don't test these
                          ;; conditions up front, file-directory-p below
                          ;; will return t because the filesystem is
                          ;; case-insensitive, and Emacs will try to move
                          ;; foo -> foo/foo, which fails.
                          (if (and (memq system-type '(ms-dos windows-nt 
cygwin))
                                   (eq op-symbol 'move)
                                   dired-one-file
                                   (string= (downcase
                                             (expand-file-name (car fn-list)))
                                            (downcase
                                             (expand-file-name target)))
                                   (not (string=
                                         (file-name-nondirectory (car fn-list))
                                         (file-name-nondirectory target))))
                              nil
                            (file-directory-p target)))
                         ((eq how-to t) nil)
                         (t (funcall how-to target)))))
        (if (and (consp into-dir) (functionp (car into-dir)))
        (apply (car into-dir) operation rfn-list fn-list target (cdr into-dir))
          (if (not (or dired-one-file into-dir))
          (error "Marked %s: target must be a directory: %s" operation target))
          ;; rename-file bombs when moving directories unless we do this:
          (or into-dir (setq target (directory-file-name target)))
    ;;; BEGIN modification by @lawlist
          (if
              (and
                (eq system-type 'darwin)
                dired-one-file
                (equal op1 "Rename")
                (equal operation "Move")
                (equal (downcase (expand-file-name dired-one-file)) (downcase 
(expand-file-name target))))
            ;; Penetrate the `set-process-sentinel' with `lexical-let'.
            (lexical-let* ((dired-one-file dired-one-file)
                           (target target))
              (set-process-sentinel
                (start-process "rename" nil "mv" dired-one-file target)
                (lambda (p e) (when (= 0 (process-exit-status p))
                  (revert-buffer)
                  (message "Renamed %s to %s" dired-one-file target)))))
          (dired-create-files
           file-creator operation fn-list
           (if into-dir                 ; target is a directory
           ;; This function uses fluid variable target when called
           ;; inside dired-create-files:
           (function
            (lambda (from)
              (expand-file-name (file-name-nondirectory from) target)))
         (function (lambda (_from) target)))
           marker-char))
    ;;; END modification by @lawlist
      )))