music 0.6.2 → 0.8.0

data/lib/music/chord.rb

@@ -1,21 +1,24 @@
+require 'set'
+
 module Music
   class Chord
-
-    def eql?(other_chord)
-      @notes == other_chord.notes
+    def eql?(other)
+      @notes == other.notes
     end
+
     def hash
       @notes.hash
     end
-    def ==(other_chord)
-      self.eql?(other_chord)
+
+    def ==(other)
+      self.eql?(other)
     end
 
     attr_reader :notes
 
     def initialize(notes)
-      raise ArgumentError, 'Chords must have at least two notes' if notes.size < 2
-      @notes = Set.new(notes) do |note|
+      fail ArgumentError, 'Chords must have at least two notes' if notes.size < 2
+      @notes = ::Set.new(notes) do |note|
         if note.is_a?(Note)
           note
         else
@@ -28,7 +31,7 @@ module Music
     # def to_i
 
     def note_strings
-      Set.new(@notes.collect(&:note_string))
+      ::Set.new(@notes.collect(&:note_string))
     end
 
     def describe
@@ -38,25 +41,25 @@ module Music
       end
 
       quality = case distances
-      when [4, 7]
-        :major
-      when [3, 7]
-        :minor
-      when [3, 6]
-        :diminished
-      when [4, 8]
-        :augmented
-      when [4, 7, 11]
-        :major_7
-      when [3, 7, 10]
-        :minor_7
-      when [3, 6, 9]
-        :diminished_7
-      when [3, 6, 10]
-        :half_diminished_7
-      when [4, 8, 10]
-        :augmented_7
-      end
+                when [4, 7]
+                  :major
+                when [3, 7]
+                  :minor
+                when [3, 6]
+                  :diminished
+                when [4, 8]
+                  :augmented
+                when [4, 7, 11]
+                  :major_7
+                when [3, 7, 10]
+                  :minor_7
+                when [3, 6, 9]
+                  :diminished_7
+                when [3, 6, 10]
+                  :half_diminished_7
+                when [4, 8, 10]
+                  :augmented_7
+                end
 
       [note_array.first.letter, quality]
     end
@@ -69,8 +72,8 @@ module Music
     #
     # @returns [Chord] The specified inversion of chord
     def inversion(amount)
-      raise ArgumentError, "Inversion amount must be greater than or equal to 1" if amount < 1
-      raise ArgumentError, "Not enough notes in chord for inversion" if amount >= @notes.size
+      fail ArgumentError, 'Inversion amount must be greater than or equal to 1' if amount < 1
+      fail ArgumentError, 'Not enough notes in chord for inversion' if amount >= @notes.size
 
       note_array = @notes.to_a.sort
       notes = (0...amount).collect { note_array.shift.adjust_by_semitones(12) }
@@ -95,9 +98,9 @@ module Music
     class << self
       def parse_chord_string(chord_string, assumed_octave = nil)
         if note_string_match = chord_string.match(/^([A-Ga-g])([#b]?)([^\d]*)(\d*)$/)
-          full_string, note, accidental, interval, octave = note_string_match.to_a
+          _, note, accidental, interval, octave = note_string_match.to_a
 
-          raise ArgumentError, 'No octave found and no octave assumed' if note.blank? && assumed_octave.nil?
+          fail ArgumentError, 'No octave found and no octave assumed' if note.empty? && assumed_octave.nil?
 
           Note.new(note + accidental + octave, assumed_octave).chord(interval)
         end

data/lib/music/note.rb

@@ -1,26 +1,21 @@
-require 'active_model'
-require 'music/patches/hash'
-
 module Music
   class Note
-    include ActiveModel::Validations
-
-    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
 
-    validates_presence_of :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
@@ -34,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
@@ -88,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
     #
@@ -106,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)
@@ -132,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
 
@@ -146,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 = {
@@ -224,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.blank?
+      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
 
@@ -249,16 +244,14 @@ module Music
     end
 
     class << self
-      extend ActiveSupport::Memoizable
-
       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].blank? && 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].present? ? match[3] : assumed_octave
+        octave = match[3].empty? ? assumed_octave : match[3]
         [match[1].upcase, match[2] == '' ? nil : match[2], octave.to_i]
       end
 
@@ -266,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
 
@@ -287,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
@@ -302,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}")
@@ -321,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
@@ -336,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.6.2'
+  VERSION = '0.8.0'
 end

data/lib/music.rb

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

data/music.gemspec

@@ -1,29 +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_dependency              "activemodel", "~> 3.2"
-  s.add_development_dependency  "rake", "~> 0.9"
-  s.add_development_dependency  "bundler", "~> 1.1.3"
-  s.add_development_dependency  "rspec", '~> 2'
-  s.add_development_dependency  "activemodel", '~> 3.2.0'
-end
+  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