codeclimate-fede 0.85.23

data/lib/cc/cli/analyze.rb

@@ -0,0 +1,90 @@
+require "cc/cli/command"
+
+module CC
+  module CLI
+    class Analyze < Command
+      ARGUMENT_LIST = "[-f format] [-e engine[:channel]] [path]".freeze
+      SHORT_HELP = "Run analysis with the given arguments".freeze
+      HELP = "#{SHORT_HELP}\n" \
+        "\n" \
+        "    -f <format>, --format <format>   Format of output. Possible values: #{CC::Analyzer::Formatters::FORMATTERS.keys.join ", "}\n" \
+        "    -e <engine[:channel]>            Engine to run. Can be specified multiple times.\n" \
+        "    --dev                            Run in development mode. Engines installed locally that are not in the manifest will be run.\n" \
+        "    path                             Path to check. Can be specified multiple times.".freeze
+
+      autoload :EngineFailure, "cc/cli/analyze/engine_failure"
+
+      include CC::Analyzer
+
+      def run
+        # Load config here so it sees ./.codeclimate.yml
+        @config = Config.load
+
+        # process args after, so it modifies loaded configuration
+        process_args
+
+        bridge = Bridge.new(
+          config: config,
+          formatter: formatter,
+          listener: CompositeContainerListener.new(
+            LoggingContainerListener.new(Analyzer.logger),
+            RaisingContainerListener.new(EngineFailure),
+          ),
+          registry: EngineRegistry.new,
+        )
+
+        bridge.run
+      end
+
+      private
+
+      attr_reader :config, :engines_disabled, :listener, :registry
+
+      def process_args
+        while (arg = @args.shift)
+          case arg
+          when "-f", "--format"
+            @formatter = Formatters.resolve(@args.shift).new(filesystem)
+          when "-e", "--engine"
+            disable_all_engines!
+            name, channel = @args.shift.split(":", 2)
+            enable_engine(name, channel)
+          when "--dev"
+            config.development = true
+          when "--no-plugins"
+            config.disable_plugins!
+          else
+            config.analysis_paths << arg
+          end
+        end
+      rescue Formatters::Formatter::InvalidFormatterError => ex
+        fatal(ex.message)
+      end
+
+      def formatter
+        @formatter ||= Formatters::PlainTextFormatter.new(filesystem)
+      end
+
+      def disable_all_engines!
+        unless engines_disabled
+          config.engines.each { |e| e.enabled = false }
+          @engines_disabled = true
+        end
+      end
+
+      def enable_engine(name, channel)
+        existing_engine = config.engines.detect { |e| e.name == name }
+        if existing_engine.present?
+          existing_engine.enabled = true
+          existing_engine.channel = channel if channel.present?
+        else
+          config.engines << Config::Engine.new(
+            name,
+            channel: channel,
+            enabled: true,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/analyze/engine_failure.rb

@@ -0,0 +1,11 @@
+module CC
+  module CLI
+    class Analyze < Command
+      class EngineFailure < StandardError
+        def initialize(message, _engine_name)
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/command.rb

@@ -0,0 +1,85 @@
+require "highline"
+require "active_support"
+require "active_support/core_ext"
+require "rainbow"
+require "cc/cli/output"
+
+module CC
+  module CLI
+    class Command
+      include CC::CLI::Output
+
+      CODECLIMATE_YAML = ".codeclimate.yml".freeze
+      NAMESPACE = name.split("::")[0..-2].join("::").freeze
+
+      def self.abstract!
+        @abstract = true
+      end
+
+      def self.abstract?
+        @abstract == true
+      end
+
+      def self.all
+        @@subclasses.reject(&:abstract?)
+      end
+
+      def self.[](name)
+        all.find { |command| command.name == "#{NAMESPACE}::#{name}" || command.command_name == name }
+      end
+
+      # rubocop: disable Style/ClassVars
+      def self.inherited(subclass)
+        @@subclasses ||= []
+        @@subclasses << subclass
+      end
+      # rubocop: enable Style/ClassVars
+
+      def self.synopsis
+        "#{command_name} #{self::ARGUMENT_LIST if const_defined?(:ARGUMENT_LIST)}".strip
+      end
+
+      def self.short_help
+        if const_defined? :SHORT_HELP
+          self::SHORT_HELP
+        else
+          ""
+        end
+      end
+
+      def self.help
+        if const_defined? :HELP
+          self::HELP
+        else
+          short_help
+        end
+      end
+
+      def initialize(args = [])
+        @args = args
+      end
+
+      def run
+        $stderr.puts "unknown command #{self.class.name.split("::").last.underscore}"
+      end
+
+      def self.command_name
+        name.gsub(/^#{NAMESPACE}::/, "").split("::").map do |part|
+          part.split(/(?=[A-Z])/).map(&:downcase).join("-")
+        end.join(":")
+      end
+
+      def execute
+        run
+      end
+
+      private
+
+      def filesystem
+        @filesystem ||= CC::Analyzer::Filesystem.new(
+          CC::Analyzer::MountedPath.code.container_path,
+        )
+      end
+    end
+  end
+end

data/lib/cc/cli/console.rb

@@ -0,0 +1,12 @@
+module CC
+  module CLI
+    class Console < Command
+      SHORT_HELP = "Open a ruby console for the CLI. Useful for developing against the CLI.".freeze
+
+      def run
+        require "pry"
+        binding.pry(quiet: true, prompt: Pry::SIMPLE_PROMPT, output: $stdout)
+      end
+    end
+  end
+end

data/lib/cc/cli/engines.rb

@@ -0,0 +1,5 @@
+require "cc/analyzer"
+
+require "cc/cli/engines/engine_command"
+require "cc/cli/engines/install"
+require "cc/cli/engines/list"

data/lib/cc/cli/engines/engine_command.rb

@@ -0,0 +1,15 @@
+require "cc/analyzer"
+
+module CC
+  module CLI
+    module Engines
+      class EngineCommand < Command
+        abstract!
+
+        def engine_registry
+          @engine_registry ||= EngineRegistry.new
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/engines/install.rb

@@ -0,0 +1,35 @@
+module CC
+  module CLI
+    module Engines
+      class Install < EngineCommand
+        SHORT_HELP = "Pull the latest images for enabled engines in your configuration".freeze
+
+        ImagePullFailure = Class.new(StandardError)
+
+        def run
+          say "Pulling docker images."
+          pull_docker_images
+        end
+
+        private
+
+        def config
+          @config ||= CC::Config.load
+        end
+
+        def pull_docker_images
+          config.engines.each(&method(:pull_engine))
+        end
+
+        def pull_engine(engine)
+          metadata = engine_registry.fetch_engine_details(engine)
+          unless system("docker pull #{metadata.image}")
+            raise ImagePullFailure, "unable to pull image #{metadata.image}"
+          end
+        rescue EngineRegistry::EngineDetailsNotFoundError
+          warn("unknown engine <#{engine.name}:#{engine.channel}>")
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/engines/list.rb

@@ -0,0 +1,18 @@
+module CC
+  module CLI
+    module Engines
+      class List < EngineCommand
+        SHORT_HELP = "List all available engines".freeze
+
+        def run
+          say "Available engines:"
+          engine_registry.
+            sort_by { |engine, _| engine.name }.
+            each do |engine, metadata|
+              say "- #{engine.name}: #{metadata.description}"
+            end
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/file_store.rb

@@ -0,0 +1,42 @@
+require "fileutils"
+require "yaml"
+
+module CC
+  module CLI
+    class FileStore
+      # This class is not supposed to be directly used. It should be sublcassed
+      # and a few constants need to be defined on the sublass to be usable.
+      #
+      # FILE_NAME is the name of the file this class wraps.
+
+      def initialize
+        load_data
+      end
+
+      def save
+        return false unless File.exist? self.class::FILE_NAME
+
+        File.open(self.class::FILE_NAME, "w") do |f|
+          YAML.dump data, f
+        end
+
+        true
+      end
+
+      private
+
+      attr_reader :data
+
+      def load_data
+        @data =
+          if File.exist? self.class::FILE_NAME
+            File.open(self.class::FILE_NAME, "r:bom|utf-8") do |f|
+              YAML.safe_load(f, [Time], [], false, self.class::FILE_NAME) || {}
+            end
+          else
+            {}
+          end
+      end
+    end
+  end
+end

data/lib/cc/cli/global_cache.rb

@@ -0,0 +1,47 @@
+require "cc/cli/file_store"
+
+module CC
+  module CLI
+    class GlobalCache < FileStore
+      FILE_NAME = "/cache.yml".freeze
+
+      # Cache entries
+
+      def last_version_check
+        data["last-version-check"] || Time.at(0)
+      end
+
+      def last_version_check=(value)
+        data["last-version-check"] =
+          if value.is_a? Time
+            value
+          else
+            Time.at(0)
+          end
+        save
+        value
+      end
+
+      def latest_version
+        data["latest-version"]
+      end
+
+      def latest_version=(value)
+        data["latest-version"] = value
+        save
+        value
+      end
+
+      def outdated
+        data["outdated"] == true
+      end
+      alias outdated? outdated
+
+      def outdated=(value)
+        data["outdated"] = value == true
+        save
+        value
+      end
+    end
+  end
+end

data/lib/cc/cli/global_config.rb

@@ -0,0 +1,35 @@
+require "cc/cli/file_store"
+require "uuid"
+
+module CC
+  module CLI
+    class GlobalConfig < FileStore
+      FILE_NAME = "/config.yml".freeze
+
+      DEFAULT_CONFIG = {
+        "check-version" => true,
+      }.freeze
+
+      # Config entries
+
+      def check_version
+        data["check-version"]
+      end
+      alias check_version? check_version
+
+      def check_version=(value)
+        data["check-version"] = value == true
+      end
+
+      def uuid
+        data["uuid"] ||= UUID.new.generate
+      end
+
+      private
+
+      def load_data
+        @data = DEFAULT_CONFIG.merge(super)
+      end
+    end
+  end
+end

data/lib/cc/cli/help.rb

@@ -0,0 +1,51 @@
+require "rainbow"
+
+module CC
+  module CLI
+    class Help < Command
+      ARGUMENT_LIST = "[command]".freeze
+      SHORT_HELP = "Display help information.".freeze
+      HELP = "#{SHORT_HELP}\n" \
+        "\n" \
+        "    no arguments   Show help summary for all commands.\n" \
+        "    [command]      Show help for specific commands. Can be specified multiple times.".freeze
+
+      def run
+        if @args.any?
+          @args.each do |command|
+            show_help(command)
+          end
+        else
+          show_help_summary
+        end
+      end
+
+      private
+
+      def show_help(command_name)
+        if (command = Command[command_name])
+          say "Usage: codeclimate #{command.synopsis}\n"
+          say "\n"
+          say "#{command.help}\n"
+          say "\n\n"
+        else
+          say "Unknown command: #{command_name}"
+        end
+      end
+
+      def show_help_summary
+        short_helps =
+          Command.all.sort_by(&:command_name).map do |command|
+            [command.synopsis, command.short_help]
+          end.compact.to_h
+
+        longest_command_length = short_helps.keys.map(&:length).max
+
+        say "Usage: codeclimate COMMAND ...\n\nAvailable commands:\n"
+        short_helps.each do |command, help|
+          say format("    %-#{longest_command_length}s    %s\n", command, help)
+        end
+      end
+    end
+  end
+end