knife-chop 0.2.6

data/lib/ruby-beautify/bin/rbeautify

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby
+require 'ruby-beautify'
+require 'optparse'
+
+include RBeautify
+
+Options = OptionParser.new do |opts|
+  opts.on("-V", "--version", "Print version") { |version| puts RBeautify::VERSION;exit 0}
+  opts.banner = "Usage: print ruby into a pretty format, or break trying."
+end
+Options.parse!
+
+if ARGV.empty?
+  begin
+    puts RBeautify.beautify_string :ruby, STDIN
+  rescue Exception => e
+    puts e.message
+    exit
+  end
+else
+  ARGV.each do |f|
+    if File.exist? f
+      puts RBeautify.beautify_string :ruby, open(f).read
+    else
+      puts "No such file: #{f}"
+    end
+  end
+end

data/lib/ruby-beautify/lib/beautifier.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+# Ruby beautifier, version 2.1, 09/11/2006
+# Copyright (c) 2006, P. Lutus
+# Released under the GPL
+
+# Changes
+# Craig Williams
+# 12/26/2011
+# Modified (very minor) to work with a Sublime Text 2 plugin
+
+# indent regexp tests
+
+@indentExp = [
+  /^module\b/,
+  /^if\b/,
+  /^\@{0,2}[\w\.]*[\s\t]*\=[\s\t]*if\b/,
+  /(=\s*|^)until\b/,
+  /(=\s*|^)for\b/,
+  /^unless\b/,
+  /^\@{0,2}[\w\.]*[\s\t]*\=[\s\t]*unless\b/,
+  /(=\s*|^)while\b/,
+  /(=\s*|^)begin\b/,
+  /(^| )case\b/,
+  /\bthen\b/,
+  /^class\b/,
+  /^rescue\b/,
+  /^def\b/,
+  /\bdo\b/,
+  /^else\b/,
+  /^elsif\b/,
+  /^ensure\b/,
+  /\bwhen\b/,
+  /\{[^\}]*$/,
+  /\[[^\]]*$/,
+  /\([^\)]*$/
+]
+
+# outdent regexp tests
+
+@outdentExp = [
+  /^rescue\b/,
+  /^ensure\b/,
+  /^elsif\b/,
+  /^end\b/,
+  /^else\b/,
+  /\bwhen\b/,
+  /^[^\{]*\}/,
+  /^[^\[]*\]/,
+  /^[^\(]*\)/
+]
+
+def makeTab(tab)
+  (tab < 0) ? "" : @tabStr * @tabSize * tab
+end
+
+def addLine(line,tab)
+  line.strip!
+  line = makeTab(tab)+line if line.length > 0
+  line + "\n"
+end
+
+def beautifyRuby(contents)
+  commentBlock = false
+  programEnd = false
+  multiLineArray = Array.new
+  multiLineStr = ""
+  tab = 0
+  source = contents
+  dest = ""
+  source.split("\n").each do |line|
+    if(!programEnd)
+      # detect program end mark
+      if(line =~ /^__END__$/)
+        programEnd = true
+      else
+        # combine continuing lines
+        if(!(line =~ /^\s*#/) && line =~ /[^\\]\\\s*$/)
+          multiLineArray.push line
+          multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
+          next
+        end
+
+        # add final line
+        if(multiLineStr.length > 0)
+          multiLineArray.push line
+          multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
+        end
+
+        tline = ((multiLineStr.length > 0)?multiLineStr:line).strip
+        if(tline =~ /^=begin/)
+          commentBlock = true
+        end
+      end
+    end
+    if(commentBlock || programEnd)
+      # add the line unchanged
+      dest += line + "\n"
+    else
+      commentLine = (tline =~ /^#/)
+      if(!commentLine)
+        # throw out sequences that will
+        # only sow confusion
+        while tline.gsub!(/'.*?'/,"")
+        end
+        while tline.gsub!(/".*?"/,"")
+        end
+        while tline.gsub!(/\`.*?\`/,"")
+        end
+        while tline.gsub!(/\{[^\{]*?\}/,"")
+        end
+        while tline.gsub!(/\([^\(]*?\)/,"")
+        end
+        while tline.gsub!(/\/.*?\//,"")
+        end
+        while tline.gsub!(/%r(.).*?\1/,"")
+        end
+        tline.gsub!(/\\\"/,"'")
+        @outdentExp.each do |re|
+          if(tline =~ re)
+            tab -= 1
+            break
+          end
+        end
+      end
+      if (multiLineArray.length > 0)
+        multiLineArray.each do |ml|
+          dest += addLine(ml,tab)
+        end
+        multiLineArray.clear
+        multiLineStr = ""
+      else
+        dest += addLine(line,tab)
+      end
+      if(!commentLine)
+        @indentExp.each do |re|
+          if(tline =~ re && !(tline =~ /\s+end\s*$/))
+            tab += 1
+            break
+          end
+        end
+      end
+    end
+    if(tline =~ /^=end/)
+      commentBlock = false
+    end
+  end
+  STDOUT.write(dest)
+  # uncomment this to complain about mismatched blocks
+  # if(tab != 0)
+  #   STDERR.puts "#{path}: Indentation error: #{tab}"
+  # end
+end
+
+tab_or_space = ARGV.first
+path         = ARGV.last
+path.gsub!("\\", "/") if RUBY_PLATFORM =~ /mswin/
+contents     = IO.read(path)
+
+if tab_or_space == 'space'
+  @tabSize = 2
+  @tabStr = " "
+else
+  @tabSize = 1
+  @tabStr = "\t"
+end
+
+beautifyRuby(contents)

data/lib/ruby-beautify/lib/ruby-beautify.rb

@@ -0,0 +1,26 @@
+require "ruby-beautify/version"
+require 'ruby-beautify/block_start'
+require 'ruby-beautify/block_end'
+require 'ruby-beautify/block_matcher'
+require 'ruby-beautify/language'
+require 'ruby-beautify/line'
+require 'ruby-beautify/config/ruby'
+
+module RBeautify
+  def self.beautify_string(language, source, use_tabs=false)
+    dest = ""
+    block = nil
+
+    unless language.is_a? RBeautify::Language
+      language = RBeautify::Language.language(language)
+    end
+
+    source.lines.each_with_index do |line_content, line_number|
+      line = RBeautify::Line.new(language, line_content, line_number, block, use_tabs)
+      dest += line.format + "\n"
+      block = line.block
+    end
+
+    return dest
+  end
+end # module RBeautify

data/lib/ruby-beautify/lib/ruby-beautify/block_end.rb

@@ -0,0 +1,23 @@
+module RBeautify
+
+  class BlockEnd
+
+    attr_accessor :block_start, :offset, :match, :after_match
+
+    def initialize(block_start, offset, match, after_match)
+      self.block_start = block_start
+      self.offset = offset
+      self.match = match
+      self.after_match = after_match
+    end
+
+    def end_offset
+      offset + match.length
+    end
+
+    def end_can_also_be_start?
+      block_start.block_matcher.end_can_also_be_start?
+    end
+  end
+
+end

data/lib/ruby-beautify/lib/ruby-beautify/block_matcher.rb

@@ -0,0 +1,153 @@
+module RBeautify
+
+  class BlockMatcher
+
+    attr_reader :language, :name, :starts, :ends, :options
+
+    def initialize(language, name, starts, ends, options = {})
+      @language = language
+      @name = name
+      @starts = starts
+      @ends = ends.nil? ? starts : ends
+      @options = options
+    end
+
+    class << self
+      def parse(language, original_block, line_number, string, current_offset)
+        block_end = original_block && original_block.parse_block_end(string, current_offset)
+
+        if (block_start = first_block_start(language,
+                                            original_block,
+                                            line_number,
+                                            string,
+                                            current_offset,
+                                            block_end.nil? ? nil : block_end.offset))
+
+          block_end = nil
+        end
+
+        if block_end
+          # Check whether the section of the line which is a block end is also a block start
+          if block_end.end_can_also_be_start? &&
+              (block_start_candidate = first_block_start(language, block_end.block_start.parent, line_number, string, current_offset)) &&
+              block_start_candidate.offset == block_end.offset
+            block_start = block_start_candidate
+          end
+
+        end
+
+        if block_start
+          if debug
+            puts "MATCH: '#{string.slice(0, string.length - block_start.match.length - block_start.after_match.length)}<START type=#{block_start.name}>#{block_start.match}</START>#{block_start.after_match}'"
+          end
+          parse(language, block_start, line_number, block_start.after_match, block_start.end_offset)
+        elsif block_end
+          if debug
+            puts "MATCH: '#{string.slice(0, string.length - block_end.match.length - block_end.after_match.length)}<END>#{block_end.match}</END>#{block_end.after_match}'"
+          end
+          parse(language, block_end.block_start.parent, line_number, block_end.after_match, block_end.end_offset)
+        else
+          original_block
+        end
+      end
+
+      def debug=(value)
+        @debug = value
+      end
+
+      def debug
+        @debug
+      end
+
+      private
+        def first_block_start(language, parent_block, line_number, string, offset, maximum_offset = nil)
+          first_block_start = nil
+          language.matchers.each do |matcher|
+            if matcher.can_nest?(parent_block)
+              if (block_start_candidate = matcher.parse_block_start(string, parent_block, offset, line_number)) &&
+                  (maximum_offset.nil? || maximum_offset > block_start_candidate.offset)
+                first_block_start = block_start_candidate
+                maximum_offset = first_block_start.offset
+              end
+            end
+          end
+          first_block_start
+        end
+    end
+
+    def parse_block_start(string, parent_block, offset, line_number)
+      if !string.empty? && (match = starts.match(string))
+        RBeautify::BlockStart.new(self, parent_block, line_number, offset + match.begin(0), match[0], match.post_match)
+      end
+    end
+
+    def indent_end_line?(block)
+      evaluate_option_for_block(:indent_end_line, block)
+    end
+
+    def indent_size(block)
+      evaluate_option_for_block(:indent_size, block) || language.indent_size
+    end
+
+    # Look for blocks within the content of this one
+    def parse_content?
+      options[:parse_content] != false
+    end
+
+    # Indent the content of this block
+    def format_content?
+      options[:format_content] != false
+    end
+
+    def can_nest?(parent_block)
+      return false unless parent_block.nil? || parent_block.parse_content?
+
+      if options[:nest_only]
+        parent_block && options[:nest_only].include?(parent_block.name)
+      else
+        parent_block.nil? ||
+          options[:nest_except].nil? || !options[:nest_except].include?(parent_block.name)
+      end
+    end
+
+    def ends?
+      ends != false
+    end
+
+    def end_is_implicit?
+      options[:end] == :implicit
+    end
+
+    def end_can_also_be_start?
+      if ends == starts
+        options[:end_can_also_be_start] == true
+      else
+        options[:end_can_also_be_start] != false
+      end
+    end
+
+    def negate_ends_match?
+      options[:negate_ends_match]
+    end
+
+    # True if blocks can contain the escape character \ which needs to be
+    # checked for on end match
+    def escape_character?
+      options[:escape_character] == true
+    end
+
+    def inspect
+      name
+    end
+
+    private
+      def evaluate_option_for_block(key, block)
+        if options[key] && options[key].respond_to?(:call)
+          options[key].call(block)
+        else
+          options[key]
+        end
+      end
+
+  end
+end

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