fet 0.3.0 → 0.3.1

data/lib/fet/degrees.rb

@@ -31,8 +31,8 @@ module Fet
       return degree_to_note_name[Degree.new(degree_name).degree_name]
     end
 
-    def select_degrees_from_midi_values(midi_value_range, number_of_degrees)
-      return select_degrees_from_midi_values_recursive(midi_value_range, [], number_of_degrees)
+    def select_degrees_from_midi_values(midi_value_range, number_of_degrees, degrees_filter)
+      return select_degrees_from_midi_values_recursive(filtered_midi_values(midi_value_range, degrees_filter), [], number_of_degrees)
     end
 
     private
@@ -42,6 +42,16 @@ module Fet
 
     attr_accessor :degree_to_note_name
 
+    def filtered_midi_values(midi_value_range, degrees_filter)
+      return midi_value_range if degrees_filter.empty?
+
+      filter_degree_indices = degrees_filter.map { |degree_name| Degree.new(degree_name).degree_index }
+      return midi_value_range.select do |midi_value|
+        degree_index = degree_index_of_midi_value(midi_value)
+        filter_degree_indices.include?(degree_index)
+      end
+    end
+
     def note_name_of_degree_internal(degree_name)
       degree = Degree.new(degree_name)
 

data/lib/fet/generator/listening.rb

@@ -9,22 +9,28 @@ module Fet
       # (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: "")
+      def initialize(exercises:, tempo:, degrees:, all_single_degree:)
         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
 
+      # NOTE: this is explicitly changed in tests, so no need to check for coverage
+      # :nocov:
+      def self.directory_prefix
+        return ""
+      end
+      # :nocov:
+
       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
+      attr_accessor :number_of_exercises, :tempo, :number_of_degrees, :note_range, :all_single_degree
 
       def generate_all_single_degree_exercises
         Fet::MAJOR_ROOT_MIDI_VALUES.each do |root|
@@ -55,7 +61,7 @@ module Fet
       def select_notes(all_notes, root_name, root_midi_value, number_degrees, key_type)
         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)
-        chosen_notes = degrees_instance.select_degrees_from_midi_values(all_notes, number_degrees)
+        chosen_notes = degrees_instance.select_degrees_from_midi_values(all_notes, number_degrees, [])
         return create_midi_file(chosen_notes, root_name, root_midi_value, key_type)
       end
 
@@ -82,7 +88,7 @@ module Fet
       end
 
       def full_filename(key_type, root_name, root_midi_value, chosen_notes)
-        result = File.join(*[directory_prefix, "listening", key_type].reject(&:empty?))
+        result = File.join(*[self.class.directory_prefix, "listening", key_type].reject(&:empty?))
         filename = root_name # note, e.g. Db
         filename += key_type == "major" ? "M" : "m" # type of note, M or m
         filename += "_" # delimiter

data/lib/fet/generator/singing.rb

@@ -4,13 +4,19 @@ module Fet
   module Generator
     # Class that generates MIDI files for the singing exercises
     class Singing
-      def initialize(tempo:, pause:, directory_prefix: "")
+      def initialize(tempo:, pause:)
         self.tempo = tempo
         self.pause = pause
         self.midi_range = HIGH_SINGING_OCTAVE_RANGE
-        self.directory_prefix = directory_prefix
       end
 
+      # NOTE: this is explicitly changed in tests, so no need to check for coverage
+      # :nocov:
+      def self.directory_prefix
+        return ""
+      end
+      # :nocov:
+
       def generate
         generate_major
         generate_minor
@@ -18,7 +24,7 @@ module Fet
 
       private
 
-      attr_accessor :tempo, :pause, :midi_range, :directory_prefix
+      attr_accessor :tempo, :pause, :midi_range
 
       def generate_major
         MusicTheory::MAJOR_KEYS.each do |root_note_name|
@@ -59,7 +65,7 @@ module Fet
       end
 
       def full_filename(key_type, root_note_name, root_midi_value, note_midi_value)
-        result = File.join(*[directory_prefix, "singing", key_type].reject(&:empty?))
+        result = File.join(*[self.class.directory_prefix, "singing", key_type].reject(&:empty?))
         filename = root_note_name # note, e.g. Db
         filename += key_type == "major" ? "M" : "m" # type of note, M or m
         filename += "_" # delimiter

data/lib/fet/generator/single_note_listening.rb

@@ -4,14 +4,20 @@ module Fet
   module Generator
     # Class that generates MIDI files for the single note listening exercises
     class SingleNoteListening
-      def initialize(tempo:, directory_prefix: "")
+      def initialize(tempo:)
         self.tempo = tempo
         self.note = Fet::Note.new("C")
         self.octave_value = 4
         self.midi_value = MidiNote.from_note(note.full_note, octave_value).midi_value
-        self.directory_prefix = directory_prefix
       end
 
+      # NOTE: this is explicitly changed in tests, so no need to check for coverage
+      # :nocov:
+      def self.directory_prefix
+        return ""
+      end
+      # :nocov:
+
       def generate
         MusicTheory::MAJOR_KEYS.each do |root_note_name|
           root_midi_value = MAJOR_ROOT_MIDI_VALUES[root_note_name]
@@ -26,7 +32,7 @@ module Fet
 
       private
 
-      attr_accessor :tempo, :note, :octave_value, :midi_value, :directory_prefix
+      attr_accessor :tempo, :note, :octave_value, :midi_value
 
       def create_midi_file(key_type, root_note_name, root_midi_value)
         progression = Fet::ChordProgression.new(offset: root_midi_value, template_type: key_type).with_offset
@@ -47,7 +53,7 @@ module Fet
       end
 
       def full_filename(key_type, root_note_name, root_midi_value)
-        result = File.join(*[directory_prefix, "listening_single_note", key_type].reject(&:empty?))
+        result = File.join(*[self.class.directory_prefix, "listening_single_note", key_type].reject(&:empty?))
         filename = root_note_name # note, e.g. Db
         filename += key_type == "major" ? "M" : "m" # type of note, M or m
         filename += "_" # delimiter

data/lib/fet/score.rb

@@ -5,8 +5,16 @@ require "json"
 module Fet
   # Holds the correct/incorrect answers to questions
   class Score
-    def initialize
-      self.score = initialize_score
+    def initialize(score: nil)
+      score_hash = score || initialize_score
+      score_hash = score_hash.map do |k, v|
+        [k.to_i, v.transform_keys(&:to_sym)]
+      end.to_h
+      self.score = score_hash
+    end
+
+    def self.merge(*scores)
+      scores.each_with_object(Fet::Score.new) { |x, res| res.merge(x) }
     end
 
     def answer_correctly(*degree_indices)
@@ -41,6 +49,23 @@ module Fet
       as_json(*options).to_json(*options)
     end
 
+    def merge(other)
+      score.each do |k, v|
+        v[:correct] += other.answered_correctly(k)
+        v[:incorrect] += other.answered_incorrectly(k)
+      end
+    end
+
+    def percentages
+      score.map do |k, _|
+        next([k, percentage(answered_correctly(k), questions_asked(k)).to_i])
+      end.to_h
+    end
+
+    def total_percentage
+      return percentage(answered_correctly, questions_asked).to_i
+    end
+
     private
 
     attr_accessor :score
@@ -48,5 +73,11 @@ module Fet
     def initialize_score
       Fet::Degree::DEGREE_NAMES.map.with_index { |_, degree_index| [degree_index, { correct: 0, incorrect: 0 }] }.to_h
     end
+
+    def percentage(correct, total)
+      return 0.0 if total.zero?
+
+      return correct.fdiv(total) * 100
+    end
   end
 end

data/lib/fet/score_summary.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "date"
+require "json"
+require "terminal-table"
+require_relative "score_summary_writer"
+
+module Fet
+  # Responsible for writing + showing the score summary to the user
+  class ScoreSummary
+    extend ScoreSummaryWriter
+
+    NO_SCORES_MESSAGE = "No scores available yet!".deep_freeze
+
+    def initialize(minimum_session_length: 0, number_of_degrees: nil, key_type: nil, begin_offset: 0, end_offset: 0)
+      self.minimum_session_length = minimum_session_length
+      self.number_of_degrees = number_of_degrees
+      self.key_type = key_type
+      self.begin_offset = begin_offset
+      self.end_offset = end_offset
+    end
+
+    def summary
+      if file_exists?
+        percentage_summary
+      else
+        puts NO_SCORES_MESSAGE
+      end
+    end
+
+    private
+
+    attr_accessor :minimum_session_length, :number_of_degrees, :key_type, :begin_offset, :end_offset
+
+    def filename
+      return self.class.scores_filename
+    end
+
+    def file_exists?
+      return File.exist?(filename)
+    end
+
+    def file_contents
+      return File.read(filename)
+    end
+
+    def games_array
+      return JSON.parse(file_contents)
+    end
+
+    def games_array_with_constraints
+      result = games_array
+      result = filter_by_seconds_elapsed(result)
+      result = filter_by_number_of_degrees(result)
+      result = filter_by_key_type(result)
+      result = filter_by_offsets(result)
+      return result
+    end
+
+    def filter_by_seconds_elapsed(games_array)
+      return games_array.select { |game_details| game_details["seconds_elapsed"] >= minimum_session_length }
+    end
+
+    def filter_by_number_of_degrees(games_array)
+      return games_array if number_of_degrees.nil?
+
+      return games_array.select { |game_details| game_details["number_of_degrees"] == number_of_degrees }
+    end
+
+    def filter_by_key_type(games_array)
+      return games_array if key_type.nil?
+
+      return games_array.select { |game_details| game_details["key_type"] == key_type }
+    end
+
+    def filter_by_offsets(games_array)
+      begin_index = 0
+      end_index = games_array.size
+      return games_array[(begin_index + begin_offset)...(end_index + end_offset)] || []
+    end
+
+    def score_instances
+      return games_array_with_constraints.map { |game_details| Fet::Score.new(score: game_details["score"]) }
+    end
+
+    def merged_score_instance
+      return Fet::Score.merge(*score_instances)
+    end
+
+    def generate_table(score_instance)
+      Terminal::Table.new do |t|
+        generate_table_header(t)
+        t.add_separator
+        generate_table_main(t, score_instance)
+        t.add_separator
+        generate_table_footer(t, score_instance)
+      end
+    end
+
+    def generate_table_header(table)
+      table.add_row(["Degree", "Answered Correctly", "Total Answered", "Percentage"])
+    end
+
+    def generate_table_main(table, score_instance)
+      score_instance.percentages.each do |degree_index, percentage|
+        table.add_row(
+          [
+            Fet::Degree::DEGREE_NAMES[degree_index].last,
+            score_instance.answered_correctly(degree_index),
+            score_instance.questions_asked(degree_index),
+            "#{percentage}%",
+          ],
+        )
+      end
+    end
+
+    def generate_table_footer(table, score_instance)
+      table.add_row(
+        [
+          "All",
+          score_instance.answered_correctly,
+          score_instance.questions_asked,
+          "#{score_instance.total_percentage}%",
+        ],
+      )
+    end
+
+    def percentage_summary
+      table = generate_table(merged_score_instance)
+      puts table
+    end
+  end
+end

data/lib/fet/score_summary_writer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "date"
+require "json"
+require "terminal-table"
+
+module Fet
+  # Methods for writing game score to file
+  module ScoreSummaryWriter
+    SCORES_FILENAME = "#{ENV["HOME"]}/.config/fet/scores".deep_freeze
+
+    # NOTE: this is explicitly changed in tests, so no need to check for coverage
+    # :nocov:
+    def scores_filename
+      return SCORES_FILENAME
+    end
+    # :nocov:
+
+    def add_entry(game)
+      write_score_to_file(game)
+    end
+
+    private
+
+    def write_score_to_file(game)
+      new_score_entries = historic_score_entries
+      new_score_entries << current_score_entry(game)
+      directory_name = File.dirname(scores_filename)
+      FileUtils.mkdir_p(directory_name)
+      File.open(scores_filename, "w") { |file| file.write(new_score_entries.to_json) }
+    end
+
+    def historic_score_entries
+      result = File.read(scores_filename)
+      return JSON.parse(result)
+    rescue Errno::ENOENT
+      return []
+    end
+
+    def current_score_entry(game)
+      return {
+        "started_at" => game.timer.started_at.to_s,
+        "seconds_elapsed" => game.timer.seconds_elapsed,
+        "number_of_degrees" => game.number_of_degrees,
+        "tempo" => game.tempo,
+        "key_type" => game.key_type,
+        "score" => game.score.score,
+      }
+    end
+  end
+end

data/lib/fet/ui/game.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ruby2d"
+require "tmpdir"
 require_relative "game_loop_handler"
 require_relative "game_setup_helper"
 require_relative "level"
@@ -14,27 +15,19 @@ module Fet
       include GameSetupHelper
       include GameLoopHandler
 
-      SCORES_FILENAME = "#{ENV["HOME"]}/.config/fet/scores".deep_freeze
+      attr_accessor :level, :score, :timer, :note_range, :tmp_directory,
+                    :tempo, :number_of_degrees, :key_type, :next_on_correct, :limit_degrees
 
-      attr_accessor :level, :score, :timer, :note_range,
-                    :tempo, :number_of_degrees, :key_type, :next_on_correct
-
-      # NOTE: this is explicitly changed in tests, so no need to check for coverage
-      # :nocov:
-      def self.scores_filename
-        return SCORES_FILENAME
-      end
-      # :nocov:
-
-      def initialize(tempo:, degrees:, key_type:, next_on_correct:)
+      def initialize(tempo:, degrees:, key_type:, next_on_correct:, limit_degrees: [])
         self.note_range = Fet::REDUCED_BY_OCTAVE_PIANO_RANGE
         self.tempo = tempo
         self.key_type = key_type
         self.number_of_degrees = degrees
         self.next_on_correct = next_on_correct
-        self.score = Score.new(self)
-        self.level = Level.new(self)
-        self.timer = Timer.new(self)
+        self.limit_degrees = limit_degrees
+        self.tmp_directory = Dir.mktmpdir
+        initialize_ui_objects
+        validate!
         setup_window
       end
 
@@ -43,7 +36,7 @@ module Fet
         level.start
         timer.start
         show_window
-        write_score_to_file
+        Fet::ScoreSummary.add_entry(self)
       end
 
       def stop
@@ -52,35 +45,28 @@ module Fet
 
       private
 
-      def show_window
-        Ruby2D::Window.show
+      def initialize_ui_objects
+        self.score = Score.new(self)
+        self.level = Level.new(self)
+        self.timer = Timer.new(self)
       end
 
-      def close_window
-        Ruby2D::Window.close
+      def validate!
+        validate_degrees!
       end
 
-      def write_score_to_file
-        new_score_entries = historic_score_entries
-        new_score_entries << current_score_entry
-        directory_name = File.dirname(self.class.scores_filename)
-        FileUtils.mkdir_p(directory_name)
-        File.open(self.class.scores_filename, "w") { |file| file.write(new_score_entries.to_json) }
+      def validate_degrees!
+        return unless !limit_degrees.empty? && number_of_degrees > limit_degrees.uniq.size
+
+        raise ArgumentError.new("Can not select #{number_of_degrees} degrees from set of #{limit_degrees}")
       end
 
-      def historic_score_entries
-        result = File.read(self.class.scores_filename)
-        return JSON.parse(result)
-      rescue Errno::ENOENT
-        return []
+      def show_window
+        Ruby2D::Window.show
       end
 
-      def current_score_entry
-        return {
-          "started_at" => timer.started_at.to_s,
-          "seconds_elapsed" => timer.seconds_elapsed,
-          "score" => score.score,
-        }
+      def close_window
+        Ruby2D::Window.close
       end
     end
   end

data/lib/fet/ui/level.rb

@@ -52,7 +52,7 @@ module Fet
       def start_self
         self.question_number += 1
         self.degrees = generate_degrees
-        self.midi_values = degrees.select_degrees_from_midi_values(game.note_range, game.number_of_degrees)
+        self.midi_values = degrees.select_degrees_from_midi_values(game.note_range, game.number_of_degrees, game.limit_degrees)
 
         update_music_objects
         play_full_question
@@ -76,19 +76,19 @@ module Fet
       end
 
       def generate_full_question_music
-        filename = "tmp/chord_progression_and_question.mid"
+        filename = File.join(game.tmp_directory, "chord_progression_and_question.mid")
         create_midilib_object("Chord Progression + Question", filename).create_full_question
         return Ruby2D::Music.new(filename)
       end
 
       def generate_chord_progression_music
-        filename = "tmp/chord_progression.mid"
+        filename = File.join(game.tmp_directory, "chord_progression.mid")
         create_midilib_object("Chord Progression", filename).create_chord_progression_of_question
         return Ruby2D::Music.new(filename)
       end
 
       def generate_notes_music
-        filename = "tmp/question.mid"
+        filename = File.join(game.tmp_directory, "question.mid")
         create_midilib_object("Question", filename).create_notes_only
         return Ruby2D::Music.new(filename)
       end

data/lib/fet/ui/level_loop_handler.rb

@@ -47,6 +47,10 @@ module Fet
         start
       end
 
+      # NOET: It seems that until the event loop finishes, the window updates don't happen.
+      #       Specifically here, selecting the correct answer will set color on a note box, but that change
+      #       does not take effect until we're out of the event loop, but by then we've already started a
+      #       new level, so the color change never shows.
       def handle_level_complete_event(event)
         return unless event.is_a?(CustomEvent) && event.type == CustomEvent::EVENT_TYPE_LEVEL_COMPLETE
 

data/lib/fet/ui/note_box.rb

@@ -99,18 +99,19 @@ module Fet
       end
 
       def generate_note_music
-        degrees = note_boxes.level.degrees
-
-        filename = "tmp/#{degree_name}.mid"
         Fet::MidilibInterface.new(
           tempo: note_boxes.level.game.tempo,
           progression: nil,
-          notes: [degrees.root_midi_value + degree_instance.degree_index],
+          notes: [note_boxes.level.degrees.root_midi_value + degree_instance.degree_index],
           info: degree_name,
-          filename: filename,
+          filename: midi_filename,
         ).create_notes_only
 
-        return Ruby2D::Music.new(filename)
+        return Ruby2D::Music.new(midi_filename)
+      end
+
+      def midi_filename
+        return File.join(note_boxes.level.game.tmp_directory, "#{degree_name}.mid")
       end
     end
   end

data/lib/fet/ui/score.rb

@@ -35,6 +35,7 @@ module Fet
       TEXT_SIZE = 36
       X_OFFSET = 508
       Y_OFFSET = 90
+      X_CORRECTION = 20
       private_constant :TEXT_SIZE, :X_OFFSET, :Y_OFFSET
 
       def text_value
@@ -79,6 +80,9 @@ module Fet
 
       def update_text
         text.text = text_value
+        # NOTE: keep "/" character in the same position as score increases
+        characters = text_value.split("/")[0].size
+        text.x = X_OFFSET - (characters - 1) * X_CORRECTION
       end
     end
   end

data/lib/fet/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fet
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Dimitrios Lisenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2021-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gli
@@ -78,6 +78,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
 description: Teaches your ear to recognize notes based on their function in a key.
 email:
 - dimitrioslisenko@gmail.com
@@ -91,7 +111,7 @@ files:
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rubocop.yml"
-- ".ruby_version"
+- ".ruby-version"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -116,9 +136,15 @@ files:
 - lib/fet.rb
 - lib/fet/chord_progression.rb
 - lib/fet/cli/generate/listening.rb
+- lib/fet/cli/generate/listening_command.rb
 - lib/fet/cli/generate/singing.rb
+- lib/fet/cli/generate/singing_command.rb
 - lib/fet/cli/generate/single_note_listening.rb
+- lib/fet/cli/generate/single_note_listening_command.rb
 - lib/fet/cli/play/listening.rb
+- lib/fet/cli/play/listening_command.rb
+- lib/fet/cli/score/summary.rb
+- lib/fet/cli/score/summary_command.rb
 - lib/fet/degree.rb
 - lib/fet/degrees.rb
 - lib/fet/exceptions.rb
@@ -134,6 +160,8 @@ files:
 - lib/fet/note.rb
 - lib/fet/note_validations.rb
 - lib/fet/score.rb
+- lib/fet/score_summary.rb
+- lib/fet/score_summary_writer.rb
 - lib/fet/ui/color_scheme.rb
 - lib/fet/ui/custom_event.rb
 - lib/fet/ui/game.rb