tailor 0.1.5 → 1.0.0.alpha

data/lib/tailor/critic.rb

@@ -0,0 +1,162 @@
+require 'erb'
+require 'yaml'
+require 'fileutils'
+require_relative 'configuration'
+require_relative 'lexer'
+require_relative 'logger'
+require_relative 'ruler'
+require_relative 'rulers'
+require_relative 'runtime_error'
+
+
+class Tailor
+  class Critic
+    include Tailor::Logger::Mixin
+    include Tailor::Rulers
+
+    RULER_OBSERVERS = {
+      spaces_before_lbrace: [:add_lbrace_observer],
+      spaces_after_lbrace: [
+        :add_comment_observer,
+        :add_ignored_nl_observer,
+        :add_lbrace_observer,
+        :add_nl_observer
+      ],
+      spaces_before_rbrace: [
+        :add_embexpr_beg_observer,
+        :add_lbrace_observer,
+        :add_rbrace_observer
+      ],
+      spaces_after_lbracket: [
+        :add_comment_observer,
+        :add_ignored_nl_observer,
+        :add_lbracket_observer,
+        :add_nl_observer
+      ],
+      spaces_before_rbracket: [:add_rbracket_observer],
+      spaces_after_lparen: [
+        :add_comment_observer,
+        :add_ignored_nl_observer,
+        :add_lparen_observer,
+        :add_nl_observer
+      ],
+      spaces_before_rparen: [:add_rparen_observer],
+      spaces_in_empty_braces: [
+        :add_embexpr_beg_observer,
+        :add_lbrace_observer,
+        :add_rbrace_observer
+      ],
+      spaces_before_comma: [
+        :add_comma_observer,
+        :add_comment_observer,
+        :add_ignored_nl_observer,
+        :add_nl_observer
+      ],
+      spaces_after_comma: [
+        :add_comma_observer,
+        :add_comment_observer,
+        :add_ignored_nl_observer,
+        :add_nl_observer
+      ],
+      max_line_length: [:add_ignored_nl_observer, :add_nl_observer],
+      indentation_spaces: [
+        :add_comment_observer,
+        :add_embexpr_beg_observer,
+        :add_embexpr_end_observer,
+        :add_ignored_nl_observer,
+        :add_kw_observer,
+        :add_lbrace_observer,
+        :add_lbracket_observer,
+        :add_lparen_observer,
+        :add_nl_observer,
+        :add_rbrace_observer,
+        :add_rbracket_observer,
+        :add_rparen_observer,
+        :add_tstring_beg_observer,
+        :add_tstring_end_observer
+      ],
+      allow_trailing_line_spaces: [:add_ignored_nl_observer, :add_nl_observer],
+      allow_hard_tabs: [:add_sp_observer],
+      allow_camel_case_methods: [:add_ident_observer],
+      allow_screaming_snake_case_classes: [:add_const_observer],
+      max_code_lines_in_class: [
+        :add_ignored_nl_observer,
+        :add_kw_observer,
+        :add_nl_observer
+      ],
+      max_code_lines_in_method: [
+        :add_ignored_nl_observer,
+        :add_kw_observer,
+        :add_nl_observer
+      ],
+      trailing_newlines: [:add_file_observer]
+    }
+
+    def initialize(configuration)
+      @file_sets = configuration
+    end
+
+    def critique
+      log "file sets keys: #{@file_sets.keys}"
+      @file_sets.each do |label, file_set|
+        log "Critiquing file_set: #{file_set}"
+
+        file_set[:file_list].each do |file|
+          log "Critiquing file: #{file}"
+          problems = check_file(file, file_set[:style])
+          yield [problems, label] if block_given?
+        end
+      end
+    end
+
+    def init_rulers(style, lexer, parent_ruler)
+      style.each do |ruler_name, value|
+        ruler =
+          instance_eval(
+            "Tailor::Rulers::#{camelize(ruler_name.to_s)}Ruler.new(#{value})"
+          )
+        parent_ruler.add_child_ruler(ruler)
+        RULER_OBSERVERS[ruler_name].each do |observer|
+          log "Adding #{observer} to lexer..."
+          lexer.send(observer, ruler)
+        end
+      end
+    end
+
+    # Converts a snake-case String to a camel-case String.
+    #
+    # @param [String] string The String to convert.
+    # @return [String] The converted String.
+    def camelize(string)
+      string.split(/_/).map { |word| word.capitalize }.join
+    end
+
+    # Adds problems found from Lexing to the {problems} list.
+    #
+    # @param [String] file The file to open, read, and check.
+    # @return [Hash] The Problems for that file.
+    def check_file(file, style)
+      log "<#{self.class}> Checking style of file: #{file}."
+      lexer = Tailor::Lexer.new(file)
+      ruler = Ruler.new
+      log "Style: #{style}"
+      init_rulers(style, lexer, ruler)
+
+      lexer.lex
+      lexer.check_added_newline
+      problems[file] = ruler.problems
+
+      { file => problems[file] }
+    end
+
+    # @return [Hash]
+    def problems
+      @problems ||= {}
+    end
+
+    # @return [Fixnum] The number of problems found so far.
+    def problem_count
+      problems.values.flatten.size
+    end
+  end
+end

data/lib/tailor/formatters/text.rb

@@ -0,0 +1,126 @@
+require 'text-table'
+
+class Tailor
+  module Formatter
+    class Text
+      def line(length=79)
+        "##{'-' * length}\n"
+      end
+
+      def file_header(file)
+        message = ""
+        message << if defined? Term::ANSIColor
+          "# #{'File:'.underscore}\n"
+        else
+          "# File:\n"
+        end
+
+        message << "#   #{file}\n"
+        message << "#\n"
+
+        message
+      end
+
+      def file_set_header(file_set)
+        message = ""
+        message << if defined? Term::ANSIColor
+          "# #{'File Set:'.underscore}\n"
+        else
+          "# File Set:\n"
+        end
+
+        message << "#   #{file_set}\n"
+        message << "#\n"
+
+        message
+      end
+
+      def problems_header(problem_list)
+        message = ""
+        message << if defined? Term::ANSIColor
+          "# #{'Problems:'.underscore}\n"
+        else
+          "# Problems:\n"
+        end
+
+        problem_list.each_with_index do |problem, i|
+          position = if problem[:line] == '<EOF>'
+            '<EOF>'
+          else
+            if defined? Term::ANSIColor
+              msg = "#{problem[:line].to_s.red.bold}:"
+              msg << "#{problem[:column].to_s.red.bold}"
+              msg
+            else
+              "#{problem[:line]}:#{problem[:column]}"
+            end
+          end
+
+          message << if defined? Term::ANSIColor
+            %Q{#  #{(i + 1).to_s.bold}.
+#    * position:  #{position}
+#    * type:      #{problem[:type].to_s.red}
+#    * message:   #{problem[:message].red}
+}
+          else
+            %Q{#  #{(i + 1)}.
+#    * position:  #{position}
+#    * type:      #{problem[:type]}
+#    * message:   #{problem[:message]}
+}
+          end
+        end
+
+        message
+      end
+
+      # Prints the report on the file that just got checked.
+      #
+      # @param [Hash] problems Value should be the file name; keys should be
+      #   problems with the file.
+      def file_report(problems, file_set_label)
+        return if problems.values.first.empty?
+
+        file = problems.keys.first
+        problem_list = problems.values.first
+        message = line
+        message << file_header(file)
+        message << file_set_header(file_set_label)
+        message << problems_header(problem_list)
+
+        message << <<-MSG
+#
+#-------------------------------------------------------------------------------
+        MSG
+
+        puts message
+      end
+
+      # Prints the report on all of the files that just got checked.
+      #
+      # @param [Hash] problems Values are filenames; keys are problems for each
+      #   of those files.
+      def summary_report(problems)
+        if problems.empty?
+          puts "Your files are in style."
+        else
+          summary_table = ::Text::Table.new
+          summary_table.head = [{ value: "Tailor Summary", colspan: 2 }]
+          summary_table.rows << [{ value: "File", align: :center },
+            { value: "Total Problems", align: :center }]
+          summary_table.rows << :separator
+
+          problems.each do |file, problem_list|
+            summary_table.rows << [file, problem_list.size]
+          end
+
+          summary_table.rows << :separator
+          summary_table.rows << ['TOTAL', problems.values.
+            map { |v| v.size }.inject(:+)]
+
+          puts summary_table
+        end
+      end
+    end
+  end
+end

data/lib/tailor/lexed_line.rb

@@ -0,0 +1,246 @@
+require_relative 'logger'
+require_relative 'lexer_constants'
+require_relative 'lexer/token'
+require 'ripper'
+
+class Tailor
+  class LexedLine < Array
+    include LexerConstants
+
+    def initialize(lexed_file, lineno)
+      @lineno = lineno
+      super(current_line_lex(lexed_file, lineno))
+    end
+
+    # @param [Array] lexed_output The lexed output for the whole file.
+    # @return [Array]
+    def current_line_lex(lexed_output, lineno)
+      lexed_output.find_all { |token| token.first.first == lineno }.uniq
+    end
+
+    # Looks at self and determines if it' s a line of just
+    # space characters: spaces, newlines.
+    #
+    # @return [Boolean]
+    def only_spaces?
+      element = first_non_space_element
+      log "first non-space element '#{element}'"
+      element.nil? || element.empty?
+    end
+
+    # @return [Boolean]
+    def comment_line?
+      first_non_space_element[1] == :on_comment
+    end
+
+    # Checks to see if the current line ends with an operator (not counting the
+    # newline that might come after it).
+    #
+    # @return [Boolean] true if the line ends with an operator; false if not.
+    def ends_with_op?
+      lexed_line = self.dup
+      tokens_in_line = lexed_line.map { |e| e[1] }
+
+      until tokens_in_line.last != (:on_ignored_nl || :on_nl)
+        tokens_in_line.pop
+        lexed_line.pop
+      end
+
+      return false if lexed_line.empty?
+
+      if MULTILINE_OPERATORS.include?(lexed_line.last.last) &&
+        tokens_in_line.last == :on_op
+        true
+      else
+        false
+      end
+    end
+
+    # Checks to see if the line ends with a keyword, and that the keyword is
+    # used as a modifier.
+    #
+    # @return [Boolean]
+    def ends_with_modifier_kw?
+      return false unless ends_with_kw?
+
+      token = Tailor::Lexer::Token.new(last.last,
+        { full_line_of_text: to_s })
+
+      token.modifier_keyword?
+    end
+
+    # @return [Boolean]
+    def does_line_end_with(event, exclude_newlines=true)
+      if exclude_newlines
+        if last_non_line_feed_event.first.empty?
+          false
+        else
+          last_non_line_feed_event[1] == event
+        end
+      else
+        self.last[1] == :on_ignored_nl || self.last[1] == :on_nl
+      end
+    end
+
+    # Checks to see if the line contains only +event+ (where it may or may not
+    # be preceded by spaces, and is proceeded by a newline).
+    #
+    # @param [Symbol] event The type of event to check for.
+    # @return [Boolean]
+    def is_line_only_a(event)
+      last_event = last_non_line_feed_event
+      return false if last_event[1] != event
+
+      index = event_index(last_event.first.last)
+      previous_event = self.at(index - 1)
+
+      previous_event.first.last.zero? || previous_event.first.last.nil?
+    end
+
+    def method_missing(meth, *args, &blk)
+      if meth.to_s =~ /^ends_with_(.+)\?$/
+        event = "on_#{$1}".to_sym
+
+        if event == :on_ignored_nl || event == :on_nl
+          does_line_end_with(event, false)
+        else
+          does_line_end_with event
+        end
+      elsif meth.to_s =~ /^only_(.+)\?$/
+        event = "on_#{$1}".to_sym
+        is_line_only_a(event)
+      else
+        super(meth, *args, &blk)
+      end
+    end
+
+    # Gets the first non-space element from a line of lexed output.
+    #
+    # @return [Array] The element; +nil+ if none is found.
+    def first_non_space_element
+      self.find do |e|
+        e[1] != :on_sp && e[1] != :on_nl && e[1] != :on_ignored_nl
+      end
+    end
+
+    # Checks to see if the current line is a keyword loop (for, while, until)
+    # that uses the optional 'do' at the end of the statement.
+    #
+    # @return [Boolean]
+    def loop_with_do?
+      keyword_elements = self.find_all { |e| e[1] == :on_kw }
+      keyword_tokens = keyword_elements.map { |e| e.last }
+      loop_start = keyword_tokens.any? { |t| LOOP_KEYWORDS.include? t }
+      with_do = keyword_tokens.any? { |t| t == 'do' }
+
+      loop_start && with_do
+    end
+
+    # @return [Boolean] +true+ if the line contains an keyword and it is in
+    #   +KEYWORDS_TO_INDENT.
+    def contains_keyword_to_indent?
+      self.any? do |e|
+        e[1] == :on_kw && KEYWORDS_TO_INDENT.include?(e[2])
+      end
+    end
+
+    # @return [Array] The lexed event that represents the last event in the
+    #   line that's not a +\n+.
+    def last_non_line_feed_event
+      self.find_all { |e| e[1] != :on_nl && e[1] != :on_ignored_nl }.last ||
+        [[]]
+    end
+
+    # @return [Fixnum] The length of the line minus the +\n+.
+    def line_length
+      event = last_non_line_feed_event
+      return 0 if event.first.empty?
+
+      event.first.last + event.last.size
+    end
+
+    # @param [Fixnum] column Number of the column to get the event for.
+    # @return [Array] The event at the given column.
+    def event_at column
+      self.find { |e| e.first.last == column }
+    end
+
+    # Useful for inspecting events relevant to this one.
+    #
+    # @example
+    #   i = lexed_line.event_index(11)
+    #   previous_event = lexed_line.at(i - 1)
+    # @param [Fixnum] column Number of the column of which event to get the
+    #   index for.
+    # @return [Fixnum] The index within +self+ that the event is at.
+    def event_index column
+      column_event = self.event_at column
+      self.index(column_event)
+    end
+
+    # @return [String] The string reassembled from self's tokens.
+    def to_s
+      self.inject('') { |new_string, e| new_string << e.last }
+    end
+
+    # If a trailing comment exists in the line, remove it and the spaces that
+    # come before it.  This is necessary, as {Ripper} doesn't trigger an event
+    # for the end of the line when the line ends with a comment.  Without this
+    # observers that key off ending the line will never get triggered, and thus
+    # style won't get checked for that line.
+    #
+    # @param [Fixnum] column The column that the comment is at.
+    # @param [String] file_text The whole file's worth of text.  Required in
+    #   order to be able to reconstruct the context in which the line exists.
+    # @return [LexedLine] The current lexed line, but with the trailing comment
+    #   removed.
+    def remove_trailing_comment(file_text)
+      file_lines = file_text.split("\n")
+      lineno = self.last.first.first
+      column = self.last.first.last
+      log "Removing comment event at #{lineno}:#{column}."
+
+      comment_index = event_index(column)
+      self.delete_at(comment_index)
+      self.insert(comment_index, [[lineno, column], :on_nl, "\n"])
+      log "Inserted newline for comma; self is now #{self.inspect}"
+
+      if self.at(comment_index - 1)[1] == :on_sp
+        self.delete_at(comment_index - 1)
+      end
+
+      new_text = self.to_s
+      log "New line as text: '#{new_text}'"
+
+      file_lines.delete_at(lineno - 1)
+      file_lines.insert(lineno - 1, new_text)
+      file_lines = file_lines.join("\n")
+
+      ripped_output = ::Ripper.lex(file_lines)
+      LexedLine.new(ripped_output, lineno)
+    end
+
+    # Determines if the current lexed line is just the end of a tstring.
+    #
+    # @param [Array] lexed_line_output The lexed output for the current line.
+    # @return [Boolean] +true+ if the line contains a +:on_tstring_end+ and
+    #   not a +:on_tstring_beg+.
+    def end_of_multi_line_string?
+      self.any? { |e| e[1] == :on_tstring_end } &&
+        self.none? { |e| e[1] == :on_tstring_beg }
+    end
+
+    #---------------------------------------------------------------------------
+    # Privates!
+    #---------------------------------------------------------------------------
+    private
+
+    def log(*args)
+      l = begin; lineno; rescue; "<EOF>"; end
+      c = begin; column; rescue; "<EOF>"; end
+      subclass_name = self.class.to_s.sub(/^Tailor::/, '')
+      args.first.insert(0, "<#{subclass_name}> #{l}[#{c}]: ")
+      Tailor::Logger.log(*args)
+    end
+  end
+end