ruby-beautify 0.92.2 → 0.93.0

data/lib/ruby-beautify/block_end.rb

@@ -1,23 +0,0 @@
-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/block_matcher.rb

@@ -1,153 +0,0 @@
-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/block_start.rb

@@ -1,119 +0,0 @@
-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/ruby-beautify/config/ruby.rb

@@ -1,131 +0,0 @@
-# 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/language.rb

@@ -1,37 +0,0 @@
-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