tuxedo 0.9.2

data/lib/tuxedo.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless
+  $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'yaml'
+require 'Open3'
+require 'tuxedo/outputter'
+require 'tuxedo/cane_parser'
+require 'tuxedo/reek_parser'
+require 'tuxedo/error'
+require 'tuxedo/runner'
+require 'tuxedo/tty'
+require 'tuxedo/formatters/cane_text_formatter'
+
+module Tuxedo
+  def self.output_to_console
+    cane_violations = Runner.run_cane
+    formatter = Formatters::CaneTextFormatter.new($stdout)
+    formatter.format(cane_violations)
+    puts ""
+
+    rp = Tuxedo::ReekParser.new
+    reek_output = Tuxedo::Runner.run_reek
+    rp.parse_reek(reek_output)
+    Tuxedo::Outputter.print_to_screen(rp.result) if rp.result.is_a? Hash
+  end
+end

data/lib/tuxedo/cane_parser.rb

@@ -0,0 +1,64 @@
+module Tuxedo
+  class CaneParser
+    attr_accessor :result
+
+    def initialize
+      self.result = { }
+    end
+
+    def parse_cane(output)
+      output.split("\n").each do |line|
+        if has_error?(line)
+          error = process_line(line)
+          push_error(error)
+        end
+      end
+      return self
+    end
+
+    def push_error(error)
+      if self.result[ error.name.to_sym ]
+        self.result[ error.name.to_sym ] << error
+      else
+        self.result[ error.name.to_sym ] = [ error ]
+      end
+    end
+
+    def process_line(line)
+      Tuxedo::Error.new( :name => get_error(line),
+                             :source => get_file(line),
+                             :line => get_lines(line))
+    end
+
+    def has_error?(line)
+      line.include?(">") || line.include?("Line contains trailing whitespaces")
+    end
+
+    def get_error(line)
+      if line.include?("Line is >80 characters")
+        error = "Line is >80 characters"
+      elsif line.include?("Line contains trailing whitespaces")
+        error = "Line contains trailing whitespaces"
+      elsif line.include?(">") # abc complexity errors have a > char too
+        error = "Maximum allowed ABC complexity"
+      end
+      error
+    end
+
+    def get_file(line)
+      if line.include?(":")
+        line.match(/([a-zA-Z0-9.\/_]+):/)[1]
+      else
+        line.split(" ").first
+      end
+    end
+
+    def get_lines(line)
+      if line.include?(":")
+        [ line.match(/:(\d+)/)[1].to_i ]
+      else
+        [ line.split(" ").last.to_i ]
+      end
+    end
+  end
+end

data/lib/tuxedo/cane_violation.rb

@@ -0,0 +1,31 @@
+require 'tuxedo/cane_violation/abc_max_violation'
+require 'tuxedo/cane_violation/undocumented_class_violation'
+require 'tuxedo/cane_violation/style_violation'
+require 'tuxedo/cane_violation/syntax_violation'
+require 'tuxedo/cane_violation/threshold_violation'
+
+module Tuxedo
+  class CaneViolation
+    def self.from_cane(cane_violation)
+      type  = cane_violation.class.name.split('::').last
+      klazz = const_defined?(type) && const_get(type)
+      klazz && klazz.from_cane(cane_violation)
+    end
+
+    def violation_type
+      self.class.name.split("::").last
+    end
+
+    def violation_type_snake_cased
+      _underscore(violation_type)
+    end
+
+    private
+
+    def _underscore(string)
+      string = string.gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      string = string.gsub(/([a-z\d])([A-Z])/,'\1_\2')
+      string.downcase
+    end
+  end
+end

data/lib/tuxedo/cane_violation/abc_max_violation.rb

@@ -0,0 +1,37 @@
+module Tuxedo
+  class CaneViolation
+    class AbcMaxViolation < CaneViolation
+      attr_accessor :file_name, :detail, :complexity
+      attr_accessor :class_name, :method_name, :expression
+
+      def self.from_cane(cane_violation)
+        violation = new
+
+        violation.file_name  = cane_violation.file_name
+        violation.detail     = cane_violation.detail
+        violation.complexity = cane_violation.complexity
+
+        parts = violation.detail.split(" > ")
+        violation.class_name  = parts[-2]
+        violation.method_name = parts[-1]
+        violation.expression  = parts[0..-2].join("::") + "." + parts[-1]
+
+        violation
+      end
+
+      def description
+        "Methods exceeded maximum allowed ABC complexity"
+      end
+
+      def to_hash
+        {
+          :violation_type => violation_type,
+          :file_name      => file_name,
+          :detail         => detail,
+          :complexity     => complexity,
+          :description    => description,
+        }
+      end
+    end
+  end
+end

data/lib/tuxedo/cane_violation/style_violation.rb

@@ -0,0 +1,40 @@
+module Tuxedo
+  class CaneViolation
+    class StyleViolation < CaneViolation
+      attr_accessor :file_name, :line_number, :message
+      attr_accessor :style_violation_type, :max_char_count, :char_count
+
+      def self.from_cane(cane_violation)
+        violation = new
+
+        violation.file_name   = cane_violation.file_name
+        violation.line_number = cane_violation.line
+        violation.message     = cane_violation.message
+
+        if cane_violation.message.match /Line is >(\d+) characters \((\d+)\)/
+          violation.style_violation_type = "LineTooLong"
+          violation.max_char_count       = $1.to_i
+          violation.char_count           = $2.to_i
+        end
+
+        violation
+      end
+
+      def description
+        "Lines violated style requirements"
+      end
+
+      def to_hash
+        {
+          :violation_type       => violation_type,
+          :file_name            => file_name,
+          :line                 => line,
+          :style_violation_type => style_violation_type,
+          :max_char_count       => max_char_count,
+          :char_count           => char_count,
+          :description          => description,
+        }
+      end
+    end
+  end
+end

data/lib/tuxedo/cane_violation/syntax_violation.rb

@@ -0,0 +1,27 @@
+module Tuxedo
+  class CaneViolation
+    class SyntaxViolation < CaneViolation
+      attr_accessor :file_name
+
+      def self.from_cane(cane_violation)
+        violation = new
+
+        violation.file_name   = cane_violation.file_name
+
+        violation
+      end
+
+      def description
+        "Files contained invalid syntax"
+      end
+
+      def to_hash
+        {
+          :violation_type => violation_type,
+          :file_name      => file_name,
+          :description    => description,
+        }
+      end
+    end
+  end
+end

data/lib/tuxedo/cane_violation/threshold_violation.rb

@@ -0,0 +1,33 @@
+module Tuxedo
+  class CaneViolation
+    class ThresholdViolation < CaneViolation
+      attr_accessor :name, :operator, :value, :limit
+
+      def self.from_cane(cane_violation)
+        violation = new
+
+        violation.name     = cane_violation.name
+        violation.operator = cane_violation.operator
+        violation.value    = cane_violation.value
+        violation.limit    = cane_violation.limit
+
+        violation
+      end
+
+      def description
+        "Quality threshold crossed"
+      end
+
+      def to_hash
+        {
+          :violation_type => violation_type,
+          :name           => name,
+          :operator       => operator,
+          :value          => value,
+          :limit          => limit,
+          :description    => description,
+        }
+      end
+    end
+  end
+end

data/lib/tuxedo/cane_violation/undocumented_class_violation.rb

@@ -0,0 +1,35 @@
+module Tuxedo
+  class CaneViolation
+    class UndocumentedClassViolation < CaneViolation
+      attr_accessor :file_name, :line_number, :line
+
+      def self.from_cane(cane_violation)
+        violation = new
+
+        violation.file_name   = cane_violation.file_name
+        violation.line_number = cane_violation.number
+        violation.line        = cane_violation.line
+
+        violation
+      end
+
+      def description
+        "Classes are not documented"
+      end
+
+      def class_name(line)
+        line.match(/class (\S+)/)[1]
+      end
+
+      def to_hash
+        {
+          :violation_type => violation_type,
+          :file_name      => file_name,
+          :line_number    => line_number,
+          :line           => line,
+          :description    => description,
+        }
+      end
+    end
+  end
+end

data/lib/tuxedo/cli.rb

@@ -0,0 +1,18 @@
+module Tuxedo
+  module Cli extend self
+    class CliResult < Struct.new(:stdout, :stderr, :exit_status)
+      def exit_code
+        exit_status.exitstatus
+      end
+    end
+
+    def sh(cmd)
+      Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+        pid = wait_thr.pid # pid of the started process.
+        exit_status = wait_thr.value
+
+        CliResult.new(stdout.read, stderr.read, exit_status)
+      end
+    end
+  end
+end

data/lib/tuxedo/error.rb

@@ -0,0 +1,15 @@
+module Tuxedo
+  class Error
+    attr_accessor :name, :source, :line
+
+    def initialize(params)
+      self.name = params[:name]
+      self.source = params[:source]
+      self.line = params[:line]
+    end
+
+    def print
+      "#{self.source} #{self.line}"
+    end
+  end
+end

data/lib/tuxedo/formatters/base_formatter.rb

@@ -0,0 +1,17 @@
+require 'stringio'
+
+module Tuxedo
+  module Formatters
+    class BaseFormatter
+      attr_reader :output
+
+      def initialize(output=nil)
+        @output = output || StringIO.new
+      end
+
+      def format(metrics)
+        # NOP
+      end
+    end
+  end
+end

data/lib/tuxedo/formatters/base_text_formatter.rb

@@ -0,0 +1,13 @@
+require 'tuxedo/formatters/base_formatter'
+
+module Tuxedo
+  module Formatters
+    class BaseTextFormatter < BaseFormatter
+      include Tty
+
+      def message(message)
+        output.puts message
+      end
+    end
+  end
+end

data/lib/tuxedo/formatters/cane_text_formatter.rb

@@ -0,0 +1,68 @@
+require 'tuxedo/formatters/base_text_formatter'
+
+module Tuxedo
+  module Formatters
+    class CaneTextFormatter < BaseTextFormatter
+      def format(violations)
+        with_color(STDOUT.tty?) do
+          format_violations_of_type(violations, "AbcMaxViolation")
+          format_style_violations(violations)
+          format_violations_of_type(violations, "SyntaxViolation")
+          format_violations_of_type(violations, "ThresholdViolation")
+          format_violations_of_type(violations, "UndocumentedClassViolation", :line_number)
+        end
+      end
+
+      private
+
+      def format_violations_of_type(violations, type, selector=nil)
+        violations = violations.select {|v| v.violation_type == type}.group_by(&:file_name)
+
+        if violations.any?
+          message yellow type
+          message_separator
+
+          format_grouped_by_file_name(violations, selector)
+          message ""
+        end
+      end
+
+      def format_style_violations(violations)
+        # Too Long Lines
+        style_violations = violations.select {|v| v.violation_type == "StyleViolation"}
+        too_long_lines =
+          style_violations.
+            select {|v| v.style_violation_type == "LineTooLong"}.
+            group_by(&:file_name)
+
+        if too_long_lines.any?
+          max = too_long_lines.values.first.first.max_char_count
+          message yellow "Line is >#{max} characters"
+          message_separator
+          format_grouped_by_file_name(too_long_lines, :line_number)
+          message ""
+        end
+      end
+
+      def message_separator
+        message green "------------------------------------"
+      end
+
+      def format_grouped_by_file_name(violations, selector=nil)
+        return unless violations.any?
+
+        if selector
+          violations.each do |file, vs|
+            puts violations.to_a if vs.nil?
+            lines = vs.map {|v| green v.send(selector)}.join(", ")
+            message "#{file} [#{lines}]"
+          end
+        else
+          violations.each do |file, vs|
+            message file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tuxedo/outputter.rb

@@ -0,0 +1,16 @@
+module Tuxedo
+  class Outputter
+    def self.print_to_screen(error_collection)
+      #errors will be hash of errors
+
+      error_collection.each do |error_type, errors|
+        puts error_type
+        puts "------------------------------------"
+        errors.each do |error|
+          puts error.print
+        end
+        puts
+      end
+    end
+  end
+end