tailor 1.0.0.alpha2 → 1.0.0

data/lib/tailor/configuration/style.rb

@@ -0,0 +1,85 @@
+class Tailor
+  class Configuration
+    class Style
+
+      # Adds a style property to a Style object.  If you're planning on creating
+      # your own {Ruler}, you need to register the property here.
+      #
+      # Defines a method from +name+ that takes 2 parameters: +value+ and
+      # +options+.  +value+ is the value to use for the {Ruler} of the same +name+
+      # for checking style. +options+ can include anything that's necessary for
+      # style checking.  A +:level+ option key is used to determine the
+      # {Tailor::Problem} level:
+      # * +:error+ results in a exit status of 1.
+      # * +:warn+ results in an exit status of 0, but gets printed in the
+      #   report.
+      #
+      # Example:
+      #   Tailor::Configuration::Style.define_property(:my_style_property)
+      #   style = Tailor::Configuration::Style.new
+      #   style.my_style_property(100, level: :warn)
+      def self.define_property(name)
+        define_method(name) do |value, *options|
+          options = options.first || { level: :error }
+          instance_variable_set("@#{name}".to_sym, [value, options])
+        end
+      end
+
+      define_property :allow_camel_case_methods
+      define_property :allow_hard_tabs
+      define_property :allow_screaming_snake_case_classes
+      define_property :allow_trailing_line_spaces
+      define_property :allow_invalid_ruby
+      define_property :indentation_spaces
+      define_property :max_code_lines_in_class
+      define_property :max_code_lines_in_method
+      define_property :max_line_length
+      define_property :spaces_after_comma
+      define_property :spaces_after_lbrace
+      define_property :spaces_after_lbracket
+      define_property :spaces_after_lparen
+      define_property :spaces_before_comma
+      define_property :spaces_before_lbrace
+      define_property :spaces_before_rbrace
+      define_property :spaces_before_rbracket
+      define_property :spaces_before_rparen
+      define_property :spaces_in_empty_braces
+      define_property :trailing_newlines
+
+      # Sets up default values.
+      def initialize
+        allow_camel_case_methods(false, level: :error)
+        allow_hard_tabs(false, level: :error)
+        allow_screaming_snake_case_classes(false, level: :error)
+        allow_trailing_line_spaces(false, level: :error)
+        allow_invalid_ruby(false, level: :warn)
+        indentation_spaces(2, level: :error)
+        max_code_lines_in_class(300, level: :error)
+        max_code_lines_in_method(30, level: :error)
+        max_line_length(80, level: :error)
+        spaces_after_comma(1, level: :error)
+        spaces_after_lbrace(1, level: :error)
+        spaces_after_lbracket(0, level: :error)
+        spaces_after_lparen(0, level: :error)
+        spaces_before_comma(0, level: :error)
+        spaces_before_lbrace(1, level: :error)
+        spaces_before_rbrace(1, level: :error)
+        spaces_before_rbracket(0, level: :error)
+        spaces_before_rparen(0, level: :error)
+        spaces_in_empty_braces(0, level: :error)
+        trailing_newlines(1, level: :error)
+      end
+
+      # Returns the current style as a Hash.
+      #
+      # @return [Hash]
+      def to_hash
+        instance_variables.inject({}) do |result, ivar|
+          result[ivar.to_s.sub(/@/, '').to_sym] = instance_variable_get(ivar)
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/tailor/critic.rb

@@ -1,137 +1,57 @@
-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
+
+  # An object of this type provides for starting the process of critiquing
+  # files.  It handles initializing the Ruler objects it needs based on the
+  # configuration given to it.
   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
+    # The instance method that starts the process of looking for problems in
+    # files.  It checks for problems in each file in each file set.  It yields
+    # the problems found and the label they were found for.
+    #
+    # @param [Hash] file_sets The file sets to critique.
+    # @yieldparam [Hash] problems The problems found for the label.
+    # @yieldparam [Symbol] label The label the problems were found for.
+    def critique(file_sets)
+      log "file sets keys: #{file_sets.keys}"
 
-    def critique
-      log "file sets keys: #{@file_sets.keys}"
-      @file_sets.each do |label, file_set|
+      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])
+
+          begin
+            problems = check_file(file, file_set[:style])
+          rescue => ex
+            $stderr.puts "Error while parsing file #{file}"
+            raise(ex)
+          end
+
           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
+    # @return [Hash]
+    def problems
+      @problems ||= {}
     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
+    # @return [Fixnum] The number of problems found so far.
+    def problem_count
+      problems.values.flatten.size
     end
 
-    # Adds problems found from Lexing to the {problems} list.
+    # 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.
@@ -139,24 +59,54 @@ class Tailor
       log "<#{self.class}> Checking style of file: #{file}."
       lexer = Tailor::Lexer.new(file)
       ruler = Ruler.new
-      log "Style: #{style}"
+      log "Style:"
+      style.each { |property, values| log "#{property}: #{values}" }
       init_rulers(style, lexer, ruler)
 
       lexer.lex
-      lexer.check_added_newline
       problems[file] = ruler.problems
 
       { file => problems[file] }
     end
 
-    # @return [Hash]
-    def problems
-      @problems ||= {}
+    private
+
+    # Creates Rulers for each ruler given in +style+ and adds the Ruler's
+    # defined observers to the given +lexer+.
+    #
+    # @param [Hash] style The Hash that defines the style to be measured
+    #   against.
+    # @param [Tailor::Lexer] lexer The Lexer object the Rulers should observe.
+    # @param [Tailor::Ruler] parent_ruler The main Ruler to add the child
+    #   Rulers to.
+    def init_rulers(style, lexer, parent_ruler)
+      style.each do |ruler_name, values|
+        ruler = "Tailor::Rulers::#{camelize(ruler_name.to_s)}Ruler"
+
+        if values.last[:level] == :off || values.last[:level] == "off"
+          msg = "Style option set to '#{values.last[:level]}'; "
+          log msg << "skipping init of '#{ruler}'"
+          next
+        end
+
+        log "Initializing ruler: #{ruler}"
+        ruler = instance_eval("#{ruler}.new(#{values.first}, #{values.last})")
+        parent_ruler.add_child_ruler(ruler)
+
+        ruler.lexer_observers.each do |observer|
+          log "Adding #{observer} to lexer..."
+          meth = "add_#{observer}_observer".to_sym
+          lexer.send(meth, ruler)
+        end
+      end
     end
 
-    # @return [Fixnum] The number of problems found so far.
-    def problem_count
-      problems.values.flatten.size
+    # 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
   end
 end

data/lib/tailor/formatter.rb

@@ -0,0 +1,38 @@
+class Tailor
+
+  # This is really just a base class for defining other Formatter types.
+  class Formatter
+    def initialize
+      @pwd = Pathname(Dir.pwd)
+    end
+
+    # This method gets called by {Tailor::Reporter} after each file is
+    # critiqued.  Redefine this to do what you want for that part of your
+    # report.
+    def file_report(file_problems, label)
+      # Redefine this for your formatter...
+    end
+
+    # This method gets called by {Tailor::Reporter} after all files are
+    # critiqued.  Redefine this to do what you want for that part of your
+    # report.
+    def summary_report(all_problems)
+      # Redefine this for your formatter...
+    end
+
+    # @param [Hash<Array>] problems
+    # @param [Symbol] level The level of problem to find.
+    # @return [Array] Problem list at the given level.
+    def problems_at_level(problems, level)
+      problems.values.flatten.find_all { |v| v[:level] == level }
+    end
+
+    # Gets a list of all types of problems included in the problem set.
+    #
+    # @param [Array] problems
+    # @return [Array<Symbol>] The list of problem types.
+    def problem_levels(problems)
+      problems.values.flatten.collect { |v| v[:level] }.uniq
+    end
+  end
+end

data/lib/tailor/formatters/text.rb

@@ -1,13 +1,23 @@
 require 'text-table'
+require 'pathname'
+require_relative '../formatter'
 
 class Tailor
-  module Formatter
-    class Text
+  module Formatters
+    class Text < Tailor::Formatter
+      PROBLEM_LEVEL_COLORS = {
+        error: :red,
+        warn: :yellow
+      }
+
+      # @return [String] A line of "#-----", with length determined by +length+.
       def line(length=79)
         "##{'-' * length}\n"
       end
 
+      # @return [String] The portion of the header that displays the file info.
       def file_header(file)
+        file = Pathname(file)
         message = ""
         message << if defined? Term::ANSIColor
           "# #{'File:'.underscore}\n"
@@ -15,12 +25,14 @@ class Tailor
           "# File:\n"
         end
 
-        message << "#   #{file}\n"
+        message << "#   #{file.relative_path_from(@pwd)}\n"
         message << "#\n"
 
         message
       end
 
+      # @return [String] The portion of the header that displays the file_set
+      #   label info.
       def file_set_header(file_set)
         message = ""
         message << if defined? Term::ANSIColor
@@ -35,6 +47,8 @@ class Tailor
         message
       end
 
+      # @return [String] The portion of the report that displays all of the
+      #   problems for the file.
       def problems_header(problem_list)
         message = ""
         message << if defined? Term::ANSIColor
@@ -44,12 +58,14 @@ class Tailor
         end
 
         problem_list.each_with_index do |problem, i|
+          color = PROBLEM_LEVEL_COLORS[problem[:level]] || :white
+
           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 = "#{problem[:line].to_s.send(color).bold}:"
+              msg << "#{problem[:column].to_s.send(color).bold}"
               msg
             else
               "#{problem[:line]}:#{problem[:column]}"
@@ -59,8 +75,8 @@ class Tailor
           message << if defined? Term::ANSIColor
             %Q{#  #{(i + 1).to_s.bold}.
 #    * position:  #{position}
-#    * type:      #{problem[:type].to_s.red}
-#    * message:   #{problem[:message].red}
+#    * property:  #{problem[:type].to_s.send(color)}
+#    * message:   #{problem[:message].send(color)}
 }
           else
             %Q{#  #{(i + 1)}.
@@ -111,12 +127,21 @@ class Tailor
           summary_table.rows << :separator
 
           problems.each do |file, problem_list|
-            summary_table.rows << [file, problem_list.size]
+            file = Pathname(file)
+            summary_table.rows << [
+              file.relative_path_from(@pwd), problem_list.size
+            ]
+          end
+
+          summary_table.rows << :separator
+
+          problem_levels(problems).inject(summary_table.rows) do |result, level|
+            result << [level.capitalize,
+              problems_at_level(problems, level).size]
           end
 
           summary_table.rows << :separator
-          summary_table.rows << ['TOTAL', problems.values.
-            map { |v| v.size }.inject(:+)]
+          summary_table.rows << ['TOTAL', problems.values.flatten.size]
 
           puts summary_table
         end