tailor 1.3.1 → 1.4.0

data/lib/tailor/ruler.rb

@@ -40,7 +40,6 @@ class Tailor
     include Tailor::Logger::Mixin
 
     attr_reader :lexer_observers
-    attr_reader :level
 
     # @param [Object] config
     # @param [Hash] options

data/lib/tailor/rulers/allow_camel_case_methods_ruler.rb

@@ -9,7 +9,6 @@ class Tailor
       end
 
       def ident_update(token, lexed_line, lineno, column)
-        ident_index = lexed_line.event_index(column)
         find_event = lexed_line.find { |e| e[1] == :on_kw && e.last == 'def' }
 
         if find_event && find_event.any?

data/lib/tailor/rulers/allow_conditional_parentheses.rb

@@ -0,0 +1,65 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+    class AllowConditionalParenthesesRuler < Tailor::Ruler
+      def initialize(style, options)
+        super(style, options)
+        add_lexer_observers :nl
+      end
+
+      def nl_update(current_lexed_line, lineno, _)
+        measure(current_lexed_line, lineno)
+      end
+
+      # Checks to see if a conditional is unnecessarily wrapped in parentheses.
+      #
+      # @param [Fixnum] line The current lexed line.
+      # @param [Fixnum] lineno Line the problem was found on.
+      def measure(line, lineno)
+        return if @config
+        return unless line.any? { |t| conditional?(t) }
+        if tokens_before_lparen?(line) and ! tokens_after_rparen?(line)
+          column = lparen_column(line)
+          @problems << Problem.new('conditional_parentheses', lineno, column,
+            "Parentheses around conditional expression at column #{column}.",
+            @options[:level])
+        end
+      end
+
+      private
+
+      def conditional?(token)
+        token[1] == :on_kw and %w{case if unless while}.include?(token[2])
+      end
+
+      def lparen?(token)
+        token[1] == :on_lparen
+      end
+
+      def lparen_column(tokens)
+        tokens.find { |t| lparen?(t) }[0][1] + 1
+      end
+
+      def tokens_before_lparen?(tokens)
+        without_spaces(
+          tokens.select do |t|
+            true if (conditional?(t))..(lparen?(t))
+          end.tap { |t| t.shift; t.pop }
+        ).empty?
+      end
+
+      def tokens_after_rparen?(tokens)
+        without_spaces(
+          tokens.reverse.tap do |nl|
+            nl.shift
+          end.take_while { |t| t[1] != :on_rparen }
+        ).any?
+      end
+
+      def without_spaces(tokens)
+        tokens.reject { |t| t[1] == :on_sp }
+      end
+    end
+  end
+end

data/lib/tailor/rulers/allow_unnecessary_double_quotes_ruler.rb

@@ -0,0 +1,61 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+    class AllowUnnecessaryDoubleQuotesRuler < Tailor::Ruler
+      def initialize(config, options)
+        super(config, options)
+        add_lexer_observers :nl
+      end
+
+      def nl_update(lexed_line, lineno, _)
+        quotes(lexed_line).each do |quote|
+          unless contains_embedded_expression?(quote) ||
+            contains_escape_sequence?(quote)
+            measure(lineno, column(quote.first))
+          end
+        end
+      end
+
+      # Checks to see if the double_quotes are unnecessary.
+      #
+      # @param [Fixnum] lineno Line the problem was found on.
+      # @param [Fixnum] column Column the problem was found on.
+      def measure(lineno, column)
+        @problems << Problem.new('unnecessary_double_quotes', lineno, column,
+          "Unnecessary double quotes at column #{column}, " +
+            'expected single quotes.', @options[:level])
+      end
+
+      private
+
+      def contains_embedded_expression?(tokens)
+        tokens.any? { |t| t[1] == :on_embexpr_beg }
+      end
+
+      def contains_escape_sequence?(tokens)
+        tokens.any? do |t|
+          t[1] == :on_tstring_content and t[2].match(/\\[a-z]+/)
+        end
+      end
+
+      def quotes(tokens)
+        tokens.select do |t|
+          true if (double_quote_start?(t))..(double_quote_end?(t))
+        end.slice_before { |t| double_quote_start?(t) }.reject { |q| q.empty? }
+      end
+
+      def column(token)
+        token[0][1]
+      end
+
+      def double_quote_start?(token)
+        token[1] == :on_tstring_beg and token[2] == '"'
+      end
+
+      def double_quote_end?(token)
+        token[1] == :on_tstring_end and token[2] == '"'
+      end
+    end
+  end
+end

data/lib/tailor/rulers/allow_unnecessary_interpolation_ruler.rb

@@ -0,0 +1,87 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+    class AllowUnnecessaryInterpolationRuler < Tailor::Ruler
+
+      EVENTS = [
+        :on_embexpr_beg,
+        :on_embexpr_end,
+        :on_rbrace,
+        :on_tstring_beg,
+        :on_tstring_content,
+        :on_tstring_end
+      ]
+
+      def initialize(config, options)
+        super(config, options)
+        reset_tokens
+        add_lexer_observers :ignored_nl, :nl
+      end
+
+      def ignored_nl_update(lexed_line, _, _)
+        add_string_tokens(lexed_line)
+      end
+
+      def nl_update(lexed_line, _, _)
+        add_string_tokens(lexed_line)
+        each_string(@tokens).each do |string|
+          measure(line_number(@tokens.first), string)
+        end
+
+        reset_tokens
+      end
+
+      # Checks if variables are interpolated unnecessarily.
+      #
+      # @param [Array] tokens The filtered tokens.
+      def measure(lineno, tokens)
+        return if @config
+        if no_content?(tokens) and one_expression?(tokens)
+          @problems << Problem.new('unnecessary_string_interpolation', lineno,
+            column(tokens.first), 'Variable interpolated unnecessarily',
+            @options[:level])
+        end
+      end
+
+      private
+
+      def add_string_tokens(lexed_line)
+        @tokens += string_tokens(lexed_line)
+      end
+
+      def column(token)
+        token.first.last + 1
+      end
+
+      def each_string(tokens)
+        tokens.select do |t|
+          true if (t[1] == :on_tstring_beg)..(t[1] == :on_tstring_end)
+        end.slice_before { |t| t[1] == :on_tstring_beg }
+      end
+
+      def line_number(token)
+        token.first.first
+      end
+
+      def no_content?(tokens)
+        ! tokens.map { |t| t[1] }.include?(:on_tstring_content)
+      end
+
+      def one_expression?(tokens)
+        tokens.select { |t| t[1] == :on_embexpr_beg }.size == 1 and
+          tokens.select do |t|
+            t[1] == :on_embexpr_end or t[1] == :on_rbrace
+          end.any?
+      end
+
+      def reset_tokens
+        @tokens = []
+      end
+
+      def string_tokens(lexed_line)
+        lexed_line.select { |t| EVENTS.include?(t[1]) }
+      end
+    end
+  end
+end

data/lib/tailor/rulers/indentation_spaces_ruler.rb

@@ -1,7 +1,10 @@
+require 'nokogiri'
 require_relative '../ruler'
 require_relative '../lexed_line'
 require_relative '../lexer/token'
+require_relative 'indentation_spaces_ruler/argument_alignment'
 require_relative 'indentation_spaces_ruler/indentation_manager'
+require_relative 'indentation_spaces_ruler/line_continuations'
 
 class Tailor
   module Rulers
@@ -12,6 +15,7 @@ class Tailor
           :comment,
           :embexpr_beg,
           :embexpr_end,
+          :file_beg,
           :ignored_nl,
           :kw,
           :lbrace,
@@ -67,21 +71,17 @@ class Tailor
       # More info: https://bugs.ruby-lang.org/issues/6211
       def embexpr_end_update(current_lexed_line, lineno, column)
         @embexpr_nesting.pop
-
-        if @manager.multi_line_braces?(lineno)
-          log 'End of multi-line braces!'
-
-          if current_lexed_line.only_embexpr_end?
-            @manager.amount_to_change_this -= 1
-            msg = 'lonely embexpr_end.  '
-            msg << "change_this -= 1 -> #{@manager.amount_to_change_this}"
-            log msg
-          end
-        end
-
         @manager.update_for_closing_reason(:on_embexpr_end, current_lexed_line)
       end
 
+      def file_beg_update(file_name)
+        # For statements that continue over multiple lines we may want to treat
+        # the second and subsequent lines differently and ident them further,
+        # controlled by the :line_continuations option.
+        @lines = LineContinuations.new(file_name) if line_continuations?
+        @args = ArgumentAlignment.new(file_name) if argument_alignment?
+      end
+
       def ignored_nl_update(current_lexed_line, lineno, column)
         log "indent reasons on entry: #{@manager.indent_reasons}"
 
@@ -110,7 +110,6 @@ class Tailor
         end
 
         @manager.update_actual_indentation(current_lexed_line)
-        @manager.set_up_line_transition
         measure(lineno, column)
 
         log "indent reasons on exit: #{@manager.indent_reasons}"
@@ -172,8 +171,6 @@ class Tailor
             last[:event_type], current_lexed_line)
         end
 
-        @manager.set_up_line_transition
-
         unless current_lexed_line.end_of_multi_line_string?
           measure(lineno, column)
         end
@@ -205,47 +202,14 @@ class Tailor
           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
-            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)
       end
 
       def rbracket_update(current_lexed_line, lineno, column)
-        if @manager.multi_line_brackets?(lineno)
-          log 'End of multi-line brackets!'
-
-          if current_lexed_line.only_rbracket?
-            @manager.amount_to_change_this -= 1
-            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)
       end
 
       def rparen_update(current_lexed_line, lineno, column)
-        if @manager.multi_line_parens?(lineno)
-          log 'End of multi-line parens!'
-
-          if current_lexed_line.only_rparen?
-            @manager.amount_to_change_this -= 1
-            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)
       end
 
@@ -272,6 +236,29 @@ class Tailor
         !@tstring_nesting.empty?
       end
 
+      def line_continuations?
+        @options[:line_continuations] and @options[:line_continuations] != :off
+      end
+
+      def with_line_continuations(lineno, should_be_at)
+        return should_be_at unless line_continuations?
+        if @lines.line_is_continuation?(lineno) and
+          @lines.line_has_nested_statements?(lineno)
+          should_be_at + @config
+        else
+          should_be_at
+        end
+      end
+
+      def argument_alignment?
+        @options[:argument_alignment] and @options[:argument_alignment] != :off
+      end
+
+      def with_argument_alignment(lineno, should_be_at)
+        return should_be_at unless argument_alignment?
+        @args.expected_column(lineno, should_be_at)
+      end
+
       # Checks if the line's indentation level is appropriate.
       #
       # @param [Fixnum] lineno The line the potential problem is on.
@@ -279,9 +266,12 @@ class Tailor
       def measure(lineno, column)
         log 'Measuring...'
 
-        if @manager.actual_indentation != @manager.should_be_at
+        should_be_at = with_line_continuations(lineno, @manager.should_be_at)
+        should_be_at = with_argument_alignment(lineno, should_be_at)
+
+        if @manager.actual_indentation != should_be_at
           msg = "Line is indented to column #{@manager.actual_indentation}, "
-          msg << "but should be at #{@manager.should_be_at}."
+          msg << "but should be at #{should_be_at}."
 
           @problems << Problem.new(problem_type, lineno,
             @manager.actual_indentation, msg, @options[:level])

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

@@ -0,0 +1,63 @@
+require 'ripper'
+require_relative './ast_xml'
+
+class Tailor
+  module Rulers
+    class IndentationSpacesRuler < Tailor::Ruler
+
+      # Determines whether arguments spread across lines are correctly
+      # aligned.
+      #
+      # Function calls with parentheses could be determined easily from
+      # the lexed line only but we need to support calls without parentheses
+      # too.
+      class ArgumentAlignment
+
+        include AstXml
+
+        def initialize(file_name)
+          @ast = build_xml(Ripper::SexpBuilder.new(File.read(file_name)).parse)
+          @lex = Ripper.lex(File.read(file_name))
+        end
+
+        def expected_column(lineno, should_be_at)
+          column = call_column(lineno) || declaration_column(lineno)
+          correct_for_literals(lineno, column) || should_be_at
+        end
+
+        private
+
+        # sexp column offsets for string literals do not include the quote
+        def correct_for_literals(lineno, column)
+          tstring_index = @lex.index do |pos, token|
+            pos[0] == lineno and pos[1] == column and
+              token == :on_tstring_content
+          end
+
+          tstring_index ? @lex[tstring_index -1][0][1] : column
+        end
+
+        def call_column(lineno)
+          [
+            first_argument(:command_call, :args_add_block, lineno),
+            first_argument(:method_add_arg, :args_add_block, lineno)
+          ].compact.min
+        end
+
+        def declaration_column(lineno)
+          first_argument(:def, :params, lineno)
+        end
+
+        def first_argument(parent, child, lineno)
+          method_defs = @ast.xpath("//#{parent}")
+          method_defs.map do |d|
+            d.xpath("descendant::#{child}[descendant::pos[@line = #{lineno}
+              ]]/descendant::pos[position() = 1 and @line != #{lineno}]/
+              @column").first.to_s.to_i
+          end.reject { |c| c == 0 }.min
+        end
+
+      end
+    end
+  end
+end