codeclimate-fede 0.85.23

data/lib/cc/cli/output.rb

@@ -0,0 +1,34 @@
+module CC
+  module CLI
+    module Output
+      def success(message)
+        terminal.say colorize(message, :green)
+      end
+
+      def say(message)
+        terminal.say message
+      end
+
+      def warn(message)
+        terminal.say colorize("WARNING: #{message}", :yellow)
+      end
+
+      def fatal(message)
+        $stderr.puts colorize(message, :red)
+        exit 1
+      end
+
+      def colorize(string, *args)
+        rainbow.wrap(string).color(*args)
+      end
+
+      def rainbow
+        @rainbow ||= Rainbow.new
+      end
+
+      def terminal
+        @terminal ||= HighLine.new($stdin, $stdout)
+      end
+    end
+  end
+end

data/lib/cc/cli/prepare.rb

@@ -0,0 +1,98 @@
+require "fileutils"
+require "ipaddr"
+require "json"
+require "net/http"
+require "pathname"
+require "uri"
+
+require "cc/resolv"
+
+module CC
+  module CLI
+    class Prepare < Command
+      ARGUMENT_LIST = "[--allow-internal-ips]".freeze
+      SHORT_HELP = "Run the commands in your prepare step.".freeze
+      HELP = "#{SHORT_HELP}\n" \
+        "\n" \
+        "    --allow-internal-ips    Allow fetching from internal IPs.".freeze
+
+      InternalHostError = Class.new(StandardError)
+      FetchError = Class.new(StandardError)
+
+      PRIVATE_ADDRESS_SUBNETS = [
+        IPAddr.new("10.0.0.0/8"),
+        IPAddr.new("172.16.0.0/12"),
+        IPAddr.new("192.168.0.0/16"),
+        IPAddr.new("fd00::/8"),
+        IPAddr.new("127.0.0.1"),
+        IPAddr.new("0:0:0:0:0:0:0:1"),
+      ].freeze
+
+      def run
+        ::CC::Resolv.with_fixed_dns { fetch_all }
+      rescue FetchError, InternalHostError => ex
+        fatal(ex.message)
+      end
+
+      private
+
+      def allow_internal_ips?
+        @args.include?("--allow-internal-ips")
+      end
+
+      def fetches
+        @fetches ||= config.prepare.fetch
+      end
+
+      def config
+        @config ||= CC::Config.load
+      end
+
+      def fetch_all
+        fetches.each do |entry|
+          fetch(entry.url, entry.path)
+        end
+      end
+
+      def fetch(url, target_path)
+        ensure_external!(url) unless allow_internal_ips?
+
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        resp = http.get(uri)
+        if resp.code == "200"
+          write_file(target_path, resp.body)
+          say("Wrote #{url} to #{target_path}")
+        else
+          raise FetchError, "Failed fetching #{url}: code=#{resp.code} body=#{resp.body}"
+        end
+      end
+
+      def write_file(target_path, content)
+        FileUtils.mkdir_p(Pathname.new(target_path).parent.to_s)
+        File.write(target_path, content)
+      end
+
+      def ensure_external!(url)
+        uri = URI.parse(url)
+
+        if internal?(uri.host)
+          raise InternalHostError, "Won't fetch #{url.inspect}: it maps to an internal address"
+        end
+      end
+
+      # rubocop:disable Style/CaseEquality
+      def internal?(host)
+        address = ::Resolv.getaddress(host)
+
+        PRIVATE_ADDRESS_SUBNETS.any? do |subnet|
+          subnet === IPAddr.new(address.to_s)
+        end
+      rescue ::Resolv::ResolvError
+        true # localhost
+      end
+      # rubocop:enable Style/CaseEquality
+    end
+  end
+end

data/lib/cc/cli/runner.rb

@@ -0,0 +1,75 @@
+require "active_support"
+require "active_support/core_ext"
+require "cc/cli/version_checker"
+
+module CC
+  module CLI
+    class Runner
+      def self.run(argv)
+        new(argv).run
+      rescue => ex
+        $stderr.puts("error: (#{ex.class}) #{ex.message}")
+        CLI.logger.debug("backtrace: #{ex.backtrace.join("\n\t")}")
+        exit 1
+      end
+
+      def initialize(args)
+        @args = args
+      end
+
+      def run
+        VersionChecker.new.check if check_version?
+
+        if command_class
+          command = command_class.new(command_arguments)
+          command.execute
+        else
+          command_not_found
+        end
+      end
+
+      def command_not_found
+        $stderr.puts "unknown command #{command}"
+        exit 1
+      end
+
+      def command_class
+        command_const = Command[command]
+        if command_const.abstract?
+          nil
+        else
+          command_const
+        end
+      rescue NameError
+        nil
+      end
+
+      def command_arguments
+        Array(@args[1..-1])
+      end
+
+      def command
+        command_name = @args.first
+        case command_name
+        when nil, "-h", "-?", "--help"
+          "help"
+        when "-v", "--version"
+          "version"
+        else
+          command_name
+        end
+      end
+
+      private
+
+      def check_version?
+        if ARGV.first == "--no-check-version"
+          ARGV.shift
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/cc/cli/validate_config.rb

@@ -0,0 +1,84 @@
+module CC
+  module CLI
+    class ValidateConfig < Command
+      NO_CONFIG_MESSAGE = "No checked in config: nothing to validate.".freeze
+      TOO_MANY_CONFIG_MESSAGE = "Don't commit both .codeclimate.yml & .codeclimate.json: only the JSON will be used.".freeze
+      SHORT_HELP = "Validate your .codeclimate.yml or .codeclimate.json.".freeze
+      VALID_CONFIG_MESSAGE = "No errors or warnings found in %s.".freeze
+
+      def run
+        require_json_or_yaml
+        process_args
+
+        if any_issues?
+          display_issues
+        else
+          puts format(VALID_CONFIG_MESSAGE, validator.path)
+        end
+
+        exit 1 unless validator.valid?
+      end
+
+      private
+
+      attr_reader :config, :registry_path, :registry_prefix, :validator
+
+      def process_args
+        @registry_path = EngineRegistry::DEFAULT_MANIFEST_PATH
+        @registry_prefix = ""
+
+        # Undocumented; we only need these from Builder so we can validate
+        # engines/channels against our own registry and prefix.
+        while (arg = @args.shift)
+          case arg
+          when "--registry" then @registry_path = @args.shift
+          when "--registry-prefix" then @registry_prefix = @args.shift
+          end
+        end
+      end
+
+      def any_issues?
+        validator.errors.any? ||
+          validator.warnings.any?
+      end
+
+      def display_issues
+        validator.errors.each do |error|
+          puts "#{colorize("ERROR", :red)}: #{error}"
+        end
+
+        validator.warnings.each do |warning|
+          puts "#{colorize("WARNING", :yellow)}: #{warning}"
+        end
+      end
+
+      def require_json_or_yaml
+        if !filesystem.exist?(Config::YAMLAdapter::DEFAULT_PATH) && !filesystem.exist?(Config::JSONAdapter::DEFAULT_PATH)
+          puts NO_CONFIG_MESSAGE
+          exit 0
+        elsif filesystem.exist?(Config::YAMLAdapter::DEFAULT_PATH) && filesystem.exist?(Config::JSONAdapter::DEFAULT_PATH)
+          puts "#{colorize("WARNING", :yellow)}: #{TOO_MANY_CONFIG_MESSAGE}"
+        end
+      end
+
+      def validator
+        @validator =
+          if filesystem.exist?(Config::JSONAdapter::DEFAULT_PATH)
+            Config::Validation::JSON.new(
+              Config::JSONAdapter::DEFAULT_PATH,
+              engine_registry,
+            )
+          elsif filesystem.exist?(Config::YAMLAdapter::DEFAULT_PATH)
+            Config::Validation::YAML.new(
+              Config::YAMLAdapter::DEFAULT_PATH,
+              engine_registry,
+            )
+          end
+      end
+
+      def engine_registry
+        EngineRegistry.new(registry_path, registry_prefix)
+      end
+    end
+  end
+end

data/lib/cc/cli/version.rb

@@ -0,0 +1,16 @@
+module CC
+  module CLI
+    class Version < Command
+      SHORT_HELP = "Display the CLI version.".freeze
+
+      def run
+        say version
+      end
+
+      def version
+        path = File.expand_path("../../../../VERSION", __FILE__)
+        @version ||= File.read(path)
+      end
+    end
+  end
+end

data/lib/cc/cli/version_checker.rb

@@ -0,0 +1,107 @@
+require "cc/cli/global_config"
+require "cc/cli/global_cache"
+
+module CC
+  module CLI
+    class VersionChecker
+      include CC::CLI::Output
+
+      VERSION_CHECK_TIMEOUT = 60 * 60 # 1 Hour in seconds
+      DEFAULT_VERSIONS_URL = "https://versions.codeclimate.com".freeze
+
+      def check
+        return unless global_config.check_version? && version_check_is_due?
+
+        print_new_version_message if outdated?
+
+        global_config.save
+      rescue => error
+        CLI.logger.debug(error)
+      end
+
+      private
+
+      def version_check_is_due?
+        Time.now > global_cache.last_version_check + VERSION_CHECK_TIMEOUT
+      end
+
+      def outdated?
+        api_response["outdated"]
+      end
+
+      def latest_version
+        api_response["latest"]
+      end
+
+      def print_new_version_message
+        warn "A new version (v#{latest_version}) is available. Upgrade instructions are available at: https://github.com/codeclimate/codeclimate#packages"
+      end
+
+      def api_response
+        @api_response ||=
+          begin
+            cache! JSON.parse(api_response_body)
+          rescue JSON::ParserError => error
+            CLI.logger.debug(error)
+            {
+              "outdated" => false,
+            }
+          end
+      end
+
+      def api_response_body
+        if http_response.is_a? Net::HTTPSuccess
+          http_response.body
+        else
+          raise Net::HTTPFatalError.new("HTTP Error", http_response)
+        end
+      rescue Net::HTTPFatalError => error
+        CLI.logger.debug(error)
+        ""
+      end
+
+      def http_response
+        @http_response ||=
+          begin
+            uri = URI.parse(ENV.fetch("CODECLIMATE_VERSIONS_URL", DEFAULT_VERSIONS_URL))
+            uri.query = { version: version, uid: global_config.uuid }.to_query
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.open_timeout = 5
+            http.read_timeout = 5
+            http.ssl_timeout = 5
+            http.use_ssl = uri.scheme == "https"
+
+            http.get(uri, "User-Agent" => user_agent)
+          end
+      end
+
+      def cache!(data)
+        global_cache.latest_version = data["latest"]
+        global_cache.outdated = data["outdated"] == true
+        global_cache.last_version_check = Time.now
+        data
+      end
+
+      def version
+        @version ||= Version.new.version
+      end
+
+      def user_agent
+        "Code Climate CLI #{version}"
+      end
+
+      def global_config
+        @global_config ||= GlobalConfig.new
+      end
+
+      def global_cache
+        @global_cache ||= GlobalCache.new
+      end
+
+      def terminal
+        @terminal ||= HighLine.new(nil, $stderr)
+      end
+    end
+  end
+end

data/lib/cc/config.rb

@@ -0,0 +1,70 @@
+require "cc/config/checks_adapter"
+require "cc/config/default_adapter"
+require "cc/config/engine"
+require "cc/config/engine_set"
+require "cc/config/json_adapter"
+require "cc/config/prepare"
+require "cc/config/validation/hash_validations"
+require "cc/config/validation/check_validator"
+require "cc/config/validation/engine_validator"
+require "cc/config/validation/fetch_validator"
+require "cc/config/validation/file_validator"
+require "cc/config/validation/json"
+require "cc/config/validation/prepare_validator"
+require "cc/config/validation/yaml"
+require "cc/config/yaml_adapter"
+
+module CC
+  class Config
+    attr_reader \
+      :analysis_paths,
+      :engines,
+      :exclude_patterns,
+      :prepare
+
+    attr_writer \
+      :development
+
+    def self.load
+      config =
+        if File.exist?(JSONAdapter::DEFAULT_PATH)
+          JSONAdapter.load.config
+        elsif File.exist?(YAMLAdapter::DEFAULT_PATH)
+          YAMLAdapter.load.config
+        else
+          {}
+        end
+      config = DefaultAdapter.new(config).config
+      config = ChecksAdapter.new(config).config
+      build(config)
+    end
+
+    def self.build(data)
+      new(
+        engines: EngineSet.new(data.fetch("plugins", {})).engines,
+        exclude_patterns: data.fetch("exclude_patterns", DefaultAdapter::EXCLUDE_PATTERNS),
+        prepare: Prepare.from_data(data["prepare"]),
+      )
+    end
+
+    def initialize(analysis_paths: [], development: false, engines: [], exclude_patterns: [], prepare: Prepare.new)
+      @analysis_paths = analysis_paths
+      @development = development
+      @engines = engines
+      @exclude_patterns = exclude_patterns
+      @prepare = prepare
+    end
+
+    def merge(other)
+      Merge.new(self, other).run
+    end
+
+    def development?
+      @development
+    end
+
+    def disable_plugins!
+      @engines.delete_if(&:plugin?)
+    end
+  end
+end