tailor 0.1.5 → 1.0.0.alpha

data/lib/tailor/lexer_constants.rb

@@ -0,0 +1,75 @@
+class Tailor
+
+  # These are important tokens that key certain styling events.  They are taken
+  # from:
+  # https://github.com/ruby/ruby/blob/trunk/ext/ripper/eventids2.c
+  # https://github.com/ruby/ruby/blob/trunk/parse.y
+  module LexerConstants
+    KEYWORDS_TO_INDENT = [
+      'begin',
+      'case',
+      'class',
+      'def',
+      'do',
+      'else',
+      'elsif',
+      'ensure',
+      'for',
+      'if',
+      'module',
+      'rescue',
+      'unless',
+      'until',
+      'when',
+      'while'
+    ]
+
+    CONTINUATION_KEYWORDS = [
+      'elsif',
+      'else',
+      'ensure',
+      'rescue',
+      'when'
+    ]
+
+    KEYWORDS_AND_MODIFIERS = [
+      'if',
+      'unless',
+      'until',
+      'while'
+    ]
+
+    MODIFIERS = {
+      'if' => :if_mod,
+      'rescue' => :rescue_mod,
+      'unless' => :unless_mod,
+      'until' => :until_mod,
+      'while' => :while_mod
+    }
+
+    MULTILINE_OPERATORS = [
+      '+', '-', '*', '**', '/', '%',    # +, -, tSTAR, tPOW, /, %
+      '<', '>', '<=', '>=',             # <, >, tLEQ, tGEQ
+      '=', '+=', '-=', '*=', '**=', '/=', '%=',
+      '&&=', '||=', '<<=',              # ...tOP_ASGN...
+      '>>', '<<',                       # tRSHFT, tLSHFT
+      '!', '&', '?', ':', '^', '~',     # !, tAMPER, ?, :, ^, ~
+      #'|',
+      '&&', '||',                       # tANDOP, tOROP
+      '==', '===', '<=>', '!=',         # tEQ, tEQQ, tCMP, tNEQ
+      '=~', '!~',                       # tMATCH, tNMATCH
+      '..', '...',                      # tDOT2, tDOT3
+      '::',                             # tCOLON2 (not sure about tCOLON3)
+      #'[]', '[]=',                      # tAREF, tASET (not sure about these)
+      '=>',                             # tASSOC
+      '->',                             # tLAMBDA
+      '~>'                              # gem_version op
+    ]
+
+    LOOP_KEYWORDS = [
+      'for',
+      'until',
+      'while'
+    ]
+  end
+end

data/lib/tailor/logger.rb

@@ -0,0 +1,28 @@
+require 'log_switch'
+
+class Tailor
+  class Logger
+    extend LogSwitch
+
+    def self.logger
+      return @logger if @logger
+      @logger ||= ::Logger.new $stdout
+
+      def @logger.format_message(level, time, progname, msg)
+        "[#{time.strftime("%Y-%m-%d %H:%M:%S")}]  #{msg}\n"
+      end
+
+      @logger
+    end
+
+    module Mixin
+      def self.included(base)
+        define_method :log do |*args|
+          class_minus_main_name = self.class.to_s.sub(/^.*::/, '')
+          args.first.insert(0, "<#{class_minus_main_name}> ")
+          Tailor::Logger.log(*args)
+        end
+      end
+    end
+  end
+end

data/lib/tailor/problem.rb

@@ -0,0 +1,100 @@
+require_relative 'logger'
+require_relative 'runtime_error'
+
+class Tailor
+
+  # A Hashed data structure that abstracts out data (especially the error
+  # message) to build reports from.
+  class Problem < Hash
+    include LogSwitch::Mixin
+
+    # @param [Symbol] type The problem type.
+    # @param [Binding] binding The context that the problem was discovered in.
+    def initialize(type, line, column, options={})
+      @type = type
+      @line = line
+      @column = column
+      @options = options
+      set_values
+      subclass_name = self.class.to_s.sub(/^Tailor::/, '')
+      msg = "<#{subclass_name}> #{self[:line]}[#{self[:column]}]: "
+      msg << "ERROR[:#{self[:type]}] #{self[:message]}"
+      log msg
+    end
+
+    # Sets the standard values for the problem based on the type and binding.
+    def set_values
+      self[:type] = @type
+      self[:line] = @line
+      self[:column] = @column
+      self[:message] = message(@type)
+    end
+
+    # Builds the message for the problem type, based on the info provided in
+    # the +@binding+.
+    #
+    # @param [Symbol] type The type of problem.
+    # @return [String] The error message.
+    def message(type)
+      case type
+      when :camel_case_method
+        "Camel-case method name found."
+      when :code_lines_in_class
+        msg = "Class/module has #{@options[:actual_count]} code lines, but "
+        msg << "should have no more than #{@options[:should_be_at]}."
+      when :code_lines_in_method
+        msg = "Method has #{@options[:actual_count]} code lines, but "
+        msg << "should have no more than #{@options[:should_be_at]}."
+      when :hard_tab
+        "Hard tab found."
+      when :indentation
+        self[:column] = @options[:actual_indentation]
+        msg = "Line is indented to #{@options[:actual_indentation]}, "
+        msg << "but should be at #{@options[:should_be_at]}."
+      when :line_length
+        msg = "Line is #{@options[:actual_length]} chars long, "
+        msg << "but should be #{@options[:should_be_at]}."
+      when :screaming_snake_case_class_name
+        "Screaming-snake-case class/module found."
+      when :spaces_after_comma
+        msg = "Line has #{@options[:actual_spaces]} space(s) after a comma, "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_before_comma
+        msg = "Line has #{@options[:actual_spaces]} space(s) before a comma, "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_after_lbrace
+        msg = "Line has #{@options[:actual_spaces]} space(s) after a {, "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_after_lbracket
+        msg = "Line has #{@options[:actual_spaces]} space(s) after a [, "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_after_lparen
+        msg = "Line has #{@options[:actual_spaces]} space(s) after a (, "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_before_lbrace
+        msg = "Line has #{@options[:actual_spaces]} space(s) before a {, "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_before_rbrace
+        msg = "Line has #{@options[:actual_spaces]} space(s) before a }, "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_before_rbracket
+        msg = "Line has #{@options[:actual_spaces]} space(s) before a ], "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_before_rparen
+        msg = "Line has #{@options[:actual_spaces]} space(s) before a ), "
+        msg << "but should have #{@options[:should_have]}."
+      when :spaces_in_empty_braces
+        msg = "Line has #{@options[:actual_spaces]} space(s) in between empty "
+        msg << "braces, but should have #{@options[:should_have]}."
+      when :trailing_newlines
+        msg = "File has #{@options[:actual_trailing_newlines]} trailing "
+        msg << "newlines, but should have #{@options[:should_have]}."
+      when :trailing_spaces
+        "Line has #{@options[:actual_trailing_spaces]} trailing spaces."
+      else
+        raise Tailor::RuntimeError,
+          "Problem type '#{type}' doesn't exist."
+      end
+    end
+  end
+end

data/lib/tailor/reporter.rb

@@ -0,0 +1,48 @@
+class Tailor
+
+  # Objects of this type are responsible for sending the right data to report
+  # formatters.
+  class Reporter
+    attr_reader :formatters
+
+    # For each in +formats+, it creates a new
+    # +Tailor::Formatter::#{formatter.capitalize}+ object and adds it to
+    # +@formatters+.
+    #
+    # @param [Array] formats A list of formatters to use for generating reports.
+    def initialize(*formats)
+      @formatters = []
+
+      formats.flatten.each do |formatter|
+        require_relative "formatters/#{formatter}"
+        @formatters << eval("Tailor::Formatter::#{formatter.capitalize}.new")
+      end
+    end
+
+    # Sends the data to each +@formatters+ to generate the report of problems
+    # for the file that was just critiqued.  A problem is in the format:
+    #
+    #   { 'path/to/file.rb' => [Problem1, Problem2, etc.]}
+    #
+    # ...where Problem1 and Problem2 are of type {Tailor::Problem}.
+    #
+    # @param [Hash] file_problems
+    # @param [Symbol,String] label The label of the file_set that defines the
+    #   problems in +file_problems+.
+    def file_report(file_problems, label)
+      @formatters.each do |formatter|
+        formatter.file_report(file_problems, label)
+      end
+    end
+
+    # Sends the data to each +@formatters+ to generate the reports of problems
+    # for all files that were just critiqued.
+    #
+    # @param [Hash] all_problems 
+    def summary_report(all_problems)
+      @formatters.each do |formatter|
+        formatter.summary_report(all_problems)
+      end
+    end
+  end
+end

data/lib/tailor/ruler.rb

@@ -0,0 +1,39 @@
+require_relative 'logger'
+require_relative 'problem'
+require_relative 'runtime_error'
+
+class Tailor
+  class Ruler
+    include Tailor::Logger::Mixin
+
+    attr_reader :cli_option
+
+    def initialize(config={})
+      @config = config
+      @problems = []
+      @child_rulers = []
+      @cli_option = ""
+      @do_measurement = true
+      log "Ruler initialized with style setting: #{@config}"
+    end
+
+    def add_child_ruler(ruler)
+      @child_rulers << ruler
+      log "Added child: #{ruler}"
+    end
+
+    def problems
+      @problems = @child_rulers.inject(@problems) do |problems, ruler|
+        problems + ruler.problems
+      end
+
+      @problems.sort_by! { |problem| problem[:line].to_i }
+    end
+
+    # Each ruler should redefine this for its needs.
+    def measure(*args)
+      raise RuntimeError,
+        "Ruler#measure called, but should be redefined by a real ruler."
+    end
+  end
+end

data/lib/tailor/rulers.rb

@@ -0,0 +1,7 @@
+Dir.glob(File.dirname(__FILE__) + '/rulers/*', &method(:require))
+
+class Tailor
+  module Rulers
+
+  end
+end

data/lib/tailor/rulers/allow_camel_case_methods_ruler.rb

@@ -0,0 +1,30 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+    class AllowCamelCaseMethodsRuler < Tailor::Ruler
+      def ident_update(token, lexed_line, lineno, column)
+        ident_index = lexed_line.event_index(column)
+        previous_event = lexed_line.event_at(ident_index - 2)
+        log "previous event: #{previous_event}"
+
+        return if previous_event.nil?
+
+        if previous_event[1] == :on_kw && previous_event.last == "def"
+          measure(token, lineno, column)
+        end
+      end
+
+      # Checks to see if the method name contains capital letters.
+      #
+      # @param [Fixnum] token The method name.
+      # @param [Fixnum] lineno Line the problem was found on.
+      # @param [Fixnum] column Column the problem was found on.
+      def measure(token, lineno, column)
+        if token.contains_capital_letter?
+          @problems << Problem.new(:camel_case_method, lineno, column)
+        end
+      end
+    end
+  end
+end

data/lib/tailor/rulers/allow_hard_tabs_ruler.rb

@@ -0,0 +1,22 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+    class AllowHardTabsRuler < Tailor::Ruler
+      def sp_update(token, lineno, column)
+        measure(token, lineno, column)
+      end
+
+      # Checks to see if the space(s) contains hard tabs.
+      #
+      # @param [Fixnum] token The space(s).
+      # @param [Fixnum] lineno Line the problem was found on.
+      # @param [Fixnum] column Column the problem was found on.
+      def measure(token, lineno, column)
+        if token.contains_hard_tab?
+          @problems << Problem.new(:hard_tab, lineno, column)
+        end
+      end
+    end
+  end
+end

data/lib/tailor/rulers/allow_screaming_snake_case_classes_ruler.rb

@@ -0,0 +1,32 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+    class AllowScreamingSnakeCaseClassesRuler < Tailor::Ruler
+      def const_update(token, lexed_line, lineno, column)
+        ident_index = lexed_line.event_index(column)
+        previous_event = lexed_line.event_at(ident_index - 2)
+        log "previous event: #{previous_event}"
+
+        return if previous_event.nil?
+
+        if previous_event[1] == :on_kw &&
+          (previous_event.last == "class" || previous_event.last == "module")
+          measure(token, lineno, column)
+        end
+      end
+
+      # Checks to see if the class name matches /[A-Z].*_/.
+      #
+      # @param [Fixnum] token The space(s).
+      # @param [Fixnum] lineno Line the potential problem is on.
+      # @param [Fixnum] column Column the potential problem is on.
+      def measure(token, lineno, column)
+        if token.screaming_snake_case?
+          @problems << Problem.new(:screaming_snake_case_class_name,
+            lineno, column)
+        end
+      end
+    end
+  end
+end

data/lib/tailor/rulers/allow_trailing_line_spaces_ruler.rb

@@ -0,0 +1,33 @@
+require_relative '../ruler'
+
+class Tailor
+  module Rulers
+    class AllowTrailingLineSpacesRuler < Tailor::Ruler
+      def ignored_nl_update(lexed_line, lineno, column)
+        log "Last event: #{lexed_line.last_non_line_feed_event}"
+        log "Line ends with space: #{lexed_line.ends_with_sp?}"
+
+        measure(lexed_line, lineno, column)
+      end
+
+      def nl_update(lexed_line, lineno, column)
+        ignored_nl_update(lexed_line, lineno, column)
+      end
+
+      # Checks to see if the line contains trailing spaces.
+      #
+      # @param [LexedLine] lexed_line The line to check for trailing spaces.
+      # @param [Fixnum] lineno Line the potential problem is on.
+      # @param [Fixnum] column Column the potential problem is on.
+      def measure(lexed_line, lineno, column)
+        if lexed_line.ends_with_sp?
+          options = {
+            actual_trailing_spaces:
+              lexed_line.last_non_line_feed_event.last.size
+          }
+          @problems << Problem.new(:trailing_spaces, lineno, column, options)
+        end
+      end
+    end
+  end
+end

data/lib/tailor/rulers/indentation_spaces_ruler.rb

@@ -0,0 +1,199 @@
+require_relative '../ruler'
+require_relative '../lexed_line'
+require_relative '../lexer/token'
+require_relative 'indentation_spaces_ruler/indentation_manager'
+
+class Tailor
+  module Rulers
+    class IndentationSpacesRuler < Tailor::Ruler
+      def initialize(config)
+        super(config)
+        @manager = IndentationManager.new(@config)
+      end
+
+      def comment_update(token, lexed_line, file_text, lineno, column)
+        # trailing comment?
+        if token.ends_with_newline?
+          log "Comment ends with newline.  Removing comment..."
+          log "Old lexed line: #{lexed_line.inspect}"
+
+          new_lexed_line = lexed_line.remove_trailing_comment(file_text)
+
+          log "New lexed line: #{new_lexed_line.inspect}"
+
+          if new_lexed_line.ends_with_ignored_nl?
+            log "New lexed line ends with :on_ignored_nl."
+            ignored_nl_update(new_lexed_line, lineno, column)
+          elsif new_lexed_line.ends_with_nl?
+            log "New lexed line ends with :on_nl."
+            nl_update(new_lexed_line, lineno, column)
+          end
+        end
+      end
+
+      def embexpr_beg_update
+        @manager.embexpr_beg = true
+      end
+
+      def embexpr_end_update
+        @manager.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."
+          # todo: maybe i shouldn't return here? ...do transitions?
+          return
+        end
+
+        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)
+            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)
+            end
+          end
+        end
+
+        @manager.update_actual_indentation(current_lexed_line)
+        @manager.set_up_line_transition
+        measure(lineno, column)
+
+        log "indent reasons on exit: #{@manager.indent_reasons}"
+        # prep for next line
+        @manager.transition_lines
+      end
+
+      def kw_update(token, lexed_line, lineno, column)
+        if token == "end"
+          @manager.update_for_closing_reason(:on_kw, lexed_line, lineno)
+          return
+        end
+
+        if token.continuation_keyword?
+          log "Continuation keyword found: '#{token}'."
+          @manager.update_for_continuation_reason(token, lexed_line, lineno)
+          return
+        end
+
+        if token.keyword_to_indent?
+          log "Indent keyword found: '#{token}'."
+          @manager.update_for_opening_reason(:on_kw, token, lineno)
+        end
+      end
+
+      def lbrace_update(lexed_line, lineno, column)
+        token = Tailor::Lexer::Token.new('{')
+        @manager.update_for_opening_reason(:on_lbrace, token, lineno)
+      end
+
+      def lbracket_update(lexed_line, lineno, column)
+        token = Tailor::Lexer::Token.new('[')
+        @manager.update_for_opening_reason(:on_lbracket, token, lineno)
+      end
+
+      def lparen_update(lineno, column)
+        token = Tailor::Lexer::Token.new('(')
+        @manager.update_for_opening_reason(:on_lparen, token, lineno)
+      end
+
+      def nl_update(current_lexed_line, lineno, column)
+        log "indent reasons on entry: #{@manager.indent_reasons}"
+        @manager.update_actual_indentation(current_lexed_line)
+
+        if @manager.last_indent_reason_type != :on_kw &&
+          @manager.last_indent_reason_type != :on_lbrace &&
+          @manager.last_indent_reason_type != :on_lbracket &&
+          @manager.last_indent_reason_type != :on_lparen &&
+          !@manager.last_indent_reason_type.nil?
+          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)
+        end
+
+        @manager.set_up_line_transition
+
+        unless current_lexed_line.end_of_multi_line_string?
+          measure(lineno, column)
+        end
+
+        log "indent reasons on exit: #{@manager.indent_reasons}"
+        @manager.transition_lines
+      end
+
+      def rbrace_update(current_lexed_line, lineno, column)
+        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}"
+          end
+        end
+
+        @manager.update_for_closing_reason(:on_rbrace, current_lexed_line, lineno)
+      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
+            log "lonely rbracket.  change_this -= 1 -> #{@manager.amount_to_change_this}"
+          end
+        end
+
+        @manager.update_for_closing_reason(:on_rbracket, current_lexed_line, lineno)
+      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
+            log "lonely rparen.  change_this -= 1 -> #{@manager.amount_to_change_this}"
+          end
+        end
+
+        @manager.update_for_closing_reason(:on_rparen, current_lexed_line, lineno)
+      end
+
+      def tstring_beg_update(lineno)
+        @manager.tstring_nesting << lineno
+        @manager.stop
+      end
+
+      def tstring_end_update
+        @manager.tstring_nesting.pop
+        @manager.start unless @manager.in_tstring?
+      end
+
+      # Checks if the line's indentation level is appropriate.
+      #
+      # @param [Fixnum] lineno The line the potential problem is on.
+      # @param [Fixnum] column The column the potential problem is on.
+      def measure(lineno, column)
+        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 }
+          )
+        end
+      end
+    end
+  end
+end