coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/theory/cadence.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # Not done yet
+    class Cadence
+    end
+  end
+end

data/lib/coltrane/theory/chord.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # It describe a chord
+
+    class Chord
+      attr_reader :root_note, :quality, :notes
+      include ChordSubstitutions
+
+      def initialize(notes: nil, root_note: nil, quality: nil, name: nil)
+        if notes
+          notes      = NoteSet[*notes] if notes.is_a?(Array)
+          @notes     = notes
+          @root_note = notes.first
+          @quality   = ChordQuality.new(notes: notes)
+        elsif root_note && quality
+          @notes     = quality.notes_for(root_note)
+          @root_note = root_note
+          @quality   = quality
+        elsif name
+          @root_note, @quality, @notes = parse_from_name(name)
+        else
+          raise WrongKeywordsError,
+                '[notes:] || [root_note:, quality:] || [name:]'
+        end
+      end
+
+      def ==(other)
+        (notes & other.notes).size == notes.size
+      end
+
+      alias eql? ==
+
+      def name
+        "#{root_note}#{quality}"
+      end
+
+      alias to_s name
+
+      def hash
+        notes.hash
+      end
+
+      def pretty_name
+        "#{root_note.pretty_name}#{quality.name}"
+      end
+
+      def intervals
+        IntervalSequence.new(NoteSet.new(notes))
+      end
+
+      def size
+        notes.size
+      end
+
+      def scales
+        Scale.having_chord(name)
+      end
+
+      def next_inversion
+        Chord.new(notes: notes.rotate(1))
+      end
+
+      def invert(n = 1)
+        Chord.new(notes: notes.rotate(n))
+      end
+
+      def previous_inversion
+        Chord.new(notes: notes.rotate(-1))
+      end
+
+      def +(other)
+        case other
+        when Note, NoteSet, Interval then Chord.new(notes: notes + other)
+        when Chord then Chord.new(notes: notes + other.notes)
+        end
+      end
+
+      def -(other)
+        case other
+        when Note, NoteSet, Interval, Numeric then Chord.new(notes: notes - other)
+        when Chord then Chord.new(notes: notes - other.notes)
+        end
+      end
+
+      protected
+
+      def parse_from_name(name)
+        chord_name, bass = name.match?(/\/9/) ? [name, nil] : name.split('/')
+        chord_regex = /([A-Z](?:#|b)?)(.*)/
+        _, root_name, quality_name = chord_name.match(chord_regex).to_a
+        root    = Note[root_name]
+        quality = ChordQuality.new(name: quality_name, bass: bass)
+        notes   = quality.notes_for(root)
+        notes << Note[bass] unless bass.nil?
+        [root, quality, notes]
+      end
+    end
+  end
+end

data/lib/coltrane/theory/chord_quality.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # It describe the quality of a chord, like maj7 or dim.
+    class ChordQuality < IntervalSequence
+      include Qualities
+      attr_reader :name
+      # QUALITIES_FILE  = File.expand_path("#{'../' * 3}data/qualities.json", __FILE__)
+
+      private
+
+      def self.chord_trie
+        File.expand_path("#{'../' * 3}data/qualities.json", __FILE__)
+        trie = QUALITIES
+
+        trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
+                          to_keys: ['Perfect Unison', 'Major Second'],
+                          suffix: 'sus2'
+
+        trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
+                          to_keys: ['Perfect Unison', 'Perfect Fourth'],
+                          suffix: 'sus4'
+        trie.deep_dup
+      end
+
+      def self.intervals_per_name(quality_names: {}, intervals: [], hash: nil)
+        hash ||= chord_trie
+        return quality_names if hash.empty?
+        if hash['name']
+          quality_names[hash.delete('name')] = intervals.map { |n| Interval.public_send(n.underscore) }
+        end
+        hash.reduce(quality_names) do |memo, (interval, values)|
+          memo.merge intervals_per_name(hash:  values,
+                                        quality_names: quality_names,
+                                        intervals: intervals + [interval])
+        end
+      end
+
+      NAMES = intervals_per_name
+
+      def find_chord(given_interval_names, trie: self.class.chord_trie, last_name: nil)
+        return if trie.nil?
+        if given_interval_names.empty?
+          @found = true
+          return trie['name']
+        end
+        interval = given_interval_names.shift
+        new_trie = trie[interval.full_name]
+        find_chord given_interval_names, last_name: (trie['name'] || last_name),
+                                         trie: new_trie
+      end
+
+      def normal_sequence
+        %i[unison third! fifth sixth! seventh ninth eleventh! thirteenth]
+      end
+
+      def sus2_sequence
+        %i[unison second! fifth sixth! seventh ninth eleventh! thirteenth]
+      end
+
+      def sus4_sequence
+        %i[unison fourth! fifth sixth! seventh ninth eleventh! thirteenth]
+      end
+
+      def retrieve_chord_intervals(chord_sequence = normal_sequence)
+        ints = IntervalSequence.new(*self)
+        chord_sequence.map do |int_sym|
+          next unless interval_name = ints.public_send(int_sym)
+          ints.delete_if { |i| i.cents == IntervalClass.new(interval_name).cents }
+          interval_name
+        end
+      end
+
+      public
+
+      def get_name
+        find_chord(retrieve_chord_intervals.compact) ||
+          find_chord(retrieve_chord_intervals(sus2_sequence).compact) ||
+          find_chord(retrieve_chord_intervals(sus4_sequence).compact) ||
+          raise(ChordNotFoundError)
+      end
+
+      def suspension_type
+        if has_major_second?
+          'sus2'
+        else has_fourth?
+             'sus4'
+        end
+      end
+
+      def initialize(name: nil, notes: nil, bass: nil)
+        if name
+          @name = bass.nil? ? name : [name, bass].join('/')
+          super(*intervals_from_name(name))
+        elsif notes
+          super(notes: notes)
+          @name = get_name
+        else
+          raise WrongKeywordsError, '[name:] || [notes:]'
+        end
+      end
+
+      alias to_s name
+
+      private
+
+      def intervals_from_name(name)
+        NAMES[name] || NAMES["M#{name}"] || raise(ChordNotFoundError)
+      end
+    end
+  end
+end

data/lib/coltrane/theory/chord_substitutions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    module ChordSubstitutions
+      def tritone_substitution
+        self + Interval.augmented_fourth
+      end
+    end
+  end
+end

data/lib/coltrane/theory/circle_of_fifths.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    class CircleOfFifths
+      attr_reader :notes
+
+      LETTER_SEQUENCE = %w[C G D A E B F].freeze
+
+      def initialize(start_note = Note['C'], size = Float::INFINITY)
+        index  = letters.index(start_note.name[0])
+        @notes = fifths(note: start_note - Interval.perfect_fifth,
+                        size: size,
+                        index: (index - 1) % LETTER_SEQUENCE.size)
+      end
+
+      private
+
+      def fifths(note:, index: nil, notes: [], size:)
+        return notes if size == 0
+        return notes if notes.any? && note.as(letters(index)).name == notes.first.name
+        fifths note: note + Interval.perfect_fifth,
+               notes: notes + [note.as(letters(index))],
+               index: index + 1,
+               size:  size - 1
+      end
+
+      def letters(i = nil)
+        i.nil? ? LETTER_SEQUENCE : LETTER_SEQUENCE[i % LETTER_SEQUENCE.size]
+      end
+    end
+  end
+end

data/lib/coltrane/theory/classic_scales.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # This module deals with well known scales on music
+    module ClassicScales
+      SCALES = {
+        'Pentatonic Major' => [2, 2, 3, 2, 3],
+        'Blues Major'      => [2, 1, 1, 3, 2, 3],
+        'Harmonic Minor'   => [2, 1, 2, 2, 1, 3, 1],
+        'Hungarian Minor'  => [2, 1, 2, 1, 1, 3, 1],
+        'Pentatonic Minor' => [3, 2, 2, 3, 2],
+        'Blues Minor'      => [3, 2, 1, 1, 3, 2],
+        'Whole Tone'       => [2, 2, 2, 2, 2, 2],
+        'Flamenco'         => [1, 3, 1, 2, 1, 2, 2],
+        'Chromatic'        => [1] * 12
+      }.freeze
+
+      GREEK_MODES = %w[
+        Ionian
+        Dorian
+        Phrygian
+        Lydian
+        Mixolydian
+        Aeolian
+        Locrian
+      ].freeze
+
+      # Creates factories for scales
+      SCALES.each do |name, distances|
+        define_method name.underscore do |tone = 'C', mode = 1|
+          new(*distances, tone: tone, mode: mode, name: name)
+        end
+      end
+
+      # Creates factories for Greek Modes
+      GREEK_MODES.each_with_index do |mode, index|
+        mode_name = mode
+        mode_n = index + 1
+        define_method mode.underscore do |tone = 'C'|
+          new(notes: DiatonicScale.new(tone).notes.rotate(index))
+        end
+      end
+
+      # Factories for the diatonic scale
+      def major(note = 'C')
+        DiatonicScale.new(note)
+      end
+
+      def minor(note = 'A')
+        DiatonicScale.new(note, major: false)
+      end
+
+      alias diatonic major
+      alias natural_minor minor
+      alias pentatonic pentatonic_major
+      alias blues blues_major
+
+      def known_scales
+        SCALES.keys + ['Major', 'Natural Minor']
+      end
+
+      # List of scales appropriate for search
+      def standard_scales
+        known_scales - ['Chromatic']
+      end
+
+      def fetch(name, tone = nil)
+        public_send(name.underscore, tone)
+      end
+
+      # def having_notes(notes)
+      #   format = { scales: [], results: {} }
+      #   standard_scales.each_with_object(format) do |name, output|
+      #     PitchClass.all.each.map do |tone|
+      #       scale = send(name.underscore, tone)
+      #       output[:results][name] ||= {}
+      #       next if output[:results][name].key?(tone.integer)
+      #       output[:scales] << scale if scale.include?(notes)
+      #       output[:results][name][tone.integer] = scale.notes & notes
+      #     end
+      #   end
+      # end
+
+      def having_notes(notes)
+        PitchClass.all
+        .reduce([]) { |scales, tone|
+          standard_scales
+          .reduce([]) { |tone_scales, scale|
+            fetch(scale, tone)
+            .yield_self { |scale|
+              (scale & notes).size > 0 ? tone_scales + [scale] : tone_scales
+            }
+          }.yield_self { |scales_for_tone|
+            scales + scales_for_tone
+          }
+        }
+        .yield_self { |scales| ScaleSet.new(*scales, searched_notes: notes) } # and convert to a set
+
+      end
+
+      def having_chords(*chords)
+        should_create = !chords.first.is_a?(Chord)
+        notes = chords.reduce(NoteSet[]) do |memo, c|
+          memo + (should_create ? Chord.new(name: c) : c).notes
+        end
+        having_notes(notes)
+      end
+
+      alias having_chord having_chords
+    end
+  end
+end

data/lib/coltrane/theory/diatonic_scale.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    class DiatonicScale < Scale
+      def initialize(tone, major: true)
+        @major = major
+        tone   = Note[tone]
+        notes  = CircleOfFifths.new(tone - (major? ? 0 : 9), 7).notes.sort
+        super notes: notes.rotate(notes.index(tone))
+      end
+
+      def name
+        major? ? 'Major' : 'Natural Minor'
+      end
+
+      def relative_minor
+        minor? ? self : self.class.new(@tone + 9, major: false)
+      end
+
+      def relative_major
+        major? ? self : self.class.new(@tone - 9, major: true)
+      end
+
+      def relative
+        major? ? relative_minor : relative_major
+      end
+
+      def major?
+        !!@major
+      end
+
+      def minor?
+        !@major
+      end
+    end
+  end
+end

data/lib/coltrane/theory/errors.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/Documentation
+
+module Coltrane
+  module Theory
+    class TheoryError < StandardError
+      def initialize(msg)
+        super msg
+      end
+    end
+
+    class BadConstructorError < TheoryError
+      def initialize(msg = nil)
+        super "Bad constructor. #{msg}"
+      end
+    end
+
+    class WrongKeywordsError < BadConstructorError
+      def initialize(msg)
+        super "Use one of the following set of keywords: #{msg}"
+      end
+    end
+
+    class WrongArgumentsError < BadConstructorError
+      def initialize(_msg)
+        super 'Wrong argument(s).'
+      end
+    end
+
+    class InvalidNoteError < BadConstructorError
+      def initialize(note)
+        super "#{note} is not a valid note"
+      end
+    end
+
+    class InvalidNotesError < BadConstructorError
+      def initialize(notes)
+        super "#{notes} are not a valid set of notes"
+      end
+    end
+
+    class HasNoNotesError < BadConstructorError
+      def initialize
+        super 'The given object does not respond to :notes, '\
+              "thereby it can't be used for this operation)"
+      end
+    end
+
+    class WrongDegreeError
+      def initialize(degree)
+        super "#{degree} is not a valid degree. Degrees for this scale must be"\
+              "between 1 and #{degrees}"
+      end
+    end
+
+    class ChordNotFoundError < TheoryError
+      def initialize
+        super "The chord you provided wasn't found. "\
+              "If you're sure this chord exists, "\
+              "would you mind to suggest it's inclusion here: "\
+              'https://github.com/pedrozath/coltrane/issues '\
+              "\n\nA tip tho: always include the letter M for major"
+      end
+    end
+
+    class IntervalNotFoundError < TheoryError
+      def initialize(arg)
+        super "The interval \"#{arg}\" that was provided wasn't found. "\
+              "If you're sure this interval exists, "\
+              "would you mind to suggest it's inclusion here: "\
+              'https://github.com/pedrozath/coltrane/issues '\
+      end
+    end
+
+    class InvalidPitchClassError < TheoryError
+      def initialize(arg)
+        super "The given frequency(#{arg}) is not considered "\
+              'part of a pitch class'\
+      end
+    end
+
+    class InvalidNoteSymbolError < TheoryError
+      def initialize(arg)
+        super "The musical notation included an unrecognizable symbol (#{arg})."
+      end
+    end
+
+    class InvalidNoteLetterError < TheoryError
+      def initialize(arg)
+        super "The musical notation included an unrecognizable letter (#{arg})."
+      end
+    end
+  end
+
+  # rubocop:enable Style/Documentation
+end