codeclimate 0.0.0 → 0.0.1

data/lib/cc/analyzer/formatters/json_formatter.rb

@@ -0,0 +1,28 @@
+module CC
+  module Analyzer
+    module Formatters
+      class JSONFormatter < Formatter
+
+        def engine_running(engine)
+          @active_engine = engine
+          yield
+          @active_engine = nil
+        end
+
+        def write(data)
+          return unless data.present?
+
+          document = JSON.parse(data)
+          document["engine_name"] = @active_engine.name
+          puts document.to_json
+        end
+
+        def failed(output)
+          $stderr.puts "\nAnalysis failed with the following output:"
+          $stderr.puts output
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/formatters/plain_text_formatter.rb

@@ -0,0 +1,114 @@
+require "rainbow"
+require "tty/spinner"
+require "active_support/number_helper"
+
+module CC
+  module Analyzer
+    module Formatters
+      class PlainTextFormatter < Formatter
+
+        def started
+          puts colorize("Starting analysis", :green)
+        end
+
+        def write(data)
+          if data.present?
+            json = JSON.parse(data)
+            if @active_engine
+              json["engine_name"] = @active_engine.name
+            end
+
+            case json["type"].downcase
+            when "issue"
+              issues << json
+            when "warning"
+              warnings << json
+            else
+              raise "Invalid type found: #{json["type"]}"
+            end
+          end
+        end
+
+        def finished
+          puts
+
+          issues_by_path.each do |path, file_issues|
+            puts colorize("== #{path} (#{pluralize(file_issues.size, "issue")}) ==", :yellow)
+
+            IssueSorter.new(file_issues).by_location.each do |issue|
+              if location = issue["location"]
+                print(colorize(LocationDescription.new(location, ": "), :cyan))
+              end
+
+              print(issue["description"])
+              print(colorize(" [#{issue["engine_name"]}]", "#333333"))
+              puts
+            end
+            puts
+          end
+
+          print(colorize("Analysis complete! Found #{pluralize(issues.size, "issue")}", :green))
+          if warnings.size > 0
+            print(colorize(" and #{pluralize(warnings.size, "warning")}", :green))
+          end
+          puts(colorize(".", :green))
+        end
+
+        def engine_running(engine)
+          @active_engine = engine
+          with_spinner("Running #{engine.name}: ") do
+            yield
+          end
+          @active_engine = nil
+        end
+
+        def failed(output)
+          spinner.stop("Failed")
+          puts colorize("\nAnalysis failed with the following output:", :red)
+          puts output
+          exit 1
+        end
+
+        private
+
+        def spinner(text = nil)
+          @spinner ||= Spinner.new(text)
+        end
+
+        def with_spinner(text)
+          spinner(text).start
+          yield
+        ensure
+          spinner.stop
+          @spinner = nil
+        end
+
+        def colorize(string, *args)
+          rainbow.wrap(string).color(*args)
+        end
+
+        def rainbow
+          @rainbow ||= Rainbow.new.tap do |rainbow|
+            rainbow.enabled = false unless @output.tty?
+          end
+        end
+
+        def issues
+          @issues ||= []
+        end
+
+        def issues_by_path
+          issues.group_by { |i| i['location']['path'] }.sort
+        end
+
+        def warnings
+          @warnings ||= []
+        end
+
+        def pluralize(number, noun)
+          "#{ActiveSupport::NumberHelper.number_to_delimited(number)} #{noun.pluralize(number)}"
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/formatters/spinner.rb

@@ -0,0 +1,34 @@
+module CC
+  module Analyzer
+    module Formatters
+      class Spinner
+        def initialize(text)
+          @spinner = TTY::Spinner.new(text)
+        end
+
+        def start
+          @thread = Thread.new do
+            loop do
+              @spinning = true
+              spinner.spin
+              sleep 0.075
+            end
+          end
+        end
+
+        def stop(text = "Done!")
+          if @spinning
+            spinner.stop(text)
+            print("\n")
+            @thread.kill
+          end
+          @spinning = false
+        end
+
+        private
+
+        attr_reader :spinner
+      end
+    end
+  end
+end

data/lib/cc/analyzer/issue_sorter.rb

@@ -0,0 +1,30 @@
+module CC
+  module Analyzer
+    class IssueSorter
+      def initialize(issues)
+        @issues = issues
+      end
+
+      def by_location
+        @issues.sort_by { |i| line_or_offset(i) }
+      end
+
+      private
+
+      def line_or_offset(issue)
+        location = issue["location"]
+
+        case
+        when location["lines"]
+          location["lines"]["begin"].to_i
+        when location["positions"] && location["positions"]["begin"]["line"]
+          location["positions"]["begin"]["line"].to_i + location["positions"]["begin"]["column"].to_i
+        when location["positions"] && location["positions"]["begin"]["offset"]
+          location["positions"]["begin"]["offset"].to_i + 1_000_000_000 # push offsets to end of list
+        else
+          0 # whole-file issues are first
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/location_description.rb

@@ -0,0 +1,51 @@
+module CC
+  module Analyzer
+    class LocationDescription
+      def initialize(location, suffix = "")
+        @location = location
+        @suffix = suffix
+      end
+
+      def to_s
+        str = ""
+        if location["lines"]
+          str << render_lines
+        elsif positions = location["positions"]
+          str << render_position(positions["begin"])
+
+          if positions["end"]
+            str << "-"
+            str << render_position(positions["end"])
+          end
+        end
+
+        str << suffix unless str.blank?
+
+        str
+      end
+
+      private
+
+      attr_reader :location, :suffix
+
+      def render_lines
+        str = location["lines"]["begin"].to_s
+        str << "-#{location["lines"]["end"]}" if location["lines"]["end"]
+        str
+      end
+
+      def render_position(position)
+        str = ""
+
+        if position["line"]
+          str << position["line"].to_s
+          str << ":#{position["column"]}" if position["column"]
+        elsif position["offset"]
+          str << position["offset"].to_s
+        end
+
+        str
+      end
+    end
+  end
+end

data/lib/cc/analyzer/null_config.rb

@@ -0,0 +1,9 @@
+module CC
+  module Analyzer
+    class NullConfig < Config
+      def initialize(*)
+        @config = { "engines" => {} }
+      end
+    end
+  end
+end

data/lib/cc/analyzer/source_buffer.rb

@@ -0,0 +1,49 @@
+# Adapted from https://github.com/whitequark/parser/blob/master/lib/parser/source/buffer.rb
+module CC
+  module Analyzer
+    class SourceBuffer
+      attr_reader :name
+      attr_reader :source
+
+      def initialize(name, source)
+        @name = name
+        @source = source
+      end
+
+      def decompose_position(position)
+        line_no, line_begin = line_for(position)
+
+        [ 1 + line_no, position - line_begin ]
+      end
+
+      def line_count
+        @source.lines.count
+      end
+
+    private
+
+      def line_for(position)
+        line_begins.bsearch do |line, line_begin|
+          line_begin <= position
+        end
+      end
+
+      def line_begins
+        unless @line_begins
+          @line_begins, index = [ [ 0, 0 ] ], 1
+
+          @source.each_char do |char|
+            if char == "\n"
+              @line_begins.unshift [ @line_begins.length, index ]
+            end
+
+            index += 1
+          end
+        end
+
+        @line_begins
+      end
+
+    end
+  end
+end

data/lib/cc/analyzer/unit_name.rb

@@ -0,0 +1,14 @@
+module CC
+  module Analyzer
+    class UnitName
+      attr_reader :full_name
+      attr_reader :local_name
+
+      def initialize(full_name, local_name)
+        @full_name = full_name
+        @local_name = local_name
+      end
+
+    end
+  end
+end

data/lib/cc/cli.rb

@@ -0,0 +1,17 @@
+require "active_support"
+require "active_support/core_ext"
+require "cc/analyzer"
+
+module CC
+  module CLI
+    autoload :Analyze, "cc/cli/analyze"
+    autoload :Command, "cc/cli/command"
+    autoload :Console, "cc/cli/console"
+    autoload :Engines, "cc/cli/engines"
+    autoload :Help, "cc/cli/help"
+    autoload :Init, "cc/cli/init"
+    autoload :Runner, "cc/cli/runner"
+    autoload :ValidateConfig, "cc/cli/validate_config"
+    autoload :Version, "cc/cli/version"
+  end
+end

data/lib/cc/cli/analyze.rb

@@ -0,0 +1,91 @@
+require "securerandom"
+
+module CC
+  module CLI
+    class Analyze < Command
+      include CC::Analyzer
+
+      def initialize(args = [])
+        super
+
+        process_args
+      end
+
+      def run
+        require_codeclimate_yml
+        if engines.empty?
+          fatal("No engines enabled. Add some to your .codeclimate.yml file!")
+        end
+
+        formatter.started
+
+        engines.each do |engine|
+          formatter.engine_running(engine) do
+            engine.run(formatter)
+          end
+        end
+
+        formatter.finished
+      end
+
+      private
+
+      def process_args
+        case @args.first
+        when '-f'
+          @args.shift # throw out the -f
+          @formatter = Formatters.resolve(@args.shift)
+        end
+      rescue Formatters::Formatter::InvalidFormatterError => e
+        fatal(e.message)
+      end
+
+      def config
+        @config ||= if filesystem.exist?(CODECLIMATE_YAML)
+          config_body = filesystem.read_path(CODECLIMATE_YAML)
+          config = Config.new(config_body)
+        else
+          config = NullConfig.new
+        end
+      end
+
+      def engine_registry
+        @engine_registry ||= EngineRegistry.new
+      end
+
+      def engine_config(engine_name)
+        config.engine_config(engine_name).
+          merge!(exclude_paths: exclude_paths).to_json
+      end
+
+      def exclude_paths
+        if config.exclude_paths
+          filesystem.files_matching(config.exclude_paths)
+        else
+          []
+        end
+      end
+
+      def engines
+        @engines ||= config.engine_names.map do |engine_name|
+          Engine.new(
+            engine_name,
+            engine_registry[engine_name],
+            path,
+            engine_config(engine_name),
+            SecureRandom.uuid
+          )
+        end
+      end
+
+      def formatter
+        @formatter ||= Formatters::PlainTextFormatter.new
+      end
+
+      def path
+        ENV['CODE_PATH']
+      end
+
+    end
+  end
+end