maximus 0.1.0

data/lib/maximus/helper.rb

@@ -0,0 +1,137 @@
+require 'rainbow'
+require 'rainbow/ext/string'
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+require 'yaml'
+
+module Maximus
+  module Helper
+
+    # See if Rails or a framework, i.e. Middleman
+    # This will usually be stored as a class variable in the inherited class, like @@is_rails = is_rails? in lint.rb
+    # Returns Boolean
+    def is_rails?
+      defined?(Rails)
+    end
+
+    # Get root directory of file being called
+    # Returns String (path)
+    def root_dir
+      is_rails? ? Rails.root.to_s : Dir.pwd.to_s
+    end
+
+    # Verify that node module is installed on the box before continuing
+    # Continues if module exists
+    def node_module_exists(node_module, install_instructions = 'npm install -g')
+      cmd = `if hash #{node_module} 2>/dev/null; then
+        echo "true"
+      else
+        echo "false"
+      fi`
+      if cmd.include? "false"
+        command_msg = "Missing command #{node_module}".color(:red)
+        abort "#{command_msg}: Please run `#{install_instructions} #{node_module}` And try again\n"
+      end
+    end
+
+    # Look for a custom config in the app's config/ directory; otherwise, use the built-in one
+    # TODO - best practice that this inherits the @opts from the model it's being included in?
+    # Returns String
+    def check_default(filename)
+      user_file = "#{@opts[:root_dir]}/config/#{filename}"
+      File.exist?(user_file) ? user_file : File.join(File.dirname(__FILE__), "config/#{filename}")
+    end
+
+    # Grab the absolute path of the reporter file
+    # Returns String
+    def reporter_path(filename)
+      File.join(File.dirname(__FILE__),"reporter/#{filename}")
+    end
+
+    # Find all files that were linted by extension
+    # Returns Array
+    def file_list(path, ext = 'scss', remover = '')
+      # Necessary so that directories aren't counted
+      collect_path = path.include?("*") ? path : "#{path}/**/*.#{ext}"
+      # Remove first slash from path if present. probably a better way to do this.
+      Dir[collect_path].collect { |file| file.gsub(remover, '').gsub(/^\/app\//, 'app/') if File.file?(file) }
+    end
+
+    # Count how many files were linted
+    # Returns Integer
+    def file_count(path, ext = 'scss')
+      file_list(path, ext).length
+    end
+
+    # Convert string to boolean
+    # Returns Boolean
+    def truthy(str)
+      return true if str == true || str =~ (/^(true|t|yes|y|1)$/i)
+      return false if str == false || str.blank? || str =~ (/^(false|f|no|n|0)$/i)
+    end
+
+    # Edit and save a YAML file
+    # Returns closed File
+    def edit_yaml(yaml_location, &block)
+      d = YAML.load_file(yaml_location)
+      block.call(d)
+      File.open(yaml_location, 'w') {|f| f.write d.to_yaml }
+    end
+
+    # Request user input
+    # Returns user input as String
+    def prompt(*args)
+      print(*args)
+      STDIN.gets
+    end
+
+    # Defines base log
+    # Returns @@log variable for use
+    def mlog
+      @@log ||= Logger.new(STDOUT)
+      @@log.level ||= Logger::INFO
+      @@log
+    end
+
+    # Determine if current process was called by a rake task
+    # Returns Boolean
+    # http://stackoverflow.com/questions/2467208/how-can-i-tell-if-rails-code-is-being-run-via-rake-or-script-generate
+    def is_rake_task?
+      File.basename($0) == 'rake'
+    end
+
+    # Convert the array from lines_added into spelled-out ranges
+    # Example: lines_added = {'filename' => ['0..10', '11..14']}
+    # Becomes {'filename' => {[0,1,2,3,4,5,6,7,8,9,10], [11,12,13,14]}}
+    # This is a git_control helper primarily but it's used in Lint
+    # TODO - I'm sure there's a better way of doing this
+    # TODO - figure out a better place to put this than in Helper
+    # Returns Hash of spelled-out arrays of integers
+    def lines_added_to_range(file)
+      changes_array = file[:changes].map { |ch| ch.split("..").map(&:to_i) }
+      changes_array.map { |e| (e[0]..e[1]).to_a }.flatten!
+    end
+
+    # Ensure @path exists
+    # Returns Boolean
+    def path_exists(path = @path)
+      path = path.split(' ') if path.is_a?(String) && path.include?(' ')
+      if path.is_a?(Array)
+        path.each do |p|
+          unless File.exist?(p)
+            puts "#{p} does not exist"
+            return false
+          end
+        end
+      else
+        if File.exist?(path)
+          return true
+        else
+          puts "#{path} does not exist"
+          return false
+        end
+      end
+    end
+
+  end
+end

data/lib/maximus/lint.rb

@@ -0,0 +1,201 @@
+require 'json'
+
+module Maximus
+  class Lint
+    attr_accessor :output
+
+    include Helper
+
+    # opts - Lint options (default: {})
+    #    :is_dev
+    #    :git_files
+    #    :root_dir
+    #    :path
+    # all lints should start with the following defined:
+    # def result method to handle the actual parsing
+    # TODO - should this be def output to be more consistent?
+    # Didn't want to trip over the instance variable @output
+    # `@task = 'name'` (__method__.to_s works fine)
+    # `@path ||= 'path/or/**/glob/to/files'` (string)
+    # they should contain the data output from the linter in JSON or
+    # JSON.parse format with the styles defined in README.md
+    # they should end with something similar to
+    # `@output[:files_inspected] ||= files_inspected(extension, delimiter, base_path_replacement)`
+    # `refine data_from_output`
+    def initialize(opts = {})
+      opts[:is_dev] ||= false
+      opts[:root_dir] ||= root_dir
+
+      @@log ||= mlog
+      @@is_rails ||= is_rails?
+      @@is_dev = opts[:is_dev]
+      @path = opts[:path]
+      @opts = opts
+      @output = {}
+    end
+
+    # Convert raw data into warnings, errors, conventions or refactors. Use this wisely.
+    # Returns complete @output as Hash
+    def refine(data)
+      # Prevent abortive empty JSON.parse error
+      data = '{}' if data.blank?
+      data = data.is_a?(String) ? JSON.parse(data) : data
+      @output[:relevant_lints] = relevant_lints( data, @opts[:git_files] ) unless @opts[:git_files].blank?
+      if @opts[:commit]
+        data = @output[:relevant_lints]
+      end
+      lint_warnings = []
+      lint_errors = []
+      lint_conventions = []
+      lint_refactors = []
+      unless data.blank?
+        data.each do |filename, error_list|
+          error_list.each do |message|
+            # so that :raw_data remains unaffected
+            message = message.clone
+            message.delete('length')
+            message['filename'] = filename
+            if message['severity'] == 'warning'
+              message.delete('severity')
+              lint_warnings << message
+            elsif message['severity'] == 'error'
+              message.delete('severity')
+              lint_errors << message
+            elsif message['severity'] == 'convention'
+              message.delete('severity')
+              lint_conventions << message
+            elsif message['severity'] == 'refactor'
+              message.delete('severity')
+              lint_refactors << message
+            end
+          end
+        end
+      end
+      @output[:lint_errors] = lint_errors
+      @output[:lint_warnings] = lint_warnings
+      @output[:lint_conventions] = lint_conventions
+      @output[:lint_refactors] = lint_refactors
+      lint_count = (lint_errors.length + lint_warnings.length + lint_conventions.length + lint_refactors.length)
+      if @@is_dev
+        lint_dev_format data unless data.blank?
+        puts lint_summarize
+        lint_ceiling lint_count
+      else
+        @@log.info lint_summarize
+        # Because this should be returned in the format it was received
+        @output[:raw_data] = data.to_json
+      end
+      @output
+    end
+
+
+    protected
+
+    # List all files inspected
+    # Returns Array
+    def files_inspected(ext, delimiter = ',', replace = @opts[:root_dir])
+      @path.is_a?(Array) ? @path.split(delimiter) : file_list(@path, ext, replace)
+    end
+
+    # Compare lint output with lines changed in commit
+    # Returns Array of lints that match the lines in commit
+    def relevant_lints(lint, files)
+      all_files = {}
+      files.each do |file|
+
+        # sometimes data will be blank but this is good - it means no errors raised in the lint
+        unless lint.blank?
+          lint_file = lint[file[:filename].to_s]
+
+          expanded = lines_added_to_range(file)
+          revert_name = file[:filename].gsub("#{@opts[:root_dir]}/", '')
+          unless lint_file.blank?
+            all_files[revert_name] = []
+
+            # TODO - originally I tried .map and delete_if, but this works,
+            # and the other method didn't cover all bases.
+            # Gotta be a better way to write this though
+            lint_file.each do |l|
+              if expanded.include?(l['line'].to_i)
+                all_files[revert_name] << l
+              end
+            end
+            # If there's nothing there, then it definitely isn't a relevant lint
+            all_files.delete(revert_name) if all_files[revert_name].blank?
+          end
+        else
+          # Optionally store the filename with a blank array
+          # all_files[file[:filename].to_s.gsub("#{@opts[:root_dir]}/", '')] = []
+        end
+      end
+      @output[:files_linted] = all_files.keys
+      all_files
+    end
+
+
+    private
+
+    # Send abbreviated results to console or to the log
+    # Returns console message
+    def lint_summarize
+      puts "\n" if @@is_dev
+
+      puts "#{'Warning'.color(:red)}: #{@output[:lint_errors].length} errors found in #{@task.to_s}" if @output[:lint_errors].length > 0
+
+      success = @task.to_s.color(:green)
+      success += ": "
+      success += "[#{@output[:lint_warnings].length}]".color(:yellow)
+      success += " " + "[#{@output[:lint_errors].length}]".color(:red)
+      if @task == 'rubocop'
+        success += " " + "[#{@output[:lint_conventions].length}]".color(:cyan)
+        success += " " + "[#{@output[:lint_refactors].length}]".color(:white)
+      end
+
+      success
+    end
+
+    # If there's just too much to handle, through a warning. MySQL may not store everything and throw an abortive error if the blob is too large
+    # Returns prompt if lint_length is greater than 100
+    # If prompt returns truthy, execution continues
+    def lint_ceiling(lint_length)
+      if lint_length > 100
+        lint_dev_format
+        failed_task = "#{@task}".color(:green)
+        errors = Rainbow("#{lint_length} failures.").red
+        errormsg = ["You wouldn't stand a chance in Rome.\nResolve thy errors and train with #{failed_task} again.", "The gods frown upon you, mortal.\n#{failed_task}. Again.", "Do not embarrass the city. Fight another day. Use #{failed_task}.", "You are without honor. Replenish it with another #{failed_task}.", "You will never claim the throne with a performance like that.", "Pompeii has been lost.", "A wise choice. Do not be discouraged from another #{failed_task}."].sample
+        errormsg += "\n\n"
+
+        go_on = prompt "\n#{errors} Continue? (y/n) "
+        abort errormsg unless truthy(go_on)
+      end
+    end
+
+    # Dev display, used for the rake task
+    # Returns console message
+    def lint_dev_format(errors = @output[:raw_data])
+      pretty_output = ''
+      errors.each do |filename, error_list|
+        pretty_output += "\n"
+        filename = filename.gsub("#{@opts[:root_dir]}/", '')
+        pretty_output += filename.color(:cyan).underline
+        pretty_output += "\n"
+        error_list.each do |message|
+          pretty_output += case message['severity']
+            when 'warning' then 'W'.color(:yellow)
+            when 'error' then 'E'.color(:red)
+            when 'convention' then 'C'.color(:cyan)
+            when 'refactor' then 'R'.color(:white)
+            else '?'.color(:blue)
+          end
+          pretty_output += ' '
+          pretty_output += message['line'].to_s.color(:blue)
+          pretty_output += " #{message['linter'].color(:green)}: "
+          pretty_output += message['reason']
+          pretty_output += "\n"
+        end
+      end
+      puts pretty_output
+    end
+
+  end
+end

data/lib/maximus/lints/brakeman.rb

@@ -0,0 +1,61 @@
+module Maximus
+  class Brakeman < Maximus::Lint
+
+    # Brakeman (requires Rails)
+    def result
+
+      return unless @@is_rails
+
+      @task = 'brakeman'
+      @path ||= @opts[:root_dir]
+
+      return unless path_exists(@path)
+
+      tmp = Tempfile.new('brakeman')
+      quietly { `brakeman #{@path} -f json -o #{tmp.path} -q` }
+      brakeman = tmp.read
+      tmp.close
+      tmp.unlink
+
+      unless brakeman.blank?
+        bjson = JSON.parse(brakeman)
+        @output[:ignored_warnings] = bjson['scan_info']['ignored_warnings']
+        @output[:checks_performed] = bjson['scan_info']['checks_performed']
+        @output[:number_of_controllers] = bjson['scan_info']['number_of_controllers']
+        @output[:number_of_models] = bjson['scan_info']['number_of_models']
+        @output[:number_of_templates] = bjson['scan_info']['number_of_templates']
+        @output[:ruby_version] = bjson['scan_info']['ruby_version']
+        @output[:rails_version] = bjson['scan_info']['rails_version']
+        brakeman = {}
+        ['warnings', 'errors'].each do |type|
+          new_brakeman = bjson[type].group_by { |s| s['file'] }
+          new_brakeman.each do |file, errors|
+            if file
+              brakeman[file.to_sym] = errors.map { |e| hash_for_brakeman(e, type) }
+            end
+          end
+        end
+        brakeman = JSON.parse(brakeman.to_json) #don't event ask
+      end
+
+      @output[:files_inspected] ||= files_inspected('rb', ' ')
+      refine brakeman
+    end
+
+
+    private
+
+    # Convert to maximus format
+    def hash_for_brakeman(error, type)
+      {
+        linter: error['warning_type'],
+        severity: type.chomp('s'),
+        reason: error['message'],
+        column: 0,
+        line: error['line'].to_i,
+        confidence: error['confidence']
+      }
+    end
+
+  end
+end

data/lib/maximus/lints/jshint.rb

@@ -0,0 +1,20 @@
+module Maximus
+  class Jshint < Maximus::Lint
+
+    # JSHint (requires node module)
+    def result
+      @task = 'jshint'
+      @path ||= @@is_rails ? "#{@opts[:root_dir]}/app/assets" : "#{@opts[:root_dir]}source/assets"
+
+      return unless path_exists(@path)
+
+      node_module_exists(@task)
+
+      jshint = `jshint #{@path} --config=#{check_default('jshint.json')} --exclude-path=#{check_default('.jshintignore')} --reporter=#{reporter_path('jshint.js')}`
+
+      @output[:files_inspected] ||= files_inspected('js')
+      refine jshint
+    end
+
+  end
+end

data/lib/maximus/lints/railsbp.rb

@@ -0,0 +1,51 @@
+module Maximus
+  class Railsbp < Maximus::Lint
+
+    # rails_best_practice (requires Rails)
+    def result
+
+      return unless @@is_rails
+
+      @task = 'railsbp'
+      @path ||= @opts[:root_dir]
+
+      return unless path_exists(@path)
+
+      tmp = Tempfile.new('railsbp')
+      `rails_best_practices #{@path} -f json --output-file #{tmp.path}`
+      railsbp = tmp.read
+      tmp.close
+      tmp.unlink
+
+      unless railsbp.blank?
+        rbj = JSON.parse(railsbp).group_by { |s| s['filename'] }
+        railsbp = {}
+        rbj.each do |file, errors|
+          if file
+            # This crazy gsub grapbs scrubs the absolute path from the filename
+            railsbp[file.gsub(Rails.root.to_s, '')[1..-1].to_sym] = errors.map { |o| hash_for_railsbp(o) }
+          end
+        end
+        railsbp = JSON.parse(railsbp.to_json) #don't event ask
+      end
+
+      @output[:files_inspected] ||= files_inspected('rb', ' ')
+      refine railsbp
+    end
+
+
+    private
+
+    # Convert to maximus format
+    def hash_for_railsbp(error)
+      {
+        linter: error['message'].gsub(/\((.*)\)/, '').strip.parameterize('_').camelize,
+        severity: 'warning',
+        reason: error['message'],
+        column: 0,
+        line: error['line_number'].to_i
+      }
+    end
+
+  end
+end