music 0.7.0 → 0.8.0

data/lib/music/note.rb

@@ -1,20 +1,21 @@
 module Music
   class Note
-
-    NOTES = ['C', 'C#/Db', 'D', 'D#/Eb', 'E', 'F', 'F#/Gb', 'G', 'G#/Ab', 'A', 'A#/Bb', 'B']
+    NOTES = [['C', 'B#'], ['C#', 'Db'], ['D'], ['D#', 'Eb'], ['E', 'Fb'], ['F', 'E#'], ['F#', 'Gb'], ['G'], ['G#', 'Ab'], ['A'], ['A#', 'Bb'], ['B', 'Cb']]
     NOTE_STRINGS = ['Ab', 'A', 'A#', 'Bb', 'B', 'C', 'C#', 'Db', 'D', 'D#', 'Eb', 'E', 'F', 'Gb', 'G', 'G#']
 
     attr_accessor :frequency
 
     include Comparable
-    def <=>(other_note)
-      self.frequency <=> other_note.frequency
+    def <=>(other)
+      self.frequency <=> other.frequency
     end
+
     def hash
       self.frequency.hash
     end
-    def eql?(other_note)
-      self.frequency == other_note.frequency
+
+    def eql?(other)
+      self.frequency == other.frequency
     end
 
     def to_s
@@ -28,10 +29,10 @@ module Music
     # @returns [Note] Note specified
     def initialize(descriptor, assumed_octave = nil)
       self.frequency = if descriptor.is_a? Numeric
-        Note.nearest_note_frequency(descriptor)
-      else
-        Note.calculate_frequency(descriptor, assumed_octave)
-      end
+                         Note.nearest_note_frequency(descriptor)
+                       else
+                         Note.calculate_frequency(descriptor, assumed_octave)
+                       end
     end
 
     # Returns string representing note with letter, accidental, and octave number
@@ -82,7 +83,7 @@ module Music
     def succ
       Note.new(Note.frequency_adjustment(self.frequency, 1))
     end
-    alias :next :succ
+    alias_method :next, :succ
 
     # Return the distance (in semitones) to a note
     #
@@ -100,21 +101,21 @@ module Music
     end
 
     {
-      :minor_second => 1,
-      :major_second => 2,
+      minor_second: 1,
+      major_second: 2,
 
-      :minor_third => 3,
-      :major_third => 4,
+      minor_third: 3,
+      major_third: 4,
 
-      :perfect_fourth => 5,
+      perfect_fourth: 5,
 
-      :tritone => 6, :diminished_fifth => 6, :flat_fifth => 6, :augmented_fourth => 6,
-      :perfect_fifth => 7,
-      :augmented_fifth => 8, :minor_sixth => 8,
+      tritone: 6, diminished_fifth: 6, flat_fifth: 6, augmented_fourth: 6,
+      perfect_fifth: 7,
+      augmented_fifth: 8, minor_sixth: 8,
 
-      :major_sixth => 9, :diminished_seventh => 9,
-      :minor_seventh => 10,
-      :major_seventh => 11
+      major_sixth: 9, diminished_seventh: 9,
+      minor_seventh: 10,
+      major_seventh: 11
     }.each do |interval, semitones_count|
       define_method interval do
         adjust_by_semitones(semitones_count)
@@ -126,12 +127,12 @@ module Music
     # @returns [Array<Note>] Notes in major scale
     def major_scale
       [self,
-        self.major_second,
-        self.major_third,
-        self.perfect_fourth,
-        self.perfect_fifth,
-        self.major_sixth,
-        self.major_seventh,
+       self.major_second,
+       self.major_third,
+       self.perfect_fourth,
+       self.perfect_fifth,
+       self.major_sixth,
+       self.major_seventh
       ]
     end
 
@@ -140,26 +141,26 @@ module Music
     # @returns [Array<Note>] Notes in minor scale
     def minor_scale
       [self,
-        self.major_second,
-        self.minor_third,
-        self.perfect_fourth,
-        self.perfect_fifth,
-        self.minor_sixth,
-        self.minor_seventh,
+       self.major_second,
+       self.minor_third,
+       self.perfect_fourth,
+       self.perfect_fifth,
+       self.minor_sixth,
+       self.minor_seventh
       ]
     end
 
     CHORD_INTERVALS = {
-      :minor => [:minor_third, :perfect_fifth],
-      :major => [:major_third, :perfect_fifth],
-      :fifth => [:perfect_fifth],
-      :diminished => [:minor_third, :diminished_fifth],
-      :augmented => [:major_third, :augmented_fifth],
-      :major_seventh => [:major_third, :perfect_fifth, :major_seventh],
-      :minor_seventh => [:minor_third, :perfect_fifth, :minor_seventh],
-      :diminished_seventh => [:minor_third, :diminished_fifth, :diminished_seventh],
-      :augmented_seventh => [:major_third, :augmented_fifth, :minor_seventh],
-      :half_diminished_seventh => [:minor_third, :diminished_fifth, :minor_seventh]
+      minor: [:minor_third, :perfect_fifth],
+      major: [:major_third, :perfect_fifth],
+      fifth: [:perfect_fifth],
+      diminished: [:minor_third, :diminished_fifth],
+      augmented: [:major_third, :augmented_fifth],
+      major_seventh: [:major_third, :perfect_fifth, :major_seventh],
+      minor_seventh: [:minor_third, :perfect_fifth, :minor_seventh],
+      diminished_seventh: [:minor_third, :diminished_fifth, :diminished_seventh],
+      augmented_seventh: [:major_third, :augmented_fifth, :minor_seventh],
+      half_diminished_seventh: [:minor_third, :diminished_fifth, :minor_seventh]
     }
 
     CHORD_ALIASES = {
@@ -218,21 +219,21 @@ module Music
       :half_dim_7 => :half_diminished_seventh,
       :half_dim_7th => :half_diminished_seventh,
       :half_dim7 => :half_diminished_seventh,
-      :half_dim7th => :half_diminished_seventh,
+      :half_dim7th => :half_diminished_seventh
     }
 
     def chord(description)
       description = :major if description.to_s.empty?
 
       description = description.to_s
-      description.downcase! unless ['M', 'M7'].include?(description)
+      description.downcase! unless %w(M M7).include?(description)
       description.gsub!(/[\s\-]+/, '_')
       description = description.to_sym
 
       intervals = CHORD_INTERVALS[description] || CHORD_INTERVALS[CHORD_ALIASES[description]]
 
       if intervals
-        Chord.new([self] + intervals.collect {|interval| self.send(interval) })
+        Chord.new([self] + intervals.collect { |interval| self.send(interval) })
       end
     end
 
@@ -246,9 +247,9 @@ module Music
       def parse_note_string(note_string, assumed_octave = nil)
         match = note_string.match(/^([A-Ga-g])([#b]?)([0-8]?)$/)
 
-        raise ArgumentError, "Did not recognize note string: #{note_string}" if !match
-        raise ArgumentError, "No octave found or specified" if match[3].empty? && assumed_octave.nil?
-        raise ArgumentError if match[3].to_i > 8 || (assumed_octave && !(0..8).include?(assumed_octave))
+        fail ArgumentError, "Did not recognize note string: #{note_string}" if !match
+        fail ArgumentError, 'No octave found or specified' if match[3].empty? && assumed_octave.nil?
+        fail ArgumentError if match[3].to_i > 8 || (assumed_octave && !(0..8).include?(assumed_octave))
 
         octave = match[3].empty? ? assumed_octave : match[3]
         [match[1].upcase, match[2] == '' ? nil : match[2], octave.to_i]
@@ -258,17 +259,9 @@ module Music
         letter1, accidental1, octave1 = parse_note_string(note_string1)
         letter2, accidental2, octave2 = parse_note_string(note_string2)
 
-        get_index = Proc.new do |letter, accidental|
-          NOTES.index do |note|
-            regex = case accidental
-            when '#' then
-              /^#{letter}#/
-            when 'b' then
-              /#{letter}b$/
-            else
-              /^#{letter}$/
-            end
-            note.match(regex)
+        get_index = proc do |letter, accidental|
+          NOTES.index do |notes|
+            notes.include?("#{letter}#{accidental}")
           end
         end
 
@@ -279,7 +272,7 @@ module Music
       end
 
       def frequency_adjustment(start_frequency, distance)
-        result = (start_frequency * (2.0 ** (distance.to_f / NOTES.size)))
+        result = (start_frequency * (2.0**(distance.to_f / NOTES.size)))
 
         # Would like to use #round(2), but want to support Ruby 1.8
         (result * 100.0).round / 100.0
@@ -294,7 +287,7 @@ module Music
         when 3
           letter, accidental, octave = args
         else
-          raise ArgumentError, "Invalid octave of arguments"
+          fail ArgumentError, 'Invalid octave of arguments'
         end
 
         distance = note_distance('A4', "#{letter}#{accidental}#{octave}")
@@ -313,14 +306,12 @@ module Music
         octave = 4 + (index / NOTES.size) # 4 is because we're using A4
         index = (index % NOTES.size)
 
-        parts = "#{NOTES[index]}".split('/')
         note = if give_flat
-          parts.last
-        else
-          parts.first
-        end
+                 NOTES[index].last
+               else
+                 NOTES[index].first
+               end
 
-        "#{note}#{octave}"
         note_parts = note.split('')
         note_parts + (note_parts.size == 1 ? [nil] : []) + [octave.to_i]
       end
@@ -328,7 +319,6 @@ module Music
       def nearest_note_frequency(frequency)
         Note.calculate_frequency(Note.calculate_note(frequency).join)
       end
-
     end
   end
 end

data/lib/music/version.rb

@@ -1,3 +1,3 @@
 module Music
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/music.rb

@@ -1,3 +1,2 @@
 require 'music/chord'
 require 'music/note'
-

data/music.gemspec

@@ -1,26 +1,26 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "music/version"
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'music/version'
 
 Gem::Specification.new do |s|
   # Basic Info
-  s.name          = "music"
+  s.name          = 'music'
   s.version       = Music::VERSION
   s.platform      = Gem::Platform::RUBY
-  s.authors       = ["Brian Underwood"]
-  s.email         = ["ml+musicgem@semi-sentient.com"]
-  s.homepage      = "http://github.com/cheerfulstoic/music"
-  s.summary       = %q{Library for performing calculations on musical elements}
-  s.description   = %q{Library for classifying notes and chords and performing calculations on them.  See README.md}
-  s.license       = %q{MIT}
+  s.authors       = ['Brian Underwood']
+  s.email         = ['ml+musicgem@semi-sentient.com']
+  s.homepage      = 'http://github.com/cheerfulstoic/music'
+  s.summary       = 'Library for performing calculations on musical elements'
+  s.description   = 'Library for classifying notes and chords and performing calculations on them.  See README.md'
+  s.license       = 'MIT'
 
   # Files
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {spec,factories}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
   # Dependencies
-  s.add_development_dependency  "rake", "~> 0.9"
-  s.add_development_dependency  "rspec", '~> 2'
+  s.add_development_dependency 'rake', '~> 0.9'
+  s.add_development_dependency 'rspec', '~> 2'
 end

data/spec/classes/chord_spec.rb

@@ -1,18 +1,19 @@
 require 'spec_helper'
+include Music
 
 describe Music::Chord do
   before :all do
     @standard_tuning_notes = [Note.new('E2'), Note.new('A2'), Note.new('D3'), Note.new('G3'), Note.new('B3'), Note.new('E4')]
 
-    @c_minor = Chord.new(['C4', 'Eb4', 'G4'])
-    @c_major = Chord.new(['C4', 'E4', 'G4'])
-    @c_diminished = Chord.new(['C4', 'Eb4', 'Gb4'])
+    @c_minor = Chord.new(%w(C4 Eb4 G4))
+    @c_major = Chord.new(%w(C4 E4 G4))
+    @c_diminished = Chord.new(%w(C4 Eb4 Gb4))
     @c_augmented = Chord.new(['C4', 'E4', 'G#4'])
-    @c_major_seventh = Chord.new(['C4', 'E4', 'G4', 'B4'])
-    @c_minor_seventh = Chord.new(['C4', 'Eb4', 'G4', 'Bb4'])
-    @c_diminished_seventh = Chord.new(['C4', 'Eb4', 'Gb4', 'A4'])
+    @c_major_seventh = Chord.new(%w(C4 E4 G4 B4))
+    @c_minor_seventh = Chord.new(%w(C4 Eb4 G4 Bb4))
+    @c_diminished_seventh = Chord.new(%w(C4 Eb4 Gb4 A4))
     @c_augmented_seventh = Chord.new(['C4', 'E4', 'G#4', 'Bb4'])
-    @c_half_diminished_seventh = Chord.new(['C4', 'Eb4', 'Gb4', 'Bb4'])
+    @c_half_diminished_seventh = Chord.new(%w(C4 Eb4 Gb4 Bb4))
   end
 
   describe '#new(notes)' do
@@ -32,7 +33,7 @@ describe Music::Chord do
 
   describe '#==' do
     it 'should recognize that the order of notes in the chord does not matter' do
-      Chord.new(['C4', 'Eb4', 'G4']).should == Chord.new(['G4', 'Eb4', 'C4'])
+      Chord.new(%w(C4 Eb4 G4)).should eq(Chord.new(%w(G4 Eb4 C4)))
     end
   end
 
@@ -40,98 +41,97 @@ describe Music::Chord do
     it 'should return a set of note strings' do
       chord = Chord.new(@standard_tuning_notes)
 
-      chord.note_strings.should == Set.new(@standard_tuning_notes.collect(&:note_string))
+      chord.note_strings.should eq(Set.new(@standard_tuning_notes.collect(&:note_string)))
     end
   end
 
   describe '#to_s' do
     it 'should output just the sorted note descriptions separated by slashes' do
-      @c_minor.to_s.should == 'C4 / D#4 / G4'
+      @c_minor.to_s.should eq('C4 / D#4 / G4')
     end
   end
 
   describe '#describe' do
-    describe "triads" do
+    describe 'triads' do
       it 'should recognize C major' do
-        @c_major.describe.should == ['C', :major]
+        @c_major.describe.should eq(['C', :major])
       end
 
       it 'should recognize C minor' do
-        Chord.new(['C4', 'Eb4', 'G4']).describe.should == ['C', :minor]
+        Chord.new(%w(C4 Eb4 G4)).describe.should eq(['C', :minor])
       end
 
       it 'should recognize C diminished' do
-        Chord.new(['C4', 'Eb4', 'Gb4']).describe.should == ['C', :diminished]
+        Chord.new(%w(C4 Eb4 Gb4)).describe.should eq(['C', :diminished])
       end
       it 'should recognize C augmented' do
-        Chord.new(['C4', 'E4', 'G#4']).describe.should == ['C', :augmented]
+        Chord.new(['C4', 'E4', 'G#4']).describe.should eq(['C', :augmented])
       end
     end
-    describe "seven chords" do
+    describe 'seven chords' do
       it 'should recognize Cmaj7' do
-        Chord.new(['C4', 'E4', 'G4', 'B4']).describe.should == ['C', :major_7]
+        Chord.new(%w(C4 E4 G4 B4)).describe.should eq(['C', :major_7])
       end
       it 'should recognize Cmin7' do
-        Chord.new(['C4', 'Eb4', 'G4', 'Bb4']).describe.should == ['C', :minor_7]
+        Chord.new(%w(C4 Eb4 G4 Bb4)).describe.should eq(['C', :minor_7])
       end
       it 'should recognize Cdim7' do
-        Chord.new(['C4', 'Eb4', 'Gb4', 'A4']).describe.should == ['C', :diminished_7]
+        Chord.new(%w(C4 Eb4 Gb4 A4)).describe.should eq(['C', :diminished_7])
       end
       it 'should recognize Cmin7b5' do
-        Chord.new(['C4', 'Eb4', 'Gb4', 'Bb4']).describe.should == ['C', :half_diminished_7]
+        Chord.new(%w(C4 Eb4 Gb4 Bb4)).describe.should eq(['C', :half_diminished_7])
       end
       it 'should recognize Caug7' do
-        Chord.new(['C4', 'E4', 'G#4', 'Bb4']).describe.should == ['C', :augmented_7]
+        Chord.new(['C4', 'E4', 'G#4', 'Bb4']).describe.should eq(['C', :augmented_7])
       end
     end
   end
 
   describe '.parse_chord_string' do
     it 'should recognize C major' do
-      Chord.parse_chord_string('Cmajor4').should == @c_major
-      Chord.parse_chord_string('CMajor4').should == @c_major
-      Chord.parse_chord_string('Cmaj4').should == @c_major
-      Chord.parse_chord_string('CMaj4').should == @c_major
-      Chord.parse_chord_string('CM4').should == @c_major
-      Chord.parse_chord_string('C4').should == @c_major
+      Chord.parse_chord_string('Cmajor4').should eq(@c_major)
+      Chord.parse_chord_string('CMajor4').should eq(@c_major)
+      Chord.parse_chord_string('Cmaj4').should eq(@c_major)
+      Chord.parse_chord_string('CMaj4').should eq(@c_major)
+      Chord.parse_chord_string('CM4').should eq(@c_major)
+      Chord.parse_chord_string('C4').should eq(@c_major)
 
       expect { Chord.parse_chord_string('C') }.to raise_error ArgumentError
-      Chord.parse_chord_string('C', 4).should == @c_major
+      Chord.parse_chord_string('C', 4).should eq(@c_major)
     end
 
     it 'should recognize C minor' do
-      Chord.parse_chord_string('Cminor4').should == @c_minor
-      Chord.parse_chord_string('CMinor4').should == @c_minor
-      Chord.parse_chord_string('Cmin4').should == @c_minor
-      Chord.parse_chord_string('CMin4').should == @c_minor
-      Chord.parse_chord_string('Cm4').should == @c_minor
+      Chord.parse_chord_string('Cminor4').should eq(@c_minor)
+      Chord.parse_chord_string('CMinor4').should eq(@c_minor)
+      Chord.parse_chord_string('Cmin4').should eq(@c_minor)
+      Chord.parse_chord_string('CMin4').should eq(@c_minor)
+      Chord.parse_chord_string('Cm4').should eq(@c_minor)
 
       expect { Chord.parse_chord_string('Cm') }.to raise_error ArgumentError
-      Chord.parse_chord_string('Cm', 4).should == @c_minor
-
+      Chord.parse_chord_string('Cm', 4).should eq(@c_minor)
     end
 
     it 'should recognize C diminished' do
-      Chord.parse_chord_string('Cdiminished4').should == @c_diminished
-      Chord.parse_chord_string('CDiminished4').should == @c_diminished
-      Chord.parse_chord_string('Cdim4').should == @c_diminished
-      Chord.parse_chord_string('CDim4').should == @c_diminished
-      Chord.parse_chord_string('CDIM4').should == @c_diminished
+      Chord.parse_chord_string('Cdiminished4').should eq(@c_diminished)
+      Chord.parse_chord_string('CDiminished4').should eq(@c_diminished)
+      Chord.parse_chord_string('Cdim4').should eq(@c_diminished)
+      Chord.parse_chord_string('CDim4').should eq(@c_diminished)
+      Chord.parse_chord_string('CDIM4').should eq(@c_diminished)
 
-      expect { Chord.parse_chord_string('Cdim').should == @c_diminished }.to raise_error ArgumentError
-      Chord.parse_chord_string('Cdim', 4).should == @c_diminished
+      expect { Chord.parse_chord_string('Cdim') }.to raise_error ArgumentError
+      Chord.parse_chord_string('Cdim', 4).should eq(@c_diminished)
     end
 
     it 'should recognize C augmented' do
-      Chord.parse_chord_string('Caugmented4').should == @c_augmented
-      Chord.parse_chord_string('Caugmented4').should == @c_augmented
-      Chord.parse_chord_string('Caug4').should == @c_augmented
-      Chord.parse_chord_string('CAug4').should == @c_augmented
-      Chord.parse_chord_string('CAUG4').should == @c_augmented
-      Chord.parse_chord_string('C+4').should == @c_augmented
+      Chord.parse_chord_string('Caugmented4').should eq(@c_augmented)
+      Chord.parse_chord_string('Caugmented4').should eq(@c_augmented)
+      Chord.parse_chord_string('Caug4').should eq(@c_augmented)
+      Chord.parse_chord_string('CAug4').should eq(@c_augmented)
+      Chord.parse_chord_string('CAUG4').should eq(@c_augmented)
+      Chord.parse_chord_string('C+4').should eq(@c_augmented)
 
-      expect { Chord.parse_chord_string('Caug').should == @c_augmented }.to raise_error ArgumentError
-      Chord.parse_chord_string('Caug', 4).should == @c_augmented
+      expect { Chord.parse_chord_string('Caug') }.to raise_error ArgumentError
+      Chord.parse_chord_string('Caug', 4).should eq(@c_augmented)
     end
 
     # TODO: Fill out other chords
@@ -139,13 +139,13 @@ describe Music::Chord do
 
   describe '#inversion' do
     it 'should adjust the lowest n notes up by an octive' do
-      @c_major.inversion(1).should == Chord.new(['E4', 'G4', 'C5'])
-      Chord.new(['Eb4', 'C4', 'Gb4']).inversion(1).should == Chord.new(['Eb4', 'C5', 'Gb4'])
+      @c_major.inversion(1).should eq(Chord.new(%w(E4 G4 C5)))
+      Chord.new(%w(Eb4 C4 Gb4)).inversion(1).should eq(Chord.new(%w(Eb4 C5 Gb4)))
 
-      @c_major.inversion(2).should == Chord.new(['E5', 'G4', 'C5'])
-      Chord.new(['Eb4', 'C4', 'Gb4']).inversion(2).should == Chord.new(['Eb5', 'C5', 'Gb4'])
+      @c_major.inversion(2).should eq(Chord.new(%w(E5 G4 C5)))
+      Chord.new(%w(Eb4 C4 Gb4)).inversion(2).should eq(Chord.new(%w(Eb5 C5 Gb4)))
 
-      @c_augmented_seventh.inversion(3).should == Chord.new(['E5', 'G#5', 'C5', 'Bb4'])
+      @c_augmented_seventh.inversion(3).should eq(Chord.new(['E5', 'G#5', 'C5', 'Bb4']))
     end
 
     it 'should raise an error when the inversion amount is too great' do
@@ -164,19 +164,19 @@ describe Music::Chord do
 
   describe '#first_inversion' do
     it 'should adjust the lowest note up by an octive' do
-      @c_major.first_inversion.should == Chord.new(['E4', 'G4', 'C5'])
+      @c_major.first_inversion.should eq(Chord.new(%w(E4 G4 C5)))
     end
   end
 
   describe '#second_inversion' do
     it 'should adjust the lowest two notes up by an octive' do
-      @c_major.second_inversion.should == Chord.new(['E5', 'G4', 'C5'])
+      @c_major.second_inversion.should eq(Chord.new(%w(E5 G4 C5)))
     end
   end
 
   describe '#third_inversion' do
     it 'should adjust the lowest three notes up by an octive' do
-      @c_augmented_seventh.third_inversion.should == Chord.new(['E5', 'G#5', 'C5', 'Bb4'])
+      @c_augmented_seventh.third_inversion.should eq(Chord.new(['E5', 'G#5', 'C5', 'Bb4']))
     end
   end
-end
+end