Method parse has 88 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def parse(arguments)
        Slop.parse(arguments) do |o|

          o.banner = "Sym (#{Sym::VERSION}) – encrypt/decrypt data with a private key\n".bold.white
          o.separator 'Usage:'.yellow

Method error has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def self.error(config: {},
      exception: nil,
      type: nil,
      details: nil,
      reason: nil,

• Read up
  Read up

Class Application has 21 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Application

    attr_accessor :opts,
                  :opts_slop,
                  :args,

Method execute has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def execute
          output = []

          output << example(comment: 'generate a new private key into an environment variable:',
                            command: 'export mykey=$(sym -g)',

Method initialize has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

      def initialize(argv, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = nil)
        self.args   = argv
        self.stdin  = stdin
        self.stdout = stdout
        self.stderr = stderr

• Read up
  Read up

Method process has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

        def process(code)
          if code == true
            content_edited = File.read(tempfile.path)
            md5            = ::Base64.encode64(Digest::MD5.new.digest(content))
            md5_edited     = ::Base64.encode64(Digest::MD5.new.digest(content_edited))

• Read up
  Read up

Method execute has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

      def execute(command)
        command += ' 2>/dev/null' if stderr_disabled
        puts "> #{command.yellow}" if opts[:verbose]
        output = `#{command}`
        result = $?

• Read up
  Read up

Method initialize has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def initialize(argv, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = nil)
        self.args   = argv
        self.stdin  = stdin
        self.stdout = stdout
        self.stderr = stderr

Method execute has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

        def execute
          file = opts[:bash_support]

          out = ''
          Sym::Constants.config.each_pair do |key, config|

• Read up
  Read up

Method key has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

        def key
          return nil if encrypted_key.nil?
          decrypted_key = nil
          if should_decrypt?
            begin

• Read up
  Read up

Method inherited has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def self.inherited(klass)
          klass.instance_eval do
            class << self
              attr_accessor :required, :incompatible

Method execute has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def execute
          file = opts[:bash_support]

          out = ''
          Sym::Constants.config.each_pair do |key, config|

Method execute has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

        def execute
          retries ||= 0
          raise Sym::Errors::NoPrivateKeyFound.new("Unable to resolve private key from argument '#{opts[:key]}'") if self.key.nil?

          the_key = self.key

• Read up
  Read up

Method options_satisfied_by? has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

              def options_satisfied_by?(opts_hash)
                proc = required_options.find { |option| option.is_a?(Proc) }
                return true if proc && proc.call(opts_hash)
                return false if incompatible_options.any? { |option| opts_hash[option] }
                required_options.to_a.delete_if { |o| o.is_a?(Proc) }.all? { |o|

• Read up
  Read up

Method read! has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

        def read!
          KeySourceCheck::CHECKS.each do |source_check|
            next unless result = source_check.detect(self) rescue nil
            if key_ = normalize_key(result.key)
              key_source_ = result.to_s

• Read up
  Read up

Method execute! has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def execute!
      initialize_key_source
      unless command
        raise Sym::Errors::InsufficientOptionsError,
              " Can not determine what to do

• Read up
  Read up

Method detect_key has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def detect_key
          begin
            reader = Detector.new(opts, input_handler, password_cache)
            key = reader.key
            key_source = reader.key_source

• Read up
  Read up

Method operation has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def operation
          return nil unless self.enabled
          with_timeout(1) do
            with_retry do
              yield if block_given?

• Read up
  Read up

Method provided_options has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def provided_options(**opts)
      provided_opts = self.opts.clone
      provided_opts.delete_if { |k, v| !v }
      if opts[:safe]
        provided_options.map do |k, v|

• Read up
  Read up

Method with_retry has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def with_retry(retries: 3, fail_block: nil)
        attempts = 0
        yield if block_given?
      rescue StandardError => e
        raise(e) if attempts >= retries

• Read up
  Read up