tailor 1.0.0.alpha2 → 1.0.0

data/lib/tailor/lexed_line.rb

@@ -1,9 +1,12 @@
 require_relative 'logger'
-require_relative 'lexer_constants'
+require_relative 'lexer/lexer_constants'
 require_relative 'lexer/token'
 require 'ripper'
 
 class Tailor
+
+  # This class provides methods for finding info about the current line.  It
+  # works off the format that results from {Tailor::Lexer}.
   class LexedLine < Array
     include LexerConstants
 
@@ -97,6 +100,9 @@ class Tailor
       previous_event.first.last.zero? || previous_event.first.last.nil?
     end
 
+    # Allows for calling a couple styles of methods:
+    # * #ends_with_(.+)?  - Allows for checking if the line ends with (.+)
+    # * #only_(.+)?  - Allows for checking if the line is only spaces and (.+)
     def method_missing(meth, *args, &blk)
       if meth.to_s =~ /^ends_with_(.+)\?$/
         event = "on_#{$1}".to_sym
@@ -145,10 +151,17 @@ class Tailor
     end
 
     # @return [Array] The lexed event that represents the last event in the
-    #   line that's not a +\n+.
+    #   line that's not a line-feed.  Line-feed events are signified by
+    #   +:on_nl+ and +on_ignored_nl+ events, and by +:on_sp+ events when they
+    #   equal +"\\\n" (which occurs when a line is broken by a backslash).
     def last_non_line_feed_event
-      self.find_all { |e| e[1] != :on_nl && e[1] != :on_ignored_nl }.last ||
-        [[]]
+      events = self.find_all do |e|
+        e[1] != :on_nl &&
+          e[1] != :on_ignored_nl &&
+          e.last != "\\\n"
+      end
+
+      events.last || [[]]
     end
 
     # @return [Fixnum] The length of the line minus the +\n+.
@@ -184,7 +197,7 @@ class Tailor
     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
+    # 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.
@@ -230,6 +243,26 @@ class Tailor
         self.none? { |e| e[1] == :on_tstring_beg }
     end
 
+    # When Ripper lexes a Symbol, it generates one event for :on_symbeg, which
+    # is the ':' token, and one for the name of the Symbol.  Since your Symbol
+    # name can be anything, the second event could be something like "class", in
+    # which case :on_kw will get called and probably result in unexpected
+    # behavior.
+    #
+    # This assumes the keyword in question is the last event in the line.
+    #
+    # @return [Boolean]
+    def keyword_is_symbol?
+      current_index = self.index(self.last)
+      previous_event = self.at(current_index - 1)
+
+      return false if previous_event.nil?
+      return false unless self.last[1] == :on_kw
+      return false unless previous_event[1] == :on_symbeg
+
+      true
+    end
+
     #---------------------------------------------------------------------------
     # Privates!
     #---------------------------------------------------------------------------

data/lib/tailor/lexer.rb

@@ -1,15 +1,16 @@
 require 'ripper'
 require_relative 'composite_observable'
 require_relative 'lexed_line'
-require_relative 'lexer_constants'
+require_relative 'lexer/lexer_constants'
 require_relative 'logger'
 require_relative 'lexer/token'
 
 
 class Tailor
 
-  # https://github.com/svenfuchs/ripper2ruby/blob/303d7ac4dfc2d8dbbdacaa6970fc41ff56b31d82/notes/scanner_events
-  # https://github.com/ruby/ruby/blob/trunk/test/ripper/test_scanner_events.rb
+  # This is what provides the main file parsing for tailor.  For every event
+  # that's encountered, it calls the appropriate notifier method.  Notifier
+  # methods are provided by {Tailor::CompositeObservable}.
   class Lexer < Ripper::Lexer
     include CompositeObservable
     include LexerConstants
@@ -31,9 +32,16 @@ class Tailor
       @added_newline = @file_text != @original_file_text
     end
 
-    def check_added_newline
-      file_changed
-      notify_file_observers(count_trailing_newlines(@original_file_text))
+    # This kicks off the process of parsing the file and publishing events
+    # as the events are discovered.
+    def lex
+      file_beg_changed
+      notify_file_beg_observers(@file_name)
+
+      super
+
+      file_end_changed
+      notify_file_end_observers(count_trailing_newlines(@original_file_text))
     end
 
     def on_backref(token)
@@ -41,11 +49,18 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches the first ` in a `` statement (the second
+    # matches :on_tstring_end; this may or may not be a Ruby bug).
+    #
+    # @param [String] token The token that the lexer matched.
     def on_backtick(token)
       log "BACKTICK: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches a comma.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_comma(token)
       log "COMMA: #{token}"
       log "Line length: #{current_line_of_text.length}"
@@ -56,6 +71,10 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches a #.  The token includes the # as well as
+    # the content after it.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_comment(token)
       log "COMMENT: '#{token}'"
 
@@ -67,6 +86,10 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches a constant (including class names, of
+    # course).
+    #
+    # @param [String] token The token that the lexer matched.
     def on_const(token)
       log "CONST: '#{token}'"
 
@@ -78,27 +101,41 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches a class variable.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_cvar(token)
       log "CVAR: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the content inside a =begin/=end.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_embdoc(token)
       log "EMBDOC: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches =begin.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_embdoc_beg(token)
       log "EMBDOC_BEG: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches =end.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_embdoc_end(token)
       log "EMBDOC_BEG: '#{token}'"
       super(token)
     end
 
-    # Matches the { in an expression embedded in a string.
+    # Called when the lexer matches a #{.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_embexpr_beg(token)
       log "EMBEXPR_BEG: '#{token}'"
       embexpr_beg_changed
@@ -106,6 +143,11 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches the } that closes a #{.  Note that as of
+    # MRI 1.9.3-p125, this never gets called.  Logged as a bug and fixed, but
+    # not yet released: https://bugs.ruby-lang.org/issues/6211.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_embexpr_end(token)
       log "EMBEXPR_END: '#{token}'"
       embexpr_end_changed
@@ -118,27 +160,42 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches a Float.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_float(token)
       log "FLOAT: '#{token}'"
       super(token)
     end
 
-    # Global variable
+    # Called when the lexer matches a global variable.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_gvar(token)
       log "GVAR: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the beginning of a heredoc.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_heredoc_beg(token)
       log "HEREDOC_BEG: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the end of a heredoc.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_heredoc_end(token)
       log "HEREDOC_END: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches an identifier (method name, variable, the
+    # text part of a Symbol, etc.).
+    #
+    # @param [String] token The token that the lexer matched.
     def on_ident(token)
       log "IDENT: '#{token}'"
       l_token = Tailor::Lexer::Token.new(token)
@@ -163,18 +220,23 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches an Integer.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_int(token)
       log "INT: '#{token}'"
       super(token)
     end
 
-    # Instance variable
+    # Called when the lexer matches an instance variable.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_ivar(token)
       log "IVAR: '#{token}'"
       super(token)
     end
 
-    # Called when the lexer matches a Ruby keyword
+    # Called when the lexer matches a Ruby keyword.
     #
     # @param [String] token The token that the lexer matched.
     def on_kw(token)
@@ -194,13 +256,20 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches a label (the first part in a non-rocket
+    # style Hash).
+    #
+    # Example:
+    #   one: 1     # Matches one:
+    #
+    # @param [String] token The token that the lexer matched.
     def on_label(token)
       log "LABEL: '#{token}'"
       super(token)
     end
 
     # Called when the lexer matches a {.  Note a #{ match calls
-    # {on_embexpr_beg}.
+    # +#on_embexpr_beg+.
     #
     # @param [String] token The token that the lexer matched.
     def on_lbrace(token)
@@ -222,6 +291,9 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches a (.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_lparen(token)
       log "LPAREN: '#{token}'"
       lparen_changed
@@ -240,12 +312,17 @@ class Tailor
       super(token)
     end
 
-    # Operators
+    # Called when the lexer matches an operator.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_op(token)
       log "OP: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches a period.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_period(token)
       log "PERIOD: '#{token}'"
 
@@ -255,6 +332,10 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches '%w'.  Statement is ended by a
+    # +:on_words_end+.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_qwords_beg(token)
       log "QWORDS_BEG: '#{token}'"
       super(token)
@@ -286,16 +367,25 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches the beginning of a Regexp.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_regexp_beg(token)
       log "REGEXP_BEG: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the end of a Regexp.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_regexp_end(token)
       log "REGEXP_END: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches a ).
+    #
+    # @param [String] token The token that the lexer matched.
     def on_rparen(token)
       log "RPAREN: '#{token}'"
 
@@ -306,68 +396,114 @@ class Tailor
       super(token)
     end
 
+    # Called when the lexer matches a ;.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_semicolon(token)
       log "SEMICOLON: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches any type of space character.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_sp(token)
       log "SP: '#{token}'; size: #{token.size}"
       l_token = Tailor::Lexer::Token.new(token)
       sp_changed
       notify_sp_observers(l_token, lineno, column)
+
+      # Deal with lines that end with \
+      if token == "\\\n"
+        current_line = LexedLine.new(super, lineno)
+        ignored_nl_changed
+        notify_ignored_nl_observers(current_line, lineno, column)
+      end
       super(token)
     end
 
+    # Called when the lexer matches the : at the beginning of a Symbol.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_symbeg(token)
       log "SYMBEG: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the -> as a lambda.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_tlambda(token)
       log "TLAMBDA: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the { that represents the beginning of a
+    # -> lambda.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_tlambeg(token)
       log "TLAMBEG: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the beginning of a String.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_tstring_beg(token)
       log "TSTRING_BEG: '#{token}'"
+      current_line = LexedLine.new(super, lineno)
       tstring_beg_changed
-      notify_tstring_beg_observers(lineno)
+      notify_tstring_beg_observers(current_line, lineno)
       super(token)
     end
 
+    # Called when the lexer matches the content of any String.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_tstring_content(token)
       log "TSTRING_CONTENT: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the end of a String.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_tstring_end(token)
       log "TSTRING_END: '#{token}'"
       tstring_end_changed
-      notify_tstring_end_observers
+      notify_tstring_end_observers(lineno)
       super(token)
     end
 
+    # Called when the lexer matches '%W'.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_words_beg(token)
       log "WORDS_BEG: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches the separators in a %w or %W (by default,
+    # this is a single space).
+    #
+    # @param [String] token The token that the lexer matched.
     def on_words_sep(token)
       log "WORDS_SEP: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches __END__.
+    #
+    # @param [String] token The token that the lexer matched.
     def on___end__(token)
       log "__END__: '#{token}'"
       super(token)
     end
 
+    # Called when the lexer matches CHAR.
+    #
+    # @param [String] token The token that the lexer matched.
     def on_CHAR(token)
       log "CHAR: '#{token}'"
       super(token)