tailor 0.1.5 → 1.0.0.alpha

data/lib/tailor/rulers/spaces_before_comma_ruler.rb

@@ -0,0 +1,67 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+
+    # Checks for spaces before a ',' as given by +@config+.
+    class SpacesBeforeCommaRuler < Tailor::Ruler
+      def initialize(config)
+        super(config)
+        @comma_columns = []
+      end
+
+      def comma_update(text_line, lineno, column)
+        @comma_columns << column
+      end
+
+      def comment_update(token, lexed_line, file_text, lineno, column)
+        if token =~ /\n$/
+          log "Found comment with trailing newline."
+          ignored_nl_update(lexed_line, lineno, column)
+        end
+      end
+
+      # Checks to see if the number of spaces before a comma equals the value
+      # at +@config+.
+      #
+      # @param [Fixnum] actual_spaces The number of spaces before the comma.
+      # @param [Fixnum] lineno Line the potential problem is on.
+      # @param [Fixnum] column Column the potential problem is on.
+      def measure(actual_spaces, lineno, column)
+        if actual_spaces != @config
+          @problems << Problem.new(:spaces_before_comma, lineno, column - 1,
+            { actual_spaces: actual_spaces, should_have: @config })
+        end
+      end
+
+      def check_spaces_before_comma(lexed_line, lineno)
+        @comma_columns.each do |c|
+          event_index = lexed_line.event_index(c)
+          if event_index.nil?
+            log "Event index is nil.  Weird..."
+            next
+          end
+
+          previous_event = lexed_line.at(event_index - 1)
+          actual_spaces = if previous_event[1] != :on_sp
+            0
+          else
+            previous_event.last.size
+          end
+
+          measure(actual_spaces, lineno, c)
+        end
+
+        @comma_columns.clear
+      end
+
+      def ignored_nl_update(lexed_line, lineno, column)
+        check_spaces_before_comma(lexed_line, lineno)
+      end
+
+      def nl_update(lexed_line, lineno, column)
+        ignored_nl_update(lexed_line, lineno, column)
+      end
+    end
+  end
+end

data/lib/tailor/rulers/spaces_before_lbrace_ruler.rb

@@ -0,0 +1,93 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+
+    # Detects spaces before a '{' as given by +@config+.  It skips checking
+    # when:
+    # * it's the first char in the line.
+    # * the char before it is a '#{'.
+    # * the char before it is a '('.
+    # * the char before it is a '['.
+    # * it's only preceded by spaces.
+    class SpacesBeforeLbraceRuler < Tailor::Ruler
+
+      # Counts the spaces before the '{'.
+      #
+      # @param [LexedLine] lexed_line
+      # @param [Fixnum] column
+      # @return [Fixnum] The number of spaces before the lbrace.
+      def count_spaces(lexed_line, column)
+        current_index = lexed_line.event_index(column)
+        log "Current event index: #{current_index}"
+        previous_event = lexed_line.at(current_index - 1)
+        log "Previous event: #{previous_event}"
+
+        if column.zero? || previous_event.nil?
+          log "lbrace must be at the beginning of the line."
+          @do_measurement = false
+          return 0
+        end
+
+        if previous_event[1] == :on_embexpr_beg
+          log "lbrace comes after a '\#{'."
+          @do_measurement = false
+          return 0
+        end
+
+        if previous_event[1] == :on_lparen
+          log "lbrace comes after a '('."
+          @do_measurement = false
+          return 0
+        end
+
+        if previous_event[1] == :on_lbracket
+          log "lbrace comes after a '['."
+          @do_measurement = false
+          return 0
+        end
+
+        return 0 if previous_event[1] != :on_sp
+
+        if current_index - 2 < 0
+          log "lbrace comes at the beginning of an indented line."
+          @do_measurement = false
+          return previous_event.last.size
+        end
+
+        previous_event.last.size
+      end
+
+      # Called by {Lexer} when :on_lbrace is encountered.
+      #
+      # @param [LexedLine] lexed_line
+      # @param [Fixnum] lineno
+      # @param [Fixnum] column
+      def lbrace_update(lexed_line, lineno, column)
+        count = count_spaces(lexed_line, column)
+        log "Found #{count} space(s) before lbrace."
+
+        if @do_measurement == false
+          log "Skipping measurement."
+        else
+          measure(count, lineno, column)
+        end
+
+        @do_measurement = true
+      end
+
+      # Checks to see if the counted spaces before an lbrace equals the value
+      # at +@config+.
+      #
+      # @param [Fixnum] count The number of spaces before the lbrace.
+      # @param [Fixnum] lineno Line the potential problem is on.
+      # @param [Fixnum] column Column the potential problem is on.
+      def measure(count, lineno, column)
+        if count != @config
+          @problems << Problem.new(:spaces_before_lbrace, lineno, column,
+            { actual_spaces: count, should_have: @config })
+        end
+      end
+    end
+  end
+end

data/lib/tailor/rulers/spaces_before_rbrace_ruler.rb

@@ -0,0 +1,98 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+
+    # Checks for spaces before a '}' as given by +@config+.  It skips checking
+    # when:
+    # * it's the first char in the line.
+    # * it's the first char in the line, preceded by spaces.
+    # * it's directly preceded by a '{'.
+    class SpacesBeforeRbraceRuler < Tailor::Ruler
+      def initialize(config)
+        super(config)
+        @lbrace_nesting = []
+      end
+
+      # @param [LexedLine] lexed_line
+      # @param [Fixnum] column
+      # @return [Fixnum] The number of spaces before the rbrace.
+      def count_spaces(lexed_line, column)
+        current_index = lexed_line.event_index(column)
+        log "Current event index: #{current_index}"
+        previous_event = lexed_line.at(current_index - 1)
+        log "Previous event: #{previous_event}"
+
+        if column.zero? || previous_event.nil?
+          log "rbrace is at the beginning of the line."
+          @do_measurement = false
+          return 0
+        end
+
+        if previous_event[1] == :on_lbrace
+          log "rbrace comes after a '{'"
+          @do_measurement = false
+          return 0
+        end
+
+        return 0 if previous_event[1] != :on_sp
+
+        if current_index - 2 < 0
+          log "rbrace is at the beginning of an indented line.  Moving on."
+          @do_measurement = false
+          return previous_event.last.size
+        end
+
+        previous_event.last.size
+      end
+
+      def embexpr_beg_update
+        @lbrace_nesting << :embexpr_beg
+      end
+
+      def lbrace_update(lexed_line, lineno, column)
+        @lbrace_nesting << :lbrace
+      end
+
+      # Checks to see if the number of spaces before an rbrace equals the value
+      # at +@config+.
+      #
+      # @param [Fixnum] count The number of spaces after the rbrace.
+      # @param [Fixnum] lineno Line the problem was found on.
+      # @param [Fixnum] column Column the problem was found on.
+      def measure(count, lineno, column)
+        if count != @config
+          @problems << Problem.new(:spaces_before_rbrace, lineno, column,
+            { actual_spaces: count, should_have: @config })
+        end
+      end
+
+      # This has to keep track of '{'s and only follow through with the check
+      # if the '{' was an lbrace because Ripper doesn't scan the '}' of an
+      # embedded expression (embexpr_end) as such.
+      #
+      # @param [Tailor::LexedLine] lexed_line
+      # @param [Fixnum] lineno
+      # @param [Fixnum] column
+      def rbrace_update(lexed_line, lineno, column)
+        if @lbrace_nesting.last == :embexpr_beg
+          @lbrace_nesting.pop
+          return
+        end
+
+        @lbrace_nesting.pop
+
+        count = count_spaces(lexed_line, column)
+        log "Found #{count} space(s) before rbrace."
+
+        if @do_measurement == false
+          log "Skipping measurement."
+        else
+          measure(count, lineno, column)
+        end
+
+        @do_measurement = true
+      end
+    end
+  end
+end

data/lib/tailor/rulers/spaces_before_rbracket_ruler.rb

@@ -0,0 +1,70 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+
+    # Checks for spaces before a ']' as given by +@config+.  It skips checking
+    # when:
+    # * it's the first char in the line.
+    # * it's directly preceded by a '['.
+    # * it's directly preceded by spaces, then a '['.
+    class SpacesBeforeRbracketRuler < Tailor::Ruler
+
+      # @param [LexedLine] lexed_line
+      # @param [Fixnum] column
+      # @return [Fixnum] The number of spaces before the rbracket.
+      def count_spaces(lexed_line, column)
+        current_index = lexed_line.event_index(column)
+        log "Current event index: #{current_index}"
+        previous_event = lexed_line.at(current_index - 1)
+        log "Previous event: #{previous_event}"
+
+        if column.zero? || previous_event.nil? ||
+          previous_event[1] == :on_lbracket
+          return nil
+        end
+
+        return 0 if previous_event[1] != :on_sp
+        return nil if current_index - 2 < 0
+
+        second_previous_event = lexed_line.at(current_index - 2)
+        return nil if second_previous_event[1] == :on_lbracket
+
+        previous_event.last.size
+      end
+
+      # Checks to see if the counted spaces before an rbracket equals the value
+      # at +@config+.
+      #
+      # @param [Fixnum] count The number of spaces before the rbracket.
+      # @param [Fixnum] lineno Line the potential problem is on.
+      # @param [Fixnum] column Column the potential problem is on.
+      def measure(count, lineno, column)
+        if count != @config
+          @problems << Problem.new(:spaces_before_rbracket, lineno, column,
+            { actual_spaces: count, should_have: @config })
+        end
+      end
+
+      # This has to keep track of '{'s and only follow through with the check
+      # if the '{' was an lbrace because Ripper doesn't scan the '}' of an
+      # embedded expression (embexpr_end) as such.
+      #
+      # @param [Tailor::LexedLine] lexed_line
+      # @param [Fixnum] lineno
+      # @param [Fixnum] column
+      def rbracket_update(lexed_line, lineno, column)
+        count = count_spaces(lexed_line, column)
+
+        if count.nil?
+          log "rbracket must be at the beginning of the line."
+          return
+        else
+          log "Found #{count} space(s) before rbracket."
+        end
+
+        measure(count, lineno, column)
+      end
+    end
+  end
+end

data/lib/tailor/rulers/spaces_before_rparen_ruler.rb

@@ -0,0 +1,70 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+
+    # Checks for spaces before a ')' as given by +@config+.  It skips checking
+    # when:
+    # * it's the first char in the line.
+    # * it's directly preceded by a '('.
+    # * it's directly preceded by spaces, then a '('.
+    class SpacesBeforeRparenRuler < Tailor::Ruler
+
+      # @param [LexedLine] lexed_line
+      # @param [Fixnum] column
+      # @return [Fixnum] The number of spaces before the rparen.
+      def count_spaces(lexed_line, column)
+        current_index = lexed_line.event_index(column)
+        log "Current event index: #{current_index}"
+        previous_event = lexed_line.at(current_index - 1)
+        log "Previous event: #{previous_event}"
+
+        if column.zero? || previous_event.nil? ||
+          previous_event[1] == :on_lparen
+          return nil
+        end
+
+        return 0 if previous_event[1] != :on_sp
+        return nil if current_index - 2 < 0
+
+        second_previous_event = lexed_line.at(current_index - 2)
+        return nil if second_previous_event[1] == :on_lparen
+
+        previous_event.last.size
+      end
+
+      # Checks to see if the counted spaces before an rparen equals the value
+      # at +@config+.
+      #
+      # @param [Fixnum] count The number of spaces before the rparen.
+      # @param [Fixnum] lineno Line the potential problem is on.
+      # @param [Fixnum] column Column the potential problem is on.
+      def measure(count, lineno, column)
+        if count != @config
+          @problems << Problem.new(:spaces_before_rparen, lineno, column,
+            { actual_spaces: count, should_have: @config })
+        end
+      end
+
+      # This has to keep track of '{'s and only follow through with the check
+      # if the '{' was an lbrace because Ripper doesn't scan the '}' of an
+      # embedded expression (embexpr_end) as such.
+      #
+      # @param [Tailor::LexedLine] lexed_line
+      # @param [Fixnum] lineno
+      # @param [Fixnum] column
+      def rparen_update(lexed_line, lineno, column)
+        count = count_spaces(lexed_line, column)
+
+        if count.nil?
+          log "rparen must be at the beginning of the line."
+          return
+        else
+          log "Found #{count} space(s) before rparen."
+        end
+
+        measure(count, lineno, column)
+      end
+    end
+  end
+end

data/lib/tailor/rulers/spaces_in_empty_braces_ruler.rb

@@ -0,0 +1,94 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+
+    # Checks for spaces that exist between a '{' and '}' when there is only
+    # space in between them.
+    class SpacesInEmptyBracesRuler < Tailor::Ruler
+      def initialize(config)
+        super(config)
+        @lbrace_nesting = []
+      end
+
+      # @param [LexedLine] lexed_line
+      # @param [Fixnum] column
+      # @return [Fixnum] The number of spaces before the rbrace.
+      def count_spaces(lexed_line, column)
+        current_index = lexed_line.event_index(column)
+        log "Current event index: #{current_index}"
+        previous_event = lexed_line.at(current_index - 1)
+        log "Previous event: #{previous_event}"
+
+        if column.zero? || previous_event.nil?
+          return
+        end
+
+        if previous_event[1] == :on_lbrace
+          return 0
+        end
+
+        if previous_event[1] == :on_sp
+          second_previous_event = lexed_line.at(current_index - 2)
+
+          if second_previous_event[1] == :on_lbrace
+            previous_event.last.size
+          else
+            nil
+          end
+        end
+      end
+
+      def embexpr_beg_update
+        @lbrace_nesting << :embexpr_beg
+      end
+
+      def lbrace_update(lexed_line, lineno, column)
+        @lbrace_nesting << :lbrace
+      end
+
+      def nl_update(lexed_line, lineno, column)
+        ignored_nl_update(lexed_line, lineno, column)
+      end
+
+      # Checks to see if the counted spaces between an lbrace and an rbrace
+      # equals the value at +@config+.
+      #
+      # @param [Fixnum] count The number of spaces before the lbrace.
+      # @param [Fixnum] lineno Line the potential problem is on.
+      # @param [Fixnum] column Column the potential problem is on.
+      def measure(count, lineno, column)
+        if count != @config
+          @problems << Problem.new(:spaces_in_empty_braces, lineno, column,
+            { actual_spaces: count, should_have: @config })
+        end
+      end
+
+      # This has to keep track of '{'s and only follow through with the check
+      # if the '{' was an lbrace because Ripper doesn't scan the '}' of an
+      # embedded expression (embexpr_end) as such.
+      #
+      # @param [Tailor::LexedLine] lexed_line
+      # @param [Fixnum] lineno
+      # @param [Fixnum] column
+      def rbrace_update(lexed_line, lineno, column)
+        if @lbrace_nesting.last == :embexpr_beg
+          @lbrace_nesting.pop
+          return
+        end
+
+        @lbrace_nesting.pop
+        count = count_spaces(lexed_line, column)
+
+        if count.nil?
+          log "Braces aren't empty.  Moving on."
+          return
+        else
+          log "Found #{count} space(s) before rbrace."
+        end
+
+        measure(count, lineno, column)
+      end
+    end
+  end
+end