RubyGems - rufo - Versions diffs - 0.0.36 → 0.0.37 - Mend

rufo 0.0.36 → 0.0.37

Files changed (7) hide show

checksums.yaml +4 -4
data/README.md +2 -838
data/lib/rufo/formatter/settings.rb +198 -0
data/lib/rufo/formatter.rb +80 -297
data/lib/rufo/version.rb +1 -1
data/lib/rufo.rb +1 -0
metadata +3 -2

checksums.yaml CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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