metronome-odd 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3498f8b8652455ef065ce8876395adb9bfcb0e8139a5ce0938981224c51ddfb1
+  data.tar.gz: 67a174595dab000f0b193a51299f4bf0f73eb0b97f589633c00cee8f3c494713
+SHA512:
+  metadata.gz: 4773f9a3f5a6abd7ae901dc819f139bda1ecc0d5a132abe9287a6e7401d39b177382818b47eed57f29a0064f56bce5db1800f1f97e6a8de727771ba193a48a6e
+  data.tar.gz: c3843cd332f0fc9d077541b136980145beea2b759db6e2aeb41b7b5bc69dde7d2bab50e8b29e1fce7016c8107f034bb7f7b14fad4ff55381c59f8d54b12b53e7

data/bin/metronome-odd

@@ -0,0 +1,406 @@
+#!/usr/bin/env ruby
+
+require 'metronome-odd'
+
+ParseLine::Line.add_command(:play, /^play$/)
+ParseLine::Line.add_command(:loop, /^loop$/)
+ParseLine::Line.add_command(:loop_speed_up, /^loop:(?<first>\d+),(?<second>\d+)\((?<times>\d+)\)$/)
+ParseLine::Line.add_command(:print_tempo, /^tempo$/)
+ParseLine::Line.add_command(:next_tempo, /^next_tempo:(?<tempo>\d+)$/)
+ParseLine::Line.add_command(:next_tempo_short, /^nt:(?<tempo>\d+)$/)
+ParseLine::Line.add_command(:force_tempo, /^force_tempo:(?<tempo>\d+)$/)
+ParseLine::Line.add_command(:force_tempo_short, /^ft:(?<tempo>\d+)$/)
+ParseLine::Line.add_command(:signature, /^sign:(?<n>\d+)x(?<d>2|4|8|16)$/)
+ParseLine::Line.add_command(:odd_signature, /^sign:(?<beats>(\d\.\d)(,(\d\.\d))*)$/)
+ParseLine::Line.add_command(:add_bar, /^add:(\((?<tempo>\d+)\))?(?<n>\d+)x(?<d>2|4|8|16)(\((?<times>\d+)\))?$/)
+ParseLine::Line.add_command(:odd_bar, /^add:(\((?<tempo>\d+)\))?(?<beats>(\d\.\d)(,(\d\.\d))*)(\((?<times>\d+)\))?$/)
+ParseLine::Line.add_command(:add_1, /^add$/)
+ParseLine::Line.add_command(:add, /^add:(?<times>\d+)$/)
+ParseLine::Line.add_command(:save, /^save:(?<practice>\w+)?$/)
+ParseLine::Line.add_command(:load, /^load:(?<practice>\w+)?$/)
+ParseLine::Line.add_command(:list, /^list$/)
+ParseLine::Line.add_command(:reset, /^reset$/)
+ParseLine::Line.add_command(:help, /^help$/)
+ParseLine::Line.add_command(:help_command, /^help:(?<command>\w+)$/)
+ParseLine::Line.add_command(:print, /^print$/)
+ParseLine::Line.add_command(:quit, /^quit$/)
+ParseLine::Line.add_command(:empty, /^$/)
+
+ParseLine::Line.add_command(:example, /^example$/)
+
+
+puts
+puts "Welcome to the Programmable Metronome, by Billy Regodón"
+
+def help
+  puts
+  puts "Use the following syntax: add:(t)nxd(T), to add a nxd bar of tempo t, T times"
+  puts "e.g.: add:(100)4x4(8) adds 8 bars of 4x4 with tempo 100"
+  puts
+  puts """Type
+    \"play\" to play the programmed bars
+    \"loop\" to play them repeatedly, press \'crtl\'+C to stop
+    \"loop:xf(N)\" to play the practice session repeatedly, speeding up xf in N repetitions
+    \"loop:t1,t2(N)\" to play the practice session, changing tempo from t1 to t2 in N repetitions
+    \"next_tempo:t\" to set the tempo of the next added bar, in beats per minute or bpm
+      you may use \"nt\" instead of \"next_tempo:t\"
+    \"force_tempo:t\" to change the tempo of the current practice session
+      you may use \"ft\" instead of \"force_tempo:t\"
+    \"sign:nxd\" to set a standard time signature, with a multiple of 2, up to 16
+    \"sign:f,f,f...\" to set an arbitrary odd bar, with f the duration of the beats
+    \"add:nxd\" to add a standard time signature with the set tempo
+    \"add:f,f,f...\" to add an arbitrary odd bar with the set tempo
+    \"add:(t)nxd(N)\" to add N bars of a standard time signature with tempo t (t and N optional)
+    \"add:(t)f,f,f...(N)\" to add N bars of an arbitrary odd bar with tempo t (t and N optional)
+    \"add\" to add one bar of the previously set type
+    \"add:N\" to add N bars of the previously set type
+    \"load:practice\" to load a previously saved practice session
+    \"save:practice\" to save the current practice session
+    \"list\" to list the available saved practice sessions
+    \"reset\" to reset to default and dismiss current practice session
+    \"help\" to print this help
+    \"help:command\" to print the help for another command
+    \"quit\" to exit"""
+  puts """\nIt is recommended that your create a practice folder to save your practice sessions
+ and that you run \"metronome-odd\" in that folder."""
+  puts """\nType \"example\" to print some example commands."""
+  puts
+end
+
+def help_command(command)
+  puts
+  puts "Type"
+  case command
+  when "play"
+    puts "   \"play\" to play the programmed bars"
+  when "loop"
+    puts """   \"loop\" to play the programmed bars repeatedly, press \'crtl\'+C to stop
+    \"loop:xf(N)\" to play the practice session repeatedly, speeding xf in N repetitions
+    \"loop:t(N)\" to play the practice session repeatedly, changing tempo to t in N repetitions"""
+  when "tempo"
+    puts "   \"tempo:t\" to set the tempo of the next added bar, in beats per minute or bpm"
+  when "force_tempo"
+    puts "   \"force_tempo:t\" to change the tempo of the current practice session"
+  when "sign"
+    puts """    \"sign:nxd\" to set a standard time signature, with a multiple of 2, up to 16
+    \"sign:f,f,f...\" to set an arbitrary odd bar, with f the duration of the beats"""
+  when "add"
+    puts """    \"add:nxd\" to add a standard time signature with the set tempo
+    \"add:f,f,f...\" to add an arbitrary odd bar with the set tempo
+    \"add:(t)nxd(N)\" to add N bars of a standard time signature with tempo t (t and N optional)
+    \"add:(t)f,f,f...(N)\" to add N bars of an arbitrary odd bar with tempo t (t and N optional)
+    \"add\" to add one bar of the previously set type
+    \"add:N\" to add N bars of the previously set type"""
+  when "print"
+    puts "    \"print\" prints the current practice session on the screen"
+  when "help"
+    puts """    \"help\" to print this help
+    \"help:command\" to print the help for another command"""
+  when "quit"
+    puts "    \"quit\" to exit"
+  else
+    puts "    Unknown command"
+  end
+  puts
+end
+
+def help_uninitialized
+  puts
+  puts "    The practice session has not been initialized"
+end
+
+def help_example
+  puts """\nType:
+    \"add\" to add a default 4x4 bar
+    \"play\" to play it
+    \"loop\" to play it repeatedly until you press \'crtl\'+C
+    \"add:3x4\" to add a 3x4 bar after the previous one
+    \"loop\" to play them in loop
+    \"print\" to print the session on the screen without playing it
+    \"reset\" to go back to default empty session
+    \"play\" or \"loop\" to verify that we have an empty session
+    \"add:1.0,1.0,0.5,1.5,0.5(3)\" to add three non-standard 9x8 bars
+    \"add:4x4\" to add a standard 4x4 after them
+    \"play\" to play the practice session
+    \"print\" to print the session on the screen without playing it
+    \"tempo\" to check that the tempo is 100
+    \"force_tempo:150\" or \"ft:150\" to change the tempo of the session to 150
+    \"play\" to play the practice session
+    \"reset\" to go back to default empty session
+    \"add\" to add a default 4x4 bar at the default 100 tempo
+    \"next_tempo:150\" or \"nt:150\" to set the tempo for the next bar
+    \"add\" to add a default 4x4 bar at 150 tempo
+    \"loop\" to play them repeatedly until you press \'crtl\'+C"
+  puts
+
+end
+
+help
+
+def reset
+  metronome = Metronome::Practice.new
+  metronome.push(Metronome::Silence.new(0.01))
+  tempo = 100
+  n = 4
+  d = 4
+  times = 1
+  beats = [1.0, 1.0, 1.0, 1.0]
+  prev_bar = :bar
+  non_initialized = true
+  [metronome, tempo, n, d, times, beats, prev_bar, non_initialized]
+end
+
+metronome, tempo, n, d, times, beats, prev_bar, non_initialized = reset
+
+loop do
+  print(">>>")
+  line = ParseLine::Line.new($stdin.gets.chomp)
+  symbol, match = line.parse
+
+  case symbol
+  when :quit
+    break
+  
+
+  when :play
+    unless non_initialized
+      metronome.play
+      puts
+    else
+      puts help_uninitialized
+    end
+
+
+  when :loop
+    unless non_initialized
+      puts "\nPlaying loop, press \'crtl\'+C to stop\n"
+      loop do
+        if metronome.loop_stop?
+          break
+        end
+      end
+      puts
+    else
+      puts help_uninitialized
+    end
+
+
+  when :loop_speed_up
+    unless non_initialized
+      puts "\nPlaying loop, press \'crtl\'+C to stop\n"
+      first_tempo = Float(match[:first])
+      second_tempo = Float(match[:second])
+      tempo = first_tempo
+      tempo_inc = second_tempo - first_tempo
+      times = Integer(match[:times])
+
+      if tempo_inc < 0.0
+        first_tempo, second_tempo = second_tempo, first_tempo
+        tempo_inc *= -1
+      end
+
+      inc = tempo_inc/times
+      loop do
+        if (second_tempo > first_tempo) && (second_tempo > tempo)
+          metronome.force_tempo(Integer(tempo))
+          tempo += inc
+        end
+        if metronome.loop_stop?
+          break
+        end
+      end
+
+      puts
+    else
+      puts help_uninitialized
+    end
+
+
+  when :print_tempo
+    puts "\n   Set tempo is #{tempo}"
+    puts
+
+
+  when :next_tempo, :next_tempo_short
+    tempo = Integer(match[:tempo])
+  
+
+  when :force_tempo, :force_tempo_short
+    metronome.force_tempo(Float(match[:tempo]))
+
+
+  when :signature
+    n = Integer(match[:n])
+    d = Integer(match[:d])
+    prev_bar = :bar
+  
+
+  when :odd_signature
+    beats = []
+    match[:beats].split(',').each do |d| beats << d.to_f end
+
+    prev_bar = :odd_bar
+
+
+  when :add_bar
+    tempo = match[:tempo] ? Integer(match[:tempo]) : tempo
+    n = Integer(match[:n])
+    d = Integer(match[:d])
+    times = match[:times] ? Integer(match[:times]) : 1
+
+    (1..times).each do
+      metronome.push(Metronome::Bar.new(tempo, n, d))
+    end
+    prev_bar = :bar
+    non_initialized = false
+
+
+  when :odd_bar
+    tempo = match[:tempo] ? Integer(match[:tempo]) : tempo
+    times = match[:times] ? Integer(match[:times]) : 1
+    beats = []
+    match[:beats].split(',').each do |d| beats << d.to_f end
+
+    (1..times).each do
+      metronome.push(Metronome::OddBar.new(tempo, beats))
+    end
+    prev_bar = :odd_bar
+    non_initialized = false
+  
+
+  when :add_1
+    if prev_bar == :bar
+      metronome.push(Metronome::Bar.new(tempo, n, d))
+    elsif prev_bar == :odd_bar
+      metronome.push(Metronome::OddBar.new(tempo, beats))
+    else
+      puts 181283
+      return -1
+    end
+    non_initialized = false
+  
+
+  when :add
+    times = Integer(match[:times])
+    (1..times).each do
+      if prev_bar == :bar
+        metronome.push(Metronome::Bar.new(tempo, n, d))
+      elsif prev_bar == :odd_bar
+        metronome.push(Metronome::OddBar.new(tempo, beats))
+      else
+        puts 181743
+        return -1
+      end
+    end
+    non_initialized = false
+
+
+  when :print
+    unless non_initialized
+      metronome.print_practice
+      puts
+    else
+      puts help_uninitialized
+    end
+
+
+  when :save
+    practice_name = match[:practice]
+
+    if metronome.length > 1
+      if Save.save_exist?(practice_name)
+        puts "\n\"#{practice_name}\" has been already used, press \"o\" to overwrite"
+        if Keypress.read_char == "o"
+          puts "\b\n    Overwriting..."
+        else
+          practice_name = :no_overwrite
+          puts "\b\n    Cancelling..."
+        end
+      else
+        puts "\n    Saving..."
+      end
+      unless practice_name == :no_overwrite
+        save_obj = Array.new
+        save_obj << metronome
+        save_obj << tempo
+        save_obj << n
+        save_obj << d
+        save_obj << times
+        save_obj << beats
+        save_obj << prev_bar
+        save_obj << non_initialized
+        if Save.save_obj(practice_name, save_obj) == 0
+          puts "    #{practice_name} successfully saved."
+        else
+          puts "    Could no save #{practice_name}"
+        end
+      end
+    else
+      puts "\n    There is no practice session to save."
+    end
+    puts
+
+
+  when :load
+    practice_name = match[:practice]
+
+    if Save.save_exist?(practice_name)
+      if metronome.length > 1
+        puts "\n    Are you sure to load a new practice session? Press \"y\" to continue."
+        unless Keypress.read_char == "y"
+          practice_name = :no_overload
+          puts "\b    Cancelling..."
+        end
+      else
+        puts
+      end
+      unless practice_name == :no_overload
+        puts "    Loading #{practice_name}..."
+        metronome, tempo, n, d, times, beats, prev_bar, non_initialized = Save.load_obj(practice_name)
+      end
+    else
+      puts "\n    File not found"
+    end
+    puts
+
+
+  when :list
+    puts "\nAvailable practice sessions:"
+    Save.list.each do |n|
+      puts "    #{n}"
+    end
+    puts
+
+
+  when :reset
+    puts "\nAre you sure to continue? Press \"y\" to confirm"
+    if Keypress.read_char == "y"
+      puts "\n    Resetting..."
+      metronome, tempo, n, d, times, beats, prev_bar, non_initialized = reset
+    end
+    puts
+
+
+  when :help
+    help
+
+
+  when :empty
+
+
+  when :help_command
+    help_command(match[:command])
+
+
+  when :example
+    help_example
+
+
+  else
+    puts
+    puts "    Unknown command"
+    puts
+  end
+end
+
+puts "Leaving..."

data/lib/metronome-odd.rb

@@ -0,0 +1,261 @@
+require 'metronome-odd/interruptible_sleep'
+require 'metronome-odd/parse_line.rb'
+require 'metronome-odd/save.rb'
+require 'metronome-odd/keypress.rb'
+
+
+module Metronome
+  class Sound
+    def initialize(sound_file)
+      @sound_file = sound_file
+      self
+    end
+
+    def is_sound_file?
+      @sound_file.extension == "aiff"
+    end
+
+    def play
+      spawn("afplay #{@sound_file}")
+    end
+
+    def set_sound(sound_file)
+      @sound_file = sound_file
+    end
+
+    private
+    def extension
+      @sound_file.split('.').last
+    end
+  end
+
+  class Silence
+    include Stop
+    include InterruptibleSleep
+    attr_accessor :duration
+
+    def initialize(duration)
+      @duration = duration
+      self
+    end
+
+    def wait
+      Signal.trap('SIGINT') do print "\b\bstopped"
+        @@stop = true
+      end
+      interruptible_sleep @duration
+    end
+
+    def play
+      self.wait
+    end
+
+    def print_sign
+    end
+  end
+
+  class Beat
+    attr_accessor :silence
+    def initialize(tempo, sound_file)
+      @sound = Sound.new(sound_file)
+      @silence = Silence.new(60.0/tempo)
+      self
+    end
+
+    def play
+      @sound.play
+      @silence.wait
+    end
+  end
+
+  class Bar
+    attr_writer :upbeat_sound_file
+    attr_writer :downbeat_sound_file
+    attr_reader :n
+    attr_reader :d
+    attr_accessor :tempo
+    attr_accessor :beat_array
+
+    def initialize(tempo, n, d)
+      data_dir = Gem.datadir("metronome-odd")
+      data_dir = data_dir ? data_dir : ""
+      @upbeat_sound_file = data_dir + "/beat_upbeat.aiff"
+      @downbeat_sound_file = data_dir + "/beat_downbeat.aiff"
+
+      @beat_array = Array.new
+      @beat_array.push(Beat.new(tempo*d/4.0, @upbeat_sound_file))
+
+      @n = n
+      @d = d
+
+      @tempo = tempo
+
+      (2..n).each do 
+        @beat_array.push(Beat.new(tempo*d/4.0, @downbeat_sound_file))
+      end
+      self
+    end
+
+    def play
+      @beat_array.each {|b| b.play}
+    end
+
+    def print_sign
+      print "|#{@n}x#{@d}|"
+    end
+
+    def set_tempo(tempo)
+      old_tempo = Float(@tempo)
+
+      @beat_array.each do |beat|
+        beat.silence.duration *= old_tempo/tempo
+      end
+
+      @tempo = tempo
+    end
+
+  end
+
+  class OddBar < Bar
+    attr_accessor :tempo
+    attr_accessor :beat_array
+
+    def initialize(tempo, in_beat)
+      data_dir = Gem.datadir("metronome-odd")
+      data_dir = data_dir ? data_dir : ""
+      @upbeat_sound_file = data_dir + "/beat_upbeat.aiff"
+      @downbeat_sound_file = data_dir + "/beat_downbeat.aiff"
+
+      @beat_array = Array.new
+      @in_beat = in_beat
+      @tempo = tempo
+
+      upbeat_b = true
+      time = 1
+      prev_beat = 1
+      in_beat.each do |t|
+        if upbeat_b
+          beat = Beat.new(tempo/t, @upbeat_sound_file)
+          upbeat_b = false
+        else
+          beat = Beat.new(tempo/t, @downbeat_sound_file)
+        end
+        @beat_array.push(beat)
+      end
+
+    end
+
+    def print_sign
+      # In order to print an odd bar, firstly we find the beat sound times
+      #   in in_sum, starting from 1.
+      # Then we add the silences in the beats in in_clone
+      # Finally we print the bar, with numbers in the beats and
+      #   semicolons in the silences that occur in a beat
+      # width may be used to change size
+      width = 8
+      max_beat = @in_beat.sum
+      in_sum = [1.0]
+      acum = 1.0
+      @in_beat.each do |e| acum=acum+e;in_sum.push(acum) end
+      in_clone = in_sum.clone
+      (1...max_beat.floor).each do |d|
+        if not(in_clone.include?(d))
+          in_clone.push(Float(d))
+        end
+      end
+      in_clone = in_clone.sort
+
+      print "|"
+      in_clone[0...-1].each_with_index do |d, i|
+        if in_sum.include?(d)
+          if d == Integer(d)
+            print(':')
+          end
+          print(d.floor)
+        else
+          print(':')
+        end
+        if d<in_clone.last
+          t = Integer((in_clone[i+1]-in_clone[i])*width-1)
+          t.times do print " " end 
+        end
+      end
+      print "|"
+    end
+  end
+
+  class Practice < Array
+    include Stop
+    @next_bar_hash = nil
+    @prev_bar = nil
+
+    def initialize
+      @next_bar_hash = Hash.new(nil)
+    end
+
+    def sound(type)
+      @@stop = false
+      bar_counter = 0 # 0 accounts for the intial silence
+
+      self.each do |b| 
+        unless b.class == Silence
+          print "\n#{bar_counter}:\t"
+          b.print_sign
+          if @next_bar_hash[b]
+            print " -> "
+            @next_bar_hash[b].print_sign
+            print "\t"
+          else
+            case type
+            when :play
+              print " - last bar! "
+            when :loop
+              print " - repeat! "
+            end
+          end
+        end
+        b.play
+        bar_counter += 1
+        if @@stop then break end
+      end
+      puts
+    end
+
+    def play
+      sound(:play)
+    end
+
+    def loop_stop?
+      sound(:loop)
+      @@stop
+    end
+
+    def force_tempo(tempo)
+      self.each do |bar|
+        unless bar.class == Silence
+          bar.set_tempo(tempo)
+        end
+      end
+    end
+
+    def push(b)
+      super(b)
+      if @prev_bar
+        @next_bar_hash[@prev_bar] = b
+      end
+      @prev_bar = b
+    end
+
+    def print_practice
+      bar_counter = 0 # 0 accounts for the intial silence
+      self.each do |b| 
+        unless b.class == Silence
+          print "\n#{bar_counter}:\t"
+          b.print_sign
+        end
+        bar_counter += 1
+      end
+      puts
+    end
+  end
+end

data/lib/metronome-odd/interruptible_sleep.rb

@@ -0,0 +1,14 @@
+module InterruptibleSleep
+  def interruptible_sleep(seconds)
+    @_sleep_check, @_sleep_interrupt = IO.pipe
+    IO.select([@_sleep_check], nil, nil, seconds)
+  end
+
+  def interrupt_sleep
+    @_sleep_interrupt.close if @_sleep_interrupt
+  end
+end
+
+module Stop
+  @@stop = false
+end

data/lib/metronome-odd/keypress.rb

@@ -0,0 +1,66 @@
+#This has since been folded into a much more robust gem called Remedy. https://rubygems.org/gems/remedy & https://github.com/acook/remedy
+
+require 'io/console'
+
+# Reads keypresses from the user including 2 and 3 escape character sequences.
+module Keypress
+  def Keypress.read_char
+    STDIN.echo = false
+    STDIN.raw!
+
+    input = STDIN.getc.chr
+    if input == "\e" then
+      input << STDIN.read_nonblock(3) rescue nil
+      input << STDIN.read_nonblock(2) rescue nil
+    end
+  ensure
+    STDIN.echo = true
+    STDIN.cooked!
+
+    return input
+  end
+
+  # oringal case statement from:
+  # http://www.alecjacobson.com/weblog/?p=75
+  def Keypress.show_single_key
+    c = read_char
+
+    case c
+    when " "
+      puts "SPACE"
+    when "\t"
+      puts "TAB"
+    when "\r"
+      puts "RETURN"
+    when "\n"
+      puts "LINE FEED"
+    when "\e"
+      puts "ESCAPE"
+    when "\e[A"
+      puts "UP ARROW"
+    when "\e[B"
+      puts "DOWN ARROW"
+    when "\e[C"
+      puts "RIGHT ARROW"
+    when "\e[D"
+      puts "LEFT ARROW"
+    when "\177"
+      puts "BACKSPACE"
+    when "\004"
+      puts "DELETE"
+    when "\e[3~"
+      puts "ALTERNATE DELETE"
+    when "\u0003"
+      puts "CONTROL-C"
+      exit 0
+    when /^.$/
+      puts "SINGLE CHAR HIT: #{c.inspect}"
+    else
+      puts "SOMETHING ELSE: #{c.inspect}"
+    end
+  end
+
+  def Keypress.test
+    show_single_key while(true)
+  end
+end

data/lib/metronome-odd/parse_line.rb

@@ -0,0 +1,40 @@
+module ParseLine
+  class Line
+    @@line_regexp_hash = nil
+    @help = false
+
+    def remove_separators
+      @line = @line.gsub(/\s+/, "")
+    end
+
+    def initialize(line)
+      if @@line_regexp_hash.nil?
+        @@line_regexp_hash = Hash.new([/^$/,/^$/])
+      end
+      @line = line
+    end
+
+    def Line.add_command(symbol, command)
+      if @@line_regexp_hash.nil?
+        @@line_regexp_hash = Hash.new([/^$/,[]])
+      end
+      @@line_regexp_hash[symbol] = command
+    end
+    
+    def parse
+      c = nil
+      s = nil
+      self.remove_separators
+      @@line_regexp_hash.each do |symbol, command_regex|
+        if @line.match(command_regex)
+          c = @line.match(command_regex)
+          s = symbol
+          break
+        end
+      end
+      [s, c]
+    end
+  end
+end
+
+

data/lib/metronome-odd/save.rb

@@ -0,0 +1,57 @@
+module Save
+  def self.file_name_format(short_name)
+    "./sp." + short_name + ".marshal"
+  end
+
+  def self.save_exist?(short_name)
+    File.exist?(Save.file_name_format(short_name))
+  end
+
+  def self.save_obj(short_name, obj)
+    file_name = Save.file_name_format(short_name)
+    file_handler = File.open(file_name, "w") {|to_file| Marshal.dump(obj, to_file)}
+    file_handler.close
+    if File.exist?(file_name)
+      return 0
+    else
+      return -1
+    end
+  end  
+
+  def self.load_obj(short_name)
+    file_name = Save.file_name_format(short_name)
+    Save.load(file_name)
+  end
+
+  def self.delete_obj(short_name)
+    file_name = Save.file_name_format(short_name)
+    Save.delete(file_name)
+  end
+
+  def self.list
+    list = []
+    ls = Dir.entries(".")
+    ls.each do |f|
+      m = f.match(/^sp\.(?<name>\w+)\.marshal$/)
+      if m
+        list.push(m[:name])
+      end
+    end
+    list
+  end
+
+  def self.load(file_name)
+    if File.exist?(file_name)
+      begin
+        file_handler = File.open(file_name, "r")
+        obj = Marshal.load(file_handler)
+        file_handler.close
+      rescue
+        obj = false
+      end
+    else
+      obj = nil
+    end
+    obj
+  end
+end

data/tests/test_metronome-odd.rb

@@ -0,0 +1,13 @@
+require './lib/metronome-odd.rb'
+require 'test/unit'
+
+class TestNAME < Test::Unit::TestCase
+
+  def test_practice
+    t = Bar.new(100, 6, 8)
+    p = Practice.new
+    (1..5).each {p.push(t)}
+    p.play
+  end
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: metronome-odd
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Guillermo Regodón
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-11-23 00:00:00.000000000 Z
+dependencies: []
+description: Metronome that can be programmed to change de tempo or the time signature.
+email:
+- guillermoregodon@gmail.com
+executables:
+- metronome-odd
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/metronome-odd
+- data/metronome-odd/beat_downbeat.aiff
+- data/metronome-odd/beat_upbeat.aiff
+- lib/metronome-odd.rb
+- lib/metronome-odd/interruptible_sleep.rb
+- lib/metronome-odd/keypress.rb
+- lib/metronome-odd/parse_line.rb
+- lib/metronome-odd/save.rb
+- tests/test_metronome-odd.rb
+homepage: https://github.com/GuillermoRegodon/rubygem-metronome-odd
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- data
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Programmable metronome
+test_files:
+- tests/test_metronome-odd.rb