Ruby siempre sangra 2 espacios?

7

Me gustaría usar sangrías de 2 espacios todo el tiempo como:

sidekiq_options({
  retry: true
})

He intentado configurar .emacs.d/init.elpara:

(setq-default indent-tabs-mode nil)
(setq-default tab-width 2)
(setq indent-line-function 'insert-tab)

(setq ruby-deep-indent-paren nil)
(setq ruby-deep-indent-paren-style nil)

Pero sigo teniendo cosas como:

sidekiq_options({
                  retry: true
                })

indentation ruby

— zlotnika
fuente

Debido a cómo Ruby analiza el código, debería poder omitir las llaves para el último argumento hash. Resuelve la pregunta de una manera ordenada:>

— wasamasa

1

No soy un usuario de ruby, pero puedes probar lo siguiente:

(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)   ;; change this to 2 if that is the width
(setq indent-line-function 'insert-tab)

— eflanigan00
fuente

Sí, en realidad ya los tenía allí (simplemente no parecían afectar ruby-mode).

— zlotnika

Inspeccione el ancho de tabulación mientras está en modo rubí. Quizás algún gancho lo cambió. Del mismo modo, este código debe estar dentro de su código de enlace de modo ruby.

— jtgd

Además, parece que quizás sea un problema con las tabulaciones, ya que las pestañas se ven mucho más anchas que 8. También parece que está tratando de sangrar para alinearse con las {'s. Puede que no sea estrictamente un problema de ANCHO de pestaña.

— jtgd

0

Todo lo que debes hacer es configurar ruby-indent-level. Por ejemplo (setq-local ruby-indent-level 2).

EDITAR :

Puede usar enh-ruby-mode, instalable desde melpa, y (setq enh-ruby-deep-indent-paren nil).

Esto dio como resultado la siguiente sangría:

sidekiq_options({
  retry: true
})

— theldoria
fuente

Lo intenté, no ayuda. No es el nivel de sangrado el problema. Es la profunda sangría.

— zlotnika

Puede mitigarlo un poco configurando (setq ruby-deep-indent-paren nil), pero sangrará 4 espacios, debido a ({.

— theldoria

0

Mirando el código de ruby-mode, parece que no hay forma de configurarlo. Una solución alternativa es anular la función. Pruebe el siguiente código y vea si funciona:

(defun ruby-smie-rules (kind token)
  (pcase (cons kind token)
    (`(:elem . basic) ruby-indent-level)
    ;; "foo" "bar" is the concatenation of the two strings, so the second
    ;; should be aligned with the first.
    (`(:elem . args) (if (looking-at "\\s\"") 0))
    ;; (`(:after . ",") (smie-rule-separator kind))
    (`(:before . ";")
     (cond
      ((smie-rule-parent-p "def" "begin" "do" "class" "module" "for"
                           "while" "until" "unless"
                           "if" "then" "elsif" "else" "when"
                           "rescue" "ensure" "{")
       (smie-rule-parent ruby-indent-level))
      ;; For (invalid) code between switch and case.
      ;; (if (smie-parent-p "switch") 4)
      ))
    (`(:before . ,(or `"(" `"[" `"{"))
     (cond
      ((and (equal token "{")
            (not (smie-rule-prev-p "(" "{" "[" "," "=>" "=" "return" ";"))
            (save-excursion
              (forward-comment -1)
              (not (eq (preceding-char) ?:))))
       ;; Curly block opener.
       (ruby-smie--indent-to-stmt))
      ((smie-rule-hanging-p)
       ;; Treat purely syntactic block-constructs as being part of their parent,
       ;; when the opening token is hanging and the parent is not an
       ;; open-paren.
       (cond
        ((eq (car (smie-indent--parent)) t) nil)
        ;; When after `.', let's always de-indent,
        ;; because when `.' is inside the line, the
        ;; additional indentation from it looks out of place.
        ((smie-rule-parent-p ".")
         ;; Traverse up the call chain until the parent is not `.',
         ;; or `.' at indentation, or at eol.
         (while (and (not (ruby-smie--bosp))
                     (equal (nth 2 (smie-backward-sexp ".")) ".")
                     (not (ruby-smie--bosp)))
           (forward-char -1))
         (smie-indent-virtual))
        (t (smie-rule-parent))))))
    (`(:after . ,(or `"(" "[" "{"))
     ;; FIXME: Shouldn't this be the default behavior of
     ;; `smie-indent-after-keyword'?
     (save-excursion
       (smie-rule-parent)))
    (`(:before . " @ ")
     (save-excursion
       (skip-chars-forward " \t")
       (cons 'column (current-column))))
    (`(:before . "do") (ruby-smie--indent-to-stmt))
    (`(:before . ".")
     (if (smie-rule-sibling-p)
         (and ruby-align-chained-calls 0)
       (smie-backward-sexp ".")
       (cons 'column (+ (current-column)
                        ruby-indent-level))))
    (`(:before . ,(or `"else" `"then" `"elsif" `"rescue" `"ensure"))
     (smie-rule-parent))
    (`(:before . "when")
     ;; Align to the previous `when', but look up the virtual
     ;; indentation of `case'.
     (if (smie-rule-sibling-p) 0 (smie-rule-parent)))
    (`(:after . ,(or "=" "+" "-" "*" "/" "&&" "||" "%" "**" "^" "&"
                     "<=>" ">" "<" ">=" "<=" "==" "===" "!=" "<<" ">>"
                     "+=" "-=" "*=" "/=" "%=" "**=" "&=" "|=" "^=" "|"
                     "<<=" ">>=" "&&=" "||=" "and" "or"))
     (and (smie-rule-parent-p ";" nil)
          (smie-indent--hanging-p)
          ruby-indent-level))
    (`(:after . ,(or "?" ":")) ruby-indent-level)
    (`(:before . ,(guard (memq (intern-soft token) ruby-alignable-keywords)))
     (when (not (ruby--at-indentation-p))
       (if (ruby-smie--indent-to-stmt-p token)
           (ruby-smie--indent-to-stmt)
         (cons 'column (current-column)))))
    (`(:before . "iuwu-mod")
     (smie-rule-parent ruby-indent-level))
    ))

La parte que edité está justo debajo de FIXME, cambiándola a (smie-rule-parent), y pareció funcionar para mí.

— Jesse
fuente