tailor 1.0.0.alpha2 → 1.0.0

data/lib/tailor/rulers/indentation_spaces_ruler.rb

@@ -6,9 +6,27 @@ require_relative 'indentation_spaces_ruler/indentation_manager'
 class Tailor
   module Rulers
     class IndentationSpacesRuler < Tailor::Ruler
-      def initialize(config)
-        super(config)
+      def initialize(config, options)
+        super(config, options)
+        add_lexer_observers(
+          :comment,
+          :embexpr_beg,
+          :embexpr_end,
+          :ignored_nl,
+          :kw,
+          :lbrace,
+          :lbracket,
+          :lparen,
+          :nl,
+          :rbrace,
+          :rbracket,
+          :rparen,
+          :tstring_beg,
+          :tstring_end
+        )
         @manager = IndentationManager.new(@config)
+        @embexpr_beg = false
+        @tstring_nesting = []
       end
 
       def comment_update(token, lexed_line, file_text, lineno, column)
@@ -32,16 +50,18 @@ class Tailor
       end
 
       def embexpr_beg_update
-        @manager.embexpr_beg = true
+        @embexpr_beg = true
       end
 
+      # Due to a Ripper bug (depending on which Ruby version you have), this may
+      # or may not get triggered.
+      # More info: https://bugs.ruby-lang.org/issues/6211
       def embexpr_end_update
-        @manager.embexpr_beg = false
+        @embexpr_beg = false
       end
 
       def ignored_nl_update(current_lexed_line, lineno, column)
         log "indent reasons on entry: #{@manager.indent_reasons}"
-        stop if @manager.tstring_nesting.size > 0
 
         if current_lexed_line.only_spaces?
           log "Line of only spaces.  Moving on."
@@ -52,13 +72,17 @@ class Tailor
         if @manager.line_ends_with_single_token_indenter?(current_lexed_line)
           log "Line ends with single-token indent token."
 
-          unless @manager.comma_is_part_of_enclosed_statement?(current_lexed_line, lineno)
+          unless @manager.in_an_enclosure? &&
+            current_lexed_line.ends_with_comma?
             log "Line-ending single-token indenter found."
             token_event = current_lexed_line.last_non_line_feed_event
 
             unless @manager.line_ends_with_same_as_last token_event
-              log "Line ends with different type of single-token indenter: #{token_event}"
-              @manager.add_indent_reason(token_event[1], token_event.last, lineno)
+              msg = "Line ends with different type of single-token "
+              msg << "indenter: #{token_event}"
+              log msg
+              @manager.add_indent_reason(token_event[1], token_event.last,
+                lineno)
             end
           end
         end
@@ -73,8 +97,13 @@ class Tailor
       end
 
       def kw_update(token, lexed_line, lineno, column)
+        if lexed_line.keyword_is_symbol?
+          log "Keyword is prefaced by a :, indicating it's really a Symbol."
+          return
+        end
+
         if token == "end"
-          @manager.update_for_closing_reason(:on_kw, lexed_line, lineno)
+          @manager.update_for_closing_reason(:on_kw, lexed_line)
           return
         end
 
@@ -117,8 +146,8 @@ class Tailor
           log "last indent reason type: #{@manager.last_indent_reason_type}"
           log "I think this is a single-token closing line..."
 
-          @manager.update_for_closing_reason(@manager.indent_reasons.last[:event_type],
-            current_lexed_line, lineno)
+          @manager.update_for_closing_reason(@manager.indent_reasons.
+            last[:event_type], current_lexed_line)
         end
 
         @manager.set_up_line_transition
@@ -131,17 +160,37 @@ class Tailor
         @manager.transition_lines
       end
 
+      # Since Ripper parses the } in a #{} as :on_rbrace instead of
+      # :on_embexpr_end, this works around that by using +@embexpr_beg to track
+      # the state of that event.  As such, this should only be called from
+      # #rbrace_update.
+      #
+      # @return [Boolean]
+      def in_embexpr?
+        @embexpr_beg == true
+      end
+
       def rbrace_update(current_lexed_line, lineno, column)
+        if in_embexpr?
+          msg = "Got :rbrace and @embexpr_beg is true. "
+          msg << " Must be at an @embexpr_end."
+          log msg
+          @embexpr_beg = false
+          return
+        end
+
         if @manager.multi_line_braces?(lineno)
           log "End of multi-line braces!"
 
           if current_lexed_line.only_rbrace?
             @manager.amount_to_change_this -= 1
-            log "lonely rbrace.  change_this -= 1 -> #{@manager.amount_to_change_this}"
+            msg = "lonely rbrace.  "
+            msg << "change_this -= 1 -> #{@manager.amount_to_change_this}"
+            log msg
           end
         end
 
-        @manager.update_for_closing_reason(:on_rbrace, current_lexed_line, lineno)
+        @manager.update_for_closing_reason(:on_rbrace, current_lexed_line)
       end
 
       def rbracket_update(current_lexed_line, lineno, column)
@@ -150,11 +199,13 @@ class Tailor
 
           if current_lexed_line.only_rbracket?
             @manager.amount_to_change_this -= 1
-            log "lonely rbracket.  change_this -= 1 -> #{@manager.amount_to_change_this}"
+            msg = "lonely rbracket.  "
+            msg << "change_this -= 1 -> #{@manager.amount_to_change_this}"
+            log msg
           end
         end
 
-        @manager.update_for_closing_reason(:on_rbracket, current_lexed_line, lineno)
+        @manager.update_for_closing_reason(:on_rbracket, current_lexed_line)
       end
 
       def rparen_update(current_lexed_line, lineno, column)
@@ -163,21 +214,36 @@ class Tailor
 
           if current_lexed_line.only_rparen?
             @manager.amount_to_change_this -= 1
-            log "lonely rparen.  change_this -= 1 -> #{@manager.amount_to_change_this}"
+            msg = "lonely rparen.  "
+            msg << "change_this -= 1 -> #{@manager.amount_to_change_this}"
+            log msg
           end
         end
 
-        @manager.update_for_closing_reason(:on_rparen, current_lexed_line, lineno)
+        @manager.update_for_closing_reason(:on_rparen, current_lexed_line)
       end
 
-      def tstring_beg_update(lineno)
-        @manager.tstring_nesting << lineno
+      def tstring_beg_update(lexed_line, lineno)
+        @tstring_nesting << lineno
+        @manager.update_actual_indentation(lexed_line)
+        log "tstring_nesting is now: #{@tstring_nesting}"
         @manager.stop
       end
 
-      def tstring_end_update
-        @manager.tstring_nesting.pop
-        @manager.start unless @manager.in_tstring?
+      def tstring_end_update(current_line)
+        unless @tstring_nesting.empty?
+          tstring_start_line = @tstring_nesting.pop
+
+          if tstring_start_line < current_line
+            measure(tstring_start_line, @manager.actual_indentation)
+          end
+        end
+
+        @manager.start unless in_tstring?
+      end
+
+      def in_tstring?
+        !@tstring_nesting.empty?
       end
 
       # Checks if the line's indentation level is appropriate.
@@ -188,10 +254,11 @@ class Tailor
         log "Measuring..."
 
         if @manager.actual_indentation != @manager.should_be_at
-          @problems << Problem.new(:indentation, lineno, column,
-            { actual_indentation: @manager.actual_indentation,
-              should_be_at: @manager.should_be_at }
-          )
+          msg = "Line is indented to column #{@manager.actual_indentation}, "
+          msg << "but should be at #{@manager.should_be_at}."
+
+          @problems << Problem.new(problem_type, lineno,
+            @manager.actual_indentation, msg, @options[:level])
         end
       end
     end

data/lib/tailor/rulers/indentation_spaces_ruler/indentation_manager.rb

@@ -1,14 +1,30 @@
 require_relative '../../ruler'
 require_relative '../../logger'
-require_relative '../../lexer_constants'
+require_relative '../../lexer/lexer_constants'
 
 class Tailor
   module Rulers
     class IndentationSpacesRuler < Tailor::Ruler
+
+      # Used for managing the state of indentation for some file/text.  An
+      # object of this type has no knowledge of the file/text itself, but rather
+      # just manages indentation expectations based on the object's user's
+      # input, somewhat like a state machine.
+      #
+      # For the sake of talking about indentation expectations, the docs here
+      # make mention of 'levels' of indentation.  A _level_ here is simply
+      # 1 * (number of spaces to indent); so if you've set (number of spaces to
+      # indent) to 2, saying something should be indented 1 level, is simply
+      # saying that it should be indented 2 spaces.
       class IndentationManager
         include Tailor::LexerConstants
         include Tailor::Logger::Mixin
 
+        # These are event names generated by the {Lexer} that signify
+        # indentation level should/could increase by 1.
+        ENCLOSERS = Set.new [:on_lbrace, :on_lbracket, :on_lparen]
+
+        # Look-up table that allows for <tt>OPEN_EVENT_FOR[:on_rbrace]</tt>.
         OPEN_EVENT_FOR = {
           on_kw: :on_kw,
           on_rbrace: :on_lbrace,
@@ -16,25 +32,27 @@ class Tailor
           on_rparen: :on_lparen
         }
 
-        attr_accessor :amount_to_change_next
+        # Allows for updating the indent expectation for the current line.
         attr_accessor :amount_to_change_this
-        attr_accessor :embexpr_beg
 
+        # @return [Fixnum] The actual number of characters the current line is
+        #   indented.
         attr_reader :actual_indentation
+
+        # @return [Array<Hash>] Each element represents a reason why code should
+        #   be indented.  Indent levels are not necessarily 1:1 relationship
+        #   to these reasons (hence the need for this class).
         attr_reader :indent_reasons
-        attr_reader :tstring_nesting
 
+        # @param [Fixnum] spaces The number of spaces each level of indentation
+        #   should move in & out.
         def initialize(spaces)
           @spaces = spaces
-
-          log "Setting @proper[:this_line] to 0."
           @proper = { this_line: 0, next_line: 0 }
           @actual_indentation = 0
-
           @indent_reasons = []
-          @tstring_nesting = []
-
           @amount_to_change_this = 0
+
           start
         end
 
@@ -44,7 +62,7 @@ class Tailor
         end
 
         # Decreases the indentation expectation for the current line by
-        # +@spaces+.
+        # 1 level.
         def decrease_this_line
           if started?
             @proper[:this_line] -= @spaces
@@ -60,10 +78,8 @@ class Tailor
           end
         end
 
-
         # Sets up expectations in +@proper+ based on the number of +/- reasons
-        # to change this and next lines, given in +@amount_to_change_this+ and
-        # +@amount_to_change_next+, respectively.
+        # to change this and next lines, given in +@amount_to_change_this+.
         def set_up_line_transition
           log "Amount to change this line: #{@amount_to_change_this}"
           decrease_this_line if @amount_to_change_this < 0
@@ -133,6 +149,7 @@ class Tailor
           lexed_line.ends_with_op? ||
             lexed_line.ends_with_comma? ||
             lexed_line.ends_with_period? ||
+            lexed_line.ends_with_label? ||
             lexed_line.ends_with_modifier_kw?
         end
 
@@ -148,61 +165,37 @@ class Tailor
           @indent_reasons.last[:event_type] == token_event[1]
         end
 
-        # Checks to see if +lexed_line+ ends with a comma, and if it is in the
-        # middle of an enclosed statement (unclosed braces, brackets, parens).
-        # You don't want to update indentation expectations for this comma if
-        # you've already done so for the start of the enclosed statement.
+        # Determines if the current spot in the file is enclosed in braces,
+        # brackets, or parens.
         #
-        # @param [LexedLine] lexed_line
-        # @param [Fixnum] lineno
         # @return [Boolean]
-        def comma_is_part_of_enclosed_statement?(lexed_line, lineno)
+        def in_an_enclosure?
           return false if @indent_reasons.empty?
 
-          lexed_line.ends_with_comma? &&
-            @indent_reasons.last[:event_type] == :on_lbrace ||
-            @indent_reasons.last[:event_type] == :on_lbracket ||
-            @indent_reasons.last[:event_type] == :on_lparen
-        end
-
-        # Checks if indentation level got increased on this line because of a
-        # keyword and if it got increased on this line because of a
-        # single-token indenter.
-        #
-        # @param [Fixnum] lineno
-        # @return [Boolean]
-        def keyword_and_single_token_line?(lineno)
-          d_tokens = @indent_reasons.find_all { |t| t[:lineno] == lineno }
-          return false if d_tokens.empty?
+          i_reasons = @indent_reasons.dup
+          log "i reasons: #{i_reasons}"
 
-          kw_token = d_tokens.reverse.find do |t|
-            ['{', '[', '('].none? { |e| t[:token] == e }
+          until ENCLOSERS.include? i_reasons.last[:event_type]
+            i_reasons.pop
+            break if i_reasons.empty?
           end
 
-          return false if kw_token.nil?
+          return false if i_reasons.empty?
 
-          s_token = @indent_reasons.reverse.find { |t| t[:lineno] == lineno }
-          return false unless s_token
-
-          true
-        end
-
-        def single_token_start_line
-          return if @indent_reasons.empty?
-
-          @indent_reasons.first[:lineno]
-        end
-
-        def double_token_start_line
-          return if @indent_reasons.empty?
-
-          @indent_reasons.last[:lineno]
-        end
-
-        def double_tokens_in_line(lineno)
-          @indent_reasons.find_all { |t| t[:lineno] == lineno}
+          i_reasons.last[:event_type] == :on_lbrace ||
+            i_reasons.last[:event_type] == :on_lbracket ||
+            i_reasons.last[:event_type] == :on_lparen
         end
 
+        # Adds to the list of reasons to indent the next line, then increases
+        # the expectation for the next line by +@spaces+.
+        #
+        # @param [Symbol] event_type The event type that caused the reason for
+        #   indenting.
+        # @param [Tailor::Token,String] token The token that caused the reason
+        #   for indenting.
+        # @param [Fixnum] lineno The line number the reason for indenting was
+        #   discovered on.
         def add_indent_reason(event_type, token, lineno)
           @indent_reasons << {
             event_type: event_type,
@@ -216,6 +209,14 @@ class Tailor
           @indent_reasons.each { |r| log r.to_s }
         end
 
+        # An "opening reason" is a reason for indenting that also has a "closing
+        # reason", such as a +def+, +{+, +[+, +(+.
+        #
+        # @param [Symbol] event_type The event type that is the opening reason.
+        # @param [Tailor::Token,String] token The token that is the opening
+        #   reasons.
+        # @param [Fixnum] lineno The line number the opening reason was found
+        #   on.
         def update_for_opening_reason(event_type, token, lineno)
           if token.modifier_keyword?
             log "Found modifier in line: '#{token}'"
@@ -232,6 +233,14 @@ class Tailor
           add_indent_reason(event_type, token, lineno)
         end
 
+        # A "continuation reason" is a reason for indenting & outdenting that's
+        # not an opening or closing reason, such as +elsif+, +rescue+, +when+
+        # (in a +case+ statement), etc.
+        #
+        # @param [Symbol] event_type The event type that is the opening reason.
+        # @param [Tailor::LexedLine] lexed_line
+        # @param [Fixnum] lineno The line number the opening reason was found
+        #   on.
         def update_for_continuation_reason(token, lexed_line, lineno)
           d_tokens = @indent_reasons.dup
           d_tokens.pop
@@ -247,22 +256,24 @@ class Tailor
 
           last_reason_line = @indent_reasons.find { |r| r[:lineno] == lineno }
 
-          if last_reason_line.nil?
-            @proper[:next_line] = @indent_reasons.last[:should_be_at] + @spaces
+          @proper[:next_line] = if last_reason_line.nil?
+            if @indent_reasons.empty?
+              @spaces
+            else
+              @indent_reasons.last[:should_be_at] + @spaces
+            end
           else
-            @proper[:next_line] = @indent_reasons.last[:should_be_at] - @spaces
+            @indent_reasons.last[:should_be_at] - @spaces
           end
         end
 
-        def update_for_closing_reason(event_type, lexed_line, lineno)
-          if event_type == :on_rbrace && @embexpr_beg == true
-            msg = "Got :rbrace and @embexpr_beg is true. "
-            msg << " Must be at an @embexpr_end."
-            log msg
-            @embexpr_beg = false
-            return
-          end
-
+        # A "closing reason" is a reason for indenting that also has an "opening
+        # reason", such as a +end+, +}+, +]+, +)+.
+        #
+        # @param [Symbol] event_type The event type that is the closing reason.
+        # @param [Tailor::Token,String] token The token that is the closing
+        #   reason.
+        def update_for_closing_reason(event_type, lexed_line)
           remove_continuation_keywords
           remove_appropriate_reason(event_type)
 
@@ -284,12 +295,14 @@ class Tailor
           end
         end
 
-        def remove_appropriate_reason(event_type)
-          last_opening_event = @indent_reasons.reverse.find do |r|
-            r[:event_type] == OPEN_EVENT_FOR[event_type]
-          end
-
-          if last_opening_event
+        # Removes the last matching opening reason reason of +event_type+ from
+        # the list of indent reasons.
+        #
+        # @param [Symbol] closing_event_type The closing event for which to find
+        #   the matching opening event to remove from the list of indent
+        #   reasons.
+        def remove_appropriate_reason(closing_event_type)
+          if last_opening_event = last_opening_event(closing_event_type)
             r_index = @indent_reasons.reverse.index(last_opening_event)
             index = @indent_reasons.size - r_index - 1
             tmp_reasons = []
@@ -299,30 +312,64 @@ class Tailor
             end
 
             @indent_reasons.replace(tmp_reasons)
+          elsif last_single_token_event
+            log "Just popped off reason: #{@indent_reasons.pop}"
           else
-            @indent_reasons.pop
+            log "Couldn't find a matching opening reason to pop off...'"
+            return
           end
 
           log "Removed indent reason; it's now:"
           @indent_reasons.each { |r| log r.to_s }
         end
 
+        # A "single-token" event is one that that causes indentation
+        # expectations to increase. They don't have have a paired closing
+        # reason like opening reasons.  Instead, they're determined to be done
+        # with their indenting when an :on_ignored_nl occurs.  Single-token
+        # events are operators and commas (commas that aren't used as
+        # separators in {, [, ( events).
+        def last_single_token_event
+          return nil if @indent_reasons.empty?
+
+          @indent_reasons.reverse.find do |r|
+            !ENCLOSERS.include? r[:event_type] &&
+              r[:event_type] != :on_kw
+          end
+        end
+
+
+        # Returns the last matching opening event that corresponds to the
+        # +closing_event_type+.
+        #
+        # @param [Symbol] closing_event_type The closing event for which to
+        #   find its associated opening event.
+        def last_opening_event(closing_event_type)
+          return nil if @indent_reasons.empty?
+
+          @indent_reasons.reverse.find do |r|
+            r[:event_type] == OPEN_EVENT_FOR[closing_event_type]
+          end
+        end
+
         def last_indent_reason_type
           return if @indent_reasons.empty?
 
           @indent_reasons.last[:event_type]
         end
 
+        # Removes all continuation keywords from the list of
+        # indentation reasons.
         def remove_continuation_keywords
           return if @indent_reasons.empty?
 
           while CONTINUATION_KEYWORDS.include?(@indent_reasons.last[:token])
-            @indent_reasons.pop
+            log "Just popped off continuation reason: #{@indent_reasons.pop}"
           end
         end
 
-        # Overriding to be able to call #multi_line_brackets?,
-        # #multi_line_braces?, and #multi_line_parens?, where each takes a
+        # Overriding to be able to call +#multi_line_brackets?+,
+        # +#multi_line_braces?+, and +#multi_line_parens?+, where each takes a
         # single parameter, which is the lineno.
         #
         # @return [Boolean]
@@ -342,6 +389,7 @@ class Tailor
               t[:token] == token
             end
 
+            log "#{meth} called, but no #{$1} were found." if tokens.empty?
             return false if tokens.empty?
 
             token_on_this_line = tokens.find { |t| t[:lineno] == lineno }
@@ -352,10 +400,6 @@ class Tailor
             super(meth, *args, &blk)
           end
         end
-
-        def in_tstring?
-          !@tstring_nesting.empty?
-        end
       end
     end
   end