feep 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c9ade110c0c083ad59f6732c2474d8f0aaabfb3
-  data.tar.gz: ea1319e91994705a44a70a8c0d0124a5e6e9703e
+  metadata.gz: a70a90d54a3e4507318bfc057c33ab7b6c880438
+  data.tar.gz: c3cf6d0841b6c5c4f0abf066827ef90741177307
 SHA512:
-  metadata.gz: 0cf79e2486d896848f42add1472d5eee509f1aa657a3a33099459fac90479ff5f66612c39124693471c3e795c1268ffe784b09ee71233c068d2957236a0c1827
-  data.tar.gz: a9f0d7edf48f2940a3e90f2e46fd45378dce2e46beb062b0cabb523ffb1b7d7d42bb4ad632a9f25a3bb63eeb5fb7129cdec5fab304837dfe3c5e310b98a6279e
+  metadata.gz: 49504c639b61f8bd3f5a59012a2748b160a6bf58dd1c29f19dcfa6984debda642738e38963acc3080961138e844954ddb668752e063f6aa26e9308fec10b93c8
+  data.tar.gz: b7c41cf69ff4a5b3c9b1bbffb132cdcfd1cb0608f7c1443c6e3e9ac5b43195c146cef85cf01093e79dfd7afb01349dacd502604e81158b773202b55b2290a222

data/README.md

@@ -1,4 +1,5 @@
 # Feep
+[![Gem Version](https://badge.fury.io/rb/feep.svg)](http://badge.fury.io/rb/feep)
 
 ## Wha?
 Use the power of Ruby gems to make your computer [feep](http://dictionary.reference.com/browse/feep) (except more musically) using sweet [WAV-file-writing technology](http://wavefilegem.com) from [Joel Strait](https://github.com/jstrait). Works on both Windows and *nix (including OS X) as it uses the standard WAV format to do its bidding.
@@ -17,23 +18,28 @@ Feep doesn't require any parameters, as it will play a 440Hz/A4 sine wave at 50%
 
 The full usage looks like this:
 
-`feep [-f, -n, --freq-or-note FREQUENCY|NOTE_NAME] [-w, --waveform WAVEFORM] [-a, --amplitude MAX_AMPLITUDE] [-d, --duration DURATION] [-save] [-loud]`
+`feep [-f, -n, --freq-or-note FREQUENCY|NOTE_NAME] [-s, --scale SCALE_ID] [-d, --degrees NUMBER_OF_SCALE_DEGREES] [-w, --waveform WAVEFORM] [-a, --amplitude MAX_AMPLITUDE] [-d, --duration DURATION] [-save] [-loud]`
 
 `-f, -n, --freq-or-note`: a number from 0 to 20000, or a valid note name from C0 to B9 (including sharps and flats). You can try a frequency outside of this range, but you may get odd results. You may also enter some combination of these with commas between them and it'll play all of them together in a chord.
 
+`-s, -scale`: a scale ID that is part of the list that the gem understands (currently). If you put in an invalid one, it will list the valid ones.
+
+`-d, --degrees`: the number of degrees of a scale you want to play. By default, the scale will play one octave.
+
 `-w, --waveform`: a string equal to "sine", "square", "saw", "triangle", or "noise".
 
-`-a, --amplitude`: a number from 0.0 (silence (why would you do this?)) to 1.0 (blast it)
+`-a, --amplitude`: a number from 0.0 (silence (why would you do this?)) to 1.0 (blast it).
 
-`-d, --duration`: number of milliseconds for the sound to last
+`-d, --duration`: number of milliseconds for the sound to last.
 
-`-save`: switch to save the resulting WAV file in the current directory. Will create it in the format of `waveform_frequency-in-Hz_volume_duration.wav`
+`-save`: switch to save the resulting WAV file in the current directory. Will create it in the format of `waveform_frequency-in-Hz_volume_duration.wav`.
 
-`-loud`: switch that displays note and file-making information
+`-loud`: switch that displays note and file-making information.
 
 ## Examples
 
-`feep` - play a C4 sine wave note at 50% full volume for 200 ms
-`feep -n Ab6 -w saw` - play a Ab6 sawtooth wave note at 50% full volume for 200 ms
-`feep -n C#5 -w square -a 0.4 -d 500` - play a C#5 square wave note at 40% full volume for 500 ms
-`feep -n 2000 -w triangle -a 0.8 -d 2000` - play a 2000Hz triangle wave note at 80% full volume for 2000 ms
+* `feep` - play a C4 sine wave note at 50% full volume for 200 ms
+* `feep -n Ab6 -w saw` - play a Ab6 sawtooth wave note at 50% full volume for 200 ms
+* `feep -n C#5 -w square -a 0.4 -d 500` - play a C#5 square wave note at 40% full volume for 500 ms
+* `feep -n 2000 -w triangle -a 0.8 -d 2000` - play a 2000Hz triangle wave note at 80% full volume for 2000 ms
+* `feep -n C3 -s major` - play a major scale with C3 as the root note

data/bin/feep

@@ -1,20 +1,27 @@
 #!/usr/bin/env ruby
 
+require 'pry'
 require 'optparse'
-require 'feep'
-
-USAGE_INSTRUCTIONS = ''
+require_relative '../lib/feep'
 
 def parse_options
-  options = {:freq_or_note => '440.000', :waveform => 'sine', :volume => 0.5, :duration => 200, :save => false, :loud => false}
+  options = {:freq_or_note => '440.000', :scale => nil, :waveform => 'sine', :volume => 0.5, :duration => 100, :save => false, :loud => false, :usage => nil}
 
   optparse = OptionParser.new do |opts|
-    opts.banner = 'usage: feep [-f, -n, --freq-or-note FREQUENCY|NOTE_NAME] [-w, --waveform WAVEFORM] [-a, --amplitude MAX_AMPLITUDE] [-d, --duration DURATION] [-save] [-loud]'
+    opts.banner = 'usage: feep [-f, -n, --freq-or-note FREQUENCY|NOTE_NAME] [-s, --scale SCALE_ID] [-d, --degrees NUMBER_OF_SCALE_DEGREES] [-w, --waveform WAVEFORM] [-a, --amplitude MAX_AMPLITUDE] [-d, --duration DURATION] [-save] [-loud]'
 
     opts.on('-f', '-n', '--freq-or-note FREQUENCY|NOTE_NAME', 'One or more frequencies or note names to play at once, e.g. 440 or A4 or 220,440,880') do |f_or_n|
       options[:freq_or_note] = f_or_n
     end
     
+    opts.on('-s', '--scale SCALE_ID', 'Name of a scale to play') do |s|
+      options[:scale] = s
+    end
+    
+    opts.on('-d', '--degrees NUMBER_OF_DEGREES', 'Number of degrees of the scale to play') do |d|
+      options[:degrees] = d
+    end
+    
     opts.on('-w', '--wave WAVEFORM', 'Waveform type to use for the sound') do |w|
       options[:waveform] = w
     end
@@ -27,11 +34,11 @@ def parse_options
       options[:duration] = d.to_i
     end
 
-    opts.on('-s', '--save', 'Save the resulting WAV file in the current directory') do
+    opts.on('--save', 'Save the resulting WAV file in the current directory') do
       options[:save] = true
     end
     
-    opts.on('-l', '--loud', 'Displays information about note(s) being played') do
+    opts.on('--loud', 'Displays information about note(s) being played') do
       options[:loud] = true
     end
 
@@ -46,7 +53,7 @@ def parse_options
     end
   end
 
-  USAGE_INSTRUCTIONS << optparse.to_s
+  options[:usage] = optparse.to_s
   optparse.parse!()
 
   return options
@@ -56,7 +63,6 @@ def print_error(error)
   case error
   when OptionParser::InvalidOption
     puts "#{$PROGRAM_NAME}: illegal option #{error.args.join(' ')}"
-    puts USAGE_INSTRUCTIONS
   else
     puts "An unexpected error occurred while running #{$PROGRAM_NAME}:"
     puts "  #{error}\n"
@@ -66,7 +72,7 @@ end
 begin
   options = parse_options
 
-  Feep.new(options)
+  Feep::Base.new(options)
 rescue => error
   print_error(error)
   exit(false)

data/feep.gemspec

@@ -25,5 +25,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry-byebug', '~> 3.0'
   spec.add_development_dependency 'bundler', '~> 1.8'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '>= 3.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.29'
 end

data/lib/feep.rb

@@ -1,213 +1,60 @@
+# lib/feep.rb
+require_relative 'feep/constants'
+require_relative 'feep/scale'
+require_relative 'feep/sound_file'
+require_relative 'feep/sound_player'
+require_relative 'feep/utils'
 require 'wavefile'
-require 'os'
-require 'feep/constants'
 
-class Feep
-  
-  # main entry point
-  def initialize(options)
-    @options = options
-    configure_sound(options)
-  end
-  
-  # convert midi notes to frequencies
-  def midi_to_freq(midi_note)
-    440.0 * (2.0 ** ((midi_note.to_f-69)/12))
-  end
-
-  # convert frequencies to midi notes
-  def freq_to_midi(freq)
-    (69 + 12 * (Math.log2(freq.to_i.abs / 440.0))).round
-  end
-
-  # makes sure that whatever kind of sound was entered on the CLI
-  # it is now a frequency to feed into the sample data generator
-  def convert_note_to_freq(freq_or_note)
-    if freq_or_note.match(/[A-Za-z]/)
-      if NOTE_FREQ.key?(freq_or_note)
-        frequency = NOTE_FREQ[freq_or_note]
-      else
-        app_error(ERROR_MSG[:note_name])
-      end
-    else
-      frequency = freq_or_note
-    end
-    
-    return frequency
-  end
+module Feep
+  class Base
 
-  # takes CLI options, massages them, and passes them to the
-  # sound generation methods
-  def configure_sound(options)
-    ### A. Check non-essential options
-    if !WAVE_TYPES.include?(options[:waveform])
-      app_error(ERROR_MSG[:wave_form])
+    # main entry point
+    def initialize(options)
+      @options = options
+      configure_sound(options)
     end
 
-    # Convert ms to secs in order to multiply the sample rate by
-    duration_s = (options[:duration].to_f / 1000)
-
-    # Make the samples to write a nice integer
-    samples_to_write = (SAMPLE_RATE * duration_s).to_i
-
-    ### B. Set frequency/note, or group of frequencies/notes, to play
-
-    # Is it a chord or a note?
-    if options[:freq_or_note].include?(',')
-      # yes, it's a chord, so create threads
-      threads = []
-      options[:freq_or_note].split(',').each do |note|
-        sound_to_play = convert_note_to_freq(note)
-        output_filename = "#{options[:waveform]}_#{sound_to_play}Hz_#{options[:volume].to_f}_#{options[:duration]}.wav"
-        threads << Thread.new {
-          play_note(sound_to_play.to_f, options[:waveform], options[:volume].to_f, options[:duration].to_i, samples_to_write, output_filename) 
-        }
+    # takes CLI options, massages them, and passes them to the
+    # sound generation methods
+    def configure_sound(options)
+      ### A. Check non-essential options
+      if !WAVE_TYPES.include?(options[:waveform])
+        print_error(ERROR_MSG[:invalid_waveform])
       end
-      threads.each { |th| th.join }
-    else
-      # no, it's a single note
-      sound_to_play = convert_note_to_freq(options[:freq_or_note])
-      output_filename = "#{options[:waveform]}_#{sound_to_play}Hz_#{options[:volume].to_f}_#{options[:duration]}.wav"
-      play_note(sound_to_play, options[:waveform], options[:volume].to_f, options[:duration].to_i, samples_to_write, output_filename)
-    end
-  end
 
-  # plays note using system wav file player
-  def play_sound(file, duration)
-    delimiter = OS.windows? ? ';' : ':'
+      # Convert ms to secs in order to multiply the sample rate by
+      duration_s = (options[:duration].to_f / 1000)
 
-    system_apps = ENV['PATH'].split(delimiter).collect { |d| Dir.entries d if Dir.exist? d }.flatten
+      # Make the samples to write a nice integer
+      samples_to_write = (SAMPLE_RATE * duration_s).to_i
 
-    if OS.windows?
-      if system_apps.include? SNDPLAYER_WIN
-        display_text_beep(duration)
-        system("#{SNDPLAYER_WIN} #{file}")
-      else
-        puts "couldn't find #{SNDPLAYER_WIN}"
-      end
-    end
+      ### B. Set frequency/note, or group of frequencies/notes, to play
 
-    if OS.mac? || OS.linux?
-      if system_apps.include? SNDPLAYER_UNIX
-        display_text_beep(duration)
-        system("#{SNDPLAYER_UNIX} #{file}")
+      # Is it a chord, scale, or single note?
+      if options[:freq_or_note].include?(',')
+        # yes, it's a chord, so create threads
+        threads = []
+        options[:freq_or_note].split(',').each do |note|
+          sound_to_play = Utils.new.convert_note_to_freq(note)
+          output_filename = "#{options[:waveform]}_#{sound_to_play}Hz_#{options[:volume].to_f}_#{options[:duration]}.wav"
+          threads << Thread.new {
+            SoundPlayer.new.play_note(sound_to_play, output_filename, samples_to_write, options) 
+          }
+        end
+        threads.each { |th| th.join }
       else
-        puts "couldn't find #{SNDPLAYER_UNIX}"
+        # it's a scale
+        if options[:scale]
+          Feep::Scale.new.play_scale(options)
+        else
+          # no, it's a single note
+          sound_to_play = Utils.convert_note_to_freq(options[:freq_or_note])
+          output_filename = "#{options[:waveform]}_#{sound_to_play}Hz_#{options[:volume].to_f}_#{options[:duration]}.wav"
+          SoundPlayer.new.play_note(sound_to_play, output_filename, samples_to_write, options)
+        end
       end
     end
-  end
-  
-  # displays a fun beep message
-  def display_text_beep(duration)
-    print 'Be'
-    1.upto(duration) {|ms|
-      if ms % 100 == 0
-        print 'e'
-      end
-    }
-    puts 'ep!'
-  end
-  
-  # removes the sound, unless marked to save
-  def remove_sound(file)
-    if !@options[:save]
-      if OS.windows?
-        system("del #{file}")
-      else
-        system("rm #{file}")
-      end
-    else
-      if @options[:loud]
-        info = WaveFile::Reader.info(file)
-        duration = info.duration
-        formatted_duration = duration.minutes.to_s.rjust(2, '0') << ':' <<
-                           duration.seconds.to_s.rjust(2, '0') << ':' <<
-                           duration.milliseconds.to_s.rjust(3, '0')
-        puts ''
-        puts "Created #{file}"
-        puts '---'
-        puts "Length:      #{formatted_duration}"
-        puts "Format:      #{info.audio_format}"
-        puts "Channels:    #{info.channels}"
-        puts "Frames:      #{info.sample_frame_count}"
-        puts "Sample Rate: #{info.sample_rate}"
-      end
-    end
-  end
-  
-  # code from Joel Strait's nanosynth to generate raw audio
-  def create_sound(frequency, waveform, samples, volume, output_filename)
-    # Generate sample data for the given frequency, amplitude, and duration.
-    # Since we are using a sample rate of 44,100Hz, 44,100 samples are required for one second of sound.
-    samples = generate_sample_data(waveform.to_sym, samples, frequency.to_f, volume.to_f)
 
-    # Wrap the array of samples in a Buffer, so that it can be written to a Wave file
-    # by the WaveFile gem. Since we generated samples between -1.0 and 1.0, the sample
-    # type should be :float
-    buffer = WaveFile::Buffer.new(samples, WaveFile::Format.new(:mono, :float, 44100))
-
-    # Write the Buffer containing our samples to a 16-bit, monophonic Wave file
-    # with a sample rate of 44,100Hz, using the WaveFile gem.
-    WaveFile::Writer.new(output_filename, WaveFile::Format.new(:mono, :pcm_16, 44100)) do |writer|
-      writer.write(buffer)
-    end
   end
-  
-  # more code from Joel Strait's nanosynth (http://joe)
-  # The dark heart of NanoSynth, the part that actually generates the audio data
-  def generate_sample_data(wave_type, num_samples, frequency, max_amplitude)
-    position_in_period = 0.0
-    position_in_period_delta = frequency / SAMPLE_RATE
-
-    # Initialize an array of samples set to 0.0. Each sample will be replaced with
-    # an actual value below.
-    samples = [].fill(0.0, 0, num_samples)
-
-    num_samples.times do |i|
-      # Add next sample to sample list. The sample value is determined by
-      # plugging position_in_period into the appropriate wave function.
-      if wave_type == :sine
-        samples[i] = Math::sin(position_in_period * TWO_PI) * max_amplitude
-      elsif wave_type == :square
-        samples[i] = (position_in_period >= 0.5) ? max_amplitude : -max_amplitude
-      elsif wave_type == :saw
-        samples[i] = ((position_in_period * 2.0) - 1.0) * max_amplitude
-      elsif wave_type == :triangle
-        samples[i] = max_amplitude - (((position_in_period * 2.0) - 1.0) * max_amplitude * 2.0).abs
-      elsif wave_type == :noise
-        samples[i] = RANDOM_GENERATOR.rand(-max_amplitude..max_amplitude)
-      end
-
-      position_in_period += position_in_period_delta
-      
-      # Constrain the period between 0.0 and 1.0.
-      # That is, keep looping and re-looping over the same period.
-      if(position_in_period >= 1.0)
-        position_in_period -= 1.0
-      end
-    end
-    
-    return samples
-  end
-  
-  # creates, plays, and removes note
-  def play_note(frequency, waveform, volume, duration, samples_to_write, output_filename)
-    if @options[:loud]
-      puts 'Playing note'
-      puts "  frequency:    #{frequency.to_f.abs}"
-      puts "  midi:         #{freq_to_midi(frequency)}"
-      puts "  duration:     #{duration}"
-    end
-    create_sound(frequency, waveform, samples_to_write, volume, output_filename)
-    play_sound(output_filename, duration)
-    remove_sound(output_filename)
-  end
-
-  # displays error, usage, and exits
-  def app_error(msg)
-    puts "#{File.basename($PROGRAM_NAME).split('.')[0]}: #{msg}"
-    puts 'usage: feep [frequency|note_name|list_of_frequencies_or_note_names] [sine|square|saw|triangle|noise] [volume] [duration] [save]'
-    exit
-  end
-
 end

data/lib/feep/constants.rb

@@ -1,4 +1,7 @@
-class Feep
+# lib/feep/constants.rb
+
+module Feep
+  # constants
   SNDPLAYER_WIN = 'sounder.exe'
   SNDPLAYER_UNIX = 'afplay'
   SAMPLE_RATE = 44100
@@ -6,6 +9,70 @@ class Feep
   RANDOM_GENERATOR = Random.new
   WAVE_TYPES = %w[sine square saw triangle noise]
 
+  # tables of musical data
+  SCALES = Hash[
+    :chromatic          => '1,1,1,1,1,1,1,1,1,1,1,1,1',
+    :whole_tone         => '2,2,2,2,2,2,2',
+    :major              => '2,2,2,1,2,2,2,1',
+    :minor_harm         => '2,1,2,2,1,3,3',
+    :minor_melodic      => '2,1,2,2,2,2,3',
+    :major_pentatonic   => '2,2,3,2,3,2',
+    :minor_pentatonic   => '3,2,2,3,2,3',
+    :blues              => '3,2,1,1,3,2,3',
+    :phyrgian           => '1,2,2,2,1,2,2,2',
+    :dorian             => '2,1,2,2,2,1,2,2'
+  ]
+  NOTES = Array[
+  'C0','C#0','D0','D#0','E0','F0','F#0','G0','G#0','A0','A#0','B0',
+  'C1','C#1','D1','D#1','E1','F1','F#1','G1','G#1','A1','A#1','B1',
+  'C2','C#2','D2','D#2','E2','F2','F#2','G2','G#2','A2','A#2','B2',
+  'C3','C#3','D3','D#3','E3','F3','F#3','G3','G#3','A3','A#3','B3',
+  'C4','C#4','D4','D#4','E4','F4','F#4','G4','G#4','A4','A#4','B4',
+  'C5','C#5','D5','D#5','E5','F5','F#5','G5','G#5','A5','A#5','B5',
+  'C6','C#6','D6','D#6','E6','F6','F#6','G6','G#6','A6','A#6','B6',
+  'C7','C#7','D7','D#7','E7','F7','F#7','G7','G#7','A7','A#7','B7',
+  'C8','C#8','D8','D#8','E8','F8','F#8','G8','G#8','A8','A#8','B8',
+  'C9','C#9','D9','D#9','E9','F9','F#9','G9','G#9','A9','A#9','B9'
+  ]
+  NOTES_ALT = Array[
+  'C0','Db0','D0','Eb0','E0','F0','Gb0','G0','Ab0','A0','Bb0','B0',
+  'C1','Db1','D1','Eb1','E1','F1','Gb1','G1','Ab1','A1','Bb1','B1',
+  'C2','Db2','D2','Eb2','E2','F2','Gb2','G2','Ab2','A2','Bb2','B2',
+  'C3','Db3','D3','Eb3','E3','F3','Gb3','G3','Ab3','A3','Bb3','B3',
+  'C4','Db4','D4','Eb4','E4','F4','Gb4','G4','Ab4','A4','Bb4','B4',
+  'C5','Db5','D5','Eb5','E5','F5','Gb5','G5','Ab5','A5','Bb5','B5',
+  'C6','Db6','D6','Eb6','E6','F6','Gb6','G6','Ab6','A6','Bb6','B6',
+  'C7','Db7','D7','Eb7','E7','F7','Gb7','G7','Ab7','A7','Bb7','B7',
+  'C8','Db8','D8','Eb8','E8','F8','Gb8','G8','Ab8','A8','Bb8','B8',
+  'C9','Db9','D9','Eb9','E9','F9','Gb9','G9','Ab9','A9','Bb9','B9'
+  ]
+
+  FREQS = Array[
+  16.351,17.324,18.354,19.445,20.601,21.827,23.124,24.499,25.956,27.500,29.135,30.868,
+  32.703,34.648,36.708,38.891,41.203,43.654,46.249,48.999,51.913,55.000,58.270,61.375,
+  65.406,69.296,73.416,77.782,82.407,87.307,92.499,97.999,103.826,110.000,116.541,
+  123.471,130.813,138.591,146.832,155.564,164.814,174.614,184.997,195.998,207.652,220.000,233.082,246.942,
+  261.626,277.183,293.665,311.127,329.628,349.228,369.994,391.995,415.305,440.000,466.164,493.883,
+  523.251,554.365,587.330,622.254,659.255,698.457,739.989,783.991,830.609,880.000,932.328,987.767,
+  1046.502,1108.731,1174.659,1244.508,1318.510,1396.913,1479.978,1567.982,1661.219,1760.000,1864.655,1975.533,
+  2093.005,2217.461,2349.318,2489.016,2637.021,2793.826,2959.956,3135.964,3322.438,3520.000,3729.310,3951.066,
+  4186.009,4434.922,4698.636,4978.032,5274.042,5587.652,5919.910,6271.928,6644.876,7040.000,7458.620,7902.132,
+  8372.018,8869.844,9397.272,9956.064,10548.084,11175.304,11839.820,12543.856,13289.752,14080.000,14917.240,15804.264
+  ]
+
+  MIDIS = Array[
+   12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,
+   24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,
+   36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
+   48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,
+   60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,
+   72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
+   84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
+   96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107,
+  108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
+  120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131
+  ]
+
   NOTE_FREQ = Hash[
   'C0' =>     16.351,
   'C#0' =>    17.324,
@@ -179,8 +246,11 @@ class Feep
   'B9' =>  15804.264
   ]
 
+  # error messages
   ERROR_MSG = Hash[
-    :note_name => 'Note name argument is invalid.',
-    :wave_form => 'Wave form type is invalid.'
+    :invalid_note => 'Note name argument is invalid.',
+    :invalid_scale => "Scale ID is invalid. Valid IDs are: #{SCALES.keys}",
+    :invalid_waveform => 'Wave form type is invalid.',
+    :scale_needs_note => 'You need to enter a valid note (-n) if you want to play a scale.'
   ]
 end

data/lib/feep/scale.rb

@@ -0,0 +1,51 @@
+# lib/feep/scale.rb
+require_relative '../feep'
+require_relative 'constants'
+
+module Feep
+  class Scale
+
+    # plays the musical scale with Feep
+    def play_scale(options)
+      unless SCALES.include?(options[:scale].to_sym)
+        Utils.print_error(:invalid_scale)
+      end
+
+      unless NOTES.include?(options[:freq_or_note]) && NOTES_ALT.include?(options[:freq_or_note])
+        Utils.print_error(:invalid_note)
+      end
+
+      steps = SCALES[options[:scale].to_sym].split(',')
+
+      note = options[:freq_or_note]
+      note_index = NOTES.index(note)
+      freq = FREQS[NOTES.index(note)]
+
+      feep_options = {:freq_or_note => note, :waveform => options[:waveform], :volume => options[:volume], :duration => options[:duration], :save => options[:save], :loud => options[:loud]}
+
+      # play number of degrees of scale supplied or one octave by default
+      degrees = options[:degrees] || steps.length
+
+      if options[:loud]
+        puts "Playing a #{options[:scale]} scale..."
+      end
+
+      1.upto(degrees.to_i) {|deg|
+        if options[:loud]
+          puts "note: #{note}, freq: #{freq}"
+        end
+        
+        # play note
+        Feep::Base.new(feep_options)
+
+        # go to the next note in the scale
+        note_index += steps[deg].to_i
+
+        # set new note to play next time around
+        note = feep_options[:freq_or_note] = NOTES[note_index]
+        freq = FREQS[note_index]
+      }
+    end
+
+  end
+end

data/lib/feep/sound_file.rb

@@ -0,0 +1,63 @@
+# lib/feep/sound_file.rb
+# Contains code from Joel Strait's nanosynth to generate raw audio
+
+require 'wavefile'
+require_relative 'constants'
+
+module Feep
+  class SoundFile
+
+    def create_sound(frequency, samples, output_filename, options)
+      # Generate sample data for the given frequency, amplitude, and duration.
+      # Since we are using a sample rate of 44,100Hz, 44,100 samples are required for one second of sound.
+      samples = generate_sample_data(options[:waveform].to_sym, samples, frequency.to_f, options[:volume].to_f)
+
+      # Wrap the array of samples in a Buffer, so that it can be written to a Wave file
+      # by the WaveFile gem. Since we generated samples between -1.0 and 1.0, the sample
+      # type should be :float
+      buffer = WaveFile::Buffer.new(samples, WaveFile::Format.new(:mono, :float, 44100))
+
+      # Write the Buffer containing our samples to a 16-bit, monophonic Wave file
+      # with a sample rate of 44,100Hz, using the WaveFile gem.
+      WaveFile::Writer.new(output_filename, WaveFile::Format.new(:mono, :pcm_16, 44100)) do |writer|
+        writer.write(buffer)
+      end
+    end
+
+    def generate_sample_data(wave_type, num_samples, frequency, max_amplitude)
+      position_in_period = 0.0
+      position_in_period_delta = frequency / SAMPLE_RATE
+
+      # Initialize an array of samples set to 0.0. Each sample will be replaced with
+      # an actual value below.
+      samples = [].fill(0.0, 0, num_samples)
+
+      num_samples.times do |i|
+        # Add next sample to sample list. The sample value is determined by
+        # plugging position_in_period into the appropriate wave function.
+        if wave_type == :sine
+          samples[i] = Math::sin(position_in_period * TWO_PI) * max_amplitude
+        elsif wave_type == :square
+          samples[i] = (position_in_period >= 0.5) ? max_amplitude : -max_amplitude
+        elsif wave_type == :saw
+          samples[i] = ((position_in_period * 2.0) - 1.0) * max_amplitude
+        elsif wave_type == :triangle
+          samples[i] = max_amplitude - (((position_in_period * 2.0) - 1.0) * max_amplitude * 2.0).abs
+        elsif wave_type == :noise
+          samples[i] = RANDOM_GENERATOR.rand(-max_amplitude..max_amplitude)
+        end
+
+        position_in_period += position_in_period_delta
+        
+        # Constrain the period between 0.0 and 1.0.
+        # That is, keep looping and re-looping over the same period.
+        if(position_in_period >= 1.0)
+          position_in_period -= 1.0
+        end
+      end
+      
+      return samples
+    end
+
+  end
+end

data/lib/feep/sound_player.rb

@@ -0,0 +1,87 @@
+require 'os'
+require_relative 'sound_file'
+require_relative 'constants'
+
+module Feep
+  class SoundPlayer
+  
+    # main function that creates, plays, and removes note
+    def play_note(frequency, output_filename, samples_to_write, options)
+      if options[:loud]
+        puts 'Playing note'
+        puts "  frequency:    #{frequency.to_f.abs}"
+        puts "  midi:         #{Utils.freq_to_midi(frequency)}"
+        puts "  duration:     #{options[:duration]}"
+      end
+      SoundFile.new.create_sound(frequency, samples_to_write, output_filename, options)
+      play_wav_file(output_filename, options[:duration])
+      remove_sound(output_filename, options)
+    end
+  
+    # use command line app to play wav file
+    def play_wav_file(file, duration)
+      delimiter = OS.windows? ? ';' : ':'
+
+      system_apps = ENV['PATH'].split(delimiter).collect { |d| Dir.entries d if Dir.exist? d }.flatten
+
+      if OS.windows?
+        if system_apps.include? SNDPLAYER_WIN
+          display_text_beep(duration)
+          system("#{SNDPLAYER_WIN} #{file}")
+        else
+          puts "couldn't find #{SNDPLAYER_WIN}"
+        end
+      end
+
+      if OS.mac? || OS.linux?
+        if system_apps.include? SNDPLAYER_UNIX
+          display_text_beep(duration)
+          system("#{SNDPLAYER_UNIX} #{file}")
+        else
+          puts "couldn't find #{SNDPLAYER_UNIX}"
+        end
+      end
+    end
+    
+    # displays a fun beep message after playing wav file
+    def display_text_beep(duration)
+      print 'Be'
+      1.upto(duration) {|ms|
+        if ms % 100 == 0
+          print 'e'
+        end
+      }
+      puts 'ep!'
+    end
+
+    # removes the sound, unless marked to save, 
+    # and optionally display info about file
+    def remove_sound(file, options)
+      unless options[:save]
+        if OS.windows?
+          system("del #{file}")
+        else
+          
+          system("rm #{file}")
+        end
+      else
+        if options[:loud]
+          info = WaveFile::Reader.info(file)
+          duration = info.duration
+          formatted_duration = duration.minutes.to_s.rjust(2, '0') << ':' <<
+                             duration.seconds.to_s.rjust(2, '0') << ':' <<
+                             duration.milliseconds.to_s.rjust(3, '0')
+          puts ''
+          puts "Created #{file}"
+          puts '---'
+          puts "Length:      #{formatted_duration}"
+          puts "Format:      #{info.audio_format}"
+          puts "Channels:    #{info.channels}"
+          puts "Frames:      #{info.sample_frame_count}"
+          puts "Sample Rate: #{info.sample_rate}"
+        end
+      end
+    end
+
+  end
+end

data/lib/feep/utils.rb

@@ -0,0 +1,40 @@
+# lib/feep/utils.rb
+module Feep
+  module Utils
+
+    # convert midi notes to frequencies
+    def self.midi_to_freq(midi_note)
+      440.0 * (2.0 ** ((midi_note.to_f-69)/12))
+    end
+
+    # convert frequencies to midi notes
+    def self.freq_to_midi(freq)
+      (69 + 12 * (Math.log2(freq.to_i.abs / 440.0))).round
+    end
+
+    # makes sure that whatever kind of sound was entered on the CLI
+    # it is now a frequency to feed into the sample data generator
+    def self.convert_note_to_freq(freq_or_note)
+      if freq_or_note.match(/[A-Za-z]/)
+        if NOTE_FREQ.key?(freq_or_note)
+          frequency = NOTE_FREQ[freq_or_note]
+        else
+          print_error(ERROR_MSG[:invalid_note])
+        end
+      else
+        frequency = freq_or_note
+      end
+      
+      return frequency
+    end
+    
+    # displays error, usage, and exits
+    def self.print_error(msg_id)
+      msg = ERROR_MSG[msg_id.to_sym]
+      puts "#{File.basename($PROGRAM_NAME).split(".")[0]}: #{msg}"
+      puts 'usage: feep [frequency|note-name|list-of-frequencies-or-note-names] [scale] [scale-degrees] [sine|square|saw|triangle|noise] [volume] [duration] [save] [loud]'
+      exit
+    end
+  
+  end
+end

data/lib/feep/version.rb

@@ -1,3 +1,3 @@
 class Feep
-  VERSION = '0.0.2'
+  VERSION = '0.0.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feep
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors:
 - Michael Chadwick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-16 00:00:00.000000000 Z
+date: 2015-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: wavefile
@@ -90,16 +90,30 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.29'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.29'
 description: Use Ruby to make your computer beep at a certain frequency for a certain
   duration. Do it for fun, or add it to other programs for easy alert sounds.
 email: mike@codana.me
@@ -117,6 +131,10 @@ files:
 - feep.gemspec
 - lib/feep.rb
 - lib/feep/constants.rb
+- lib/feep/scale.rb
+- lib/feep/sound_file.rb
+- lib/feep/sound_player.rb
+- lib/feep/utils.rb
 - lib/feep/version.rb
 - spec/feep_spec.rb
 - spec/spec_helper.rb