rufo 0.0.36 → 0.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 217daf75d51d00f8dc47f3b98c8e4403d10a4d99
-  data.tar.gz: c95e8308df7067fb8221f99e4a19804b3c82c09d
+  metadata.gz: fb66c78ddab7f72ff2c62ea1a6c8d268ee07871a
+  data.tar.gz: cdb227d8ae51899ffe33bf2468f7dccbe95f5b2a
 SHA512:
-  metadata.gz: 623c8db7e7e98ae87904f55cc6661beabc119adac24593fc533f82e03893deff64328a2a2ecb6db46d39e43e477c0b74da8e7d8f1556c394c7105a21792e3666
-  data.tar.gz: 229519b8ba228f3924b4b1340a48fdcbd1dd97bebaf1604702b57a1faf1bfa3ab29844d31e50a4d5f1f94cbaa46b3b2ed28e363d36a6fc486f4d3b6c90676f05
+  metadata.gz: 6bebee1f9ef22fa4a3589cf0000f187e94da9f0224819922ca48cc13dbccd0c5349756956626c02230cda2e0f4fd4f91b7c2db1c287f5421d92c78151a5d0046
+  data.tar.gz: d7485eaa65ed1783c83f8134f5f97b298380f969c0600490d9d5f6e697f4ef3ff3fa5f32b2de5661823a5910fb21ba4e1c56fab5b2b65db4dab810a3c1de4024

data/README.md

@@ -145,7 +145,7 @@ according to **rufo**, and will exit with exit code 1.
 ## Editor support
 
 - Atom: [rufo-atom](https://github.com/bmulvihill/rufo-atom) :construction:
-- Emacs [emacs-rufo](https://github.com/aleandros/emacs-rufo) :construction: or [rufo-mode.el](https://github.com/danielma/rufo-mode.el) :construction:
+- Emacs [emacs-rufo](https://github.com/aleandros/emacs-rufo) :construction: or [rufo.el](https://github.com/danielma/rufo.el)
 - Sublime Text: [sublime-rufo](https://github.com/asterite/sublime-rufo)
 - Vim: [rufo-vim](https://github.com/splattael/rufo-vim)
 - Visual Studio Code: [rufo-vscode](https://marketplace.visualstudio.com/items?itemName=siliconsenthil.rufo-vscode)
@@ -177,843 +177,7 @@ To configure Rufo, place a `.rufo` file in your project. When formatting a file
 via the `rufo` program, a `.rufo` file will try to be found in that directory or parent directories.
 
 The `.rufo` file is a Ruby file that is evaluated in the context of the formatter.
-The available configurations are listed below.
-
-### indent_size
-
-Sets the indent size. Default: 2
-
-### spaces_inside_hash_brace
-
-Allow spaces inside hash braces?
-
-- `:dynamic`: (default) if there's a space, keep it. Otherwise don't add it.
-- `:always`: always add a space
-- `:never`: never add a space
-- `:match`: if there's a leading space, keep it (just one) and match the closing brace with one space before it
-
-With `:always`, hashes will look like this:
-
-```ruby
-{ :foo => 1, :bar => 2 }
-```
-
-With `:never`, hashes will look like this:
-
-```ruby
-{:foo => 1, :bar => 2}
-```
-
-With `:match`, hashes will look like any of these:
-
-```ruby
-{ :foo => 1, :bar => 2 }
-{:foo => 1, :bar => 2}
-```
-
-With `:dynamic`, any of the above choices is fine, and any amount of space (or zero) is preserved.
-
-### spaces_inside_array_bracket
-
-Allow spaces inside array brackets?
-
-- `:dynamic`: (default) if there's a space, keep it. Otherwise don't add it.
-- `:always`: always add a space
-- `:never`: never add a space
-- `:match`: if there's a leading space, keep it (just one) and match the closing bracket with one space before it
-
-With `:always`, arrays will look like this:
-
-```ruby
-[ 1, 2 ]
-```
-
-With `:never`, arrays will look like this:
-
-```ruby
-[1, 2]
-```
-
-With `:match`, arrays will look like any of these:
-
-```ruby
-[ 1, 2 ]
-[1, 2]
-```
-
-With `:dynamic`, any of the above choices is fine.
-
-### spaces_around_equal
-
-How to format spaces around an equal (`=`) sign?
-
-- `:dynamic`: (default) allow any number of spaces (even zero) around the equal sign
-- `:one`: always use one space before and after the equal sign
-
-Given this code:
-
-```ruby
-a=1
-b  =  2
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-a = 1
-b = 2
-```
-
-With `:dynamic` it won't modify it.
-
-If `align_assignments` is `true`, then this setting has no effect and `:one`
-will be used when no other assignments are above/below an assignment.
-
-### spaces_in_ternary
-
-How to format spaces around a ternary (`cond ? then : else`) operator?
-
-- `:dynamic`: (default) allow any number of spaces (even zero) around `?` and `:`
-- `:one`: always use one space before and after `?` and `:`
-
-Given this code:
-
-```ruby
-a?b:c
-a  ?  b  :  c
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-a ? b : c
-a ? b : c
-```
-
-With `:dynamic` it won't modify it.
-
-### spaces_in_suffix
-
-How to format spaces around a suffix `if`, `unless`, etc?
-
-- `:dynamic`: (default) allow any number of spaces (even zero) around `if`
-- `:one`: always use one space before and after `if`
-
-Given this code:
-
-```ruby
-a  if  b
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-a if b
-```
-
-With `:dynamic` it won't modify it.
-
-### spaces_in_commands
-
-How to format spaces after command names (a command is a call without parentheses)?
-
-- `:dynamic`: (default) allow any number of spaces after a command name
-- `:one`: always use one space after a command name
-
-Given this code:
-
-```ruby
-include Foo
-extend  Bar
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-include Foo
-extend Bar
-```
-
-With `:dynamic` it won't modify it.
-
-### spaces_around_block_brace
-
-How to format spaces around block braces?
-
-- `:dynamic`: (default) allow any number of spaces around block braces
-- `:one`: always use one space around block braces
-
-Given this code:
-
-```ruby
-foo{|x|1}
-foo {|x|1}
-foo { |x|1}
-foo { |x| 1}
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-foo { |x| 1 }
-foo { |x| 1 }
-foo { |x| 1 }
-foo { |x| 1 }
-```
-
-With `:dynamic` it won't modify it.
-
-### spaces_after_comma
-
-How to format spaces after commas?
-
-- `:dynamic`: (default) allow any number of spaces around block braces
-- `:one`: always use one space after a comma
-
-Given this code:
-
-```ruby
-foo 1,  2,   3
-[1,  2,  3]
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-foo 1, 2, 3
-[1, 2, 3]
-```
-
-With `:dynamic` it won't modify it.
-
-### spaces_around_hash_arrow
-
-How to format spaces around a hash arrow or keyword argument?
-
-- `:dynamic`: (default) allow any number of spaces around hash arrows
-- `:one`: always use one space around hash arrows
-
-Given this code:
-
-```ruby
-{ 1  =>  2, 3    =>  4 }
-{ foo:  1,  bar:  2 }
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-{ 1 => 2, 3 => 4 }
-{ foo: 1, bar: 2}
-```
-
-With `:dynamic` it won't modify it.
-
-If `align_hash_keys` is `true`, then this setting has no effect and `:one`
-will be used when no other hash keys are above/below.
-
-### spaces_around_when
-
-How to format spaces around a case when and then?
-
-- `:dynamic`: (default) allow any number of spaces around a case when and then
-- `:one`: always use one space around a case when and then
-
-Given this code:
-
-```ruby
-case foo
-when   1  then 2
-end
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-case foo
-when 1 then 2
-end
-```
-
-With `:dynamic` it won't modify it.
-
-If `align_case_when` is `true`, then this setting has no effect and `:one`
-will be used when no other case when are above/below.
-
-### spaces_around_dot
-
-How to format spaces around a call dot?
-
-- `:dynamic`: (default) allow any number of spaces around a call dot
-- `:no`: no spaces around a call dot
-
-Given this code:
-
-```ruby
-foo .  bar
-foo :: bar
-foo &. bar
-```
-
-With `:no` the formatter will change it to:
-
-```ruby
-foo.bar
-foo::bar
-foo&.bar
-```
-
-With `:dynamic` it won't modify it.
-
-### spaces_after_lambda_arrow
-
-How to format spaces after a lambda arrow?
-
-- `:dynamic`: (default) allow any number of spaces after a lambda arrow
-- `:no`: no spaces after a lambda arrow
-
-Given this code:
-
-```ruby
-->{ 1 }
-->  { 2 }
-```
-
-With `:no` the formatter will change it to:
-
-```ruby
-->{ 1 }
-->{ 2 }
-```
-
-With `:dynamic` it won't modify it.
-
-For spaces inside the braces, the `spaces_around_block_brace` setting is used.
-
-### spaces_around_unary
-
-How to format spaces around a unary operator?
-
-- `:dynamic`: (default) allow any number of spaces around a unary operator
-- `:no`: no spaces around a unary operator
-
-Given this code:
-
-```ruby
-+1
--  2
-! x
-```
-
-With `:no` the formatter will change it to:
-
-```ruby
-+1
--2
-!x
-```
-
-With `:dynamic` it won't modify it.
-
-### spaces_around_binary
-
-How to format spaces around a binary operator?
-
-- `:dynamic`: (default) allow any number of spaces around a binary operator
-- `:one`: at most one space around a binary operator
-
-Given this code:
-
-```ruby
-1+2
-1 +2
-1+ 2
-1  +  2
-```
-
-With `:one` the formatter will change it to:
-
-```ruby
-1+2
-1 + 2
-1+2
-1 + 2
-```
-
-Note that with `:one` the spaces are kept balanced: if there's no space
-before the operator, no space is kept after it. If there's a space
-before the operator, a space is added after it.
-
-With `:dynamic` it won't modify it.
-
-### spaces_after_method_name
-
-How to format spaces after a method name?
-
-- `:dynamic`: (default) allow any number of spaces
-- `:no`: no spaces after a method name
-
-Given this code:
-
-```ruby
-def plus_one   (x) x + 1 end
-def plus_twenty(x) x + 20 end
-```
-
-With `:no` the formatter will change it to:
-
-```ruby
-def plus_one(x) x + 1 end
-def plus_twenty(x) x + 20 end
-```
-
-With `:dynamic` it won't modify it.
-
-### parens_in_def
-
-Use parentheses in defs?
-
-- `:dynamic`: (default) don't modify existing methods parentheses choice
-- `:yes`: always use parentheses (add them if they are not there)
-
-Given this code:
-
-```ruby
-def foo x, y
-end
-
-def bar(x, y)
-end
-```
-
-With `:yes` the formatter will change it to:
-
-```ruby
-def foo(x, y)
-end
-
-def bar(x, y)
-end
-```
-
-With `:dynamic` it won't modify it.
-
-### double_newline_inside_type
-
-Allow an empty line inside a type declaration?
-
-- `:dynamic`: (default) allow at most one empty newline
-- `:no`: no empty newlines inside type declarations
-
-Given this code:
-
-```ruby
-class Foo
-
-  CONST = 1
-
-end
-
-class Bar
-  CONST = 2
- end
-```
-
-With `:no` the formatter will change it to:
-
-```ruby
-class Foo
-  CONST = 1
-end
-
-class Bar
-  CONST = 2
-end
-```
-
-With `:dynamic` it won't modify it.
-
-### visibility_indent
-
-How to indent code after a visibility method (`public`, `protected`, `private`)?
-
-- `:dynamic`: (default) keep the current code's choice according to the first expression that follows
-- `:indent`: indent code after the visibility method
-- `:align`: align code at the same column as the visibility method
-
-Given this code:
-
-```ruby
-class Foo
-  private
-
-  def foo
-  end
-
-    def bar
-    end
-end
-
-class Bar
-  private
-
-    def foo
-    end
-
-  def bar
-  end
-end
-```
-
-With `:dynamic`, the formatter will change it to:
-
-```ruby
-class Foo
-  private
-
-  def foo
-  end
-
-  def bar
-  end
-end
-
-class Bar
-  private
-
-    def foo
-    end
-
-    def bar
-    end
-end
-```
-
-Note that the formatter unified the indentation choice according to the first
-expression. It makes no sense to keep two choices together inside a same type
-declaration.
-
-With `:align`, the formatter will change it to:
-
-```ruby
-class Foo
-  private
-
-  def foo
-  end
-
-  def bar
-  end
-end
-
-class Bar
-  private
-
-  def foo
-  end
-
-  def bar
-  end
-end
-```
-
-With `:indent`, the formatter will change it to:
-
-```ruby
-class Foo
-  private
-
-  def foo
-  end
-
-    def bar
-    end
-end
-
-class Bar
-  private
-
-    def foo
-    end
-
-    def bar
-    end
-end
-```
-
-**NOTE:** There's another commonly used indentation style which is `:dedent`:
-
-```ruby
-class Foo
-  def foo
-  end
-
-private
-
-  def bar
-  end
-end
-```
-
-Rufo currently doesn't support it, but in the future it might.
-
-### align_comments
-
-Align successive comments?
-
-- `false`: (default) don't align comments (preserve existing code)
-- `true`: align successive comments
-
-Given this code:
-
-```ruby
-foo = 1 # some comment
-barbaz = 2 # some other comment
-```
-
-With `true`, the formatter will change it to:
-
-```ruby
-foo = 1    # some comment
-barbaz = 2 # some other comment
-```
-
-With `false` it won't modify it.
-
-### align_assignments
-
-Align successive assignments?
-
-- `false`: (default) don't align assignments (preserve existing code)
-- `true`: align successive assignments
-
-Given this code:
-
-```ruby
-foo = 1
-barbaz = 2
-```
-
-With `true`, the formatter will change it to:
-
-```ruby
-foo    = 1
-barbaz = 2
-```
-
-With `false` it won't modify it.
-
-### align_hash_keys
-
-Align successive hash keys?
-
-- `false`: (default) don't align hash keys (preserve existing code)
-- `true`: align successive hash keys
-
-Given this code:
-
-```ruby
-{
-  foo: 1,
-  barbaz: 2,
-}
-
-{
-  :foo => 1,
-  :barbaz => 2,
-}
-
-method foo: 1,
-       barbaz: 2
-```
-
-With `true`, the formatter will change it to:
-
-```ruby
-{
-  foo:    1,
-  barbaz: 2,
-}
-
-{
-  :foo =>    1,
-  :barbaz => 2,
-}
-
-method foo:    1,
-       barbaz: 2
-```
-
-With `false` it won't modify it.
-
-### align_case_when
-
-Align successive case when?
-
-- `false`: (default) don't align case when (preserve existing code)
-- `true`: align successive case when
-
-Given this code:
-
-```ruby
-case exp
-when foo then 2
-when barbaz then 3
-end
-```
-
-With `true`, the formatter will change it to:
-
-```ruby
-case exp
-when foo    then 2
-when barbaz then 3
-end
-```
-
-With `false` it won't modify it.
-
-### align_chained_calls
-
-Align chained calls to the dot?
-
-- `false`: (default) don't align chained calls to the dot (preserve existing code)
-- `true`: align chained calls to the dot
-
-Given this code:
-
-```ruby
-foo.bar
-   .baz
-
-foo.bar
-  .baz
-```
-
-With `true`, the formatter will change it to:
-
-```ruby
-foo.bar
-   .baz
-
-foo.bar
-   .baz
-```
-
-With `false` it won't modify it.
-
-Note that with `false` it will keep it aligned to the dot if it's already like that.
-
-### trailing_commas
-
-Use trailing commas in array and hash literals, and keyword arguments?
-
-- `:dynamic`: (default) if there's a trailing comma, keep it. Otherwise, don't remove it
-- `:always`: always put a trailing comma
-- `:never`: never put a trailing comma
-
-Given this code:
-
-```ruby
-[
-  1,
-  2
-]
-
-[
-  1,
-  2,
-]
-
-{
-  foo: 1,
-  bar: 2
-}
-
-{
-  foo: 1,
-  bar: 2,
-}
-
-foo(
-  x: 1,
-  y: 2
-)
-
-foo(
-  x: 1,
-  y: 2,
-)
-```
-
-With `:always`, the formatter will change it to:
-
-```ruby
-[
-  1,
-  2,
-]
-
-[
-  1,
-  2,
-]
-
-{
-  foo: 1,
-  bar: 2,
-}
-
-{
-  foo: 1,
-  bar: 2,
-}
-
-foo(
-  x: 1,
-  y: 2,
-)
-
-foo(
-  x: 1,
-  y: 2,
-)
-```
-With `:never`, the formatter will change it to:
-
-```ruby
-[
-  1,
-  2
-]
-
-[
-  1,
-  2
-]
-
-{
-  foo: 1,
-  bar: 2
-}
-
-{
-  foo: 1,
-  bar: 2
-}
-
-foo(
-  x: 1,
-  y: 2
-)
-
-foo(
-  x: 1,
-  y: 2
-)
-```
-
-With `:dynamic` it won't modify it.
+The available settings are listed [here](https://github.com/asterite/rufo/wiki/Settings).
 
 ## How it works