tailor 1.0.0.alpha2 → 1.0.0

data/lib/tailor/{lexer_constants.rb → lexer/lexer_constants.rb}

@@ -1,11 +1,13 @@
+require 'set'
+
 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
+  # * 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 = [
+    KEYWORDS_TO_INDENT = Set.new [
       'begin',
       'case',
       'class',
@@ -24,7 +26,7 @@ class Tailor
       'while'
     ]
 
-    CONTINUATION_KEYWORDS = [
+    CONTINUATION_KEYWORDS = Set.new [
       'elsif',
       'else',
       'ensure',
@@ -32,7 +34,7 @@ class Tailor
       'when'
     ]
 
-    KEYWORDS_AND_MODIFIERS = [
+    KEYWORDS_AND_MODIFIERS = Set.new [
       'if',
       'unless',
       'until',
@@ -47,7 +49,7 @@ class Tailor
       'while' => :while_mod
     }
 
-    MULTILINE_OPERATORS = [
+    MULTILINE_OPERATORS = Set.new [
       '+', '-', '*', '**', '/', '%',    # +, -, tSTAR, tPOW, /, %
       '<', '>', '<=', '>=',             # <, >, tLEQ, tGEQ
       '=', '+=', '-=', '*=', '**=', '/=', '%=',
@@ -66,7 +68,7 @@ class Tailor
       '~>'                              # gem_version op
     ]
 
-    LOOP_KEYWORDS = [
+    LOOP_KEYWORDS = Set.new [
       'for',
       'until',
       'while'

data/lib/tailor/lexer/token.rb

@@ -1,13 +1,17 @@
 require 'ripper'
-require_relative '../lexer_constants'
+require_relative 'lexer_constants'
 require_relative '../logger'
 
 class Tailor
   class Lexer < ::Ripper::Lexer
+
+    # Helper methods for tokens that are parsed by {Tailor::Lexer}.
     class Token < String
       include LexerConstants
       include Tailor::Logger::Mixin
 
+      # @param [String] the_token
+      # @param [Hash] options
       def initialize(the_token, options={})
         super(the_token)
         @options = options
@@ -78,7 +82,7 @@ class Tailor
 
           if sexp_line.nil?
             log "sexp line was nil again."
-            log "Trying one more time with the last char removed from the line..."
+            log "Trying 1 more time with the last char removed from the line..."
             line_of_text.chop!
             sexp_line = Ripper.sexp(line_of_text)
           end

data/lib/tailor/logger.rb

@@ -4,6 +4,8 @@ class Tailor
   class Logger
     extend LogSwitch
 
+    # Overrides the LogSwitch Logger to custom format the time format in log
+    # messages.
     def self.logger
       return @logger if @logger
       @logger ||= ::Logger.new $stdout
@@ -15,6 +17,8 @@ class Tailor
       @logger
     end
 
+    # Provides an .included hook to insert the name of the class for each log
+    # message in the class that includes the Mixin.
     module Mixin
       def self.included(base)
         define_method :log do |*args|

data/lib/tailor/problem.rb

@@ -3,22 +3,23 @@ require_relative 'runtime_error'
 
 class Tailor
 
-  # A Hashed data structure that abstracts out data (especially the error
-  # message) to build reports from.
+  # A Hashed data structure that simply defines the data needed to report a
+  # problem
   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={})
+    def initialize(type, line, column, message, level)
       @type = type
       @line = line
       @column = column
-      @options = options
+      @message = message
+      @level = level
       set_values
       subclass_name = self.class.to_s.sub(/^Tailor::/, '')
       msg = "<#{subclass_name}> #{self[:line]}[#{self[:column]}]: "
-      msg << "ERROR[:#{self[:type]}] #{self[:message]}"
+      msg << "#{@level.upcase}[:#{self[:type]}] #{self[:message]}"
       log msg
     end
 
@@ -27,74 +28,8 @@ class Tailor
       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
+      self[:message] = @message
+      self[:level] = @level
     end
   end
 end

data/lib/tailor/reporter.rb

@@ -15,7 +15,7 @@ class Tailor
 
       formats.flatten.each do |formatter|
         require_relative "formatters/#{formatter}"
-        @formatters << eval("Tailor::Formatter::#{formatter.capitalize}.new")
+        @formatters << eval("Tailor::Formatters::#{formatter.capitalize}.new")
       end
     end
 

data/lib/tailor/ruler.rb

@@ -1,27 +1,72 @@
 require_relative 'logger'
 require_relative 'problem'
 require_relative 'runtime_error'
+require_relative '../ext/string_ext'
 
 class Tailor
+
+  # This is a composite class, geared for getting at or managing the Rulers
+  # that should be used for measuring style.  To do so, create a new object of
+  # this type, then add child rulers to that object using +#add_child_ruler+.
+  # After using the Ruler, you'll have access to all of the problems found by
+  # all of the child rulers via +#problems+.
+  #
+  # Example:
+  #   ruler = Ruler.new
+  #   file_length_ruler = FileLengthRuler.new
+  #   ruler.add_child_ruler(file_length_ruler)
+  #   # use ruler
+  #   ruler.problems      # => [{ all of your file length problems... }]
+  #
+  # There's really no measuring functionality in this base class--it's merely
+  # for aggregating child data and for providing a base class to create child
+  # Rulers from.  Speaking of... if you want, you can create your own rulers.
+  # A Ruler requires a few things:
+  #
+  # First, it needs a list of Lexer events to observer.  Tailor uses its Lexer
+  # to publish events (in this case, characters or string Ruby constructs) of
+  # interest to its observers.  Rulers subscribe to those events so that they
+  # can detect the problems they're looking for.  These are defined as a Set in
+  # @lexer_observers.  Adding to that list means the Ruler will subscribe to
+  # those events.
+  #
+  # Example:
+  #   class MyRuler < Tailor::Ruler
+  #     def initialize
+  #       add_lexer_observers = :nl_observer, :kw_observer
+  #     end
+  #   end
   class Ruler
     include Tailor::Logger::Mixin
 
-    attr_reader :cli_option
+    attr_reader :lexer_observers
+    attr_reader :level
 
-    def initialize(config={})
+    # @param [Object] config
+    # @param [Hash] options
+    def initialize(config=nil, options={ level: :error })
       @config = config
-      @problems = []
-      @child_rulers = []
-      @cli_option = ""
+      @options = options
       @do_measurement = true
       log "Ruler initialized with style setting: #{@config}"
+      log "Ruler initialized with problem level setting: #{@options[:level]}"
+
+      @child_rulers = []
+      @lexer_observers = []
+      @problems = []
     end
 
+    # Adds the {Tailor::Ruler} object to the list of child rulers.
+    #
+    # @param [Tailor::Ruler] ruler
     def add_child_ruler(ruler)
       @child_rulers << ruler
-      log "Added child: #{ruler}"
+      log "Added child ruler: #{ruler}"
     end
 
+    # Gets all of the problems from all child rulers.
+    #
+    # @return [Array] The list of problems.
     def problems
       @problems = @child_rulers.inject(@problems) do |problems, ruler|
         problems + ruler.problems
@@ -35,5 +80,21 @@ class Tailor
       raise RuntimeError,
         "Ruler#measure called, but should be redefined by a real ruler."
     end
+
+    # Converts the {Tailor::Ruler} name to snake case.
+    #
+    # @return [String] The ruler name as snake-case that represents the problem
+    #   that was found.
+    def problem_type
+      self.class.to_s =~ /^.+::(\S+)Ruler$/
+
+      $1.underscore
+    end
+
+    private
+
+    def add_lexer_observers(*lexer_observer)
+      @lexer_observers = lexer_observer
+    end
   end
 end

data/lib/tailor/rulers/allow_camel_case_methods_ruler.rb

@@ -3,6 +3,11 @@ require_relative '../ruler'
 class Tailor
   module Rulers
     class AllowCamelCaseMethodsRuler < Tailor::Ruler
+      def initialize(style, options)
+        super(style, options)
+        add_lexer_observers :ident
+      end
+
       def ident_update(token, lexed_line, lineno, column)
         ident_index = lexed_line.event_index(column)
         previous_event = lexed_line.event_at(ident_index - 2)
@@ -22,7 +27,10 @@ class Tailor
       # @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)
+          problem_message = "Camel-case method name found."
+
+          @problems << Problem.new(problem_type, lineno, column,
+            problem_message, @options[:level])
         end
       end
     end

data/lib/tailor/rulers/allow_hard_tabs_ruler.rb

@@ -3,6 +3,11 @@ require_relative '../ruler'
 class Tailor
   module Rulers
     class AllowHardTabsRuler < Tailor::Ruler
+      def initialize(config, options)
+        super(config, options)
+        add_lexer_observers :sp
+      end
+
       def sp_update(token, lineno, column)
         measure(token, lineno, column)
       end
@@ -14,7 +19,10 @@ class Tailor
       # @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)
+          problem_message = "Hard tab found."
+
+          @problems << Problem.new(problem_type, lineno, column,
+            problem_message, @options[:level])
         end
       end
     end

data/lib/tailor/rulers/allow_invalid_ruby_ruler.rb

@@ -0,0 +1,38 @@
+require_relative '../ruler'
+
+
+class Tailor
+  module Rulers
+    class AllowInvalidRubyRuler < Tailor::Ruler
+      def initialize(config, options)
+        super(config, options)
+        add_lexer_observers :file_beg
+      end
+
+      def file_beg_update(file_name)
+        @file_name = file_name
+        measure
+      end
+
+      # @return [Boolean]
+      def invalid_ruby?
+        log "Checking for valid Ruby..."
+        result = `ruby -c #{@file_name}`
+
+        result.size.zero?
+      end
+
+      def measure
+        if invalid_ruby? && @config == false
+          lineno = 0
+          column = 0
+          msg = "File contains invalid Ruby; run `ruby -c [your_file.rb]` "
+          msg << "for more details."
+
+          @problems << Problem.new(problem_type, lineno, column, msg,
+            @options[:level])
+        end
+      end
+    end
+  end
+end

data/lib/tailor/rulers/allow_screaming_snake_case_classes_ruler.rb

@@ -3,6 +3,11 @@ require_relative '../ruler'
 class Tailor
   module Rulers
     class AllowScreamingSnakeCaseClassesRuler < Tailor::Ruler
+      def initialize(config, options)
+        super(config, options)
+        add_lexer_observers :const
+      end
+
       def const_update(token, lexed_line, lineno, column)
         ident_index = lexed_line.event_index(column)
         previous_event = lexed_line.event_at(ident_index - 2)
@@ -23,8 +28,10 @@ class Tailor
       # @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)
+          problem_message = "Screaming-snake-case class/module found."
+
+          @problems << Problem.new(problem_type, lineno, column,
+            problem_message, @options[:level])
         end
       end
     end

data/lib/tailor/rulers/allow_trailing_line_spaces_ruler.rb

@@ -3,6 +3,11 @@ require_relative '../ruler'
 class Tailor
   module Rulers
     class AllowTrailingLineSpacesRuler < Tailor::Ruler
+      def initialize(config, options)
+        super(config, options)
+        add_lexer_observers :ignored_nl, :nl
+      end
+
       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?}"
@@ -21,11 +26,11 @@ class Tailor
       # @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)
+          actual = lexed_line.last_non_line_feed_event.last.size
+          problem_message = "Line has #{actual} trailing spaces."
+
+          @problems << Problem.new(problem_type, lineno, column,
+            problem_message, @options[:level])
         end
       end
     end