codeclimate 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 464d6f323fb090523a3559db160cbd7b3595e5e0
-  data.tar.gz: 7530dca475ec183d06b2c1cd034c6d9fd58f8c5c
+  metadata.gz: 6842c09f09430b3567358c4bc07a5f2915216b6b
+  data.tar.gz: 39475d633f642086e097cb601c76d7a4c2ff960a
 SHA512:
-  metadata.gz: 45a2d8f3d1353a380f19edef20f2d0528f3a418a227a9e4ae538f400752459bf65e45f567243db33af687a4834e096f6744b8c265ec244a2ff6ecf5dacd3b42d
-  data.tar.gz: c0e183378665f425dde7591de921cbdf2dca8019eabbd504ae260821e32829d20d6ce4c8fcc499fc083c1d3a8d0d5fd85d66e4770548877310d1a69249031cfb
+  metadata.gz: 67d8f45e400b833b025baa3b0e1aa18ebf19ec920f7ab92e83cd8d0c02ee37811ab40e9f2e5307e8b6e5b81f5f3e287d695c28c9782d48645da0ab967fb554f3
+  data.tar.gz: 3c3492bcf903f23da01a83e0f775799c4a984c479b45a7312cb6ba75746e9fa0a180c1cd7f7ae120c9aad5d44b06f5002acfd0b70f43dcdb862b643a10d1243d

data/bin/codeclimate

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "../lib")))
+
+require "cc/cli"
+
+ENV["FILESYSTEM_DIR"] ||= "."
+
+CC::CLI::Runner.run(ARGV)

data/config/engines.yml

@@ -0,0 +1,95 @@
+# This file lists all the engines available to be run for analysis.
+#
+# Each engine must have an `image_name` and `description`.
+#
+# When a repo has files that match the `enable_regexps`, that engine will be
+# enabled by default in the codeclimate.yml file. That file will also have in it
+# the `default_ratings_paths` globs, which are used during analysis to determine
+# which files should be rated.
+#
+rubocop:
+  image_name: codeclimate/codeclimate-rubocop
+  image_id: 41273519bce24e59685106ff3f4519abc20233fdaf46093576cefecc093b795f
+  description: A Ruby static code analyzer, based on the community Ruby style guide.
+  community: false
+  enable_regexps:
+    - \.rb$
+  default_ratings_paths:
+    - "**.rb"
+gofmt:
+  image_name: codeclimate/codeclimate-gofmt
+  image_id: fe7b20a9eda6e0bd154fbbb289f0d18ff3ffc41d891cd3b2e5dbe7e015180396
+  description: gofmt
+  community: true
+  enable_regexps:
+    - \.go$
+  default_ratings_paths:
+    - "**.go"
+golint:
+  image_name: codeclimate/codeclimate-golint
+  image_id: cfde0099114d8b18bec8419d9ed359efac03069821cb967144b807d02ada1412
+  description: golint
+  community: true
+  enable_regexps:
+    - \.go$
+  default_ratings_paths:
+    - "**.go"
+govet:
+  image_name: codeclimate/codeclimate-govet
+  image_id: fe7690da7198c569a28b69189909eb4c1199d2987bf50ab5d3bbd20d83139489
+  description: govet
+  community: true
+  enable_regexps:
+    - \.go$
+  default_ratings_paths:
+    - "**.go"
+coffeelint:
+  image_name: codeclimate/codeclimate-coffeelint
+  description: A style checker for CoffeeScript
+  community: false
+  enable_regexps:
+    - \.coffee$
+  default_ratings_paths:
+    - "**.coffee"
+eslint:
+  image_name: codeclimate/codeclimate-eslint
+  image_id: 28a9ec7c5fc88a67317b6193c3ddc72f1402ba2500e8ed3c6feab6d06ca91f65
+  description: A JavaScript/JSX linting utility
+  community: false
+  enable_regexps:
+    - \.js$
+    - \.jsx$
+  default_ratings_paths:
+    - "**.js"
+    - "**.jsx"
+csslint:
+  image_name: codeclimate/codeclimate-csslint
+  image_id: 3d5aea2e5f241ff1daff33bd86cc5a819a34c81471e31ca70992f6de5e8edf43
+  description: Automated linting of Cascading Stylesheets
+  community: false
+  enable_regexps:
+    - \.css$
+  default_ratings_paths:
+    - "**.css"
+watson:
+  image_name: codeclimate/codeclimate-watson
+  description: A young Ember Doctor to help you fix your code.
+  community: true
+  enable_regexps:
+  default_ratings_paths:
+    - "app/**"
+rubymotion:
+  image_name: codeclimate/codeclimate-rubymotion
+  description: Rubymotion-specific rubocop checks
+  community: true
+  enable_regexps:
+  default_ratings_paths:
+    - "**.rb"
+bundler-audit:
+  image_name: codeclimate/codeclimate-bundler-audit
+  description: Patch-level verification for Bundler
+  community: false
+  enable_patterns:
+    - Gemfile.lock
+  default_ratings_paths:
+    - Gemfile.lock

data/lib/cc/analyzer.rb

@@ -0,0 +1,26 @@
+module CC
+  module Analyzer
+    autoload :Accumulator,        "cc/analyzer/accumulator"
+    autoload :Config,             "cc/analyzer/config"
+    autoload :Engine,             "cc/analyzer/engine"
+    autoload :EngineClient,       "cc/analyzer/engine_client"
+    autoload :EngineProcess,      "cc/analyzer/engine_process"
+    autoload :EngineRegistry,     "cc/analyzer/engine_registry"
+    autoload :Filesystem,         "cc/analyzer/filesystem"
+    autoload :Formatters,         "cc/analyzer/formatters"
+    autoload :IssueSorter,        "cc/analyzer/issue_sorter"
+    autoload :LocationDescription,"cc/analyzer/location_description"
+    autoload :NullConfig,         "cc/analyzer/null_config"
+    autoload :SourceBuffer,       "cc/analyzer/source_buffer"
+    autoload :UnitName,           "cc/analyzer/unit_name"
+
+    class DummyStatsd
+      def method_missing(*args)
+        yield if block_given?
+      end
+    end
+
+    cattr_accessor :statsd
+    self.statsd = DummyStatsd.new
+  end
+end

data/lib/cc/analyzer/config.rb

@@ -0,0 +1,73 @@
+require "yaml"
+
+module CC
+  module Analyzer
+    class Config
+
+      def initialize(config_body)
+        @config = YAML.safe_load(config_body) || {"engines"=> {} }
+        @config["engines"] ||= {}
+
+        expand_shorthand
+      end
+
+      def to_hash
+        @config
+      end
+
+      def engine_config(engine_name)
+        @config["engines"][engine_name] || {}
+      end
+
+      def engine_names
+        @config["engines"].keys.select { |name| engine_enabled?(name) }
+      end
+
+      def engine_present?(engine_name)
+        @config["engines"][engine_name].present?
+      end
+
+      def engine_enabled?(engine_name)
+        @config["engines"][engine_name] && @config["engines"][engine_name]["enabled"]
+      end
+
+      def enable_engine(engine_name)
+        if engine_present?(engine_name)
+          @config["engines"][engine_name]["enabled"] = true
+        else
+          @config["engines"][engine_name] = { "enabled" => true }
+        end
+      end
+
+      def exclude_paths
+        @config["exclude_paths"]
+      end
+
+      def disable_engine(engine_name)
+        if engine_present?(engine_name) && engine_enabled?(engine_name)
+          @config["engines"][engine_name]["enabled"] = false
+        end
+      end
+
+      def remove_engine(engine_name)
+        if engine_present?(engine_name)
+          @config["engines"].delete(engine_name)
+        end
+      end
+
+      def to_yaml
+        @config.to_yaml
+      end
+
+    private
+
+      def expand_shorthand
+        @config["engines"].each do |name, engine_config|
+          if [true, false].include?(engine_config)
+            @config["engines"][name] = { "enabled" => engine_config }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/engine.rb

@@ -0,0 +1,108 @@
+require "posix/spawn"
+require "securerandom"
+
+module CC
+  module Analyzer
+    class Engine
+      attr_reader :name
+
+      TIMEOUT = 15 * 60 # 15m
+
+      def initialize(name, metadata, code_path, config_json, label)
+        @name = name
+        @metadata = metadata
+        @code_path = code_path
+        @config_json = config_json
+        @label = label.to_s
+      end
+
+      def run(stdout_io, stderr_io = StringIO.new)
+        pid, _, out, err = POSIX::Spawn.popen4(*docker_run_command)
+        engine_running = true
+
+        t_out = Thread.new do
+          out.each_line("\0") do |chunk|
+            stdout_io.write(chunk.chomp("\0"))
+          end
+        end
+
+        t_err = Thread.new do
+          err.each_line do |line|
+            if stderr_io
+              stderr_io.write(line)
+            end
+          end
+        end
+
+        Thread.new do
+          sleep TIMEOUT
+
+          if engine_running
+            Thread.current.abort_on_exception = true
+            run_command("docker kill #{container_name}")
+
+            raise EngineTimeout, "engine #{name} ran past #{TIMEOUT} seconds and was killed"
+          end
+        end
+
+        pid, status = Process.waitpid2(pid)
+        engine_running = false
+        Analyzer.statsd.increment("cli.engines.finished")
+
+        if status.success?
+          Analyzer.statsd.increment("cli.engines.names.#{name}.result.success")
+          Analyzer.statsd.increment("cli.engines.result.success")
+        else
+          Analyzer.statsd.increment("cli.engines.names.#{name}.result.error")
+          Analyzer.statsd.increment("cli.engines.result.error")
+
+          raise EngineFailure, "engine #{name} failed with status #{status.exitstatus} and stderr #{stderr_io.string.inspect}"
+        end
+      ensure
+        t_out.join if t_out
+        t_err.join if t_err
+      end
+
+      private
+
+      def container_name
+        @container_name ||= "cc-engines-#{name}-#{SecureRandom.uuid}"
+      end
+
+      def docker_run_command
+        [
+          "docker", "run",
+          "--rm",
+          "--cap-drop", "all",
+          "--label", "com.codeclimate.label=#{@label}",
+          "--name", container_name,
+          "--memory", 512_000_000.to_s, # bytes
+          "--memory-swap", "-1",
+          "--net", "none",
+          "--volume", "#{@code_path}:/code:ro",
+          "--env-file", env_file,
+          @metadata["image_name"],
+          @metadata["command"], # String or Array
+        ].flatten.compact
+      end
+
+      def env_file
+        path = File.join("/tmp/cc", SecureRandom.uuid)
+        File.write(path, "ENGINE_CONFIG=#{@config_json}")
+        path
+      end
+
+      def run_command(command)
+        spawn = POSIX::Spawn::Child.new(command)
+
+        unless spawn.status.success?
+          raise CommandFailure, "command '#{command}' failed with status #{spawn.status.exitstatus} and output #{spawn.err}"
+        end
+      end
+
+      CommandFailure = Class.new(StandardError)
+      EngineFailure = Class.new(StandardError)
+      EngineTimeout = Class.new(StandardError)
+    end
+  end
+end

data/lib/cc/analyzer/engine_registry.rb

@@ -0,0 +1,21 @@
+require "safe_yaml"
+
+module CC
+  module Analyzer
+    class EngineRegistry
+      def initialize
+        @path = File.expand_path("../../../../config/engines.yml", __FILE__)
+        @config = YAML.safe_load_file(@path)
+      end
+
+      def [](engine_name)
+        @config[engine_name]
+      end
+
+      def list
+        @config
+      end
+    end
+  end
+end
+

data/lib/cc/analyzer/filesystem.rb

@@ -0,0 +1,48 @@
+module CC
+  module Analyzer
+    class Filesystem
+
+      def initialize(root)
+        @root = root
+      end
+
+      def exist?(path)
+        File.exist?(path_for(path))
+      end
+
+      def source_buffer_for(path)
+        SourceBuffer.new(path, read_path(path))
+      end
+
+      def read_path(path)
+        File.read(path_for(path))
+      end
+
+      def file_paths
+        Dir.chdir(@root) do
+          Dir["**/*.*"].select { |path| File.file?(path) }.sort
+        end
+      end
+
+      def all
+        @files ||= Dir.chdir(@root) { Dir.glob("**/*") }
+      end
+
+      def any?(&block)
+        all.any?(&block)
+      end
+
+      def files_matching(globs)
+        Dir.chdir(@root) do
+          globs.map do |glob|
+            Dir.glob(glob)
+          end.flatten.sort.uniq
+        end
+      end
+
+      def path_for(path)
+        File.join(@root, path)
+      end
+    end
+  end
+end

data/lib/cc/analyzer/formatters.rb

@@ -0,0 +1,19 @@
+module CC
+  module Analyzer
+    module Formatters
+      autoload :Formatter,  "cc/analyzer/formatters/formatter"
+      autoload :JSONFormatter, "cc/analyzer/formatters/json_formatter"
+      autoload :PlainTextFormatter,  "cc/analyzer/formatters/plain_text_formatter"
+      autoload :Spinner, "cc/analyzer/formatters/spinner"
+
+      FORMATTERS = {
+        json: JSONFormatter,
+        text: PlainTextFormatter,
+      }.freeze
+
+      def self.resolve(name)
+        FORMATTERS[name.to_sym].new or raise InvalidFormatterError, "'#{name}' is not a valid formatter. Valid options are: #{FORMATTERS.keys.join(", ")}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module CC
+  module Analyzer
+    module Formatters
+      class Formatter
+        def initialize(output = $stdout)
+          @output = output
+        end
+
+        def write(data)
+        end
+
+        def started
+        end
+
+        def engine_running(engine)
+          yield
+        end
+
+        def finished
+        end
+
+        def failed(output)
+        end
+
+        InvalidFormatterError = Class.new(StandardError)
+      end
+    end
+  end
+end