music 0.5.1 → 0.6.1

data/.gitignore

@@ -45,4 +45,6 @@ pkg
 #.redcar
 
 # For rubinius:
-#*.rbc
+*.rbc
+*.rbx
+

data/Gemfile

@@ -1,2 +1,8 @@
 source "http://rubygems.org"
 gemspec
+
+group :development do
+  gem 'guard-bundler'
+  gem 'guard-rspec'
+  gem 'rb-fsevent', '~> 0.9.1'
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    music (0.5.0)
+    music (0.5.1)
 
 GEM
   remote: http://rubygems.org/
@@ -13,10 +13,29 @@ GEM
       i18n (~> 0.6)
       multi_json (~> 1.0)
     builder (3.0.0)
+    coderay (1.0.8)
     diff-lcs (1.1.3)
+    guard (1.5.3)
+      listen (>= 0.4.2)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-bundler (1.0.0)
+      bundler (~> 1.0)
+      guard (~> 1.1)
+    guard-rspec (1.2.1)
+      guard (>= 1.1)
     i18n (0.6.0)
+    listen (0.5.3)
+    lumberjack (1.0.2)
+    method_source (0.8.1)
     multi_json (1.3.5)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
     rake (0.9.2.2)
+    rb-fsevent (0.9.2)
     rspec (2.10.0)
       rspec-core (~> 2.10.0)
       rspec-expectations (~> 2.10.0)
@@ -25,6 +44,8 @@ GEM
     rspec-expectations (2.10.0)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.10.1)
+    slop (3.3.3)
+    thor (0.16.0)
 
 PLATFORMS
   ruby
@@ -32,6 +53,9 @@ PLATFORMS
 DEPENDENCIES
   activemodel (>= 3.2.0)
   bundler (>= 1.1.3)
+  guard-bundler
+  guard-rspec
   music!
   rake (>= 0.9)
+  rb-fsevent (~> 0.9.1)
   rspec

data/Guardfile

@@ -0,0 +1,29 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  # Uncomment next line if Gemfile contain `gemspec' command
+  # watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', :version => 2, :rvm => ['1.9.3', '1.8.7', 'rbx'] do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+  
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end

data/README.md

@@ -3,6 +3,8 @@ music
 
 The *music* gem provides a means on calculating notes and chords.
 
+[![Build Status](https://travis-ci.org/cheerfulstoic/music.png)](https://travis-ci.org/cheerfulstoic/music)
+
 Examples:
 ---------
 
@@ -39,7 +41,17 @@ Describe chords:
 
     Chord.new(['C4', 'Eb4', 'Gb4'])     # => ['C', :diminished]
 
-*For further usage, see the examples in the spec files*
+*For further usage:*
+ * Docs: http://rubydoc.info/github/cheerfulstoic/music/frames
+ * See the examples in the spec files
+
+TODOs:
+======
+
+ * Use the term musical term 'interval' or 'semitones' instead of 'distance' in code
+ * 'C-' can be used to represent C minor
+ * There can be many versions of chords.  See: http://giventowail.com/lessons/evan/the-basics-major-minor-and-power-chords?phpMyAdmin=97715a053dab6cd797cf01c69d7492a4
+ * Implement calculation of 'cents'
 
 Contributing to music
 =====================

data/lib/music/chord.rb

@@ -1,22 +1,40 @@
 module Music
   class Chord
+
+    def eql?(other_chord)
+      @notes == other_chord.notes
+    end
+    def hash
+      @notes.hash
+    end
+    def ==(other_chord)
+      self.eql?(other_chord)
+    end
+
+    attr_reader :notes
+
     def initialize(notes)
-      @notes = notes.collect do |note|
+      raise 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
           Note.new(note)
         end
-      end.sort
+      end
     end
 
+    # Spec and implement
+    # def to_i
+
     def note_strings
-      @notes.collect(&:note_string)
+      Set.new(@notes.collect(&:note_string))
     end
 
     def describe
-      distances = (1...@notes.size).collect do |i|
-        @notes[0].distance_to(@notes[i])
+      note_array = @notes.to_a.sort
+      distances = (1...note_array.size).collect do |i|
+        note_array[0].distance_to(note_array[i])
       end
 
       quality = case distances
@@ -40,7 +58,50 @@ module Music
         :augmented_7
       end
 
-      [@notes.first.letter, quality]
+      [note_array.first.letter, quality]
+    end
+
+    def to_s
+      @notes.to_a.sort.collect(&:to_s).join(' / ')
+    end
+
+    # Give the Nth inversion of the chord which simply adjusts the lowest N notes up by one octive
+    #
+    # @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
+
+      note_array = @notes.to_a.sort
+      notes = (0...amount).collect { note_array.shift.adjust_by_semitones(12) }
+      Chord.new(notes + note_array)
+    end
+
+    # Calls inversion(1)
+    def first_inversion
+      self.inversion(1)
+    end
+
+    # Calls inversion(2)
+    def second_inversion
+      self.inversion(2)
+    end
+
+    # Calls inversion(3)
+    def third_inversion
+      self.inversion(3)
+    end
+
+    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
+
+          raise ArgumentError, 'No octave found and no octave assumed' if note.blank? && assumed_octave.nil?
+
+          Note.new(note + accidental + octave, assumed_octave).chord(interval)
+        end
+      end
     end
   end
 end

data/lib/music/note.rb

@@ -16,7 +16,22 @@ module Music
     def <=>(other_note)
       self.frequency <=> other_note.frequency
     end
+    def hash
+      self.frequency.hash
+    end
+    def eql?(other_note)
+      self.frequency == other_note.frequency
+    end
+
+    def to_s
+      self.note_string
+    end
 
+    # Creates a new note
+    #
+    # @param [String, Numeric] descriptor Either a string describing the note (e.g. 'C#4') or a number giving the note's frequency (e.g. 440)
+    # @param [Numeric, nil] assumed_octave If no octive is given in the descriptor, use this
+    # @returns [Note] Note specified
     def initialize(descriptor, assumed_octave = nil)
       self.frequency = if descriptor.is_a? Numeric
         Note.nearest_note_frequency(descriptor)
@@ -25,35 +40,214 @@ module Music
       end
     end
 
+    # Returns string representing note with letter, accidental, and octave number
+    # e.g. 'C#5'
+    #
+    # @param [boolean] give_flat Should the result give a flat? (defults to giving a sharp)
+    # @return [String] The resulting note string
     def note_string(give_flat = false)
       Note.calculate_note(self.frequency, give_flat).join
     end
 
+    # Returns the letter portion of the note
+    # e.g. 'C'
+    #
+    # @param [boolean] give_flat Should the result be based on giving a flat? (defaults to giving a sharp)
+    # @return [String] The resulting note letter
     def letter(give_flat = false)
       Note.calculate_note(self.frequency, give_flat)[0]
     end
 
+    # Returns the accidental portion of the note
+    # e.g. '#' or 'b'
+    #
+    # @param [boolean] give_flat Should the result give a flat? (defaults to giving a sharp)
+    # @return [String] The resulting accidental
     def accidental(give_flat = false)
       Note.calculate_note(self.frequency, give_flat)[1]
     end
 
+    # Returns the octive number of the note
+    # e.g. 4
+    #
+    # @return [Fixnum] The resulting octive number
     def octave
       Note.calculate_note(self.frequency)[2]
     end
 
-    def pred
+    # Return the previous note (adjusted by one semitone down)
+    #
+    # @return [Note] The previous note
+    def prev
       Note.new(Note.frequency_adjustment(self.frequency, -1))
     end
 
+    # Return the next note (adjusted by one semitone up)
+    #
+    # @return [Note] The next note
     def succ
       Note.new(Note.frequency_adjustment(self.frequency, 1))
     end
     alias :next :succ
 
+    # Return the distance (in semitones) to a note
+    #
+    # @return [Fixnum] Number of semitones
     def distance_to(note)
       Note.note_distance(self.note_string, note.note_string)
     end
 
+    # Return another note adjusted by a given interval
+    #
+    # @param [Fixnum] interval Number of semitones to adjust by
+    # @return [Note] Resulting note after adjustment
+    def adjust_by_semitones(interval)
+      Note.new(Note.frequency_adjustment(self.frequency, interval))
+    end
+
+    {
+      :minor_second => 1,
+      :major_second => 2,
+
+      :minor_third => 3,
+      :major_third => 4,
+
+      :perfect_fourth => 5,
+
+      :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
+    }.each do |interval, semitones_count|
+      define_method interval do
+        adjust_by_semitones(semitones_count)
+      end
+    end
+
+    # Uses note as key to give major scale
+    #
+    # @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,
+      ]
+    end
+
+    # Uses note as key to give minor scale
+    #
+    # @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,
+      ]
+    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]
+    }
+
+    CHORD_ALIASES = {
+      :min => :minor,
+      :m => :minor,
+      :maj => :major,
+      :M => :major,
+      :p => :fifth,
+      :pow => :fifth,
+      :power => :fifth,
+      :'5' => :fifth,
+      :'5th' => :fifth,
+      :dim => :diminished,
+      :aug => :augmented,
+      :'+' => :augmented,
+
+      :maj_seventh => :major_seventh,
+      :major_7 => :major_seventh,
+      :major_7th => :major_seventh,
+      :maj_7 => :major_seventh,
+      :maj_7th => :major_seventh,
+      :maj7 => :major_seventh,
+      :maj7th => :major_seventh,
+      :M7 => :major_seventh,
+
+      :min_seventh => :minor_seventh,
+      :minor_7 => :minor_seventh,
+      :minor_7th => :minor_seventh,
+      :min_7 => :minor_seventh,
+      :min_7th => :minor_seventh,
+      :min7 => :minor_seventh,
+      :min7th => :minor_seventh,
+      :m7 => :minor_seventh,
+
+      :dim_seventh => :diminished_seventh,
+      :diminished_7 => :diminished_seventh,
+      :diminished_7th => :diminished_seventh,
+      :dim_7 => :diminished_seventh,
+      :dim_7th => :diminished_seventh,
+      :dim7 => :diminished_seventh,
+      :dim7th => :diminished_seventh,
+      :d7 => :diminished_seventh,
+
+      :aug_seventh => :augmented_seventh,
+      :augmented_7 => :augmented_seventh,
+      :augmented_7th => :augmented_seventh,
+      :aug_7 => :augmented_seventh,
+      :aug_7th => :augmented_seventh,
+      :aug7 => :augmented_seventh,
+      :aug7th => :augmented_seventh,
+      :'+7' => :augmented_seventh,
+
+      :half_dim_seventh => :half_diminished_seventh,
+      :half_diminished_7 => :half_diminished_seventh,
+      :half_diminished_7th => :half_diminished_seventh,
+      :half_dim_7 => :half_diminished_seventh,
+      :half_dim_7th => :half_diminished_seventh,
+      :half_dim7 => :half_diminished_seventh,
+      :half_dim7th => :half_diminished_seventh,
+    }
+
+    def chord(description)
+      description = :major if description.blank?
+
+      description = description.to_s
+      description.downcase! unless ['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) })
+      end
+    end
+
+    (CHORD_INTERVALS.keys + CHORD_ALIASES.keys).each do |chord_description|
+      define_method "#{chord_description}_chord" do
+        self.chord(chord_description)
+      end
+    end
+
     class << self
       extend ActiveSupport::Memoizable
 

data/lib/music/version.rb

@@ -1,3 +1,3 @@
 module Music
-  VERSION = '0.5.1'
+  VERSION = '0.6.1'
 end

data/spec/classes/chord_spec.rb

@@ -3,6 +3,16 @@ require 'spec_helper'
 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_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_augmented_seventh = Chord.new(['C4', 'E4', 'G#4', 'Bb4'])
+    @c_half_diminished_seventh = Chord.new(['C4', 'Eb4', 'Gb4', 'Bb4'])
   end
 
   describe '#new(notes)' do
@@ -14,23 +24,36 @@ describe Music::Chord do
       Chord.new(@standard_tuning_notes.collect(&:note_string))
     end
 
-    it 'should sort the notes by frequency' do
-      Chord.new(['A2', 'E2']).note_strings.should == ['E2', 'A2']
+    it 'should validate that chords must have at least two notes' do
+      lambda { Chord.new(['C4']) }.should raise_error(ArgumentError, 'Chords must have at least two notes')
+      lambda { Chord.new([]) }.should raise_error(ArgumentError, 'Chords must have at least two notes')
+    end
+  end
+
+  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'])
     end
   end
 
   describe '#note_strings' do
-    it 'should return an array of note strings' do
+    it 'should return a set of note strings' do
       chord = Chord.new(@standard_tuning_notes)
 
-      chord.note_strings.should == @standard_tuning_notes.collect(&:note_string)
+      chord.note_strings.should == 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'
     end
   end
 
   describe '#describe' do
     describe "triads" do
       it 'should recognize C major' do
-        Chord.new(['C4', 'E4', 'G4']).describe.should == ['C', :major]
+        @c_major.describe.should == ['C', :major]
       end
 
       it 'should recognize C minor' do
@@ -62,4 +85,98 @@ describe Music::Chord do
       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
+
+      expect { Chord.parse_chord_string('C') }.to raise_error ArgumentError
+      Chord.parse_chord_string('C', 4).should == @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
+
+      expect { Chord.parse_chord_string('Cm') }.to raise_error ArgumentError
+      Chord.parse_chord_string('Cm', 4).should == @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
+
+      expect { Chord.parse_chord_string('Cdim').should == @c_diminished }.to raise_error ArgumentError
+      Chord.parse_chord_string('Cdim', 4).should == @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
+
+      expect { Chord.parse_chord_string('Caug').should == @c_augmented }.to raise_error ArgumentError
+      Chord.parse_chord_string('Caug', 4).should == @c_augmented
+    end
+
+    # TODO: Fill out other chords
+  end
+
+  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(2).should == Chord.new(['E5', 'G4', 'C5'])
+      Chord.new(['Eb4', 'C4', 'Gb4']).inversion(2).should == Chord.new(['Eb5', 'C5', 'Gb4'])
+
+      @c_augmented_seventh.inversion(3).should == Chord.new(['E5', 'G#5', 'C5', 'Bb4'])
+    end
+
+    it 'should raise an error when the inversion amount is too great' do
+      lambda { @c_major.inversion(3) }.should raise_error(ArgumentError, 'Not enough notes in chord for inversion')
+      lambda { @c_major.inversion(4) }.should raise_error(ArgumentError, 'Not enough notes in chord for inversion')
+
+      lambda { @c_augmented_seventh.inversion(4) }.should raise_error(ArgumentError, 'Not enough notes in chord for inversion')
+      lambda { @c_augmented_seventh.inversion(5) }.should raise_error(ArgumentError, 'Not enough notes in chord for inversion')
+    end
+
+    it 'should raise an error when the inversion amount is too small' do
+      lambda { @c_major.inversion(0) }.should raise_error(ArgumentError, 'Inversion amount must be greater than or equal to 1')
+      lambda { @c_major.inversion(-1) }.should raise_error(ArgumentError, 'Inversion amount must be greater than or equal to 1')
+    end
+  end
+
+  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'])
+    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'])
+    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'])
+    end
+  end
 end

data/spec/classes/note_spec.rb

@@ -151,6 +151,330 @@ describe Music::Note do
     end
   end
 
+  describe 'interval calculations' do
+    let(:c4) { Note.new('C4') }
+    let(:b4) { Note.new('B4') }
+    
+    it { c4.should have_an_interval :minor_second, 'C#4' }
+    it { b4.should have_an_interval :minor_second, 'C5' }
+
+    it { c4.should have_an_interval :major_second, 'D4' }
+    it { b4.should have_an_interval :major_second, 'C#5' }
+
+
+    it { c4.should have_an_interval :minor_third, 'D#4' }
+    it { b4.should have_an_interval :minor_third, 'D5' }
+
+    it { c4.should have_an_interval :major_third, 'E4' }
+    it { b4.should have_an_interval :major_third, 'D#5' }
+
+    it { c4.should have_an_interval :perfect_fourth, 'F4' }
+    it { b4.should have_an_interval :perfect_fourth, 'E5' }
+
+    # Enharmonic equivalents
+    it { c4.should have_an_interval :tritone, 'F#4' }
+    it { b4.should have_an_interval :tritone, 'F5' }
+    it { c4.should have_an_interval :diminished_fifth, 'F#4' }
+    it { b4.should have_an_interval :diminished_fifth, 'F5' }
+    it { c4.should have_an_interval :flat_fifth, 'F#4' }
+    it { b4.should have_an_interval :flat_fifth, 'F5' }
+    it { c4.should have_an_interval :augmented_fourth, 'F#4' }
+    it { b4.should have_an_interval :augmented_fourth, 'F5' }
+
+    it { c4.should have_an_interval :perfect_fifth, 'G4' }
+    it { b4.should have_an_interval :perfect_fifth, 'F#5' }
+
+    # Enharmonic equivalents
+    it { c4.should have_an_interval :augmented_fifth, 'G#4' }
+    it { b4.should have_an_interval :augmented_fifth, 'G5' }
+    it { c4.should have_an_interval :minor_sixth, 'G#4' }
+    it { b4.should have_an_interval :minor_sixth, 'G5' }
+
+    it { c4.should have_an_interval :major_sixth, 'A4' }
+    it { b4.should have_an_interval :major_sixth, 'G#5' }
+
+    it { c4.should have_an_interval :diminished_seventh, 'A4' }
+    it { b4.should have_an_interval :diminished_seventh, 'G#5' }
+
+    it { c4.should have_an_interval :minor_seventh, 'A#4' }
+    it { b4.should have_an_interval :minor_seventh, 'A5' }
+
+    it { c4.should have_an_interval :major_seventh, 'B4' }
+    it { b4.should have_an_interval :major_seventh, 'A#5' }
+  end
+
+
+  describe 'scales from notes (as scale key)' do
+    describe '#major_scale' do
+      Note.new('C4').major_scale.should == [
+        Note.new('C4'),
+        Note.new('D4'),
+        Note.new('E4'),
+        Note.new('F4'),
+        Note.new('G4'),
+        Note.new('A4'),
+        Note.new('B4')
+      ]
+
+      Note.new('G4').major_scale.should == [
+        Note.new('G4'),
+        Note.new('A4'),
+        Note.new('B4'),
+        Note.new('C5'),
+        Note.new('D5'),
+        Note.new('E5'),
+        Note.new('F#5')
+      ]
+    end
+
+    describe '#minor_scale' do
+      Note.new('C4').minor_scale.should == [
+        Note.new('C4'),
+        Note.new('D4'),
+        Note.new('D#4'),
+        Note.new('F4'),
+        Note.new('G4'),
+        Note.new('G#4'),
+        Note.new('A#4')
+      ]
+
+      Note.new('G4').minor_scale.should == [
+        Note.new('G4'),
+        Note.new('A4'),
+        Note.new('A#4'),
+        Note.new('C5'),
+        Note.new('D5'),
+        Note.new('D#5'),
+        Note.new('F5')
+      ]
+    end
+  end
+
+  describe '#to_s' do
+    it 'should output the note_string' do
+      Note.new('E4').to_s.should == 'E4'
+    end
+
+    it 'should use the sharp version' do
+      Note.new('D#5').to_s.should == 'D#5'
+      Note.new('Eb5').to_s.should == 'D#5'
+    end
+  end
+
+  describe 'chords from notes' do
+    c4 = Note.new('C4')
+    
+    c_minor = Chord.new(['C4', 'Eb4', 'G4'])
+    c_major = Chord.new(['C4', 'E4', 'G4'])
+    c_fifth = Chord.new(['C4', 'G4'])
+    c_diminished = Chord.new(['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_augmented_seventh = Chord.new(['C4', 'E4', 'G#4', 'Bb4'])
+    c_half_diminished_seventh = Chord.new(['C4', 'Eb4', 'Gb4', 'Bb4'])
+
+    describe 'chords from notes' do
+      describe '#chord' do
+        it 'should recognize minor chords' do
+          c4.chord(:minor).should == c_minor
+          c4.chord('Minor').should == c_minor
+          c4.chord('minor').should == c_minor
+          c4.chord('min').should == c_minor
+          c4.chord('MIN').should == c_minor
+          c4.chord('m').should == c_minor
+        end
+
+        it 'should recognize major chords' do
+          c4.chord(:major).should == c_major
+          c4.chord('Major').should == c_major
+          c4.chord('major').should == c_major
+          c4.chord('maj').should == c_major
+          c4.chord('MAJ').should == c_major
+          c4.chord('M').should == c_major
+          c4.chord('').should == c_major
+        end
+
+        it 'should recognize power chords' do
+          c4.chord(:power).should == c_fifth
+          c4.chord(:fifth).should == c_fifth
+          c4.chord('Power').should == c_fifth
+          c4.chord('power').should == c_fifth
+          c4.chord('Fifth').should == c_fifth
+          c4.chord('fifth').should == c_fifth
+          c4.chord('pow').should == c_fifth
+          c4.chord('POW').should == c_fifth
+          c4.chord('5').should == c_fifth
+        end
+
+        it 'should recognize diminished chords' do
+          c4.chord(:diminished).should == c_diminished
+          c4.chord('Diminished').should == c_diminished
+          c4.chord('diminished').should == c_diminished
+          c4.chord('dim').should == c_diminished
+          c4.chord('DIM').should == c_diminished
+        end
+
+        it 'should recognize augmented chords' do
+          c4.chord(:augmented).should == c_augmented
+          c4.chord('Augmented').should == c_augmented
+          c4.chord('augmented').should == c_augmented
+          c4.chord('aug').should == c_augmented
+          c4.chord('AUG').should == c_augmented
+          c4.chord('+').should == c_augmented
+        end
+
+        it 'should recognize major seventh chords' do
+          c4.chord(:major_seventh).should == c_major_seventh
+          c4.chord('major_seventh').should == c_major_seventh
+          c4.chord('major seventh').should == c_major_seventh
+          c4.chord('Major seventh').should == c_major_seventh
+          c4.chord('maj seventh').should == c_major_seventh
+          c4.chord('maj 7').should == c_major_seventh
+          c4.chord('maj 7th').should == c_major_seventh
+          c4.chord('maj7').should == c_major_seventh
+          c4.chord('maj7th').should == c_major_seventh
+          c4.chord('MAJ7').should == c_major_seventh
+          c4.chord('M7').should == c_major_seventh
+        end
+
+        it 'should recognize minor seventh chords' do
+          c4.chord(:minor_seventh).should == c_minor_seventh
+          c4.chord('minor_seventh').should == c_minor_seventh
+          c4.chord('minor seventh').should == c_minor_seventh
+          c4.chord('minor seventh').should == c_minor_seventh
+          c4.chord('min seventh').should == c_minor_seventh
+          c4.chord('min 7').should == c_minor_seventh
+          c4.chord('min 7th').should == c_minor_seventh
+          c4.chord('min7').should == c_minor_seventh
+          c4.chord('min7th').should == c_minor_seventh
+          c4.chord('min7').should == c_minor_seventh
+          c4.chord('m7').should == c_minor_seventh
+        end
+
+        it 'should recognize diminished seventh chords' do
+          c4.chord(:diminished_seventh).should == c_diminished_seventh
+          c4.chord('diminished_seventh').should == c_diminished_seventh
+          c4.chord('diminished seventh').should == c_diminished_seventh
+          c4.chord('diminished seventh').should == c_diminished_seventh
+          c4.chord('dim seventh').should == c_diminished_seventh
+          c4.chord('dim 7').should == c_diminished_seventh
+          c4.chord('dim 7th').should == c_diminished_seventh
+          c4.chord('dim7').should == c_diminished_seventh
+          c4.chord('dim7th').should == c_diminished_seventh
+          c4.chord('dim7').should == c_diminished_seventh
+          c4.chord('d7').should == c_diminished_seventh
+        end
+
+        it 'should recognize augmented seventh chords' do
+          c4.chord(:augmented_seventh).should == c_augmented_seventh
+          c4.chord('augmented_seventh').should == c_augmented_seventh
+          c4.chord('augmented seventh').should == c_augmented_seventh
+          c4.chord('augmented seventh').should == c_augmented_seventh
+          c4.chord('aug seventh').should == c_augmented_seventh
+          c4.chord('aug 7').should == c_augmented_seventh
+          c4.chord('aug 7th').should == c_augmented_seventh
+          c4.chord('aug7').should == c_augmented_seventh
+          c4.chord('aug7th').should == c_augmented_seventh
+          c4.chord('aug7').should == c_augmented_seventh
+          c4.chord('+7').should == c_augmented_seventh
+        end
+
+        it 'should recognize half diminished seventh chords' do
+          c4.chord(:half_diminished_seventh).should == c_half_diminished_seventh
+          c4.chord('half_diminished_7').should == c_half_diminished_seventh
+          c4.chord('half_diminished_7th').should == c_half_diminished_seventh
+          c4.chord('half-diminished seventh').should == c_half_diminished_seventh
+          c4.chord('half-diminished 7').should == c_half_diminished_seventh
+          c4.chord('half-diminished 7th').should == c_half_diminished_seventh
+          c4.chord('half_dim seventh').should == c_half_diminished_seventh
+          c4.chord('half_dim 7').should == c_half_diminished_seventh
+          c4.chord('half_dim 7th').should == c_half_diminished_seventh
+          c4.chord('half_dim7').should == c_half_diminished_seventh
+          c4.chord('half_dim7th').should == c_half_diminished_seventh
+          c4.chord('half_dim7').should == c_half_diminished_seventh
+        end
+      end
+
+      describe 'chord methods' do
+        it 'should have minor methods' do
+          c4.minor_chord.should == c_minor
+          c4.min_chord.should == c_minor
+          c4.m_chord.should == c_minor
+        end
+
+        it 'should have major methods' do
+          c4.major_chord.should == c_major
+          c4.maj_chord.should == c_major
+          c4.M_chord.should == c_major
+        end
+
+        it 'should have diminished methods' do
+          c4.diminished_chord.should == c_diminished
+          c4.dim_chord.should == c_diminished
+        end
+
+        it 'should have augmented methods' do
+          c4.augmented_chord.should == c_augmented
+          c4.aug_chord.should == c_augmented
+        end
+
+        it 'should have major seventh methods' do
+          c4.major_seventh_chord.should == c_major_seventh
+          c4.maj_seventh_chord.should == c_major_seventh
+          c4.maj_7_chord.should == c_major_seventh
+          c4.maj_7th_chord.should == c_major_seventh
+          c4.maj7_chord.should == c_major_seventh
+          c4.maj7th_chord.should == c_major_seventh
+          c4.M7_chord.should == c_major_seventh
+        end
+
+        it 'should have minor seventh methods' do
+          c4.minor_seventh_chord.should == c_minor_seventh
+          c4.min_seventh_chord.should == c_minor_seventh
+          c4.min_7_chord.should == c_minor_seventh
+          c4.min_7th_chord.should == c_minor_seventh
+          c4.min7_chord.should == c_minor_seventh
+          c4.min7th_chord.should == c_minor_seventh
+          c4.m7_chord.should == c_minor_seventh
+        end
+
+        it 'should have diminished seventh methods' do
+          c4.diminished_seventh_chord.should == c_diminished_seventh
+          c4.dim_seventh_chord.should == c_diminished_seventh
+          c4.dim_7_chord.should == c_diminished_seventh
+          c4.dim_7th_chord.should == c_diminished_seventh
+          c4.dim7_chord.should == c_diminished_seventh
+          c4.dim7th_chord.should == c_diminished_seventh
+          c4.d7_chord.should == c_diminished_seventh
+        end
+
+        it 'should have augmented seventh methods' do
+          c4.augmented_seventh_chord.should == c_augmented_seventh
+          c4.aug_seventh_chord.should == c_augmented_seventh
+          c4.aug_7_chord.should == c_augmented_seventh
+          c4.aug_7th_chord.should == c_augmented_seventh
+          c4.aug7_chord.should == c_augmented_seventh
+          c4.aug7th_chord.should == c_augmented_seventh
+          c4.send('+7_chord').should == c_augmented_seventh
+        end
+
+        it 'should have half diminished seventh methods' do
+          c4.half_diminished_seventh_chord.should == c_half_diminished_seventh
+          c4.half_diminished_7_chord.should == c_half_diminished_seventh
+          c4.half_diminished_7th_chord.should == c_half_diminished_seventh
+          c4.half_dim_seventh_chord.should == c_half_diminished_seventh
+          c4.half_dim_7_chord.should == c_half_diminished_seventh
+          c4.half_dim_7th_chord.should == c_half_diminished_seventh
+          c4.half_dim7_chord.should == c_half_diminished_seventh
+          c4.half_dim7th_chord.should == c_half_diminished_seventh
+        end
+      end
+    end
+
+  end
+
   describe ".calculate_frequency(letter, accidental, octave)" do
     {
       ['C', nil, 0] => 16.35,
@@ -201,6 +525,8 @@ describe Music::Note do
     end
   end
 
+  # TODO: Should return accurracy
+  # Thought: ((frequency off) / (distance to next note's frequency)) * 2.0?
   describe ".calculate_note(frequency)" do
     test_frequencies = {
       [16.35] => ['C', nil, 0],
@@ -258,7 +584,7 @@ describe Music::Note do
     end
 
     it "should allow getting of previous note" do
-      Note.new(739.99).pred.should == Note.new(698.46)
+      Note.new(739.99).prev.should == Note.new(698.46)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1 +1,3 @@
 require 'music'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}

data/spec/support/matchers/have_an_interval.rb

@@ -0,0 +1,13 @@
+RSpec::Matchers.define :have_an_interval do |interval_description, expected_note_string|
+  match do |note|
+    note.send(interval_description).note_string == expected_note_string
+  end
+
+  failure_message_for_should do |note|
+  	"Expected #{note.note_string}'s #{interval_description} interval to be #{expected_note_string}"
+  end
+
+  description do |note|
+  	"have an #{interval_description} interval of #{expected_note_string} for #{note.note_string}"
+  end
+end

metadata

@@ -1,98 +1,94 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: music
-version: !ruby/object:Gem::Version 
-  hash: 9
+version: !ruby/object:Gem::Version
+  version: 0.6.1
   prerelease: 
-  segments: 
-  - 0
-  - 5
-  - 1
-  version: 0.5.1
 platform: ruby
-authors: 
+authors:
 - Brian Underwood
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-05-15 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 25
-        segments: 
-        - 0
-        - 9
-        version: "0.9"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: bundler
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 21
-        segments: 
-        - 1
-        - 1
-        - 3
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.1.3
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: activemodel
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 3
-        - 2
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 3.2.0
   type: :development
-  version_requirements: *id004
-description: Library for classifying notes and chords and performing calculations on them.  See README.md
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Library for classifying notes and chords and performing calculations
+  on them.  See README.md
+email:
 - ml+musicgem@semi-sentient.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .document
 - .gitignore
 - .travis.yml
 - Gemfile
 - Gemfile.lock
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -106,43 +102,35 @@ files:
 - spec/classes/hash_spec.rb
 - spec/classes/note_spec.rb
 - spec/spec_helper.rb
+- spec/support/matchers/have_an_interval.rb
 homepage: http://github.com/cheerfulstoic/music
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 31
-      segments: 
-      - 1
-      - 8
-      version: "1.8"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.8'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Library for performing calculations on musical elements
-test_files: 
+test_files:
 - spec/classes/chord_spec.rb
 - spec/classes/hash_spec.rb
 - spec/classes/note_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 
+- spec/support/matchers/have_an_interval.rb