tailor 0.0.3 → 0.1.0

data/lib/tailor/indentation.rb

@@ -0,0 +1,251 @@
+require 'tailor/spacing'
+
+module Tailor
+
+  # Provides methods for checking indentation problems in a FileLine.
+  module Indentation
+    include Tailor::Spacing
+
+    INDENT_SIZE = 2
+    HARD_TAB_SIZE = 4
+
+    INDENT_EXPRESSIONS = [
+      /^class\b/,
+      /^module\b/,
+      /^def\b/,
+      /(=\s*|^)if\b/,
+      /(=\s*|^)until\b/,
+      /(=\s*|^)for\b/,
+      /(=\s*|^)unless\b/,
+      /(=\s*|^)while\b/,
+      /(=\s*|^)begin\b/,
+      /(=\s*|^)case\b/,
+      /\bthen\b/,
+#      /^rescue\b/,
+      /\bdo\b/,
+#      /^else\b/,
+#      /^elsif\b/,
+#      /^ensure\b/,
+#      /\bwhen\b/,
+      /\{[^\}]*$/,
+      /\[[^\]]*$/
+      ]
+
+    OUTDENT_EXPRESSIONS = [
+      /^rescue\b/,
+      /^ensure\b/,
+      /^elsif\b/,
+#      /^end\b/,
+      /^else\b/,
+      /\bwhen\b/,
+#      /^[^\{]*\}/,    # matches and end } when no { appears
+#      /^[^\[]*\]/
+      ]
+
+    END_EXPRESSIONS = [
+      /^end\b/,
+      /^[^\{]*\}/,    # matches and end } when no { appears
+      /^[^\[]*\]/     # matches and end ] when no [ appears
+      ]
+
+    ##
+    # Determines the number of spaces the line is indented.
+    #
+    # @return [Number] Returns the number of spaces the line is indented.
+    def indented_spaces
+      # Find out how many spaces exist at the beginning of the line
+      spaces = self.scan(/^\x20+/).first
+
+      unless spaces.nil?
+        return spaces.length
+      end
+
+      return 0
+    end
+
+    ##
+    # Determines the level to which the line is indented.  For Ruby, this
+    #   should be 2 spaces.  Note that this treats lines that are indented an
+    #   odd number of spaces as a multiple of 0.5 levels of indentation.
+    #
+    # @return [Float] The level.
+    def is_at_level
+      spaces = indented_spaces
+
+      if spaces.eql? 0
+        return 0.0
+      end
+
+      return spaces.to_f / 2.0
+    end
+
+    ##
+    # Checks to see if the line contains a statement that should be indented.
+    #
+    # @return [Boolean] True if the line contains one of the statements and
+    #   does not contain 'end'.
+    def indent?
+      return false if self.comment_line?
+
+      INDENT_EXPRESSIONS.each do |regexp|
+        result = self.strip.scan(regexp)
+
+        if(self.strip =~ regexp && !(self =~ /\s+end\s*$/))
+          return true
+        end
+      end
+
+      return false
+    end
+
+    ##
+    # Checks to see if the line contains a statement that should be outdented.
+    #
+    # @return [Boolean] True if the line contains one of the statements.
+    def outdent?
+      return false if self.comment_line?
+
+      OUTDENT_EXPRESSIONS.each do |regexp|
+        result = self.strip.scan(regexp)
+
+        # If it does contain an expression, set the proper level to be out 1.0.
+        unless result.empty?
+          return true
+        end
+      end
+
+      return false
+    end
+
+    ##
+    # Checks to see if the line contains a statement that ends a code chunk:
+    #   end, ], or }.
+    #
+    # @return [Boolean] True if the line contains one of the statements.
+    def contains_end?
+      return false if self.comment_line?
+
+      END_EXPRESSIONS.each do |regexp|
+        result = self.strip.scan(regexp)
+
+        # If it does contain an expression, set the proper level to be out 1.0.
+        unless result.empty?
+          #@logger.debug "Found match: #{regexp}"
+          return true
+        end
+      end
+
+      return false
+    end
+
+    ##
+    # Simply compares the level the line is at to the parameter that's passed
+    #   in.  The proper level is maintained outside of this module.
+    #
+    # @return [Boolean] True if level of the line doesn't match the level
+    #   passed in.  Also returns true if the line is an empty line, since that
+    #   line doens't need to be checked.
+    def at_improper_level? proper_level
+      current_level = self.is_at_level
+
+      if current_level == proper_level or self.empty_line?
+        return false
+      end
+
+      message = "Line is at level #{current_level}, "
+      message += "but should be at level #{proper_level}:"
+      @line_problem_count += 1
+      print_problem message
+
+      return true
+    end
+
+    def ends_with_operator?
+      if self.comment_line?
+        return false
+      end
+
+      result = false
+
+      OPERATORS.each_pair do |op_family, op_values|
+        op_values.each do |op|
+          match = self.scan(/.*#{Regexp.escape(op)}\s*$/)
+
+          next if op == '?' and self.question_mark_method?
+
+          unless match.empty?
+            logger = Logger.new(STDOUT)
+            logger.debug "Matched on op: #{op}"
+            result = true
+          end
+        end
+      end
+
+      return result
+    end
+
+    def ends_with_comma?
+      if self.comment_line?
+        return false
+      end
+
+      unless self.scan(/.*,\s*$/).empty?
+        puts "Ends with comma."
+        return true
+      end
+
+      return false
+    end
+
+    def ends_with_backslash?
+      if self.comment_line?
+        return false
+      end
+
+      unless self.scan(/.*\\\s*$/).empty?
+        puts "Ends with backslash."
+        return true
+      end
+
+      return false
+    end
+
+    def unclosed_parenthesis?
+      if self.comment_line?
+        return false
+      end
+
+      unless self.scan(/\([^\)]*(?!=\))\s*$/).empty?
+        puts "Ends with unclose parenthesis."
+        return true
+      end
+
+      return false
+    end
+
+    def only_closed_parenthesis?
+      if self.comment_line?
+        return false
+      end
+
+      unless self.scan(/^\s*[^\(](\w*|\s*)\)/).empty?
+        return true
+      end
+
+      return false
+    end
+
+    def multi_line_statement?
+      if self.comment_line?
+        return false
+      end
+
+      if self.ends_with_operator? or self.ends_with_comma? or
+        self.ends_with_backslash? or self.unclosed_parenthesis?
+        return true
+      end
+
+      return false
+    end
+  end
+end

data/lib/tailor/spacing.rb

@@ -0,0 +1,243 @@
+require 'tailor'
+require 'tailor/file_line'
+
+module Tailor
+
+  # This module provides methods for detecting spacing problems on a single
+  # line in a file.  The real intent here is to mix in to the FileLine class.
+  module Spacing
+    # TODO: Add skipping of comment lines.
+    SPACING_CONDITIONS = {
+      :more_than_one_space_after_comma => [
+        /\,\x20{2,}(\w|'|"|:).*((?:(?!#\s*)).)*$/,
+        "[Spacing]  Line has a comma with > 1 space after it"
+        ],
+      :no_space_after_comma => [
+        /\,\x20{0}\S/,
+        "[Spacing]  Line has a comma with 0 spaces after it"
+        ],
+      :space_before_comma => [
+        /\S\x20+\,/,
+        "[Spacing]  Line has at least one space before a comma"
+        ],
+      :space_after_open_parenthesis => [
+        /\(\x20+/,
+        "[Spacing]  Line has a '(' with spaces after it"
+        ],
+      :space_before_closed_parenthesis => [
+        /^\s*[^#]\w+.*\x20+\)/,
+        "[Spacing]  Line has a ')' with spaces before it"
+        ],
+      :space_around_open_bracket => [
+        /^\s*[^#](\w+\x20+\[|.*\[\x20+)/,
+        "[Spacing]  Line has a '[' with at least 1 space around it"
+        ],
+      :space_before_closed_bracket => [
+        /^\s*[^#]\w+.*\x20+\]/,
+        "[Spacing]  Line has a ']' with spaces before it"
+        ],
+      :hard_tabbed => [
+        /\t+/,
+        "[Spacing]  Line contains hard tabs"
+        ],
+      :trailing_whitespace => [
+        /(\x20+|\x09+)$/,
+        #"[Spacing]  Line contains #{trailing_whitespace_count} " +
+        "[Spacing]  Line contains trailing whitespaces"
+        ],
+      :no_space_around_open_curly_brace => [
+        /^\s*((?:(?!def).)*)(=|\w)\x20{0}\{|\{\x20{0}(\||:|"|')/,
+        "[Spacing]  Line contains 0 spaces on at least one side of a '{'"
+        ],
+      :no_space_before_closed_curly_brace => [
+        /^\s*((?:(?!#\{).)*)(?:(?!\{)\S)\x20{0}\}/,
+        "[Spacing]  Line contains 0 spaces before a '}'"
+        ],
+      :more_than_one_space_around_open_curly_brace => [
+        /\w\x20{2,}\{|\{\x20{2,}\|/,
+        "[Spacing]  Line contains >1 spaces around a '{'"
+        ],
+      :more_than_one_space_before_closed_curly_brace => [
+        /\w\x20{2,}\}\s*$/,
+        "[Spacing]  Line contains >1 spaces before a '}'"
+        ],
+      :not_one_space_around_ternary_colon => [
+        /^.*\?.*\w((\x20{0}|\x20{2,}):(?!:)|[^:|\[]:(\x20{0}|\x20{2,})\w)/,
+        "[Spacing]  Line contains ternary ':' with not 1 space around it"
+        ]
+      }
+
+    ##
+    # Detect spacing problems around all predefined bad cases.
+    #
+    # @return [Number] The number of problems discovered during detection.
+    def spacing_problems
+      problem_count = 0
+
+      # Disregard text in regexps
+      self.gsub!(/\/.*?\//, "''")
+      self.gsub!(/'.*?'/, "''")
+
+      SPACING_CONDITIONS.each_pair do |condition, values|
+        unless self.scan(values.first).empty?
+          problem_count += 1
+          @line_problem_count += 1
+          print_problem values[1]
+        end
+      end
+      problem_count
+    end
+
+    ##
+    # Checks to see if there's whitespace at the end of the line.  Prints the
+    #   number of whitespaces at the end of the line.
+    #
+    # @return [Boolean] Returns true if there's whitespace at the end of the
+    #   line.
+=begin
+    def trailing_whitespace?
+      count = self.trailing_whitespace_count
+
+      if count > 0
+        @line_problem_count += 1
+        print_problem "Line contains #{count} trailing whitespace(s):"
+        return true
+      end
+
+      return false
+    end
+=end
+    ##
+    # Checks to see if the line has trailing whitespace at the end of it. Note
+    #   that this excludes empty lines that have spaces on them!
+    #
+    # @return [Number] Returns the number of trailing spaces at the end of the
+    #   line.
+    def trailing_whitespace_count
+      spaces = self.scan(/(\x20+|\x09+)$/)
+
+      if spaces.first.eql? nil
+        return 0
+      end
+
+      return spaces.first.first.length
+    end
+    module_function :trailing_whitespace_count
+
+    ##
+    # Checks to see if there's no spaces before a given string.  If the line
+    #   being checked is a method with a question mark at the end of it, this
+    #   skips checking the line.
+    #
+    # @param [String] string The string to check for spaces before.
+    # @return [Boolean] True if there are no spaces before the string.
+    def no_space_before? string
+      # Get out if the check is for a '?' and that's part of a method name.
+      if self.question_mark_method?
+        return false
+      end
+
+      # Get out if this line is a comment line
+      if self.comment_line?
+        return false
+      end
+
+      # Get out if the string is within another string
+      if word_is_in_string? string
+        return false
+      end
+
+      counts = []
+      spaces_before(string).each { |s| counts << s }
+
+      result = false
+      counts.each do |count|
+        if count == 0
+          @line_problem_count += 1
+          print_problem "Line has a '#{string}' with 0 spaces before it:"
+          result = true
+        end
+      end
+
+      result
+    end
+
+    ##
+    # Checks to see if there's no spaces after a given string.
+    #
+    # @param [String] string The string to check for spaces after.
+    # @return [Boolean] True if there are no spaces after the string.
+    def no_space_after? string
+      # Get out if the check is for a '?' and that's part of a method name.
+      if self.question_mark_method?
+        return false
+      end
+
+      # Get out if this line is a comment line
+      if self.comment_line?
+        return false
+      end
+
+      # Get out if the string is within another string
+      if word_is_in_string? string
+        return false
+      end
+
+      # Get out if the string is within another string
+      if word_is_in_regexp? string
+        return false
+      end
+
+      counts = []
+      spaces_after(string).each { |s| counts << s }
+
+      result = false
+      counts.each do |count|
+        if count == 0
+          @line_problem_count += 1
+          print_problem "Line has a '#{string}' with 0 spaces after it:"
+          result = true
+        end
+      end
+
+      result
+    end
+
+    ##
+    # Gets the number of spaces after a string.
+    #
+    # @param [String] string The string to check for spaces after.
+    # @return [Array<Number>] An array that holds the number of spaces after
+    #   every time the given string appears in a line.
+    def spaces_after string
+      # Get out if this line is a comment line
+      if self.comment_line?
+        return false
+      end
+
+      right_side_match = Regexp.new(Regexp.escape(string) + '\x20*')
+
+      occurences = self.scan(right_side_match)
+
+      results = []
+      occurences.each do |o|
+        string_spaces = o.sub(string, '')
+        results << string_spaces.size
+      end
+
+      results
+    end
+
+    ##
+    # Checks to see if the line contains a method name with a ?.
+    #
+    # @return [Boolean] True if the line contains a method line include?.
+    def question_mark_method?
+      if self.scan(/[a-zA-Z|_]\w*\?/).empty?
+        return false
+      end
+
+      return true
+    end
+  end
+end