Method parse has a Cognitive Complexity of 73 (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

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

Open

require 'date'

module Optimist
  # note: this is duplicated in gemspec
  # please change over there too

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 87 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"])

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

Class Parser has 24 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 = {}

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

Open

class Option

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

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 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 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
                remains << "-#{short_remaining}"
                return remains += args[i + 1..-1]
              end

Avoid deeply nested control flow statements.

Open

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

Method opt has a Cognitive Complexity of 7 (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 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.short

• Read up
  Read up

Avoid too many return statements within this method.

Open

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

Avoid too many return statements within this method.

Open

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

Avoid too many return statements within this method.

Open

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

Method registry_getopttype has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

  def self.registry_getopttype(type)
    return nil unless type
    if type.respond_to?(:name)
      type = type.name
      lookup = type.downcase.to_sym

• Read up
  Read up

Method die has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

  def die(arg, msg = nil, error_code = nil)
    msg, error_code = nil, msg if msg.kind_of?(Integer)
    if msg
      $stderr.puts "Error: argument --#{@specs[arg].long} #{msg}."
    else

• Read up
  Read up

Method handle_short_opt has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

  def self.handle_short_opt(sopt)
    sopt = sopt.to_s if sopt && sopt != :none
    sopt = case sopt
           when /^-(.)$/          then $1
           when nil, :none, /^.$/ then sopt

• Read up
  Read up