File optimist.rb has 824 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'date'

module Optimist
VERSION = "3.1.0"

Method parse has a Cognitive Complexity of 61 (exceeds 5 allowed). Consider refactoring.

Open

  def parse(cmdline = ARGV)
    vals = {}
    required = {}

    opt :version, "Print version and exit" if @version && ! (@specs[:version] || @long["version"])

• Read up
  Read up

Method each_arg has a Cognitive Complexity of 51 (exceeds 5 allowed). Consider refactoring.

Open

  def each_arg(args)
    remains = []
    i = 0

    until i >= args.length

• Read up
  Read up

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

Open

  def parse(cmdline = ARGV)
    vals = {}
    required = {}

    opt :version, "Print version and exit" if @version && ! (@specs[:version] || @long["version"])

Class Option has 27 methods (exceeds 20 allowed). Consider refactoring.

Open

class Option

  attr_accessor :name, :short, :long, :default, :permitted, :permitted_response
  attr_writer :multi_given

Class Parser has 26 methods (exceeds 20 allowed). Consider refactoring.

Open

class Parser

  ## The registry is a class-instance-variable map of option aliases to their subclassed Option class.
  @registry = {}

Method each_arg has 69 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def each_arg(args)
    remains = []
    i = 0

    until i >= args.length

Method educate has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

  def educate(stream = $stdout)
    width # hack: calculate it now; otherwise we have to be careful not to
          # call this unless the cursor's at the beginning of a line.

    left = {}

• Read up
  Read up

Method wrap_line has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

  def wrap_line(str, opts = {})
    prefix = opts[:prefix] || 0
    width = opts[:width] || (self.width - 1)
    start = 0
    ret = []

• Read up
  Read up

Method parse has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

  def parse(paramlist, _neg_given)
    paramlist.map do |pg|
      pg.map do |param|
        next param if param.is_a?(Date)
        begin

• Read up
  Read up

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

Open

  def handle_unknown_argument(arg, candidates, suggestions)
    errstring = "unknown argument '#{arg}'"
    if (suggestions &&
      Module::const_defined?("DidYouMean") &&
      Module::const_defined?("DidYouMean::JaroWinkler") &&

• Read up
  Read up

Method opt has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

  def opt(name, desc = "", opts = {}, &b)
    opts[:callback] ||= b if block_given?
    opts[:desc] ||= desc

    o = Option.create(name, desc, opts)

• Read up
  Read up

Method get_type_from_disdef has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

  def self.get_type_from_disdef(optdef, opttype, disambiguated_default)
    if disambiguated_default.is_a? Array
      return(optdef.first.class.name.downcase + "s") if !optdef.empty?
      if opttype
        raise ArgumentError, "multiple argument type must be plural" unless opttype.multi_arg?

• Read up
  Read up

Method handle_unknown_argument has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def handle_unknown_argument(arg, candidates, suggestions)
    errstring = "unknown argument '#{arg}'"
    if (suggestions &&
      Module::const_defined?("DidYouMean") &&
      Module::const_defined?("DidYouMean::JaroWinkler") &&

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

Open

  def add(values)
    values = [values] unless values.is_a?(Array) # box the value
    values = values.compact
    if values.include?(:none)
      if values.size == 1

• Read up
  Read up

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

Open

  def parse(paramlist, _neg_given)
    paramlist.map do |pg|
      pg.map do |param|
        if param =~ /^(stdin|-)$/i
          $stdin

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

              if @stop_on_unknown
                short_remaining << shortargs[j + 1..-1].join
                remains << "-#{short_remaining.join}"
                return remains += args[i + 1..-1]
              end

Avoid deeply nested control flow statements.

Open

              if @stop_on_unknown
                remains << "-#{short_remaining.join}"
                return remains += args[i + 1..-1]
              end

Method resolve_default_short_options! has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  def resolve_default_short_options!
    @order.each do |type, name|
      opts = @specs[name]
      next if type != :opt || opts.doesnt_need_autogen_short
      c = opts.long.long.split(//).find { |d| d !~ Optimist::ShortNames::INVALID_ARG_REGEX && !@short.member?(d) }

• Read up
  Read up

Avoid too many return statements within this method.

Open

                return remains += args[i + 1..-1]