rufo 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79ef4a1c02b2ae85e1c35468b779ef931a14ccb6
-  data.tar.gz: c6ff325301c90a8840e44301c8547a8a757ef4a9
+  metadata.gz: 568bbd1f6cd032ca58647141b94d48748688a1af
+  data.tar.gz: f4d143cd048591f4a98869d7709384fdfd8b362c
 SHA512:
-  metadata.gz: 5b48e1a4c25987a2eceb77b8e4d346afc261cf8a9317be090a36c524a02ed36b66f0e33b0a61fb6e1c7fda4e7df7b57f3076bb4e7a0c2e9375936f686e51b89f
-  data.tar.gz: 891eb7a6d97363517b1350ffc9244f257d591f2fa474673555767db95db6709993c6a7de039bc067e814e604d4e13463b1c5d8425c658e542f57b597230417cb
+  metadata.gz: '0854453cd81dbaaa44175c794c595ce171de33320b2c51ba2e5a6f61dec76f175e82c0a0c572d1826aca71ff289f777d01c2ea283ba9713a7bed643123a31f30'
+  data.tar.gz: 1c6469b61a0f9601a48a93811df18131fae20ff226965cbd7962f92b7427d17d7d98a8fb9c157cb2074794707d671126377573b3329aa1936b4d18045a9e5470

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,4 @@
+<!--
+  Thank you for contributing to rufo!
+  Please remember to update the CHANGELOG with the contents of this PR.
+-->

data/.rufo

@@ -1,24 +1,2 @@
-indent_size                 2
-spaces_inside_hash_brace    :never
-spaces_inside_array_bracket :never
-spaces_around_equal         :one
-spaces_in_ternary           :one
-spaces_in_suffix            :one
-spaces_in_commands          :dynamic
-spaces_around_block_brace   :one
-spaces_after_comma          :dynamic
-spaces_around_hash_arrow    :one
-spaces_around_when          :one
-spaces_around_dot           :no
-spaces_after_lambda_arrow   :no
-spaces_around_unary         :no
-spaces_around_binary        :one
-parens_in_def               :yes
-double_newline_inside_type  :no
-visibility_indent           :align
-trailing_commas             :always
-align_comments              true
-align_assignments           false
-align_hash_keys             false
 align_case_when             true
 align_chained_calls         true

data/.travis.yml

@@ -2,10 +2,10 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.4.1
-  - 2.3.4
-  - 2.2.7
+  - 2.4.2
+  - 2.3.5
+  - 2.2.8
   - ruby-head
-before_install: gem install bundler -v 1.15.1
+before_install: gem install bundler -v 1.15.4
 script:
   - bundle exec rake ci

data/CHANGELOG.md

@@ -0,0 +1,51 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0] - 2017-11-13
+### Changed
+Config parsing and handling:
+- No longer using `eval` to parse config files
+- Warnings have been added for invalid config keys and values
+
+The default for the following options has changed:
+- parens_in_def: `:dynamic` > `:yes`
+- trailing_commas: `:dynamic` > `true`
+
+Valid options for:
+- trailing_commas: `[:always, :never]` > `[true, false]`
+
+### Removed
+The following configuration options have been **removed**, and replaced with non-configurable sane defaults, [per discussion](https://github.com/ruby-formatter/rufo/issues/2):
+- align_assignments
+- align_comments
+- align_hash_keys
+- indent_size
+- spaces_after_comma
+- spaces_after_lambda_arrow
+- spaces_around_block_brace
+- spaces_around_dot
+- spaces_around_equal
+- spaces_around_hash_arrow
+- spaces_around_unary
+- spaces_around_when
+- spaces_in_commands
+- spaces_in_suffix
+- spaces_in_ternary
+- spaces_inside_array_bracket
+- spaces_inside_hash_brace
+- visibility_indent
+- double_newline_inside_type
+- spaces_around_binary
+
+### Fixed
+- Fix crash in Ruby <= 2.3.4, <= 2.4.1 in the presence of certain squiggly doc (`<<~`) with multiple embedded expressions. The real fix here is to upgrade Ruby to >= 2.3.5 / >= 2.4.2
+- Fix dedent bug and bad formatting caused by comments within chained calls (issue [#49](https://github.com/ruby-formatter/rufo/issues/49))
+- Fix formatting bug for `for i, in [[1, 2]] ; x ; end` (issue [#45](https://github.com/ruby-formatter/rufo/issues/45))
+
+## [0.1.0] - 2017-10-08
+Beginning of logging changes!

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, cmd: 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/README.md

@@ -1,23 +1,48 @@
 # Rufo
 
 [![Build Status](https://travis-ci.org/ruby-formatter/rufo.svg)](https://travis-ci.org/ruby-formatter/rufo)
+[![Gem](https://img.shields.io/gem/v/rufo.svg)](https://rubygems.org/gems/rufo)
 
 **Ru**by **fo**rmatter
 
-## Why
 
-Rufo's primary use case is as a text-editor plugin, to autoformat files on save or
-on demand. For this reason it needs to be fast. If the formatter is slow, saving
-a file becomes painful.
+Rufo is as an _opinionated_ ruby formatter, intended to be used via the command line as a text-editor plugin, to autoformat files on save or on demand.
 
-Right now, Rufo can format it's [formatter](https://github.com/ruby-formatter/rufo/blob/master/lib/rufo/formatter.rb),
-a 3000+ lines file, in about 290ms. It can format a ~500 lines file in 180ms. Since most files
-have less than 500 lines, the time is acceptable.
+Unlike the best known Ruby formatter [RuboCop](https://github.com/bbatsov/rubocop), Rufo offers little in the way of configuration. Like other language formatters such as [gofmt](https://golang.org/cmd/gofmt/), [prettier](https://github.com/prettier/prettier), and [autopep8](https://github.com/hhatto/autopep8), we strive to find a "one true format" for Ruby code, and make sure your code adheres to it, with zero config where possible.
+
+RuboCop does much more than just format code though, so feel free to run them both!
+
+Rufo supports all Ruby versions >= 2.2.4, but works most reliably with >= 2.3.**5** / >= 2.4.**2**, due to a bug in Ruby's Ripper parser.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rufo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it system wide with:
+
+    $ gem install rufo
+
+## Editor support
+
+Once the gem is installed, enable format on save integration in your editor of choice with the following libraries:
+
+- Atom: [rufo-atom](https://github.com/bmulvihill/rufo-atom) :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/ruby-formatter/sublime-rufo)
+- Vim: [rufo-vim](https://github.com/splattael/rufo-vim)
+- Visual Studio Code: [vscode-rufo](https://marketplace.visualstudio.com/items?itemName=mbessey.vscode-rufo) or [rufo-vscode](https://marketplace.visualstudio.com/items?itemName=siliconsenthil.rufo-vscode)
+
+If you're interested in developing your own plugin check out the [development docs](docs/developing-rufo.md). Did you already write a plugin? That's great! Let us know about it and
+we will list it here.
 
-There's at least one other good Ruby formatter I know: [RuboCop](https://github.com/bbatsov/rubocop).
-However, it takes between 2 and 5 seconds to format a 3000+ lines file, and about 1 second to format
-a 500 lines file. A second is too much delay for a plugin editor. Additionally, RuboCop is much more
-than just a code formatter. Rufo is and will always be a code formatter.
 
 ## Unobtrusive by default
 
@@ -48,7 +73,7 @@ register :action,  "Save"
 ```
 
 Here too, an extra space is added to align `"Format"` with `"Save"`. Again, Rufo will preserve
-this choice.
+this choice, while still enforcing that truly badly aligned code is formatted.
 
 Another example is aligning call parameters:
 
@@ -90,36 +115,6 @@ All of the alignment choices above are fine depending on the context where they
 used, and Rufo will not destroy that choice. It will, however, keep things aligned
 so they look good.
 
-If Rufo does not change these things by default, what does it do? Well, it makes sure that:
-
-- code at the beginning of a line is correctly indented
-- array and hash elements are aligned
-- there are no spaces **before** commas
-- there are no more than one consecutive empty lines
-- methods are separated by an empty line
-- no trailing semicolons remain
-- no trailing whitespace remains
-- a trailing newline at the end of the file remains
-
-And of course it can be configured to do much more.
-Check the [Settings](https://github.com/ruby-formatter/rufo/wiki/Settings) section in the [Wiki](https://github.com/ruby-formatter/rufo/wiki) for more details.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'rufo'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install rufo
-
 ## Usage
 
 ### Format files or directories
@@ -151,41 +146,15 @@ according to **Rufo**, and will exit with exit code 3.
 | `1` | Error. Either `Ripper` could not parse syntax or input file is missing |
 | `3` | Input changed. Formatted code differs from input |
 
-## Editor support
-
-- Atom: [rufo-atom](https://github.com/bmulvihill/rufo-atom) :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/ruby-formatter/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) or [vscode-rufo](https://marketplace.visualstudio.com/items?itemName=mbessey.vscode-rufo)
-
-
-Did you write a plugin for your favorite editor? That's great! Let me know about it and
-I will list it here.
-
-### Tips for editor plugin implementors
-
-It is especially convenient if your code is automatically _formatted on save_.
-For example, surrounding a piece of code with `if ... end` will automatically indent
-the code when you save. Likewise, it will be automatically unindented should you remove it.
-
-For this to work best, the cursor position must be preserved, otherwise it becomes
-pretty annoying if the cursor is reset to the top of the editor.
-
-You should compute a diff between the old content and new content
-and apply the necessary changes. You can check out how this is done in the
-[Sublime Text plugin for Rufo](https://github.com/ruby-formatter/sublime-rufo):
-
-- [diff_match_patch.py](https://github.com/ruby-formatter/sublime-rufo/blob/master/diff_match_patch.py) contains the diff algorithm (you can port it to other languages or try to search for a similar algorithm online)
-- [rufo_format.py](https://github.com/ruby-formatter/sublime-rufo/blob/master/rufo_format.py#L46-L53) consumes the diff result and applies it chunk by chunk in the editor's view
 
 ## Configuration
 
+Rufo supports limited configuration.
 To configure Rufo, place a `.rufo` file in your project. Then when you format a file or a directory,
 Rufo will look for a `.rufo` file in that directory or parent directories and apply the configuration.
 
 The `.rufo` file is a Ruby file that is evaluated in the context of the formatter.
-The available settings are listed [here](https://github.com/ruby-formatter/rufo/wiki/Settings).
+The available settings are listed [here](docs/settings.md).
 
 ## How it works
 

data/docs/developing-rufo.md

@@ -0,0 +1,17 @@
+# Rufo Development
+
+## Tips for editor plugin implementors
+
+It is especially convenient if your code is automatically _formatted on save_.
+For example, surrounding a piece of code with `if ... end` will automatically indent
+the code when you save. Likewise, it will be automatically unindented should you remove it.
+
+For this to work best, the cursor position must be preserved, otherwise it becomes
+pretty annoying if the cursor is reset to the top of the editor.
+
+You should compute a diff between the old content and new content
+and apply the necessary changes. You can check out how this is done in the
+[Sublime Text plugin for Rufo](https://github.com/ruby-formatter/sublime-rufo):
+
+- [diff_match_patch.py](https://github.com/ruby-formatter/sublime-rufo/blob/master/diff_match_patch.py) contains the diff algorithm (you can port it to other languages or try to search for a similar algorithm online)
+- [rufo_format.py](https://github.com/ruby-formatter/sublime-rufo/blob/master/rufo_format.py#L46-L53) consumes the diff result and applies it chunk by chunk in the editor's view

data/docs/releasing-a-gem.md

@@ -0,0 +1,17 @@
+# Releasing a gem
+
+1. Ensure that the tests pass and everything is working!
+
+2. Add missing release notes to `CHANGELOG.md`
+
+3. Bump version in
+  * `lib/rufo/version.rb`
+  * `CHANGELOG.md`
+
+4. Commit version bump via
+  * `git commit -v "Version X.Y.Z"`
+
+5. Release gem to RubyGems via
+  * `rake release`
+
+6. :tada:

data/docs/settings.md

@@ -0,0 +1,219 @@
+# Settings
+
+Rufo supports limited configuration.
+To configure Rufo, place a `.rufo` file in your project.
+Each configuration is a call with one argument. For example:
+
+```ruby
+# .rufo
+trailing_commas false
+parens_in_def :dynamic
+```
+
+## :warning: Settings are going away! :warning:
+
+The settings described below will be removed from future versions of rufo :skull:
+
+See https://github.com/ruby-formatter/rufo/issues/2 for more context!
+
+## Table of contents
+
+- [align_case_when](#align_case_when)
+- [align_chained_calls](#align_chained_calls)
+- [parens_in_def](#parens_in_def)
+- [trailing_commas](#trailing_commas)
+
+### 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.
+
+### parens_in_def
+
+Use parentheses in defs?
+
+- `:yes`: (default) always use parentheses (add them if they are not there)
+- `:dynamic`: don't modify existing methods parentheses choice
+
+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.
+
+### trailing_commas
+
+Use trailing commas in array and hash literals, and keyword arguments?
+
+- `:always`: (default) 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
+)
+```