fet 0.2.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fet.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/fet/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fet"
+  spec.version       = Fet::VERSION
+  spec.authors       = ["Dimitrios Lisenko"]
+  spec.email         = ["dimitrioslisenko@gmail.com"]
+
+  spec.summary       = "A functional ear trainer."
+  spec.description   = "Teaches your ear to recognize notes based on their function in a key."
+  spec.homepage      = "https://github.com/DimitriosLisenko/fet"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/DimitriosLisenko/fet"
+  spec.metadata["changelog_uri"] = "https://github.com/DimitriosLisenko/fet/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir = "bin"
+  spec.executables = ["fet"]
+  spec.require_paths = ["lib"]
+
+  # Gem runtime dependencies - place development dependencies inside Gemfile
+  spec.add_dependency "gli", "~> 2.20", ">= 2.20.1"
+  spec.add_dependency "ice_nine", "~> 0.11.2"
+  spec.add_dependency "midilib", "~> 2.0", ">= 2.0.5"
+
+  # RDoc configuration
+  spec.extra_rdoc_files = ["README.rdoc", "fet.rdoc"]
+  spec.rdoc_options << "--title" << "fet" << "--main" << "README.rdoc" << "-ri"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/fet.rdoc

@@ -0,0 +1,94 @@
+== fet - Functional Ear Trainer
+
+v0.2.0
+
+=== Global Options
+=== --help
+Show this message
+
+
+
+=== --version
+Display the program version
+
+
+
+=== Commands
+==== Command: <tt>generate </tt>
+Generate MIDI files for ear training
+
+
+===== Commands
+====== Command: <tt>listening </tt>
+Generate MIDI files for listening
+
+Each MIDI file will contain a chord progression, followed by the specified number of degrees - first harmonically, then melodically after a pause.
+======= Options
+======= -d|--degrees arg
+
+Number of degrees to play
+
+[Default Value] 1
+[Must Match] ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"]
+
+
+======= -e|--exercises arg
+
+Number of exercises to generate
+
+[Default Value] 200
+
+
+======= -t|--tempo arg
+
+Tempo at which the chord progression is played at
+
+[Default Value] 120
+
+
+======= -a|--[no-]all-single-degree
+Generate all single degree listening exercises (ignores -e and -d flag)
+
+
+
+====== Command: <tt>singing </tt>
+Generate MIDI files for singing
+
+Each MIDI file will contain a chord progression, followed by a specified pause, during which the degree should be sung. The degree is then played for confirmation.
+======= Options
+======= -p|--pause arg
+
+How many seconds to wait before playing the correct note
+
+[Default Value] 3
+
+
+======= -t|--tempo arg
+
+Tempo at which the chord progression is played at
+
+[Default Value] 120
+
+
+====== Command: <tt>single_note_listening </tt>
+Generate MIDI files for listening (single note)
+
+Each MIDI file will contain a chord progression, followed the same note across all files.
+======= Options
+======= -t|--tempo arg
+
+Tempo at which the chord progression is played at
+
+[Default Value] 120
+
+
+==== Command: <tt>help  command</tt>
+Shows a list of commands or help for one command
+
+Gets help for the application or its commands. Can also list the commands in a way helpful to creating a bash-style completion function
+===== Options
+===== -c
+List commands one per line, to assist with shell completion
+
+
+

data/lib/fet/chord_progression.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Fet
+  # Class in charge of generating chord progressions, as well as any associated music theory
+  class ChordProgression
+    TEMPLATE_MAJOR = "major".deep_freeze
+    TEMPLATE_MINOR = "minor".deep_freeze
+
+    DEFAULT_TEMPLATES = {
+      # I-IV-V7-I
+      TEMPLATE_MAJOR => [[0, 4, 7], [0, 5, 9], [-1, 5, 7], [0, 4, 7]],
+      # i-iv-V7-i
+      TEMPLATE_MINOR => [[0, 3, 7], [0, 5, 8], [-1, 5, 7], [0, 3, 7]],
+    }.deep_freeze
+
+    attr_accessor :template, :offset
+
+    def initialize(offset:, template_type: nil, template: nil)
+      self.template = template_type ? DEFAULT_TEMPLATES[template_type] : template
+      validate_template!
+
+      self.offset = offset
+      validate_offset!
+    end
+
+    def with_offset
+      return template.map { |chord| chord.map { |note| note + offset } }
+    end
+
+    private
+
+    def validate_template!
+      validate_nonempty_array!(template, template)
+      template.each do |chord|
+        validate_nonempty_array!(template, chord)
+        chord.each do |offset|
+          validate_integer!(template, offset)
+        end
+      end
+    end
+
+    def validate_offset!
+      validate_integer!(offset, offset)
+    end
+
+    def validate_nonempty_array!(core, element)
+      raise Fet::InvalidChordProgression.new(core) unless element.is_a?(Array)
+      raise Fet::InvalidChordProgression.new(core) if element.empty?
+    end
+
+    def validate_integer!(core, element)
+      raise Fet::InvalidChordProgression.new(core) unless element.is_a?(Integer)
+    end
+  end
+end

data/lib/fet/cli/generate/listening.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fet
+  module Cli
+    module Generate
+      # CLI implementation for the "generate listening" command
+      module Listening
+        def self.run(_global_options, options, _args)
+          Fet::Generator::Listening.new(
+            exercises: options[:exercises],
+            tempo: options[:tempo],
+            degrees: options[:degrees],
+            all_single_degree: options[:"all-single-degree"],
+            directory_prefix: options[:directory_prefix] || "",
+          ).generate
+        end
+      end
+    end
+  end
+end

data/lib/fet/cli/generate/singing.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fet
+  module Cli
+    module Generate
+      # CLI implementation for the "generate singing" command
+      module Singing
+        def self.run(_global_options, options, _args)
+          Fet::Generator::Singing.new(
+            tempo: options[:tempo],
+            pause: options[:pause],
+            directory_prefix: options[:directory_prefix] || "",
+          ).generate
+        end
+      end
+    end
+  end
+end

data/lib/fet/cli/generate/single_note_listening.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fet
+  module Cli
+    module Generate
+      # CLI implementation for the "generate single_note_listening" command
+      module SingleNoteListening
+        def self.run(_global_options, options, _args)
+          Fet::Generator::SingleNoteListening.new(
+            tempo: options[:tempo],
+            directory_prefix: options[:directory_prefix] || "",
+          ).generate
+        end
+      end
+    end
+  end
+end

data/lib/fet/degree.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Fet
+  # This class handles validation of degree names and extraction of values from it
+  class Degree
+    DEGREE_NAMES = [
+      ["1"],
+      ["#1", "b2"],
+      ["2"],
+      ["#2", "b3"],
+      ["3"],
+      ["4"],
+      ["#4", "b5"],
+      ["5"],
+      ["#5", "b6"],
+      ["6"],
+      ["#6", "b7"],
+      ["7"],
+    ].deep_freeze
+
+    attr_reader :degree_name
+
+    def initialize(degree_name)
+      self.degree_name = degree_name
+      validate_degree_name!
+    end
+
+    def degree_accidental
+      return degree_name.size == 2 ? degree_name[0] : nil
+    end
+
+    def degree_value
+      return degree_name.size == 2 ? degree_name[1].to_i : degree_name[0].to_i
+    end
+
+    private
+
+    attr_writer :degree_name
+
+    def validate_degree_name!
+      raise InvalidDegreeName.new(degree_name) unless DEGREE_NAMES.flatten.include?(degree_name)
+    end
+  end
+end

data/lib/fet/degrees.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "degree"
+require_relative "midi_note"
+
+module Fet
+  # This class handles determining the degrees for a given root
+  class Degrees
+    attr_reader :root_name,
+                :octave_value
+
+    def initialize(root_name:, octave_value:)
+      self.root_name = root_name
+      self.octave_value = octave_value
+      self.degree_to_note_name = generate_degree_to_note_name
+    end
+
+    def root_midi_value
+      return MidiNote.from_note(root_name, octave_value).midi_value
+    end
+
+    def degree_names_of_midi_value(midi_value)
+      return Degree::DEGREE_NAMES[degree_index_of_midi_value(midi_value)]
+    end
+
+    def note_name_of_degree(degree_name)
+      return degree_to_note_name[Degree.new(degree_name).degree_name]
+    end
+
+    private
+
+    attr_writer :root_name,
+                :octave_value
+
+    attr_accessor :degree_to_note_name
+
+    def note_name_of_degree_internal(degree_name)
+      degree = Degree.new(degree_name)
+
+      notes_array = Fet::MusicTheory.notes_of_mode(root_name, "major")
+      note_name = notes_array[degree.degree_value - 1]
+
+      return Note.new(note_name).flattened_note.full_note if degree.degree_accidental == "b"
+      return Note.new(note_name).sharpened_note.full_note if degree.degree_accidental == "#"
+
+      return Note.new(note_name).full_note
+    end
+
+    def generate_degree_to_note_name
+      result = {}
+      Degree::DEGREE_NAMES.flatten.each do |degree_name|
+        result[degree_name] = note_name_of_degree_internal(degree_name)
+      end
+      return result
+    end
+
+    def degree_index_of_midi_value(midi_value)
+      return MidiNote.new(midi_value).degree(root_midi_value)
+    end
+  end
+end

data/lib/fet/exceptions.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fet
+  class Error < StandardError; end
+
+  class InvalidNote < Error; end
+
+  class InvalidChordProgression < Error; end
+
+  class InvalidModeName < Error; end
+
+  class InvalidMidiNote < Error; end
+
+  class InvalidDegreeName < Error; end
+
+  # TODO: this can be removed if the circle of fifths is generated dynamically
+  class UnsupportedRootName < Error; end
+end

data/lib/fet/generator/listening.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Fet
+  module Generator
+    # Class that generates MIDI files for the listening exercises
+    class Listening
+      # The reason number of exercises is required is because the actual number generated is quite large
+      # For three degrees, it's something like 88C3, but a bit smaller because one you choose 1, you actually exclude some of the 88 other than just itself
+      # (i.e. if you chose the b2 degree, you exclude the rest of the b2 degrees too)
+      # 2 degrees => 21592 (left it for a while and it seemed to stop at this value) - comparable to 64C2 * 12 = 24192
+      # 3 degrees => 252398 (before I stopped it, there was more being generated)
+      def initialize(exercises:, tempo:, degrees:, all_single_degree:, directory_prefix: "")
+        self.number_of_exercises = exercises
+        self.all_single_degree = all_single_degree
+        self.tempo = tempo
+        self.number_of_degrees = degrees
+        self.note_range = Fet::REDUCED_BY_OCTAVE_PIANO_RANGE
+        self.directory_prefix = directory_prefix
+      end
+
+      def generate
+        all_single_degree ? generate_all_single_degree_exercises : generate_number_of_exercises
+      end
+
+      private
+
+      attr_accessor :number_of_exercises, :tempo, :number_of_degrees, :note_range, :all_single_degree, :directory_prefix
+
+      def generate_all_single_degree_exercises
+        Fet::MAJOR_ROOT_MIDI_VALUES.each do |root|
+          note_range.each do |note|
+            select_notes_recursive([note], [], root, 1, "major")
+          end
+        end
+
+        Fet::MINOR_ROOT_MIDI_VALUES.each do |root|
+          note_range.each do |note|
+            select_notes_recursive([note], [], root, 1, "minor")
+          end
+        end
+      end
+
+      def generate_number_of_exercises
+        number_of_exercises.times do
+          # Create major key exercises
+          root = Fet::MAJOR_ROOT_MIDI_VALUES.to_a.sample
+          until select_notes_recursive(note_range, [], root, number_of_degrees, "major"); end
+
+          # Create minor key exercises
+          root = Fet::MINOR_ROOT_MIDI_VALUES.to_a.sample
+          until select_notes_recursive(note_range, [], root, number_of_degrees, "minor"); end
+        end
+      end
+
+      def select_notes_recursive(all_notes, chosen_notes, root, number_degrees, key_type)
+        return create_midi_file(chosen_notes, root, key_type) if number_degrees.zero?
+
+        selected_note = all_notes.sample
+        chosen_notes << selected_note
+
+        all_notes_without_note_degree = all_notes.reject { |note| Fet::MidiNote.new(note).degree(root[1]) == Fet::MidiNote.new(selected_note).degree(root[1]) }
+        select_notes_recursive(all_notes_without_note_degree, chosen_notes, root, number_degrees - 1, key_type)
+      end
+
+      def create_midi_file(chosen_notes, root, key_type)
+        # Sort so that the file name corresponds to degree of lowest to highest
+        chosen_notes = chosen_notes.sort
+
+        filename = full_filename(key_type, root, chosen_notes)
+        return false if File.exist?(filename)
+
+        progression = Fet::ChordProgression.new(offset: root[1], template_type: key_type).with_offset
+        Fet::MidilibInterface.new(
+          tempo: tempo, progression: progression, notes: chosen_notes, info: generate_midi_info(key_type, root, chosen_notes), filename: filename,
+        ).create_listening_midi_file
+        return true
+      end
+
+      def generate_midi_info(key_type, root, chosen_notes)
+        return [
+          "Key: [#{root[0]} #{key_type}]",
+          "Degrees: [#{chosen_notes.map { |i| Fet::MusicTheory::DEGREES[(i - root[1]) % 12] }}]",
+          "Notes: [#{chosen_notes}]",
+        ].join(" ")
+      end
+
+      def full_filename(key_type, root, chosen_notes)
+        result = File.join(*[directory_prefix, "listening", key_type].reject(&:empty?))
+        filename = root[0].to_s # note, e.g. Db
+        filename += key_type == "major" ? "M" : "m" # type of note, M or m
+        filename += "_" # delimiter
+        filename += chosen_notes.map { |i| note_filename_part(root[0], root[1], i) }.join("_") # chosen notes description, e.g. b7(Cb4)
+        filename += ".mid" # extension
+        return File.join(result, filename)
+      end
+
+      def note_filename_part(root_name, root_midi_value, note_midi_value)
+        root_octave_value = Fet::MidiNote.new(root_midi_value).octave_number
+        degrees_instance = Fet::Degrees.new(root_name: root_name, octave_value: root_octave_value)
+        degree_name = degrees_instance.degree_names_of_midi_value(note_midi_value).last
+        note_name = degrees_instance.note_name_of_degree(degree_name)
+        note_octave_value = Fet::MidiNote.new(note_midi_value).octave_number
+        return "#{degree_name}(#{note_name}#{note_octave_value})" # e.g. b7(Cb4)
+      end
+    end
+  end
+end