rufo 0.0.32 → 0.0.33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 567434311fc51fc2df58435a9b746c8bceb677b6
4
- data.tar.gz: 952b5fde3de3a1a1613b80da0f2b77a1bbf08883
3
+ metadata.gz: f3fd395a366e561d4a5196bd66a89e84488ca699
4
+ data.tar.gz: b1e5f7872f193254a8287a0778a9c6a747c4532a
5
5
  SHA512:
6
- metadata.gz: c2922786da9e59ad5077d32fbe48b233416bf44d8c8e8719a02d73731ced2158f9051fb3e8fff8d1090d91d647e87e0b29cee7e58c8abcc73dcdc9fcdca239d4
7
- data.tar.gz: 2c535a76bb09f8af19f0582873b58dab19b66d3fda4d784ad4dfc1e86dcf29539bd7f938ad0a0d916446e1ab18c67545e1d641bf186bbc2f72db324936c6bc62
6
+ metadata.gz: abef0e942b850cbfbd21a032f63dd1f7a9d487ae4d1dd2fbc071232f7ff434f5dddb855faba972773e6d0a1747e15d59ab11e85e3920c838d5c2afb4b7135498
7
+ data.tar.gz: 701c57b9d9bdca0a1e5bd121f6abd33b1ecff4cdeb6c1449905bd77d3064fc4facdb2381d472043b25a09e898be12972ab89ea016e7010bb35ff398f6dca1db9
data/.rufo CHANGED
@@ -1,10 +1,24 @@
1
- space_after_array_bracket :never
2
- space_after_hash_brace :dynamic
3
- preserve_whitespace true
4
- align_comments true
5
- align_assignments false
6
- align_hash_keys true
7
- align_case_when true
8
- align_chained_calls false
9
- indent_size 2
10
- trailing_commas :always
1
+ indent_size 2
2
+ spaces_inside_hash_brace :never
3
+ spaces_inside_array_bracket :never
4
+ spaces_around_equal :one
5
+ spaces_in_ternary :one
6
+ spaces_in_suffix :one
7
+ spaces_in_commands :dynamic
8
+ spaces_around_block_brace :one
9
+ spaces_after_comma :dynamic
10
+ spaces_around_hash_arrow :one
11
+ spaces_around_when :one
12
+ spaces_around_dot :no
13
+ spaces_after_lambda_arrow :no
14
+ spaces_around_unary :no
15
+ spaces_around_binary :one
16
+ parens_in_def :yes
17
+ double_newline_inside_type :no
18
+ visibility_indent :align
19
+ trailing_commas :always
20
+ align_comments true
21
+ align_assignments false
22
+ align_hash_keys false
23
+ align_case_when true
24
+ align_chained_calls true
data/README.md CHANGED
@@ -19,6 +19,88 @@ However, it takes between 2 and 5 seconds to format a 3000+ lines file, and abou
19
19
  a 500 lines file. A second is too much delay for a plugin editor. Additionally, RuboCop is much more
20
20
  than just a code formatter. Rufo is and will always be a code formatter.
21
21
 
22
+ ## Unobtrusive by default
23
+
24
+ We Ruby programmers think code beauty and readability is very important. We might align code
25
+ in some ways that a formatter would come and destroy. Many are against automatic code formatters
26
+ for this reason.
27
+
28
+ By default, Rufo is configured in a way that these decisions are preserved. In this way you
29
+ can start using it in your favorite text editor without forcing your whole team to start using it.
30
+
31
+ For example, this code:
32
+
33
+ ```ruby
34
+ class Foo
35
+ include Bar
36
+ extend Baz
37
+ end
38
+ ```
39
+
40
+ has an extra space after `extend`, but by doing that `Bar` becomes aligned with `Baz`.
41
+ It might look better for some, and Rufo preserves this choice by default.
42
+
43
+ A similar example is aligning call arguments:
44
+
45
+ ```ruby
46
+ register :command, "Format"
47
+ register :action, "Save"
48
+ ```
49
+
50
+ Here too, an extra space is added to align `"Format"` with `"Save"`. Again, Rufo will preserve
51
+ this choice.
52
+
53
+ Another example is aligning call parameters:
54
+
55
+ ```ruby
56
+ # Align with respect to the first parameter
57
+ foo 1, 2,
58
+ 3, 4,
59
+ 5
60
+
61
+ # Align by regular indent (2 spaces)
62
+ foo 1, 2,
63
+ 3, 4,
64
+ 5
65
+
66
+ # Align arrays
67
+ foo 1, [
68
+ 2,
69
+ 3,
70
+ ]
71
+
72
+ # Don't extra align arrays:
73
+ foo 1, [
74
+ 2,
75
+ 3,
76
+ ]
77
+
78
+ # Aling trailing calls
79
+ assert foo(
80
+ 1
81
+ )
82
+
83
+ # Don't extra align trailing calls
84
+ assert foo(
85
+ 1
86
+ )
87
+ ```
88
+
89
+ All of the alignment choices above are fine depending on the context where they are
90
+ used, and Rufo will not destroy that choice. It will, however, keep things aligned
91
+ so they look good.
92
+
93
+ If Rufo does not change these things by default, what does it do? Well, it makes sure that:
94
+
95
+ - code at the beginning of a line is correctly indented
96
+ - array and hash elements are aligned
97
+ - there are no spaces **before** commas
98
+ - there are no more than one consecutive empty lines
99
+ - methods are separated by an empty line
100
+ - no trailing semicolons remain
101
+
102
+ And of course it can be configured to do more. Check the settings section below.
103
+
22
104
  ## Installation
23
105
 
24
106
  Add this line to your application's Gemfile:
@@ -70,105 +152,808 @@ I will list it here.
70
152
 
71
153
  ## Configuration
72
154
 
73
- Rufo follows most of the conventions found in this [Ruby style guide](https://github.com/bbatsov/ruby-style-guide). It does a bit more than that, and it can also be configured a bit.
74
-
75
- To configure it, place a `.rufo` file in your project. When formatting a file or a directory
155
+ To configure Rufo, place a `.rufo` file in your project. When formatting a file or a directory
76
156
  via the `rufo` program, a `.rufo` file will try to be found in that directory or parent directories.
77
157
 
78
- The `.rufo` file is a Ruby file that is evaluated in the context of the formatter. These are the
79
- available configurations:
158
+ The `.rufo` file is a Ruby file that is evaluated in the context of the formatter.
159
+ The available configurations are listed below.
160
+
161
+ ### indent_size
162
+
163
+ Sets the indent size. Default: 2
164
+
165
+ ### spaces_inside_hash_brace
166
+
167
+ Allow spaces inside hash braces?
168
+
169
+ - `:dynamic`: (default) if there's a space, keep it. Otherwise don't add it.
170
+ - `:always`: always add a space
171
+ - `:never`: never add a space
172
+
173
+ With `:always`, hashes will look like this:
174
+
175
+ ```ruby
176
+ { :foo => 1, :bar => 2}
177
+ ```
178
+
179
+ With `:never`, hashes will look like this:
180
+
181
+ ```ruby
182
+ {:foo => 1, :bar => 2}
183
+ ```
184
+
185
+ With `:dynamic`, any of the above choices is fine.
186
+
187
+ ### spaces_inside_array_bracket
188
+
189
+ Allow spaces inside array brackets?
190
+
191
+ - `:dynamic`: (default) if there's a space, keep it. Otherwise don't add it.
192
+ - `:always`: always add a space
193
+ - `:never`: never add a space
194
+
195
+ With `:always`, arrays will look like this:
196
+
197
+ ```ruby
198
+ [ 1, 2 ]
199
+ ```
200
+
201
+ With `:never`, arrays will look like this:
202
+
203
+ ```ruby
204
+ [1, 2]
205
+ ```
206
+
207
+ With `:dynamic`, any of the above choices is fine.
208
+
209
+ ### spaces_around_equal
210
+
211
+ How to format spaces around an equal (`=`) sign?
212
+
213
+ - `:dynamic`: (default) allow any number of spaces (even zero) around the equal sign
214
+ - `:one`: always use one space before and after the equal sign
215
+
216
+ Given this code:
217
+
218
+ ```ruby
219
+ a=1
220
+ b = 2
221
+ ```
222
+
223
+ With `:one` the formatter will change it to:
224
+
225
+ ```ruby
226
+ a = 1
227
+ b = 2
228
+ ```
229
+
230
+ With `:dynamic` it won't modify it.
231
+
232
+ If `align_assignments` is `true`, then this setting has no effect and `:one`
233
+ will be used when no other assignments are above/below an assignment.
234
+
235
+ ### spaces_around_ternary
236
+
237
+ How to format spaces around a ternary (`cond ? then : else`) operator?
238
+
239
+ - `:dynamic`: (default) allow any number of spaces (even zero) around `?` and `:`
240
+ - `:one`: always use one space before and after `?` and `:`
241
+
242
+ Given this code:
243
+
244
+ ```ruby
245
+ a?b:c
246
+ a ? b : c
247
+ ```
248
+
249
+ With `:one` the formatter will change it to:
250
+
251
+ ```ruby
252
+ a ? b : c
253
+ a ? b : c
254
+ ```
255
+
256
+ With `:dynamic` it won't modify it.
257
+
258
+ ### spaces_in_suffix
259
+
260
+ How to format spaces around a suffix `if`, `unless`, etc?
261
+
262
+ - `:dynamic`: (default) allow any number of spaces (even zero) around `if`
263
+ - `:one`: always use one space before and after `if`
264
+
265
+ Given this code:
266
+
267
+ ```ruby
268
+ a if b
269
+ ```
270
+
271
+ With `:one` the formatter will change it to:
272
+
273
+ ```ruby
274
+ a if b
275
+ ```
276
+
277
+ With `:dynamic` it won't modify it.
278
+
279
+ ### spaces_in_commands
280
+
281
+ How to format spaces after command names (a command is a call without parentheses)?
282
+
283
+ - `:dynamic`: (default) allow any number of spaces after a command name
284
+ - `:one`: always use one space after a command name
285
+
286
+ Given this code:
287
+
288
+ ```ruby
289
+ include Foo
290
+ extend Bar
291
+ ```
292
+
293
+ With `:one` the formatter will change it to:
294
+
295
+ ```ruby
296
+ include Foo
297
+ extend Bar
298
+ ```
299
+
300
+ With `:dynamic` it won't modify it.
301
+
302
+ ### spaces_around_block_brace
303
+
304
+ How to format spaces around block braces?
305
+
306
+ - `:dynamic`: (default) allow any number of spaces around block braces
307
+ - `:one`: always use one space around block braces
308
+
309
+ Given this code:
310
+
311
+ ```ruby
312
+ foo{|x|1}
313
+ foo {|x|1}
314
+ foo { |x|1}
315
+ foo { |x| 1}
316
+ ```
317
+
318
+ With `:one` the formatter will change it to:
319
+
320
+ ```ruby
321
+ foo { |x| 1 }
322
+ foo { |x| 1 }
323
+ foo { |x| 1 }
324
+ foo { |x| 1 }
325
+ ```
326
+
327
+ With `:dynamic` it won't modify it.
328
+
329
+ ### spaces_after_comma
330
+
331
+ How to format spaces after commas?
332
+
333
+ - `:dynamic`: (default) allow any number of spaces around block braces
334
+ - `:one`: always use one space after a comma
335
+
336
+ Given this code:
337
+
338
+ ```ruby
339
+ foo 1, 2, 3
340
+ [1, 2, 3]
341
+ ```
342
+
343
+ With `:one` the formatter will change it to:
344
+
345
+ ```ruby
346
+ foo 1, 2, 3
347
+ [1, 2, 3]
348
+ ```
349
+
350
+ With `:dynamic` it won't modify it.
351
+
352
+ ### spaces_around_hash_arrow
353
+
354
+ How to format spaces around a hash arrow or keyword argument?
355
+
356
+ - `:dynamic`: (default) allow any number of spaces around hash arrows
357
+ - `:one`: always use one space around hash arrows
358
+
359
+ Given this code:
360
+
361
+ ```ruby
362
+ { 1 => 2, 3 => 4 }
363
+ { foo: 1, bar: 2 }
364
+ ```
365
+
366
+ With `:one` the formatter will change it to:
367
+
368
+ ```ruby
369
+ { 1 => 2, 3 => 4 }
370
+ { foo: 1, bar: 2}
371
+ ```
372
+
373
+ With `:dynamic` it won't modify it.
374
+
375
+ If `align_hash_keys` is `true`, then this setting has no effect and `:one`
376
+ will be used when no other hash keys are above/below.
377
+
378
+ ### spaces_around_when
379
+
380
+ How to format spaces around a case when and then?
381
+
382
+ - `:dynamic`: (default) allow any number of spaces around a case when and then
383
+ - `:one`: always use one space around a case when and then
384
+
385
+ Given this code:
386
+
387
+ ```ruby
388
+ case foo
389
+ when 1 then 2
390
+ end
391
+ ```
392
+
393
+ With `:one` the formatter will change it to:
394
+
395
+ ```ruby
396
+ case foo
397
+ when 1 then 2
398
+ end
399
+ ```
400
+
401
+ With `:dynamic` it won't modify it.
402
+
403
+ If `align_case_when` is `true`, then this setting has no effect and `:one`
404
+ will be used when no other case when are above/below.
405
+
406
+ ### spaces_around_dot
407
+
408
+ How to format spaces around a call dot?
409
+
410
+ - `:dynamic`: (default) allow any number of spaces around a call dot
411
+ - `:no`: no spaces around a call dot
412
+
413
+ Given this code:
414
+
415
+ ```ruby
416
+ foo . bar
417
+ foo :: bar
418
+ foo &. bar
419
+ ```
420
+
421
+ With `:no` the formatter will change it to:
422
+
423
+ ```ruby
424
+ foo.bar
425
+ foo::bar
426
+ foo&.bar
427
+ ```
428
+
429
+ With `:dynamic` it won't modify it.
430
+
431
+ ### spaces_after_lambda_arrow
432
+
433
+ How to format spaces after a lambda arrow?
434
+
435
+ - `:dynamic`: (default) allow any number of spaces after a lambda arrow
436
+ - `:no`: no spaces after a lambda arrow
437
+
438
+ Given this code:
439
+
440
+ ```ruby
441
+ ->{ 1 }
442
+ -> { 2 }
443
+ ```
444
+
445
+ With `:no` the formatter will change it to:
446
+
447
+ ```ruby
448
+ ->{ 1 }
449
+ ->{ 2 }
450
+ ```
451
+
452
+ With `:dynamic` it won't modify it.
453
+
454
+ For spaces inside the braces, the `spaces_around_block_brace` setting is used.
455
+
456
+ ### spaces_around_unary
457
+
458
+ How to format spaces around a unary operator?
459
+
460
+ - `:dynamic`: (default) allow any number of spaces around a unary operator
461
+ - `:no`: no spaces around a unary operator
462
+
463
+ Given this code:
464
+
465
+ ```ruby
466
+ +1
467
+ - 2
468
+ ! x
469
+ ```
470
+
471
+ With `:no` the formatter will change it to:
472
+
473
+ ```ruby
474
+ +1
475
+ -2
476
+ !x
477
+ ```
478
+
479
+ With `:dynamic` it won't modify it.
480
+
481
+ ### spaces_around_binary
482
+
483
+ How to format spaces around a binary operator?
484
+
485
+ - `:dynamic`: (default) allow any number of spaces around a binary operator
486
+ - `:one`: at most one space around a binary operator
487
+
488
+ Given this code:
489
+
490
+ ```ruby
491
+ 1+2
492
+ 1 +2
493
+ 1+ 2
494
+ 1 + 2
495
+ ```
496
+
497
+ With `:one` the formatter will change it to:
498
+
499
+ ```ruby
500
+ 1+2
501
+ 1 + 2
502
+ 1+2
503
+ 1 + 2
504
+ ```
505
+
506
+ Note that with `:one` the spaces are kept balanced: if there's no space
507
+ before the operator, no space is kept after it. If there's a space
508
+ before the operator, a space is added after it.
509
+
510
+ With `:dynamic` it won't modify it.
511
+
512
+ ### parens_in_defs
513
+
514
+ Use parentheses in defs?
515
+
516
+ - `:dynamic`: (default) don't modify existing methods parentheses choice
517
+ - `:yes`: always use parentheses (add them if they are not there)
518
+
519
+ Given this code:
520
+
521
+ ```ruby
522
+ def foo x, y
523
+ end
524
+
525
+ def bar(x, y)
526
+ end
527
+ ```
528
+
529
+ With `:yes` the formatter will change it to:
530
+
531
+ ```ruby
532
+ def foo(x, y)
533
+ end
534
+
535
+ def bar(x, y)
536
+ end
537
+ ```
538
+
539
+ With `:dynamic` it won't modify it.
540
+
541
+ ### double_newline_inside_type
542
+
543
+ Allow an empty line inside a type declaration?
544
+
545
+ - `:dynamic`: (default) allow at most one empty newline
546
+ - `:no`: no empty newlines inside type declarations
547
+
548
+ Given this code:
549
+
550
+ ```ruby
551
+ class Foo
552
+
553
+ CONST = 1
554
+
555
+ end
556
+
557
+ class Bar
558
+ CONST = 2
559
+ end
560
+ ```
561
+
562
+ With `:no` the formatter will change it to:
563
+
564
+ ```ruby
565
+ class Foo
566
+ CONST = 1
567
+ end
568
+
569
+ class Bar
570
+ CONST = 2
571
+ end
572
+ ```
573
+
574
+ With `:dynamic` it won't modify it.
575
+
576
+ ### visibility_indent
577
+
578
+ How to indent code after a visibility method (`public`, `protected`, `private`)?
579
+
580
+ - `:dynamic`: (default) keep the current code's choice according to the first expression that follows
581
+ - `:indent`: indent code after the visibility method
582
+ - `:align`: align code at the same column as the visibility method
583
+
584
+ Given this code:
585
+
586
+ ```ruby
587
+ class Foo
588
+ private
589
+
590
+ def foo
591
+ end
592
+
593
+ def bar
594
+ end
595
+ end
596
+
597
+ class Bar
598
+ private
599
+
600
+ def foo
601
+ end
602
+
603
+ def bar
604
+ end
605
+ end
606
+ ```
607
+
608
+ With `:dynamic`, the formatter will change it to:
609
+
610
+ ```ruby
611
+ class Foo
612
+ private
613
+
614
+ def foo
615
+ end
616
+
617
+ def bar
618
+ end
619
+ end
620
+
621
+ class Bar
622
+ private
623
+
624
+ def foo
625
+ end
626
+
627
+ def bar
628
+ end
629
+ end
630
+ ```
631
+
632
+ Note that the formatter unified the indentation choice according to the first
633
+ expression. It makes no sense to keep two choices together inside a same type
634
+ declaration.
635
+
636
+ With `:align`, the formatter will change it to:
80
637
 
81
638
  ```ruby
82
- # Whether to put a space after an array bracket. Valid values are:
83
- #
84
- # * :dynamic: if there's a space, keep it. If not, don't add it
85
- # * :always: always put a space after an array bracket (default)
86
- # * :never: never put a space after an array bracket
87
- space_after_array_bracket :dynamic
639
+ class Foo
640
+ private
641
+
642
+ def foo
643
+ end
88
644
 
89
- # Whether to put a space after a hash brace. Valid values are:
90
- #
91
- # * :dynamic: if there's a space, keep it. If not, don't add it (default)
92
- # * :always: always put a space after a hash brace
93
- # * :never: never put a space after a hash brace
94
- space_after_hash_brace :dynamic
645
+ def bar
646
+ end
647
+ end
95
648
 
96
- # Whether to align successive comments (default: false)
97
- align_comments false
649
+ class Bar
650
+ private
98
651
 
99
- # Whether to align successive assignments (default: false)
100
- align_assignments false
652
+ def foo
653
+ end
101
654
 
102
- # Whether to align successive hash keys (default: false)
103
- align_hash_keys false
655
+ def bar
656
+ end
657
+ end
658
+ ```
104
659
 
105
- # Whether to align successive case when (default: false)
106
- align_case_when false
660
+ With `:indent`, the formatter will change it to:
661
+
662
+ ```ruby
663
+ class Foo
664
+ private
107
665
 
108
- # Whether to align chained calls to the first dot in the first line (default: false)
109
- align_chained_calls false
666
+ def foo
667
+ end
110
668
 
111
- # Preserve whitespace after assignments target and values,
112
- # after calls that start with a space, hash arrows and commas (default: true).
113
- #
114
- # This allows for manual alignment of some code that would otherwise
115
- # be impossible to automatically format or preserve "beautiful".
116
- #
117
- # If `align_assignments` is true, this doesn't apply to assignments.
118
- # If `align_hash_keys` is true, this doesn't apply to hash keys.
119
- #
120
- #
121
- # Can also be set to `:YES` to preserve whitespace in many more places,
122
- # in case there's no clear rule in your workplace/project as to when
123
- # to leave spaces or not. This includes spaces (or the absence of them)
124
- # around dots, braces, pipes and hash keys and values.
125
- preserve_whitespace true
669
+ def bar
670
+ end
671
+ end
126
672
 
127
- # The indent size (default: 2)
128
- indent_size 2
673
+ class Bar
674
+ private
129
675
 
130
- # Whether to place commas at the end of a multi-line list
131
- #
132
- # * :dynamic: if there's a comma, keep it. If not, don't add it (default)
133
- # * :always: always put a comma
134
- # * :never: never put a comma
135
- trailing_commas :dyanmic
676
+ def foo
677
+ end
678
+
679
+ def bar
680
+ end
681
+ end
136
682
  ```
137
683
 
138
- As time passes there might be more configurations available. Please open an
139
- issue if you need something else to be configurable.
684
+ **NOTE:** There's another commonly used indentation style which is `:dedent`:
685
+
686
+ ```ruby
687
+ class Foo
688
+ def foo
689
+ end
690
+
691
+ private
692
+
693
+ def bar
694
+ end
695
+ end
696
+ ```
140
697
 
141
- ## Formatting rules
698
+ Rufo currently doesn't support it, but in the future it might.
142
699
 
143
- Rufo follows most of the conventions found in this [Ruby style guide](https://github.com/bbatsov/ruby-style-guide).
700
+ ### align_comments
144
701
 
145
- However, there are some differences. Some of them are:
702
+ Align successive comments?
146
703
 
147
- ### `*`, `/` and `**` don't require spaces around them
704
+ - `false`: (default) don't align comments (preserve existing code)
705
+ - `true`: align successive comments
148
706
 
149
- All of these are good:
707
+ Given this code:
150
708
 
151
709
  ```ruby
152
- # First option
153
- 2*x + 3*y + z
710
+ foo = 1 # some comment
711
+ barbaz = 2 # some other comment
712
+ ```
154
713
 
155
- # Second option
156
- 2 * x + 3 * y + z
714
+ With `true`, the formatter will change it to:
157
715
 
158
- # Another option
159
- 2 * x + 3*y + z
716
+ ```ruby
717
+ foo = 1 # some comment
718
+ barbaz = 2 # some other comment
160
719
  ```
161
720
 
162
- Rufo will leave them as they are. The reason is that the first format looks
163
- good mathematically. If you do insert a space before the `*` operator,
164
- a space will be inserted afterwards.
721
+ With `false` it won't modify it.
722
+
723
+ ### align_assignments
724
+
725
+ Align successive assignments?
165
726
 
166
- ## Status
727
+ - `false`: (default) don't align assignments (preserve existing code)
728
+ - `true`: align successive assignments
729
+
730
+ Given this code:
731
+
732
+ ```ruby
733
+ foo = 1
734
+ barbaz = 2
735
+ ```
736
+
737
+ With `true`, the formatter will change it to:
738
+
739
+ ```ruby
740
+ foo = 1
741
+ barbaz = 2
742
+ ```
743
+
744
+ With `false` it won't modify it.
745
+
746
+ ### align_hash_keys
747
+
748
+ Align successive hash keys?
749
+
750
+ - `false`: (default) don't align hash keys (preserve existing code)
751
+ - `true`: align successive hash keys
752
+
753
+ Given this code:
754
+
755
+ ```ruby
756
+ {
757
+ foo: 1,
758
+ barbaz: 2,
759
+ }
760
+
761
+ {
762
+ :foo => 1,
763
+ :barbaz => 2,
764
+ }
765
+
766
+ method foo: 1,
767
+ barbaz: 2
768
+ ```
769
+
770
+ With `true`, the formatter will change it to:
771
+
772
+ ```ruby
773
+ {
774
+ foo: 1,
775
+ barbaz: 2,
776
+ }
777
+
778
+ {
779
+ :foo => 1,
780
+ :barbaz => 2,
781
+ }
782
+
783
+ method foo: 1,
784
+ barbaz: 2
785
+ ```
167
786
 
168
- The formatter is able to format `rails` and other projects, so at this point
169
- it's pretty mature. There might still be some bugs. Don't hesitate
170
- to open an issue if you find something is not working well. In any case, if the formatter
171
- chokes on some valid input you will get an error prompting you to submit a bug report here :-)
787
+ With `false` it won't modify it.
788
+
789
+ ### align_case_when
790
+
791
+ Align successive case when?
792
+
793
+ - `false`: (default) don't align case when (preserve existing code)
794
+ - `true`: align successive case when
795
+
796
+ Given this code:
797
+
798
+ ```ruby
799
+ case exp
800
+ when foo then 2
801
+ when barbaz then 3
802
+ end
803
+ ```
804
+
805
+ With `true`, the formatter will change it to:
806
+
807
+ ```ruby
808
+ case exp
809
+ when foo then 2
810
+ when barbaz then 3
811
+ end
812
+ ```
813
+
814
+ With `false` it won't modify it.
815
+
816
+ ### align_chained_calls
817
+
818
+ Align chained calls to the dot?
819
+
820
+ - `false`: (default) don't align chained calls to the dot (preserve existing code)
821
+ - `true`: align chained calls to the dot
822
+
823
+ Given this code:
824
+
825
+ ```ruby
826
+ foo.bar
827
+ .baz
828
+
829
+ foo.bar
830
+ .baz
831
+ ```
832
+
833
+ With `true`, the formatter will change it to:
834
+
835
+ ```ruby
836
+ foo.bar
837
+ .baz
838
+
839
+ foo.bar
840
+ .baz
841
+ ```
842
+
843
+ With `false` it won't modify it.
844
+
845
+ Note that with `false` it will keep it aligned to the dot if it's already like that.
846
+
847
+ ### trailing_commas
848
+
849
+ Use trailing commas in array and hash literals, and keyword arguments?
850
+
851
+ - `:dynamic`: (default) if there's a trailing comma, keep it. Otherwise, don't remove it
852
+ - `:always`: always put a trailing comma
853
+ - `:never`: never put a trailing comma
854
+
855
+ Given this code:
856
+
857
+ ```ruby
858
+ [
859
+ 1,
860
+ 2
861
+ ]
862
+
863
+ [
864
+ 1,
865
+ 2,
866
+ ]
867
+
868
+ {
869
+ foo: 1,
870
+ bar: 2
871
+ }
872
+
873
+ {
874
+ foo: 1,
875
+ bar: 2,
876
+ }
877
+
878
+ foo(
879
+ x: 1,
880
+ y: 2
881
+ )
882
+
883
+ foo(
884
+ x: 1,
885
+ y: 2,
886
+ )
887
+ ```
888
+
889
+ With `:always`, the formatter will change it to:
890
+
891
+ ```ruby
892
+ [
893
+ 1,
894
+ 2,
895
+ ]
896
+
897
+ [
898
+ 1,
899
+ 2,
900
+ ]
901
+
902
+ {
903
+ foo: 1,
904
+ bar: 2,
905
+ }
906
+
907
+ {
908
+ foo: 1,
909
+ bar: 2,
910
+ }
911
+
912
+ foo(
913
+ x: 1,
914
+ y: 2,
915
+ )
916
+
917
+ foo(
918
+ x: 1,
919
+ y: 2,
920
+ )
921
+ ```
922
+ With `:never`, the formatter will change it to:
923
+
924
+ ```ruby
925
+ [
926
+ 1,
927
+ 2
928
+ ]
929
+
930
+ [
931
+ 1,
932
+ 2
933
+ ]
934
+
935
+ {
936
+ foo: 1,
937
+ bar: 2
938
+ }
939
+
940
+ {
941
+ foo: 1,
942
+ bar: 2
943
+ }
944
+
945
+ foo(
946
+ x: 1,
947
+ y: 2
948
+ )
949
+
950
+ foo(
951
+ x: 1,
952
+ y: 2
953
+ )
954
+ ``
955
+
956
+ With `:dynamic` it won't modify it.
172
957
 
173
958
  ## How it works
174
959