Class Chord has 32 methods (exceeds 20 allowed). Consider refactoring.

Open

      class Chord
        include Comparable
        attr_reader :guitar_notes, :guitar, :free_fingers, :target_chord, :barre

        MAX_FRET_SPAN = 3

Class Interval has 29 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Interval < IntervalClass
      attr_reader :letter_distance, :cents
      alias compound? compound

      class << self

Class IntervalClass has 28 methods (exceeds 20 allowed). Consider refactoring.

Open

    class IntervalClass < FrequencyInterval
      QUALITY_SEQUENCE = [
        %w[P],
        %w[m M],
        %w[m M],

Method border has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

        def border(x, y)
          edge = [guitar.tuning.size * 2 - 2, chord_height + 1]
          x_on_start  = x == 0
          y_on_start  = y == 0
          x_on_edge   = x == edge[0]

• Read up
  Read up

Method render_notes has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

        def render_notes
          guitar_notes.strings.reverse.map.with_index.map do |string, str_i|
            Array.new(frets + 2) do |i|
              if i.zero?
                Paint[

• Read up
  Read up

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

Open

    class PitchClass
      attr_reader :integer
      include Comparable

      NOTATION = %w[C C# D D# E F F# G G# A A# B].freeze

File qualities.rb has 257 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module Qualities
  QUALITIES = {
    'Perfect Unison' => {
      'Minor Third' => {
        'Diminished Fifth' => {

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

Open

    class IntervalSequence
      extend Forwardable
      attr_reader :intervals

      def_delegators :@intervals, :map, :each, :[], :size,

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

Open

    class Scale
      extend ClassicScales
      extend Forwardable

      def_delegators :notes, :accidentals, :sharps, :flats

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

Open

        def self.find_by_notation(guitar, chord_notation)
          chord_notation
          .split('-')
          .map
          .with_index do |n, i|

• Read up
  Read up

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

Open

      def initialize(arg_1 = nil, arg_2 = nil, ascending: true,
                     letter_distance: nil,
                     semitones: nil,
                     compound: false)
        if arg_1 && !arg_2 # assumes arg_1 is a letter

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

Open

      def initialize(notation = nil, chord: nil, key: nil, scale: nil)
        if notation.nil? && chord.nil? || key.nil? && scale.nil?
          raise WrongKeywordsError,
                '[notation, [scale: || key:]] '\
                '[chord:, [scale: || key:]] '\

• Read up
  Read up

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

Open

        def fetch_descendant_chords
          return [self] if guitar_notes.size >= guitar.strings.size
          possible_new_notes(notes_available.positive?).reduce([]) do |memo, n|
            barre = n.fret if guitar_notes.last == n.fret
            fingers_change = n.fret == barre || n.fret.zero? ? 0 : 1

• Read up
  Read up

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

Open

      def initialize(arg_1 = nil, arg_2 = nil, ascending: true,
                     letter_distance: nil,
                     semitones: nil,
                     compound: false)
        if arg_1 && !arg_2 # assumes arg_1 is a letter

• Read up
  Read up

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

Open

      def initialize(notation_arg = nil,
                     note: nil,
                     octave: nil,
                     notation: nil,
                     frequency: nil)

• Read up
  Read up

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

Open

      def initialize(*intervals, notes: nil, relative_intervals: nil)
        if intervals.any?
          @intervals = if intervals.first.is_a?(Interval)
                         intervals
                       else

• Read up
  Read up

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

Open

      def chords(size = 3..12)
        size = (size..size) if size.is_a?(Integer)
        scale_rotations = interval_sequence.inversions
        ChordQuality.intervals_per_name.reduce([]) do |memo1, (qname, qintervals)|
          next memo1 unless size.include?(qintervals.size)

• Read up
  Read up

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

Open

        def render
          output = []
          scale_width = scale_set.results.keys.map(&:size).max
          scale_set.results.each do |name, scales_by_tone|
            output << name.ljust(scale_width + 1, ' ')

• Read up
  Read up

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

Open

      def initialize(notation = nil, chords: nil, roman_chords: nil, key: nil, scale: nil)
        if notation.nil? && chords.nil? && roman_chords.nil? || key.nil? && scale.nil?
          raise WrongKeywordsError,
            '[chords:, [scale: || key:]] '\
            '[roman_chords:, [scale: || key:]] '\

• Read up
  Read up

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

Open

        def replace_x(line, notes, size, index = 0)
          line.gsub('X' * size).with_index do |_match, i|
            note = notes[i % notes.size]
            next ' ' * size unless note_set.include?(note)
            Paint[replacer(note)[size == 2 ? 0..2 : index], 'red']

• Read up
  Read up