ruby-beautify 0.9.0

data/lib/rbeautify/block_start.rb

@@ -0,0 +1,119 @@
+module RBeautify
+
+  class BlockStart
+
+    attr_reader :block_matcher, :parent, :offset, :match, :after_match, :line_number
+
+    class << self
+      def first_common_ancestor(first, second)
+        if first.nil? || second.nil?
+          nil
+        else
+          (first.ancestors & second.ancestors).last
+        end
+      end
+    end
+
+    def initialize(block_matcher, parent, line_number, offset, match, after_match)
+      @block_matcher = block_matcher
+      @parent = parent
+      @offset = offset
+      @match = match
+      @after_match = after_match
+      @line_number = line_number
+    end
+
+    def end_offset
+      offset + match.length
+    end
+
+    def parse_block_end(string, offset)
+      block_end = parse_explicit_block_end(string, offset)
+
+      # Handle case where end is implicit
+      if block_end.nil? && end_is_implicit? && parent
+        block_end = parent.parse_block_end(string, offset)
+      end
+
+      block_end
+    end
+
+    def format_content?
+      block_matcher.format_content?
+    end
+
+    def parse_content?
+      block_matcher.parse_content?
+    end
+
+    def indent_end_line?
+      block_matcher.indent_end_line?(self)
+    end
+
+    def total_indent_size
+      parent.nil? ? indent_size : parent.total_indent_size + indent_size
+    end
+
+    def indent_size
+      block_matcher.indent_size(self)
+    end
+
+    def end_is_implicit?
+      block_matcher.end_is_implicit?
+    end
+
+    def name
+      block_matcher.name
+    end
+
+    # Returns true if strict ancestor of
+    def strict_ancestor_of?(block_start)
+      block_start && block_start.parent && (self == block_start.parent || strict_ancestor_of?(block_start.parent))
+    end
+
+    def ancestors
+      if parent
+        parent.ancestors + [self]
+      else
+        [self]
+      end
+    end
+
+    private
+      def ends?
+        block_matcher.ends?
+      end
+
+      def negate_ends_match?
+        block_matcher.negate_ends_match?
+      end
+
+      def escape_character?
+        block_matcher.escape_character?
+      end
+
+      def parse_explicit_block_end(string, offset)
+        block_end = nil
+
+        if ends?
+
+          if match = block_matcher.ends.match(string)
+            unless negate_ends_match?
+              if escape_character? &&
+                  ((escape_chars = match.pre_match.match(/\\*$/)) && (escape_chars[0].size % 2 == 1))
+                # If there are an odd number of escape characters just before
+                # the match then this match should be skipped
+                return parse_explicit_block_end(match.post_match, offset + escape_chars[0].size + match[0].length)
+              else
+                return RBeautify::BlockEnd.new(self, offset + match.begin(0), match[0], match.post_match)
+              end
+            end
+          elsif negate_ends_match?
+            return RBeautify::BlockEnd.new(self, offset, '', string)
+          end
+
+        end
+      end
+
+  end
+end

data/lib/rbeautify/config/ruby.rb

@@ -0,0 +1,131 @@
+# define ruby language
+
+unless RBeautify::Language.language(:ruby)
+
+  ruby = RBeautify::Language.add_language(:ruby)
+
+  pre_keyword_boundary = '(^|[^a-z0-9A-Z:._])' # like \b but with : , . _ all added to list of exceptions
+  start_statement_boundary = '(^|(;|=)\s*)'
+  continue_statement_boundary = '(^|;\s*)'
+  ruby.indent_size = 2
+
+  ruby.add_matcher(:program_end, /^__END__$/, false, :format_content => false, :parse_content => false)
+
+  ruby.add_matcher(:multiline_comment, /^=begin/, /^=end/, :format_content => false, :parse_content => false)
+
+  ruby.add_matcher(:double_quote,
+                   /"/,
+                   /"/,
+                   :parse_content => true,
+                   :format_content => false,
+                   :escape_character => true,
+                   :nest_except => [:double_quote, :single_quote, :regex, :back_tick])
+
+  # NEED TO MODIFY DOUBLE QUOTE TO BE FORMATTED to get this to work
+  ruby.add_matcher(:interpolation,
+                   /#\{/,
+                   /\}/,
+                   :nest_only => [:double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:single_quote,
+                   /'/,
+                   /'/,
+                   :parse_content => false,
+                   :format_content => false,
+                   :escape_character => true,
+                   :nest_except => [:double_quote, :single_quote, :regex, :back_tick])
+
+  ruby.add_matcher(:regex,
+                   /(^|((,|=|~)\s*))\//, # Try to distinguish it from division sign
+                   /\//,
+                   :format_content => false,
+                   :escape_character => true,
+                   :end_can_also_be_start => false,
+                   :nest_except => [:double_quote, :single_quote, :regex, :back_tick])
+
+  ruby.add_matcher(:back_tick,
+                   /`/,
+                   /`/,
+                   :format_content => false,
+                   :escape_character => true,
+                   :nest_except => [:double_quote, :single_quote, :regex, :back_tick])
+
+  ruby.add_matcher(:standard,
+                   /((#{start_statement_boundary}(module|class|def))|#{pre_keyword_boundary}do)\b/,
+                   /(((^|;|\s)end)|#{continue_statement_boundary}(rescue|ensure))\b/,
+                   :nest_except => [:double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:more,
+                   /#{start_statement_boundary}(until|for|while)\b/,
+                   /(((^|;|\s)end)|#{continue_statement_boundary}(rescue|ensure))\b/,
+                   :nest_except => [:double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:begin,
+                   /((#{start_statement_boundary}begin)|(#{continue_statement_boundary}(ensure|rescue)))\b/,
+                   /(((^|;|\s)end)|#{continue_statement_boundary}(rescue|ensure|else))\b/,
+                   :nest_except => [:double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:if,
+                   /((#{start_statement_boundary}(if|unless))|#{continue_statement_boundary}(then|elsif|else))\b/,
+                   /(((^|;|\s)end)|(#{continue_statement_boundary}(then|elsif|else)))\b/,
+                   :nest_except => [:case, :double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:case,
+                   /#{pre_keyword_boundary}case\b/,
+                   /(^|;|\s)end\b/,
+                   :nest_except => [:double_quote, :regex, :backtick],
+                   :indent_size => 0)
+
+  ruby.add_matcher(:inner_case,
+                   /#{continue_statement_boundary}(when|else|then)\b/,
+                   /#{continue_statement_boundary}(when|else|then)\b/,
+                   :nest_only => [:case],
+                   :end => :implicit,
+                   :end_can_also_be_start => true,
+                   :nest_except => [:double_quote, :regex, :backtick])
+
+  # TODO: Improve the check that this is not a block with arguments. Will
+  # currently match any bracket followed by spaces and |.
+  bracket_indent_end_line_proc = Proc.new { |block| !block.after_match.empty? && !block.after_match.match(/^\|/) }
+  bracket_indent_size_proc = Proc.new do |block|
+    if bracket_indent_end_line_proc.call(block)
+      strict_ancestors_on_same_line = block.ancestors.select { |a| a != block && a.line_number == block.line_number }
+      block.end_offset - strict_ancestors_on_same_line.inject(0) { |sum, a| sum + a.indent_size }
+    end
+  end
+
+  ruby.add_matcher(:curly_bracket,
+                   /\{\s*/,
+                   /\}/,
+                   :indent_end_line => bracket_indent_end_line_proc,
+                   :indent_size => bracket_indent_size_proc,
+                   :nest_except => [:double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:round_bracket,
+                   /\(\s*/,
+                   /\)/,
+                   :indent_end_line => bracket_indent_end_line_proc,
+                   :indent_size => bracket_indent_size_proc,
+                   :nest_except => [:double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:square_bracket,
+                   /\[\s*/,
+                   /\]/,
+                   :indent_end_line => bracket_indent_end_line_proc,
+                   :indent_size => bracket_indent_size_proc,
+                   :nest_except => [:double_quote, :regex, :backtick])
+
+  ruby.add_matcher(:comment, /(\s*)?#/,
+                   /$/,
+                   :parse_content => false,
+                   :format_content => false,
+                   :nest_except => [:double_quote, :single_quote, :regex, :back_tick])
+
+  ruby.add_matcher(:continuing_line,
+                   /(,|\.|\+|-|=\>|=|&&|\|\||\\|==|\s\?|:|<<)(\s*)?(#.*)?$/,
+                   /(^|(,|\.|\+|-|=\>|=|&&|\|\||\\|==|\s\?|:|<<)(\s*)?)(#.*)?$/,
+                   :indent_end_line => true,
+                   :negate_ends_match => true,
+                   :nest_except => [:continuing_line, :curly_bracket, :round_bracket, :square_bracket, :double_quote, :single_quote, :regex, :back_tick])
+
+end

data/lib/rbeautify/language.rb

@@ -0,0 +1,37 @@
+module RBeautify
+  class Language
+
+    @@languages = {}
+
+    attr_reader :matchers
+    attr_accessor :indent_size
+
+    class << self
+
+      def language(name)
+        languages[name]
+      end
+
+      def languages
+        @@languages
+      end
+
+      def add_language(name)
+        languages[name] = new()
+      end
+    end
+
+    def initialize
+      @matchers = []
+    end
+
+    def add_matcher(name, starts, ends, options = {})
+      self.matchers << BlockMatcher.new(self, name, starts, ends, options)
+    end
+
+    def matcher(name)
+      self.matchers.detect { |matcher| matcher.name == name}
+    end
+
+  end
+end

data/lib/rbeautify/line.rb

@@ -0,0 +1,53 @@
+module RBeautify
+  class Line
+
+    attr_reader :language, :content, :line_number, :original_block, :block, :indent_character
+
+    def initialize(language, content, line_number, original_block = nil, use_tabs = false)
+      @language = language
+      @content = content
+      @original_block = original_block
+      @indent_character = use_tabs ? "\t" : "  "
+      @block = BlockMatcher.parse(language, original_block, line_number, stripped, 0)
+    end
+
+    def format
+      if @formatted.nil?
+        if format?
+          if stripped.length == 0
+            @formatted = ""
+          else
+            @formatted = tab_string + stripped
+          end
+        else
+          @formatted = content
+        end
+      end
+
+      @formatted
+    end
+
+    private
+    def format?
+      original_block.nil? || original_block.format_content?
+    end
+
+    def indent_size
+      if (block.nil? || block.strict_ancestor_of?(original_block)) && (original_block && original_block.indent_end_line?)
+        original_block.total_indent_size
+      else
+        common_ancestor = BlockStart.first_common_ancestor(original_block, block)
+        common_ancestor.nil? ? 0 : common_ancestor.total_indent_size
+      end
+    end
+
+    def tab_string
+      indent_character * (indent_size / 2 ) + (indent_size.odd? ? ' ' : '')
+    end
+
+    def stripped
+      @stripped = content.strip
+    end
+
+  end
+end

data/license.txt

@@ -0,0 +1,77 @@
+ All software in this package is covered by the MIT license and beerware (rev42).
+
+   Copyright (c) 2011 Ernie Brodeur
+
+   Permission is hereby granted, free of charge, to any person
+   obtaining a copy of this software and associated documentation
+   files (the "Software"), to deal in the Software without
+   restriction, including without limitation the rights to use,
+   copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following
+   conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+   OTHER DEALINGS IN THE SOFTWARE.
+
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * Ernie Brodeur wrote this package. As long as you retain this notice you
+ * can do whatever you want with his stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.
+ * ----------------------------------------------------------------------------
+ */
+
+Further supported by: https://github.com/CraigWilliams/BeautifyRuby/blob/master/lib/rbeautify.rb
+
+All of BeautifyRuby is licensed under the MIT license.
+
+Copyright (c) 2011 Craig Williams <cwilliams.allancraig@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Pieces provided originally by: http://www.arachnoid.com/ruby/rubyBeautifier.html
+
+/***************************************************************************
+ *   Copyright (C) 2008, Joel Chippindale, Paul Lutus                      *
+ *                                                                         *
+ *   This program is free software: you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation, either version 3 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *                                                                         *
+ ***************************************************************************/

data/rbeautify.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |gem|
+  gem.name        = 'ruby-beautify'
+  gem.version     = '0.9.0'
+  gem.summary     = "a cli tool (and module) to beautify ruby code."
+  gem.description = gem.summary
+  gem.authors     = ["Ernie Brodeur", "Craig Williams", "Joel Chippindale", "Paul Lutus"]
+  gem.email       = 'ebrodeur@ujami.net'
+  gem.homepage    = "https://github.com/erniebrodeur/ruby-beautify"
+
+  gem.add_development_dependency "rspec"
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+end

data/spec/fixtures/ruby.yml

@@ -0,0 +1,408 @@
+- name: indent if else end statement
+  input: |
+    if foo
+    bar = 1
+    elsif foo2
+    bar = 2
+    else
+    bar = 3
+    end
+  output: |
+    if foo
+      bar = 1
+    elsif foo2
+      bar = 2
+    else
+      bar = 3
+    end
+
+- name: handle case where if begins and ends on same line
+  input: |
+    foo do
+    if a then b = 1 else b = 2 end
+    end
+  output: |
+    foo do
+      if a then b = 1 else b = 2 end
+    end
+
+- name: indent not double indent case/when statement
+  input: |
+    case foo
+    when 1
+    bar = 'some string'
+    when 2
+    bar = 'some other string'
+    when 3 then bar = '3'
+    else
+    bar = '4'
+    end
+  output: |
+    case foo
+    when 1
+      bar = 'some string'
+    when 2
+      bar = 'some other string'
+    when 3 then bar = '3'
+    else
+      bar = '4'
+    end
+
+- name: indent while statement
+  input: |
+    def foo
+    bar = 1
+    while bar < 3
+    puts bar
+    bar = bar.next
+    end
+    end
+  output: |
+    def foo
+      bar = 1
+      while bar < 3
+        puts bar
+        bar = bar.next
+      end
+    end
+
+- name: ignore code after end of line comment
+  input: |
+    def method_containing_end_of_line_comment
+    a = b # Comment containing do
+    end
+  output: |
+    def method_containing_end_of_line_comment
+      a = b # Comment containing do
+    end
+
+- name :not indent multineline comment:
+  input: |
+    =begin
+    Comment
+    =end
+    foo
+
+- name: indent lines after first of multiline code
+  input: |
+    def method_with_multiline_method_call
+    multiline_method_call \
+    first_arg,
+    second_arg,
+    third_arg
+    end
+  output: |
+    def method_with_multiline_method_call
+      multiline_method_call \
+        first_arg,
+        second_arg,
+        third_arg
+    end
+
+- name: indent method call with bracketed multiline arguments
+  input: |
+    def method_with_multiline_method_call
+    multiline_method_call(foo,
+    bar,
+    foobar)
+    end
+  output: |
+    def method_with_multiline_method_call
+      multiline_method_call(foo,
+                            bar,
+                            foobar)
+    end
+
+- name: indent method call with bracketed multiline arguments_even_if_not_first_block_on_line
+  input: |
+    if (foo = bar(first_arg,
+    second_arg))
+    do_something
+    end
+  output: |
+    if (foo = bar(first_arg,
+                  second_arg))
+      do_something
+    end
+
+- name: indent method call with multiline arguments (implicit brackets)
+  input: |
+    def method_with_multiline_method_call
+    multiline_method_call first_arg,
+    second_arg,
+    # Comment in the middle of all this
+    third_arg
+    
+    another_method_call
+    end
+  output: |
+    def method_with_multiline_method_call
+      multiline_method_call first_arg,
+        second_arg,
+        # Comment in the middle of all this
+        third_arg
+    
+      another_method_call
+    end
+
+- name: should indent multiline method call chains
+  input: |
+    def method_with_multiline_method_call_chain
+    multiline_method_call.
+    foo.
+    bar
+    
+    another_method_call
+    end
+  output: |
+    def method_with_multiline_method_call_chain
+      multiline_method_call.
+        foo.
+        bar
+    
+      another_method_call
+    end
+
+- name: handle multiline code with escaped quotes in strings
+  input: |
+    def method_containing_multiline_code_with_strings
+    a = "foo #{method}" +
+    "bar"
+    end
+  output: |
+    def method_containing_multiline_code_with_strings
+      a = "foo #{method}" +
+        "bar"
+    end
+
+- name: not change the indentation of multiline strings
+  input: |
+    def method_containing_long_string
+    a = "
+          Some text across multiple lines
+          And another line
+          "
+    b = 5
+    end
+  output: |
+    def method_containing_long_string
+      a = "
+          Some text across multiple lines
+          And another line
+          "
+      b = 5
+    end
+
+- name: not treat divison as start of regex
+  input: |
+    def foo
+    a = 1/2
+    b = :foo
+    end
+  output: |
+    def foo
+      a = 1/2
+      b = :foo
+    end
+
+- name: not indent multiline string even if it uses non quote delimiter
+  pending: implementation of block matcher for non quote delimited strings
+  input: |
+    foo = <<TEXT
+          some string
+          and more string
+    TEXT
+
+- name: recognize when two blocks end on the same line
+  input: |
+    class Foo
+    def foobar
+    if a = 3
+    return 5
+    end; end
+    end
+  output: |
+    class Foo
+      def foobar
+        if a = 3
+          return 5
+      end; end
+    end
+
+- name: indent multiline array definition
+  input: |
+    class Foo
+    @@bar = [1, 2,
+    3, 4]
+    end
+  output: |
+    class Foo
+      @@bar = [1, 2,
+               3, 4]
+    end
+
+- name: indent multiline array definition (all on separate lines)
+  input: |
+    class Foo
+    @@bar = [
+    1,
+    2,
+    3,
+    4
+    ]
+    end
+  output: |
+    class Foo
+      @@bar = [
+        1,
+        2,
+        3,
+        4
+      ]
+    end
+
+- name: indent multiline hash definition
+  input: |
+    class Foo
+    @@bar = { :foo => 1, :bar => 2
+    :c => 3, :d => 4 }
+    end
+  output: |
+    class Foo
+      @@bar = { :foo => 1, :bar => 2
+                :c => 3, :d => 4 }
+    end
+
+- name: indent multiline block delimited with curly brackets
+  input: |
+    foo = bar.collect { |paragraph|
+    paragraph.strip
+    }.join("\n")
+  output: |
+    foo = bar.collect { |paragraph|
+      paragraph.strip
+    }.join("\n")
+
+- name: indent method call with bracketed multiline arguments including continuing statements
+  pending: Implementation of support for continuing statements in bracketed multline arguments
+  input: |
+    def foo
+    bar(first_arg,
+    second_part_a +
+    second_part_b,
+    third_arg)
+    end
+  output: |
+    def foo
+      bar(first_arg,
+          second_part_a +
+            second_part_b,
+          third_arg)
+    end
+
+- name: indent continuing lines ending in = and +
+  input: |
+    def foo
+    @bar ||=
+    1 +
+    2
+    end
+  output: |
+    def foo
+      @bar ||=
+        1 +
+        2
+    end
+
+- name: indent block within implicit brackets
+  pending: Implementation of support for this feature
+  input: |
+    def foo
+    bar first_arg,
+    second_arg,
+    [
+    1,
+    2,
+    3
+    ],
+    last_arg
+    end
+  output: |
+    def foo
+      bar first_arg,
+        second_arg,
+        [
+          1,
+          2,
+          3
+        ],
+        last_arg
+    end
+
+- name: "should not treat ':', '_' or '.' as word boundaries before keywords"
+  input: |
+    case params[:do]
+    when "update_if"
+    update_if.if
+    when "update_do"
+    update_do.do
+    end
+  output: |
+    case params[:do]
+    when "update_if"
+      update_if.if
+    when "update_do"
+      update_do.do
+    end
+
+- name: should recognize interpolation and not match other content within double quotes
+  input: |
+    def foo
+     return "Foo#{" (#{bar})"}"
+    end
+  output: |
+    def foo
+      return "Foo#{" (#{bar})"}"
+    end
+
+- name: should not non interpolated content within regexes and strings and backticks
+  input: |
+    def foo
+    @foo = [
+    /" if bar/,
+    `ls if`,
+    "if fun =",
+    'else'
+    ]
+    end
+  output: |
+    def foo
+      @foo = [
+        /" if bar/,
+        `ls if`,
+        "if fun =",
+        'else'
+      ]
+    end
+
+- name: should handle one liners that include an end statement correctly
+  input: |
+    def foo; puts 'foo' end
+    def bar; puts 'bar' end
+  output: |
+    def foo; puts 'foo' end
+    def bar; puts 'bar' end
+
+- name: should handle if and unless statements that are terminated implicitly
+  input: |
+    def foo
+    bar = (1 + 2) if foobar
+    baz unless foobaz
+    Boo.new(:boo) rescue raise('Houston we have a problem')
+    end
+  output: |
+    def foo
+      bar = (1 + 2) if foobar
+      baz unless foobaz
+      Boo.new(:boo) rescue raise('Houston we have a problem')
+    end