sugarcane 0.0.1

data/lib/sugarcane/menu.rb

@@ -0,0 +1,228 @@
+require "ncursesw"
+
+module SugarCane
+
+  # Produces a ncurses menu that the user can navigate with:
+  #   J/  K: Move up/down
+  #       Q: Quit
+  #   Enter: Open violation in text editor
+  #
+  # Constructor Parameters:
+  #   checks: like ones produced from style_check.rb or doc_check.rb
+  #   opts: command-line parsed options applied to each check
+  #   height: the maximum number of items that can be in the menu
+  class Menu
+
+  TITLE = <<-'SUGARCANE'
+  ___ _   _  __ _  __ _ _ __ ___ __ _ _ __   ___
+ / __| | | |/ _` |/ _` | '__/ __/ _` | '_ \ / _ \
+ \__ \ |_| | (_| | (_| | | | (_| (_| | | | |  __/
+ |___/\__,_|\__, |\__,_|_|  \___\__,_|_| |_|\___|
+            |___/
+  SUGARCANE
+
+    # Don't trust ncursew keys as they don't always work
+    KEY_C = 99
+    KEY_Q = 113
+    KEY_X = 120
+    KEY_J = 106
+    KEY_K = 107
+    KEY_W = 119
+    KEY_S = 115
+    KEY_O = 111
+    KEY_UP = 259
+    KEY_DOWN = 258
+    KEY_ENTER = 13
+    KEY_SPACE = 32
+
+    def initialize(checks, options, height = 30)
+      @checks = checks
+      @options = options
+      @height = height
+      check_violations
+    end
+
+    def run
+      if @data.nil? or @data.empty?
+        return nil
+      end
+      begin
+        # can't go in separate function because redeclares constants
+        Ncurses.initscr
+        init_ncurses
+        draw_menu(@menu, @menu_position)
+        draw_fix_window(@fix_window)
+        draw_title_window(@title_window)
+        while ch = @menu.wgetch
+          case ch
+          when KEY_K, KEY_W, KEY_UP
+            # draw menu, 'move up'
+            @menu_position -= 1 unless @menu_position == @min_position
+            @data_position -= 1 unless @data_position == 0
+          when KEY_J, KEY_S, KEY_DOWN
+            # draw_info 'move down'
+            @menu_position += 1 unless @menu_position == @max_position
+            @data_position += 1 unless @data_position == @size - 1
+          when KEY_O, KEY_ENTER, KEY_SPACE
+            clean_up
+            selected = @data[@data_position]
+            edit_file(selected[:file], selected[:line])
+            init_ncurses
+            check_violations
+          when KEY_Q, KEY_X
+            clean_up
+            break
+          end
+          # For cycling through the options but is buggy
+          # @data_position = @size - 1 if @data_position < 0
+          # @data_position = 0 if @data_position > @size - 1
+          draw_menu(@menu, @menu_position)
+          draw_fix_window(@fix_window)
+          draw_title_window(@title_window)
+        end
+        return @data[@data_position]
+      ensure
+        clean_up
+      end
+    end
+
+    def draw_menu(menu, active_index=nil)
+      Ncurses.stdscr.border(*([0]*8))
+      Ncurses.stdscr.refresh
+      menu.clear
+      menu.border(*([0]*8))
+      @height.times do |i|
+        menu.move(i + 1, 1)
+        position = i + @data_position - @menu_position
+        file = @data[position][:file]
+        if @data[position][:line]
+          line = " #{@data[position][:line]}: "
+        else
+          line = " "
+        end
+        desc = @data[position][:menu_description] || ""
+        if desc.length > Ncurses.COLS - 10
+          desc << "..."
+        end
+        if i == active_index
+          style = Ncurses::A_STANDOUT
+          menu.attrset(style)
+          menu.addstr(file)
+          menu.addstr(line)
+          menu.addstr(desc)
+          menu.attrset(Ncurses::A_NORMAL)
+        else
+          menu.attrset(Ncurses.COLOR_PAIR(2))
+          menu.addstr(file)
+          menu.attrset(Ncurses.COLOR_PAIR(3))
+          menu.addstr(line)
+          menu.attrset(Ncurses.COLOR_PAIR(4))
+          menu.addstr(desc)
+          # menu.attrset(Ncurses.COLOR_PAIR(1))
+          menu.attrset(Ncurses::A_NORMAL)
+        end
+      end
+      menu.refresh
+      Ncurses.keypad(menu, true)
+    end
+
+    def draw_title_window(window)
+      window.clear
+      # window.border(*([0]*8))
+      window.attrset(Ncurses.COLOR_PAIR(5))
+      window.addstr(TITLE)
+      window.attrset(Ncurses.COLOR_PAIR(1))
+      window.refresh
+    end
+
+    def draw_fix_window(window)
+      window.clear
+      window.border(*([0]*8))
+      window.move(1, 1)
+      line = "Violations left: #{@data.size}"
+      window.addstr(line)
+      window.refresh
+    end
+
+    def init_ncurses
+      Ncurses.cbreak
+      Ncurses.start_color
+      Ncurses.noecho
+      Ncurses.nonl
+      Ncurses.curs_set(0)
+
+      if Ncurses.has_colors?
+        @background_color = Ncurses::COLOR_BLACK
+        Ncurses.init_pair(1, Ncurses::COLOR_WHITE, @background_color)
+        Ncurses.init_pair(2, Ncurses::COLOR_BLUE, @background_color)
+        Ncurses.init_pair(3, Ncurses::COLOR_CYAN, @background_color)
+        Ncurses.init_pair(4, Ncurses::COLOR_RED, @background_color)
+        Ncurses.init_pair(5, Ncurses::COLOR_GREEN, @background_color)
+      end
+
+      @title_window = Ncurses::WINDOW.new(5, Ncurses.COLS - 2,2,1)
+      @menu = Ncurses::WINDOW.new(@height + 2, Ncurses.COLS - 2,7,1)
+      @fix_window = Ncurses::WINDOW.new(3, Ncurses.COLS - 2,@height+9,1)
+    end
+
+    def clean_up
+      Ncurses.stdscr.clear
+      Ncurses.stdscr.refresh
+      Ncurses.echo
+      Ncurses.nocbreak
+      Ncurses.nl
+      Ncurses.endwin
+    end
+
+    def edit_file(file, line)
+      if @options[:editor]
+        system("#{@options[:editor]} +#{line} #{file}")
+      # If someone purchased sublime, they probably want to use it
+      elsif program_exist? "sublimetext"
+        system("sublimetext #{file}:#{line}")
+      elsif ENV['VISUAL']
+        system("#{ENV['VISUAL']} +#{line} #{file}")
+      elsif program_exist? "vim"
+        system("vim +#{line} #{file}")
+      elsif program_exist? "gedit"
+        system("gedit +#{line} #{file}")
+      elsif program_exist? "nano"
+        system("nano +#{line} #{file}")
+      elsif program_exist? "geany"
+        system("geany +#{line} #{file}")
+      else
+        # :(
+        system("notepad.exe #{file}")
+      end
+    end
+
+    # Allegedly cross-platform way to determine if an executable is in PATH
+    def program_exist?(command)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(::File::PATH_SEPARATOR).each do |path|
+        exts.each { |ext|
+          exe = ::File.join(path, "#{command}#{ext}")
+          return exe if ::File.executable? exe
+        }
+      end
+      return nil
+    end
+
+    def check_violations
+      violations = @checks.
+        map {|check| check.new(@options).violations }.
+        flatten
+      @data = violations
+      @height = [@data.size,@height].min
+      @size = @data.size
+      @min_position = 0
+      @max_position = @height - 1
+      @data_position ||= 0
+      @menu_position ||= 0
+      if @data_position > @size - 1
+        @data_position = @size - 1
+      end
+      return violations
+    end
+  end
+end

data/lib/sugarcane/rake_task.rb

@@ -0,0 +1,78 @@
+require 'rake'
+require 'rake/tasklib'
+
+require 'sugarcane/cli/options'
+require 'sugarcane/cli/parser'
+
+module SugarCane
+  # Creates a rake task to run cane with given configuration.
+  #
+  # Examples
+  #
+  #   desc "Run code quality checks"
+  #   Cane::RakeTask.new(:quality) do |cane|
+  #     cane.abc_max = 10
+  #     cane.doc_glob = 'lib/**/*.rb'
+  #     cane.no_style = true
+  #     cane.add_threshold 'coverage/covered_percent', :>=, 99
+  #   end
+  class RakeTask < ::Rake::TaskLib
+    attr_accessor :name
+    attr_reader :options
+
+    SugarCane::CLI.default_options.keys.each do |name|
+      define_method(name) do
+        options.fetch(name)
+      end
+
+      define_method("#{name}=") do |v|
+        options[name] = v
+      end
+    end
+
+    # Add a threshold check. If the file exists and it contains a number,
+    # compare that number with the given value using the operator.
+    def add_threshold(file, operator, value)
+      if operator == :>=
+        @options[:gte] << [file, value]
+      end
+    end
+
+    def use(check, options = {})
+      @options.merge!(options)
+      @options[:checks] = @options[:checks] + [check]
+    end
+
+    def canefile=(file)
+      canefile = SugarCane::CLI::Parser.new
+      canefile.parser.parse!(canefile.read_options_from_file(file))
+      options.merge! canefile.options
+    end
+
+    def initialize(task_name = nil)
+      self.name = task_name || :cane
+      @gte = []
+      @options = SugarCane::CLI.default_options
+      @options[:report] = true
+
+      if block_given?
+        yield self
+      else
+        if File.exists?('./sugarcane')
+          self.canefile = './.sugarcane'
+        else
+          self.canefile = './.cane'
+        end
+      end
+
+      unless ::Rake.application.last_comment
+        desc %(Check code quality metrics with cane)
+      end
+
+      task name do
+        require 'sugarcane/cli'
+        abort unless SugarCane.run(options)
+      end
+    end
+  end
+end

data/lib/sugarcane/runner.rb

@@ -0,0 +1,59 @@
+require 'parallel'
+
+require 'sugarcane/violation_formatter'
+require 'sugarcane/json_formatter'
+require 'sugarcane/menu'
+
+# Accepts a parsed configuration and passes those options to a new Runner
+module SugarCane
+  def run(*args)
+    Runner.new(*args).run
+  end
+  module_function :run
+
+  # Orchestrates the running of checks per the provided configuration, and
+  # hands the result to a formatter for display. This is the core of the
+  # application, but for the actual entry point see `SugarCane::CLI`.
+  class Runner
+    def initialize(spec)
+      @opts = spec
+      @checks = spec[:checks]
+    end
+
+    def run
+      check_options(violations, opts)
+      violations.length <= opts.fetch(:max_violations)
+    end
+
+    protected
+
+    attr_reader :opts, :checks
+
+    def violations
+      @violations ||= checks.
+        map { |check| check.new(opts).violations }.
+        flatten
+    end
+
+    def check_violations
+      @violations = checks.
+        map { |check| check.new(opts).violations }.
+        flatten
+    end
+
+    def check_options(violations, opts)
+      if opts[:report]
+        outputter.print ViolationFormatter.new(violations, opts)
+      elsif opts[:json]
+        outputter.print JsonFormatter.new(violations, opts)
+      else
+        menu = SugarCane::Menu.new(@checks, @opts)
+        menu.run
+      end
+    end
+
+    def outputter
+      opts.fetch(:out, $stdout)
+    end
+  end
+end

data/lib/sugarcane/style_check.rb

@@ -0,0 +1,91 @@
+require 'set'
+
+require 'sugarcane/file'
+require 'sugarcane/task_runner'
+
+module SugarCane
+
+  # Creates violations for files that do not meet style conventions. Only
+  # highly obvious, probable, and non-controversial checks are performed here.
+  # It is not the goal of the tool to provide an extensive style report, but
+  # only to prevent stupid mistakes.
+  class StyleCheck < Struct.new(:opts)
+
+    def self.key; :style; end
+    def self.name; "style checking"; end
+    def self.options
+      {
+        style_glob:    ['Glob to run style checks over',
+                           default:  '{app,lib,spec}/**/*.rb',
+                           variable: 'GLOB',
+                           clobber:  :no_style],
+        style_measure: ['Max line length',
+                           default: 80,
+                           cast:    :to_i,
+                           clobber: :no_style],
+        style_exclude: ['Exclude file or glob from style checking',
+                         variable: 'GLOB',
+                         type: Array,
+                         default: [],
+                         clobber: :no_style],
+        no_style:      ['Disable style checking', cast: ->(x) { !x }]
+      }
+    end
+
+    def violations
+      return [] if opts[:no_style]
+
+      worker.map(file_list) do |file_path|
+        map_lines(file_path) do |line, line_number|
+          violations_for_line(line.chomp).map {|message| {
+            file:        file_path,
+            line:        line_number + 1,
+            value:       line.length,
+            label:       message,
+            description: "Lines violated style requirements",
+            menu_description: message
+          }}
+        end
+      end.flatten
+    end
+
+    protected
+
+    def violations_for_line(line)
+      result = []
+      if line.length > measure
+        result << "Line is > #{measure} characters (#{line.length})"
+      end
+      result << "Line contains trailing whitespace" if line =~ /\s$/
+      result << "Line contains hard tabs"           if line =~ /\t/
+      result
+    end
+
+    def file_list
+      Dir[opts.fetch(:style_glob)].reject {|f| excluded?(f) }
+    end
+
+    def measure
+      opts.fetch(:style_measure)
+    end
+
+    def map_lines(file_path, &block)
+      SugarCane::File.iterator(file_path).map.with_index(&block)
+    end
+
+    def exclusions
+      @exclusions ||= opts.fetch(:style_exclude, []).flatten.map do |i|
+        Dir[i]
+      end.flatten.to_set
+    end
+
+    def excluded?(file)
+      exclusions.include?(file)
+    end
+
+    def worker
+      SugarCane.task_runner(opts)
+    end
+  end
+
+end

data/lib/sugarcane/task_runner.rb

@@ -0,0 +1,20 @@
+# Provides a SimpleTaskRunner or Parallel task runner based on configuration
+module SugarCane
+  def task_runner(opts)
+    if opts[:parallel]
+      Parallel
+    else
+      SimpleTaskRunner
+    end
+  end
+  module_function :task_runner
+
+  # Mirrors the Parallel gem's interface but does not provide any parallelism.
+  # This is faster for smaller tasks since it doesn't incur any overhead for
+  # creating new processes and communicating between them.
+  class SimpleTaskRunner
+    def self.map(enumerable, &block)
+      enumerable.map(&block)
+    end
+  end
+end

data/lib/sugarcane/threshold_check.rb

@@ -0,0 +1,83 @@
+require 'sugarcane/file'
+
+module SugarCane
+
+  # Configurable check that allows the contents of a file to be compared against
+  # a given value.
+  class ThresholdCheck < Struct.new(:opts)
+    THRESHOLDS = {
+      lt:  :<,
+      lte: :<=,
+      eq:  :==,
+      gte: :>=,
+      gt:  :>
+    }
+
+    def self.key; :threshold; end
+    def self.options
+      THRESHOLDS.each_with_object({}) do |(key, value), h|
+        h[key] = ["Check the number in FILE is #{value} to THRESHOLD " +
+                  "(a number or another file name)",
+                    variable: "FILE,THRESHOLD",
+                    type:     Array]
+      end
+    end
+
+    def violations
+      thresholds.map do |operator, file, threshold|
+        value = normalized_limit(file)
+        limit = normalized_limit(threshold)
+
+        if !limit.real?
+          {
+            description: 'Quality threshold could not be read',
+            label:       "%s is not a number or a file" % [
+              threshold
+            ]
+          }
+        elsif !value.send(operator, limit)
+          {
+            description: 'Quality threshold crossed',
+            label:       "%s is %s, should be %s %s" % [
+              file, value, operator, limit
+            ]
+          }
+        end
+      end.compact
+    end
+
+    def normalized_limit(limit)
+      Float(limit)
+    rescue ArgumentError
+      value_from_file(limit)
+    end
+
+    def value_from_file(file)
+      begin
+        contents = SugarCane::File.contents(file).scan(/\d+\.?\d*/).first.to_f
+      rescue Errno::ENOENT
+        UnavailableValue.new
+      end
+    end
+
+    def thresholds
+      THRESHOLDS.map do |k, v|
+        opts.fetch(k, []).map do |x|
+          x.unshift(v)
+        end
+      end.reduce(:+)
+    end
+
+    # Null object for all cases when the value to be compared against cannot be
+    # read.
+    class UnavailableValue
+      def <(_); false; end
+      def >(_); false; end
+      def <=(_); false; end
+      def >=(_); false; end
+      def to_s; 'unavailable'; end
+      def real?; false; end
+    end
+  end
+
+end

data/lib/sugarcane/version.rb

@@ -0,0 +1,3 @@
+module SugarCane
+  VERSION = '0.0.1'
+end

data/lib/sugarcane/violation_formatter.rb

@@ -0,0 +1,75 @@
+require 'stringio'
+require 'ostruct'
+
+module SugarCane
+
+  # Computes a string to be displayed as output from an array of violations
+  # computed by the checks.
+  class ViolationFormatter
+    attr_reader :violations, :options
+
+    def initialize(violations, options = {})
+      @violations = violations.map do |v|
+        v.merge(file_and_line: v[:line] ?
+          "%s:%i" % v.values_at(:file, :line) :
+          v[:file]
+        )
+      end
+
+      @options = options
+    end
+
+    def to_s
+      return "" if violations.empty?
+
+      string = violations.group_by {|x| x[:description] }.map do |d, vs|
+        format_group_header(d, vs) +
+          format_violations(vs)
+      end.join("\n") + "\n\n" + totals + "\n\n"
+
+      if violations.count > options.fetch(:max_violations, 0)
+        string = colorize(string)
+      end
+
+      string
+    end
+
+    protected
+
+    def format_group_header(description, violations)
+      ["", "%s (%i):" % [description, violations.length], ""]
+    end
+
+    def format_violations(violations)
+      columns = [:file_and_line, :label, :value]
+
+      widths = column_widths(violations, columns)
+
+      violations.map do |v|
+        format_violation(v, widths)
+      end
+    end
+
+    def column_widths(violations, columns)
+      columns.each_with_object({}) do |column, h|
+        h[column] = violations.map {|v| v[column].to_s.length }.max
+      end
+    end
+
+    def format_violation(v, column_widths)
+      '  ' + column_widths.keys.map {|column|
+        v[column].to_s.ljust(column_widths[column])
+      }.join('  ').strip
+    end
+
+    def colorize(string)
+      return string unless options[:color]
+
+      "\e[31m#{string}\e[0m"
+    end
+
+    def totals
+      "Total Violations: #{violations.length}"
+    end
+  end
+end