knife-chop 0.2.6

data/lib/ruby-beautify/lib/ruby-beautify/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/ruby-beautify/lib/ruby-beautify/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/ruby-beautify/lib/ruby-beautify/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/lib/ruby-beautify/lib/ruby-beautify/version.rb

@@ -0,0 +1,3 @@
+module RBeautify
+  VERSION = "0.92.2"
+end

data/lib/ruby-beautify/ruby-beautify.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path('../lib/ruby-beautify/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'ruby-beautify'
+  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"]
+  gem.version       = RBeautify::VERSION
+end

data/lib/ruby-beautify/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