codeclimate 0.2.9 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5b6caa0a6dc7642c6e5abb6533c8c24c7bd49f4
-  data.tar.gz: 98bb65ce704a03ba8ed98a4ff697d2a424ef0fd3
+  metadata.gz: 32566ddd677d0f2659e3a463d78a2a41e78eee0e
+  data.tar.gz: 650ce0df21367faa2b8f94362a01ed46c9057620
 SHA512:
-  metadata.gz: 17ecabe1ace73fbd5f37c83a78b2bd1e5a683aa1b518684a33ebd8885246c8bb289f804c692d63bd443b35ef1f0f576cfbc382691c6c89368516c8aa8a6edc1c
-  data.tar.gz: f62c7be59d492698e22496c265b4f6c3c9993100ec861bce94227f9e4ffceda8bc8809ba2c75be9fae94a3d7d355c5b167ba30119e03ee42835d0e80b77e6906
+  metadata.gz: bbeaad0b4a597ccbefcd387eca14627711d5e1b43184d1c65f414dfd9c2af4774b4867a19493292f6d904a1cce9182be69d0767789afc0585662b32e9176fabd
+  data.tar.gz: cb8c64a2ddac15d5c9c65de165e0ed9c84a09a2f5d2f6d3aeeeac63759b550f1f8c45518d28da30776aae954e81ad9fc679797a1cb80c0e311912c3824d95f8d

data/bin/check

@@ -4,7 +4,7 @@ command -v docker > /dev/null 2>&1 || {
   exit 1
 }
 
-docker version | grep -Fq "Server version" || {
+docker version | grep -q "Server version\|Server:" || {
   echo "Unable to run \`docker version', the docker daemon may not be running" >&2
 
   if command -v boot2docker > /dev/null 2>&1; then

data/bin/release

@@ -0,0 +1,41 @@
+#!/bin/sh
+#
+# Release a new version of this repository
+#
+# Usage: bin/release VERSION
+#
+###
+set -e
+
+set -- 0.2.11
+if [ -z "$1" ]; then
+  echo "usage: bin/release VERSION" >&2
+  exit 64
+fi
+
+version=$1
+
+if ! bundle exec rake; then
+  echo "test failure, not releasing" >&2
+  exit 1
+fi
+
+printf "RELEASE %s => %s\n" "$(< VERSION)" "$version"
+# git checkout master
+# git pull
+
+# printf "%s\n" "$version" > VERSION
+# bundle
+# git add VERSION Gemfile.lock
+# git commit -m "Release v$version"
+
+rake release
+
+# docker build --rm -t codeclimate/codeclimate .
+# docker push codeclimate/codeclimate
+
+# (cd ../homebrew-formulae/ && bin/release "$version")
+
+# TODO: automate this final step
+echo "Be sure to update release notes:"
+echo "- TODO URL"

data/lib/cc/analyzer.rb

@@ -1,22 +1,22 @@
 module CC
   module Analyzer
-    autoload :Accumulator,        "cc/analyzer/accumulator"
-    autoload :Config,             "cc/analyzer/config"
-    autoload :Container,          "cc/analyzer/container"
-    autoload :Engine,             "cc/analyzer/engine"
-    autoload :EngineClient,       "cc/analyzer/engine_client"
+    autoload :CompositeContainerListener, "cc/analyzer/composite_container_listener"
+    autoload :Config, "cc/analyzer/config"
+    autoload :Container, "cc/analyzer/container"
+    autoload :ContainerListener, "cc/analyzer/container_listener"
+    autoload :Engine, "cc/analyzer/engine"
     autoload :EngineOutputFilter, "cc/analyzer/engine_output_filter"
-    autoload :EngineRegistry,     "cc/analyzer/engine_registry"
-    autoload :EnginesRunner,      "cc/analyzer/engines_runner"
-    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 :NullContainerLog,   "cc/analyzer/null_container_log"
-    autoload :PathPatterns,       "cc/analyzer/path_patterns"
-    autoload :SourceBuffer,       "cc/analyzer/source_buffer"
-    autoload :UnitName,           "cc/analyzer/unit_name"
+    autoload :EngineRegistry, "cc/analyzer/engine_registry"
+    autoload :EnginesRunner, "cc/analyzer/engines_runner"
+    autoload :Filesystem, "cc/analyzer/filesystem"
+    autoload :Formatters, "cc/analyzer/formatters"
+    autoload :IssueSorter, "cc/analyzer/issue_sorter"
+    autoload :LocationDescription, "cc/analyzer/location_description"
+    autoload :LoggingContainerListener, "cc/analyzer/logging_container_listener"
+    autoload :PathPatterns, "cc/analyzer/path_patterns"
+    autoload :RaisingContainerListener, "cc/analyzer/raising_container_listener"
+    autoload :SourceBuffer, "cc/analyzer/source_buffer"
+    autoload :StatsdContainerListener, "cc/analyzer/statsd_container_listener"
 
     class DummyStatsd
       def method_missing(*)

data/lib/cc/analyzer/composite_container_listener.rb

@@ -0,0 +1,25 @@
+module CC
+  module Analyzer
+    class CompositeContainerListener < ContainerListener
+      def initialize(*listeners)
+        @listeners = listeners
+      end
+
+      def started(data)
+        listeners.each { |listener| listener.started(data) }
+      end
+
+      def timed_out(data)
+        listeners.each { |listener| listener.timed_out(data) }
+      end
+
+      def finished(data)
+        listeners.each { |listener| listener.finished(data) }
+      end
+
+      private
+
+      attr_reader :listeners
+    end
+  end
+end

data/lib/cc/analyzer/container.rb

@@ -3,19 +3,27 @@ require "posix/spawn"
 module CC
   module Analyzer
     class Container
+      ContainerData = Struct.new(
+        :image,         # image used to create the container
+        :name,          # name given to the container when created
+        :duration,      # duration, for a finished event
+        :status,        # status, for a finished event
+        :stderr,        # stderr, for a finished event
+      )
+
       DEFAULT_TIMEOUT = 15 * 60 # 15m
 
       def initialize(
         image:,
         name:,
         command: nil,
-        log: NullContainerLog.new,
+        listener: ContainerListener.new,
         timeout: DEFAULT_TIMEOUT
       )
         @image = image
         @name = name
         @command = command
-        @log = log
+        @listener = listener
         @timeout = timeout
 
         @output_delimeter = "\n"
@@ -31,7 +39,8 @@ module CC
       end
 
       def run(options = [])
-        @log.started(@image, @name)
+        started = Time.now
+        @listener.started(container_data)
 
         pid, _, out, err = POSIX::Spawn.popen4(*docker_run_command(options))
 
@@ -41,14 +50,15 @@ module CC
 
         _, status = Process.waitpid2(pid)
 
-        @log.finished(@image, @name, status, @stderr_io.string)
+        duration = ((Time.now - started) * 1000).round
+        @listener.finished(container_data(duration: duration, status: status))
 
         t_timeout.kill
       ensure
         t_timeout.kill if t_timeout
 
         if @timed_out
-          @log.timed_out(@image, @name, @timeout)
+          @listener.timed_out(container_data(duration: @timeout))
           t_out.kill if t_out
           t_err.kill if t_err
         else
@@ -93,6 +103,16 @@ module CC
           Process.kill("KILL", pid)
         end
       end
+
+      def container_data(duration: nil, status: nil)
+        ContainerData.new(
+          @image,
+          @name,
+          duration,
+          status,
+          @stderr_io.string
+        )
+      end
     end
   end
 end

data/lib/cc/analyzer/container_listener.rb

@@ -0,0 +1,14 @@
+module CC
+  module Analyzer
+    class ContainerListener
+      def started(_data)
+      end
+
+      def timed_out(_data)
+      end
+
+      def finished(_data)
+      end
+    end
+  end
+end

data/lib/cc/analyzer/engine.rb

@@ -3,7 +3,8 @@ require "securerandom"
 module CC
   module Analyzer
     class Engine
-      autoload :ContainerLog, "cc/analyzer/engine/container_log"
+      EngineFailure = Class.new(StandardError)
+      EngineTimeout = Class.new(StandardError)
 
       attr_reader :name
 
@@ -15,12 +16,19 @@ module CC
         @label = label.to_s
       end
 
-      def run(stdout_io:, container_log: NullContainerLog.new)
+      def run(stdout_io, container_listener)
+        composite_listener = CompositeContainerListener.new(
+          container_listener,
+          LoggingContainerListener.new(name, Analyzer.logger),
+          StatsdContainerListener.new(name, Analyzer.statsd),
+          RaisingContainerListener.new(name, EngineFailure, EngineTimeout),
+        )
+
         container = Container.new(
           image: @metadata["image"],
           command: @metadata["command"],
           name: container_name,
-          log: ContainerLog.new(name, container_log)
+          listener: composite_listener,
         )
 
         container.on_output("\0") do |output|

data/lib/cc/analyzer/engines_runner.rb

@@ -14,14 +14,12 @@ module CC
         @container_label = container_label
       end
 
-      def run(container_log = NullContainerLog.new)
+      def run(container_listener = ContainerListener.new)
         raise NoEnabledEngines if engines.empty?
 
-        Analyzer.logger.info("running #{engines.size} engines")
-
         @formatter.started
 
-        engines.each { |engine| run_engine(engine, container_log) }
+        engines.each { |engine| run_engine(engine, container_listener) }
 
         @formatter.finished
       ensure
@@ -30,21 +28,10 @@ module CC
 
       private
 
-      def run_engine(engine, container_log)
-        Analyzer.logger.info("starting engine #{engine.name}")
-
-        Analyzer.statsd.time("engines.time") do
-          Analyzer.statsd.time("engines.names.#{engine.name}.time") do
-            @formatter.engine_running(engine) do
-              engine.run(
-                stdout_io: @formatter,
-                container_log: container_log
-              )
-            end
-          end
+      def run_engine(engine, container_listener)
+        @formatter.engine_running(engine) do
+          engine.run(@formatter, container_listener)
         end
-
-        Analyzer.logger.info("finished engine #{engine.name}")
       end
 
       def engines

data/lib/cc/analyzer/logging_container_listener.rb

@@ -0,0 +1,22 @@
+module CC
+  module Analyzer
+    class LoggingContainerListener < ContainerListener
+      def initialize(engine_name, logger)
+        @engine_name = engine_name
+        @logger = logger
+      end
+
+      def started(_data)
+        logger.info("starting engine #{engine_name}")
+      end
+
+      def finished(_data)
+        logger.info("finished engine #{engine_name}")
+      end
+
+      private
+
+      attr_reader :engine_name, :logger
+    end
+  end
+end

data/lib/cc/analyzer/raising_container_listener.rb

@@ -0,0 +1,32 @@
+module CC
+  module Analyzer
+    class RaisingContainerListener < ContainerListener
+      def initialize(engine_name, failure_ex, timeout_ex)
+        @engine_name = engine_name
+        @failure_ex = failure_ex
+        @timeout_ex = timeout_ex
+      end
+
+      def timed_out(data)
+        message = "engine #{engine_name} ran for #{data.duration} seconds"
+        message << " and was killed"
+
+        raise timeout_ex, message
+      end
+
+      def finished(data)
+        unless data.status.success?
+          message = "engine #{engine_name} failed"
+          message << " with status #{data.status.exitstatus}"
+          message << " and stderr \n#{data.stderr}"
+
+          raise failure_ex, message
+        end
+      end
+
+      private
+
+      attr_reader :engine_name, :failure_ex, :timeout_ex
+    end
+  end
+end

data/lib/cc/analyzer/statsd_container_listener.rb

@@ -0,0 +1,45 @@
+module CC
+  module Analyzer
+    class StatsdContainerListener < ContainerListener
+      def initialize(engine_name, statsd)
+        @engine_name = engine_name
+        @statsd = statsd
+      end
+
+      def started(_data)
+        increment("started")
+      end
+
+      def timed_out(data)
+        timing("time", data.duration)
+        increment("result.error")
+        increment("result.error.timeout")
+      end
+
+      def finished(data)
+        timing("time", data.duration)
+        increment("finished")
+
+        if data.status.success?
+          increment("result.success")
+        else
+          increment("result.error")
+        end
+      end
+
+      private
+
+      attr_reader :engine_name, :statsd
+
+      def increment(metric)
+        statsd.increment("engines.#{metric}")
+        statsd.increment("engines.names.#{engine_name}.#{metric}")
+      end
+
+      def timing(metric, ms)
+        statsd.timing("engines.#{metric}", ms)
+        statsd.timing("engines.names.#{engine_name}.#{metric}", ms)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codeclimate
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.11
 platform: ruby
 authors:
 - Code Climate
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-14 00:00:00.000000000 Z
+date: 2015-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -188,12 +188,14 @@ extra_rdoc_files: []
 files:
 - bin/check
 - bin/codeclimate
+- bin/release
 - config/engines.yml
 - lib/cc/analyzer.rb
+- lib/cc/analyzer/composite_container_listener.rb
 - lib/cc/analyzer/config.rb
 - lib/cc/analyzer/container.rb
+- lib/cc/analyzer/container_listener.rb
 - lib/cc/analyzer/engine.rb
-- lib/cc/analyzer/engine/container_log.rb
 - lib/cc/analyzer/engine_output_filter.rb
 - lib/cc/analyzer/engine_registry.rb
 - lib/cc/analyzer/engines_runner.rb
@@ -205,11 +207,11 @@ files:
 - lib/cc/analyzer/formatters/spinner.rb
 - lib/cc/analyzer/issue_sorter.rb
 - lib/cc/analyzer/location_description.rb
-- lib/cc/analyzer/null_config.rb
-- lib/cc/analyzer/null_container_log.rb
+- lib/cc/analyzer/logging_container_listener.rb
 - lib/cc/analyzer/path_patterns.rb
+- lib/cc/analyzer/raising_container_listener.rb
 - lib/cc/analyzer/source_buffer.rb
-- lib/cc/analyzer/unit_name.rb
+- lib/cc/analyzer/statsd_container_listener.rb
 - lib/cc/cli.rb
 - lib/cc/cli/analyze.rb
 - lib/cc/cli/command.rb

data/lib/cc/analyzer/engine/container_log.rb

@@ -1,48 +0,0 @@
-module CC
-  module Analyzer
-    class Engine
-      EngineFailure = Class.new(StandardError)
-      EngineTimeout = Class.new(StandardError)
-
-      class ContainerLog
-        def initialize(name, inner_log)
-          @name = name
-          @inner_log = inner_log
-        end
-
-        def started(image, name)
-          @inner_log.started(image, name)
-
-          Analyzer.statsd.increment("cli.engines.started")
-        end
-
-        def timed_out(image, name, timeout)
-          @inner_log.timed_out(image, name, timeout)
-
-          Analyzer.statsd.increment("cli.engines.result.error")
-          Analyzer.statsd.increment("cli.engines.result.error.timeout")
-          Analyzer.statsd.increment("cli.engines.names.#{@name}.result.error")
-          Analyzer.statsd.increment("cli.engines.names.#{@name}.result.error.timeout")
-
-          raise EngineTimeout, "engine #{@name} ran past #{timeout} seconds and was killed"
-        end
-
-        def finished(image, name, status, stderr)
-          @inner_log.finished(image, name, status, stderr)
-
-          Analyzer.statsd.increment("cli.engines.finished")
-
-          if status.success?
-            Analyzer.statsd.increment("cli.engines.result.success")
-            Analyzer.statsd.increment("cli.engines.names.#{@name}.result.success")
-          else
-            Analyzer.statsd.increment("cli.engines.result.error")
-            Analyzer.statsd.increment("cli.engines.names.#{@name}.result.error")
-
-            raise EngineFailure, "engine #{@name} failed with status #{status.exitstatus} and stderr \n#{stderr}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cc/analyzer/null_config.rb

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

data/lib/cc/analyzer/null_container_log.rb

@@ -1,14 +0,0 @@
-module CC
-  module Analyzer
-    class NullContainerLog
-      def started(_image, _name)
-      end
-
-      def timed_out(_image, _name, _seconds)
-      end
-
-      def finished(_image, _name, _status, _stderr)
-      end
-    end
-  end
-end

data/lib/cc/analyzer/unit_name.rb

@@ -1,14 +0,0 @@
-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