fet 0.2.0

data/lib/fet/note.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "note_validations"
+
+module Fet
+  # Class responsible for parsing and validating musical notes from a string, e.g. "Eb"
+  class Note
+    include NoteValidations
+
+    ACCIDENTAL_TO_SEMITONES_MAP = {
+      "b" => -1,
+      "#" => 1,
+      "x" => 2,
+    }.deep_freeze
+
+    # TODO: this class could also potentially handle the octave number - note that e.g. Bb,B,Bx... are in octave 3 while Cb,C,C# are in octave 4
+    attr_accessor :full_note,
+                  :natural_note,
+                  :accidental
+
+    def initialize(note)
+      self.full_note = note
+      validate_full_note!
+
+      self.natural_note = note[0]
+      validate_natural_note!
+
+      self.accidental = note[1..]
+      validate_accidental!
+    end
+
+    def self.accidental_from_semitone_offset(semitone_offset)
+      return "" if semitone_offset.zero?
+      return "b" * -semitone_offset if semitone_offset.negative?
+
+      number_of_hashes = (semitone_offset % 2).zero? ? 0 : 1
+      number_of_xs = semitone_offset / 2
+      return "#" * number_of_hashes + "x" * number_of_xs
+    end
+
+    # NOTE: performs the following conversions:
+    # Fbb -> Fb -> F -> F# ->Fx -> F#x -> Fxx
+    def sharpened_note
+      note_as_string = case
+                       when accidental.start_with?("b")
+                         "#{natural_note}#{accidental[1..]}"
+                       when accidental.start_with?("#")
+                         "#{natural_note}x#{accidental[1..]}"
+                       else
+                         "#{natural_note}##{accidental}"
+                       end
+
+      return Note.new(note_as_string)
+    end
+
+    # NOTE: performs the following conversions:
+    # Fxx -> F#x -> Fx -> F# -> F -> Fb -> Fbb
+    def flattened_note
+      note_as_string = case
+                       when accidental.start_with?("x")
+                         "#{natural_note}##{accidental[1..]}"
+                       when accidental.start_with?("#")
+                         "#{natural_note}#{accidental[1..]}"
+                       else
+                         "#{natural_note}#{accidental}b"
+                       end
+
+      return Note.new(note_as_string)
+    end
+
+    # NOTE: normalizing the note means:
+    # - converting the natural note + accidentals such that the remaining accidental is either "b", "", or "#", or
+    # - if a note name is provided, then convert the accidental such that the natural note matches the pitch of the original
+    def normalized_note
+      remaining_semitones = accidental_to_semitone_offset
+      next_note = remaining_semitones.positive? ? next_natural_note : previous_natural_note
+      next_note_offset = remaining_semitones.positive? ? semitone_offset_to_next_natural_note : semitone_offset_to_previous_natural_note
+      return Note.new(full_note) if next_note_offset.abs > remaining_semitones.abs
+
+      return Note.new("#{next_note}#{self.class.accidental_from_semitone_offset(remaining_semitones - next_note_offset)}").normalized_note
+    end
+
+    # NOTE: Note.new("E").change_natural_note("D") -> Note.new("Dx")
+    # def change_natural_note(new_natural_note)
+    #   semitone_offset = accidental_to_semitone_offset
+    #   return Note.new("#{natural_note}#{self.class.accidental_from_semitone_offset(semitone_offset)}") if new_natural_note == natural_note
+    # end
+
+    def degree(root_name)
+      notes_array = Fet::MusicTheory.notes_of_mode(root_name, "major")
+      index = notes_array.index { |note| Note.new(note).natural_note == natural_note }
+
+      degree = index + 1
+      degree_note = Note.new(notes_array[index])
+
+      accidental_difference = accidental_to_semitone_offset - degree_note.accidental_to_semitone_offset
+      return "#{self.class.accidental_from_semitone_offset(accidental_difference)}#{degree}"
+    end
+
+    def accidental_to_semitone_offset
+      return accidental.chars.map { |char| ACCIDENTAL_TO_SEMITONES_MAP[char] }.sum
+    end
+
+    def natural?
+      return accidental.chars.empty?
+    end
+
+    def flattened?
+      return accidental.chars.include?("b")
+    end
+
+    def sharpened?
+      return accidental.chars.include?("#") || accidental.chars.include?("x")
+    end
+
+    private
+
+    def next_natural_note
+      index = Fet::MusicTheory::ORDERED_NATURAL_NOTES.index(natural_note)
+      index = (index + 1) % Fet::MusicTheory::ORDERED_NATURAL_NOTES.size
+      return Fet::MusicTheory::ORDERED_NATURAL_NOTES[index]
+    end
+
+    def previous_natural_note
+      index = Fet::MusicTheory::ORDERED_NATURAL_NOTES.index(natural_note)
+      index = (index - 1) % Fet::MusicTheory::ORDERED_NATURAL_NOTES.size
+      return Fet::MusicTheory::ORDERED_NATURAL_NOTES[index]
+    end
+
+    def semitone_offset_to_next_natural_note
+      return Fet::MusicTheory::SEMITONES_TO_NEXT_NATURAL_NOTE[natural_note]
+    end
+
+    def semitone_offset_to_previous_natural_note
+      return -Fet::MusicTheory::SEMITONES_TO_NEXT_NATURAL_NOTE[previous_natural_note]
+    end
+  end
+end

data/lib/fet/note_validations.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Fet
+  # Module holding validations for the Note class
+  module NoteValidations
+    private
+
+    def validate_full_note!
+      raise InvalidNote.new(full_note) unless full_note.is_a?(String)
+    end
+
+    def validate_natural_note!
+      raise InvalidNote.new(full_note) unless natural_note.is_a?(String)
+      raise InvalidNote.new(full_note) unless MusicTheory::CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.include?(natural_note)
+    end
+
+    def validate_accidental!
+      raise InvalidNote.new(full_note) unless valid_accidental_type?
+      return if accidental.empty?
+
+      raise InvalidNote.new(full_note) unless valid_accidental_logic?
+    end
+
+    def valid_accidental_type?
+      return accidental.is_a?(String)
+    end
+
+    def valid_accidental_logic?
+      return false unless valid_accidental_characters?
+      return false if can_be_flat_accidental? && !valid_flat_accidental?
+      return false if can_be_sharp_accidental? && !valid_sharp_accidental?
+
+      return true
+    end
+
+    def valid_accidental_characters?
+      return accidental.chars.uniq.all? { |char| ["b", "#", "x"].include?(char) }
+    end
+
+    def can_be_flat_accidental?
+      return accidental.chars.uniq.include?("b")
+    end
+
+    def valid_flat_accidental?
+      return accidental.chars.uniq.all? { |char| ["b"].include?(char) } # there can only be "b" characters
+    end
+
+    def can_be_sharp_accidental?
+      return accidental.chars.uniq.include?("#") || accidental.chars.uniq.include?("x")
+    end
+
+    def valid_sharp_accidental?
+      return accidental.chars.uniq.all? { |char| ["#", "x"].include?(char) } && # only allow "#" and "x" characters
+             [0, 1].include?(accidental.chars.select { |char| char == "#" }.size) && # there can be at most one "#" character
+             accidental.chars.sort.join == accidental # the "#" character must come before any "x" characters
+    end
+  end
+end

data/lib/fet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Fet
+  VERSION = "0.2.0"
+end

data/lib/fet.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "ice_nine"
+require "ice_nine/core_ext/object"
+
+Dir["#{__dir__}/fet/**/*.rb"].each { |file| require_relative(file.delete_prefix("#{__dir__}/")) }
+
+# Base Gem module
+module Fet
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: fet
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Dimitrios Lisenko
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.20.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.20.1
+- !ruby/object:Gem::Dependency
+  name: ice_nine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: midilib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+description: Teaches your ear to recognize notes based on their function in a key.
+email:
+- dimitrioslisenko@gmail.com
+executables:
+- fet
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- fet.rdoc
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby_version"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.txt
+- README.md
+- README.rdoc
+- Rakefile
+- bin/bash_scripts/cleanup_listening_exercises.sh
+- bin/bash_scripts/cleanup_singing_exercises.sh
+- bin/bash_scripts/midi_to_mp3.sh
+- bin/console
+- bin/fet
+- bin/setup
+- fet.gemspec
+- fet.rdoc
+- lib/fet.rb
+- lib/fet/chord_progression.rb
+- lib/fet/cli/generate/listening.rb
+- lib/fet/cli/generate/singing.rb
+- lib/fet/cli/generate/single_note_listening.rb
+- lib/fet/degree.rb
+- lib/fet/degrees.rb
+- lib/fet/exceptions.rb
+- lib/fet/generator/listening.rb
+- lib/fet/generator/singing.rb
+- lib/fet/generator/single_note_listening.rb
+- lib/fet/hardcoded_midi_values.rb
+- lib/fet/instrument_ranges.rb
+- lib/fet/midi_note.rb
+- lib/fet/midilib_interface.rb
+- lib/fet/music_theory.rb
+- lib/fet/note.rb
+- lib/fet/note_validations.rb
+- lib/fet/version.rb
+homepage: https://github.com/DimitriosLisenko/fet
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/DimitriosLisenko/fet
+  source_code_uri: https://github.com/DimitriosLisenko/fet
+  changelog_uri: https://github.com/DimitriosLisenko/fet/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options:
+- "--title"
+- fet
+- "--main"
+- README.rdoc
+- "-ri"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A functional ear trainer.
+test_files: []