tailor 1.0.1 → 1.1.0

data/lib/tailor/configuration/file_set.rb

@@ -0,0 +1,110 @@
+require_relative '../runtime_error'
+require_relative '../logger'
+require_relative 'style'
+
+class Tailor
+  class Configuration
+    class FileSet < Hash
+      include Tailor::Logger::Mixin
+
+      DEFAULT_GLOB = 'lib/**/*.rb'
+
+      attr_reader :style
+      attr_accessor :file_list
+
+      # @param [Hash] style Style options to merge into the default Style
+      #   settings.
+      # @param [String,Array] file_expression
+      def initialize(file_expression=nil, style=nil)
+        @style = if style
+          Style.new.to_hash.merge(style)
+        else
+          Style.new.to_hash
+        end
+
+        self[:style] = @style
+
+        file_expression ||= DEFAULT_GLOB
+        @file_list = build_file_list(file_expression)
+        self[:file_list] = @file_list
+      end
+
+      def update_file_list(file_expression)
+        new_list = build_file_list(file_expression)
+        @file_list.concat(new_list).uniq!
+      end
+
+      def update_style(new_style)
+        @style.to_hash.merge!(new_style)
+      end
+
+      def [](key)
+        if key == :style
+          @style.to_hash
+        elsif key == :file_list
+          @file_list
+        else
+          raise Tailor::RuntimeError, "Invalid key requested: #{key}"
+        end
+      end
+
+      def file_list=(file_expression)
+        @file_list = build_file_list(file_expression)
+      end
+
+      private
+
+      # The list of the files in the project to check.
+      #
+      # @param [String] file_expression Path to the file, directory or file_expression to check.
+      # @return [Array] The list of files to check.
+      def build_file_list(file_expression)
+        files_in_project = if file_expression.is_a? Array
+          log "Configured file_expression is an Array: #{file_expression}"
+
+          file_expression.map do |e|
+            if File.directory?(e)
+              all_files_in_dir(e)
+            else
+              e
+            end
+          end.flatten.uniq
+        elsif File.directory? file_expression
+          log "Configured file_expression is an directory: #{file_expression}"
+          all_files_in_dir(file_expression)
+        elsif File.file? file_expression
+          log "Configured file_expression is a single-file: #{file_expression}"
+          [file_expression]
+        else
+          log "Configured file_expression is a glob: #{file_expression}"
+          Dir.glob file_expression
+        end
+
+        list_with_absolute_paths = []
+
+        files_in_project.each do |file|
+          new_file = File.expand_path(file)
+          log "file: #{new_file}"
+
+          if File.exists? new_file
+            list_with_absolute_paths <<  new_file
+          end
+        end
+
+        list_with_absolute_paths.sort
+      end
+
+      # Gets a list of only files that are in +base_dir+.
+      #
+      # @param [String] base_dir The directory to get the file list for.
+      # @return [Array<String>] The List of files.
+      def all_files_in_dir(base_dir)
+        files = Dir.glob(File.join(base_dir, '**', '*')).find_all do |file|
+          file if File.file?(file)
+        end
+
+        files
+      end
+    end
+  end
+end

data/lib/tailor/formatters/text.rb

@@ -1,30 +1,28 @@
-require 'text-table'
 require 'pathname'
+require 'term/ansicolor'
 require_relative '../formatter'
 
+
 class Tailor
   module Formatters
     class Text < Tailor::Formatter
+      include Term::ANSIColor
+
       PROBLEM_LEVEL_COLORS = {
-        error: :red,
-        warn: :yellow
+        error: 'red',
+        warn: 'yellow'
       }
 
-      # @return [String] A line of "#-----", with length determined by +length+.
-      def line(length=79)
-        "##{'-' * length}\n"
+      # @return [String] A line of "#----#-", with length determined by +length+.
+      def line(length=78)
+        "##{'-' * 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"
-        else
-          "# File:\n"
-        end
-
+        message = "# "
+        message << underscore { "File:\n" }
         message << "#   #{file.relative_path_from(@pwd)}\n"
         message << "#\n"
 
@@ -34,13 +32,8 @@ class Tailor
       # @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
-          "# #{'File Set:'.underscore}\n"
-        else
-          "# File Set:\n"
-        end
-
+        message = "# "
+        message << underscore { "File Set:\n" }
         message << "#   #{file_set}\n"
         message << "#\n"
 
@@ -50,46 +43,32 @@ class Tailor
       # @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
-          "# #{'Problems:'.underscore}\n"
-        else
-          "# Problems:\n"
-        end
+        message = "# "
+        message << underscore { "Problems:\n" }
 
         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.send(color).bold}:"
-              msg << "#{problem[:column].to_s.send(color).bold}"
-              msg
-            else
-              "#{problem[:line]}:#{problem[:column]}"
-            end
-          end
-
-          message << if defined? Term::ANSIColor
-            %Q{#  #{(i + 1).to_s.bold}.
-#    * position:  #{position}
-#    * property:  #{problem[:type].to_s.send(color)}
-#    * message:   #{problem[:message].send(color)}
-}
-          else
-            %Q{#  #{(i + 1)}.
-#    * position:  #{position}
-#    * type:      #{problem[:type]}
-#    * message:   #{problem[:message]}
-}
-          end
+          color = PROBLEM_LEVEL_COLORS[problem[:level]] || 'white'
+
+          position = position(problem[:line], problem[:column])
+          message << "#  " + bold { "#{(i + 1)}." } + "\n"
+          message << "#    * position:  "
+          message << bold { instance_eval("#{color} position") } + "\n"
+          message << "#    * property:  "
+          message << instance_eval("#{color} problem[:type].to_s") + "\n"
+          message << "#    * message:   "
+          message << instance_eval("#{color} problem[:message].to_s") + "\n"
         end
 
         message
       end
 
+      # @param [Fixnum] line
+      # @param [Fixnum] column
+      # @return [String] The position the problem was found at.
+      def position(line, column)
+        line == '<EOF>' ? '<EOF>' : "#{line}:#{column}"
+      end
+
       # Prints the report on the file that just got checked.
       #
       # @param [Hash] problems Value should be the file name; keys should be
@@ -104,47 +83,97 @@ class Tailor
         message << file_set_header(file_set_label)
         message << problems_header(problem_list)
 
-        message << <<-MSG
-#
-#-------------------------------------------------------------------------------
-        MSG
+        message << "#\n"
+        message << line
 
         puts message
       end
 
+      MAX_STRING_SIZE = 68
+
       # 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|
-            file = Pathname(file)
-            summary_table.rows << [
-              file.relative_path_from(@pwd), problem_list.size
-            ]
-          end
+        summary_table = summary_header
+        i = 0
 
-          summary_table.rows << :separator
+        problems.each do |file, problem_list|
+          report_line = summary_file_line(file, problem_list)
 
-          problem_levels(problems).inject(summary_table.rows) do |result, level|
-            result << [level.capitalize,
-              problems_at_level(problems, level).size]
+          report_line = if i % 2 == 1
+            on_intense_black { report_line }
+          else
+            bold { report_line }
           end
 
-          summary_table.rows << :separator
-          summary_table.rows << ['TOTAL', problems.values.flatten.size]
+          summary_table << "# " << report_line << reset << "|\n"
+          i += 1
+        end
+
+        summary_table << line
+        summary_table << summary_level_totals(problems)
+        summary_table << "#   " << bold{ summary_first_col('TOTAL', 67) }
+        summary_table << "|"
+        summary_table << bold { total_problems(problems).to_s.rjust(6) }
+        summary_table << " |\n"
+        summary_table << line
+
+        puts summary_table
+      end
+
+      def summary_header
+        summary_table = line
+        summary_table << "# "
+        summary_table << bold { 'Tailor Summary'.rjust(40)  }
+        summary_table << "|\n".rjust(39)
+        summary_table << line
+        summary_table << '#   ' << summary_first_col('File', 67) + '| '
+        summary_table << 'Probs'.rjust(1)
+        summary_table << " |\n".rjust(2)
+        summary_table << line
+
+        summary_table
+      end
+
+      def summary_file_line(file, problem_list)
+        file = Pathname(file)
+        relative_path = file.relative_path_from(@pwd)
+        problem_count = problem_list.size
+
+        "#{summary_first_col(relative_path)} | " + problem_count.to_s.rjust(5) + " "
+      end
 
-          puts summary_table
+      def summary_first_col(path, string_size=MAX_STRING_SIZE)
+        fp = path.to_s.ljust(string_size)
+        offset = fp.size - string_size
+        end_of_string = fp[offset..-1]
+        end_of_string.sub!(/^.{3}/, '...') unless offset.zero?
+
+        end_of_string
+      end
+
+      def summary_level_totals(problems)
+        return "" if total_problems(problems).zero?
+
+        output = problem_levels(problems).inject("") do |result, level|
+          color = PROBLEM_LEVEL_COLORS[level] || 'white'
+
+          result << "#   "
+          result << instance_eval("#{color} { summary_first_col(level.capitalize, 67) }")
+          result << "|"
+          result << instance_eval("#{color} { problems_at_level(problems, level).size.to_s.rjust(6) }")
+          result << " |\n"
         end
+
+        output << line
+
+        output
+      end
+
+      def total_problems(problems)
+        problems.values.flatten.size
       end
     end
   end

data/lib/tailor/rake_task.rb

@@ -0,0 +1,148 @@
+require 'rake'
+require 'rake/tasklib'
+require_relative 'critic'
+require_relative 'configuration'
+require_relative 'logger'
+require_relative 'reporter'
+require_relative 'cli/options'
+
+begin
+  # Support Rake > 0.8.7
+  require 'rake/dsl_definition'
+rescue LoadError
+end
+
+class Tailor
+
+  # This class lets you define Rake tasks to drive tailor.  Specifying options
+  # is similar to specifying options in a configuration file.
+  #
+  # @example Use Tailor CLI Options
+  #   Tailor::RakeTask.new do |task|
+  #     task.tailor_opts = %w(--no-color --max-line-length=100)
+  #   end
+  #
+  # @example A task specifically for features
+  #   Tailor::RakeTask.new(:tailor_features) do |task|
+  #     task.file_set 'features/**/*.rb', :features do |style|
+  #       style.max_line_length 100, level: :warn
+  #       style.trailing_newlines 2
+  #     end
+  #   end
+  #
+  # @example Use and override a configuration file
+  #   Tailor::RakeTask.new do |task|
+  #     task.config_file = 'hardcore_stylin.rb'
+  #     task.file_set 'lib/**/*.rb' do |style|
+  #       style.indentation_spaces 2, level: :warn
+  #     end
+  #   end
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined? ::Rake::DSL
+
+    # Use a specific configuration file.  If you have a .tailor file, your
+    # RakeTask will automatically use that.
+    #
+    # @return [String] The path to the configuration file.
+    attr_accessor :config_file
+
+    # Specify any extra options (CLI options).  These will override any options
+    # set in your config file.
+    attr_accessor :tailor_opts
+
+    attr_accessor :formatters
+
+    # @param [String] name The task name.
+    # @param [String] desc Description of the task.
+    def initialize(name = "tailor", desc = "Check style")
+      Tailor::Logger.log = false
+
+      @name, @desc = name, desc
+      @tailor_opts = []
+      @file_sets = []
+      @recursive_file_sets = []
+
+      yield self if block_given?
+
+      define_task
+    end
+
+    # Add a file set to critique, just like you would in a config file.
+    #
+    # @param [String] file_expression
+    # @param [Symbol] label
+    def file_set(file_expression, label=:default, &block)
+      @file_sets << [file_expression, label, block]
+    end
+
+    # Add a recursive file set to critique, just like you would in a config
+    # file.
+    #
+    # @param [String] file_expression
+    # @param [Symbol] label
+    def recursive_file_set(file_expression, label=:default, &block)
+      @recursive_file_sets << [file_expression, label, block]
+    end
+
+    private
+
+    def define_task
+      desc @desc
+      task @name do
+        if config_file
+          @tailor_opts.concat %W(--config-file=#{config_file})
+        end
+
+        configuration = create_config
+        @reporter = Tailor::Reporter.new(configuration.formatters)
+
+        create_file_sets_for configuration
+        create_recursive_file_sets_for configuration
+        check_default_file_set_in configuration
+
+        critic = Tailor::Critic.new
+
+        critic.critique(configuration.file_sets) do |problems_for_file, label|
+          @reporter.file_report(problems_for_file, label)
+        end
+
+        @reporter.summary_report(critic.problems)
+
+        critic.problem_count > 0
+      end
+    end
+
+    # @return [Tailor::Configuration]
+    def create_config
+      configuration = Tailor::Configuration.new([],
+        Tailor::CLI::Options.parse!(@tailor_opts))
+      configuration.load!
+      configuration.formatters(formatters) if formatters
+
+      configuration
+    end
+
+    # @param [Tailor::Configuration] config
+    def create_recursive_file_sets_for config
+      unless @recursive_file_sets.empty?
+        @recursive_file_sets.each do |fs|
+          config.recursive_file_set(fs[0], fs[1], &fs[2])
+        end
+      end
+    end
+
+    # @param [Tailor::Configuration] config
+    def create_file_sets_for config
+      unless @file_sets.empty?
+        @file_sets.each { |fs| config.file_set(fs[0], fs[1], &fs[2]) }
+      end
+    end
+
+    # @param [Tailor::Configuration] config
+    def check_default_file_set_in config
+      if @file_sets.none? { |fs| fs[1] == :default }
+        config.file_sets.delete(:default)
+      end
+    end
+  end
+end