music 0.5.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,48 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    music-utils (0.5.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.2)
+      activesupport (= 3.2.2)
+      builder (~> 3.0.0)
+    activesupport (3.2.2)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    multi_json (1.1.0)
+    rake (0.9.2.2)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (>= 3.0)
+  bundler (>= 1.1.3)
+  music-utils!
+  rake (>= 0.9)
+  rspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Brian Underwood
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+music
+=====
+
+The *music* gem provides a means on calculating notes and chords.
+
+Examples:
+---------
+
+Creating notes:
+
+    note = Note.new(698.46) # Creates a note object with the frequency 698.46
+    note = Note.new('F#6') # Creates an F sharp note in the 6th octave
+
+Comparing notes:
+
+    Note.new(698.46) < Note.new(1975.53)    # => true
+    Note.new(698.46) == Note.new('F5')      # => true
+
+Converting from frequency to note string and vice versa:
+
+    Note.new(698.46).note_string    # => 'F5'
+    Note.new('Bb3').frequency       # => 233.08
+
+Find how many semitones two notes are apart:
+
+    Note.note_distance('A4', 'A#4')     # => 1
+    Note.note_distance('B1', 'F1')      # => -6
+    Note.note_distance('G#1', 'Ab1')    # => 0
+
+Adjust frequencies by semitones:
+
+    Note.frequency_adjustment(440.0, 15)    # => 1046.50
+
+Create chords:
+
+    chord = Chord.new(['C4', 'E4', 'G4'])   # Create a C major chord
+
+Describe chords:
+
+    Chord.new(['C4', 'Eb4', 'Gb4'])     # => ['C', :diminished]
+
+*For further usage, see the examples in the spec files*
+
+Contributing to music
+=====================
+
+Contributions are welcome.  Check out the issues list and feel free to fork and make a pull request if you have any fixes/additions.
+
+Copyright
+=========
+
+Copyright (c) 2012 Brian Underwood. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+task :default => [:spec]
+
+desc "Run all test"
+task :test => [:spec]
+
+# RSpec tasks
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.ruby_opts = '-I lib'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--color --format doc']
+end
+
+# Gems tasks
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+desc "Clean automatically generated files"
+task :clean do
+  FileUtils.rm_rf "pkg"
+end
+

data/lib/music.rb

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

data/lib/music/chord.rb

@@ -0,0 +1,36 @@
+module Music
+  class Chord
+    def initialize(notes)
+      @notes = notes.collect do |note|
+        if note.is_a?(Note)
+          note
+        else
+          Note.new(note)
+        end
+      end.sort
+    end
+
+    def note_strings
+      @notes.collect(&:note_string)
+    end
+
+    def describe
+      distances = (1...@notes.size).collect do |i|
+        @notes[0].distance_to(@notes[i])
+      end
+
+      quality = case distances
+      when [4, 7]
+        :major
+      when [3, 7]
+        :minor
+      when [3, 6]
+        :diminished
+      when [4, 8]
+        :augmented
+      end
+
+      [@notes.first.letter, quality]
+    end
+  end
+end

data/lib/music/note.rb

@@ -0,0 +1,148 @@
+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']
+    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
+    end
+
+    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
+    end
+
+    def note_string(give_flat = false)
+      Note.calculate_note(self.frequency, give_flat).join
+    end
+
+    def letter(give_flat = false)
+      Note.calculate_note(self.frequency, give_flat)[0]
+    end
+
+    def accidental(give_flat = false)
+      Note.calculate_note(self.frequency, give_flat)[1]
+    end
+
+    def octave
+      Note.calculate_note(self.frequency)[2]
+    end
+
+    def pred
+      Note.new(Note.frequency_adjustment(self.frequency, -1))
+    end
+
+    def succ
+      Note.new(Note.frequency_adjustment(self.frequency, 1))
+    end
+    alias :next :succ
+
+    def distance_to(note)
+      Note.note_distance(self.note_string, note.note_string)
+    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))
+
+        octave = match[3].present? ? match[3] : assumed_octave
+        [match[1].upcase, match[2] == '' ? nil : match[2], octave.to_i]
+      end
+
+      def note_distance(note_string1, note_string2)
+        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)
+          end
+        end
+
+        index1 = get_index.call(letter1, accidental1)
+        index2 = get_index.call(letter2, accidental2)
+
+        (index2 - index1) + ((octave2.to_i - octave1.to_i) * NOTES.size)
+      end
+
+      def frequency_adjustment(start_frequency, distance)
+        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
+      end
+
+      def calculate_frequency(*args)
+        case args.size
+        when 1
+          letter, accidental, octave = parse_note_string(args[0])
+        when 2
+          letter, accidental, octave = parse_note_string(args[0], args[1])
+        when 3
+          letter, accidental, octave = args
+        else
+          raise ArgumentError, "Invalid octave of arguments"
+        end
+
+        distance = note_distance('A4', "#{letter}#{accidental}#{octave}")
+
+        frequency_adjustment(440.0, distance)
+      end
+
+      def calculate_note(frequency, give_flat = false)
+        # Would like to use #log(frequency / 440.0, 2), but would like to support Ruby 1.8
+        frequency_log_base_2 = Math.log(frequency / 440.0) / Math.log(2)
+
+        distance = (NOTES.size * frequency_log_base_2).round
+
+        index = 9 + distance # 9 is index for A
+
+        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
+
+        "#{note}#{octave}"
+        note_parts = note.split('')
+        note_parts + (note_parts.size == 1 ? [nil] : []) + [octave.to_i]
+      end
+
+      def nearest_note_frequency(frequency)
+        Note.calculate_frequency(Note.calculate_note(frequency).join)
+      end
+
+    end
+  end
+end

data/lib/music/patches/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def flip
+    Hash[*self.to_a.collect(&:reverse).flatten]
+  end
+end

data/lib/music/version.rb

@@ -0,0 +1,3 @@
+module Music
+  VERSION = '0.5.0'
+end

data/music.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "music/version"
+
+Gem::Specification.new do |s|
+  # Basic Info
+  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}
+
+  # 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"]
+  
+  # Ruby Gems Version
+  s.required_rubygems_version = ">= 1.8"
+
+  # Dependencies
+  s.add_development_dependency  "rake", ">= 0.9"
+  s.add_development_dependency  "bundler", ">= 1.1.3"
+  s.add_development_dependency  "rspec"
+  s.add_development_dependency  "activemodel", '>= 3.2.0'
+end

data/spec/classes/chord_spec.rb

@@ -0,0 +1,55 @@
+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')]
+  end
+
+  describe '#new(notes)' do
+    it 'should take an array of Note objects' do
+      Chord.new(@standard_tuning_notes)
+    end
+
+    it 'should take an array of note strings' 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']
+    end
+  end
+
+  describe '#note_strings' do
+    it 'should return an array of note strings' do
+      chord = Chord.new(@standard_tuning_notes)
+
+      chord.note_strings.should == @standard_tuning_notes.collect(&:note_string)
+    end
+  end
+
+  describe '#describe' do
+    describe 'major chords' do
+      it 'should recognize C major' do
+        Chord.new(['C4', 'E4', 'G4']).describe.should == ['C', :major]
+      end
+    end
+
+    describe 'minor chords' do
+      it 'should recognize C minor' do
+        Chord.new(['C4', 'Eb4', 'G4']).describe.should == ['C', :minor]
+      end
+    end
+
+    describe 'diminished chords' do
+      it 'should recognize C diminished' do
+        Chord.new(['C4', 'Eb4', 'Gb4']).describe.should == ['C', :diminished]
+      end
+    end
+
+    describe 'augmented chords' do
+      it 'should recognize C augmented' do
+        Chord.new(['C4', 'E4', 'G#4']).describe.should == ['C', :augmented]
+      end
+    end
+  end
+end

data/spec/classes/hash_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'music/patches/hash'
+
+describe Hash do
+  describe '#flip' do
+    it "Should reverse keys and values" do
+      {1 => 2, 3 => 4}.flip.should == {2 => 1, 4 => 3}
+
+      {'foo' => 'bar', 'baz' => 'bitz'}.flip.should == {'bitz' => 'baz', 'bar' => 'foo'}
+    end
+
+    it "Should return an empty hash from an empty hash" do
+      {}.flip.should == {}
+    end
+  end
+
+end

data/spec/classes/note_spec.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+include Music
+
+describe Music::Note do
+
+  describe "#new" do
+    it "should allow note strings to initalize notes" do
+      Note.new('E0').frequency.should == 20.60
+      Note.new('Bb3').frequency.should == 233.08
+    end
+
+    it "should allow frequencies to initalize notes" do
+      Note.new(698.46).note_string.should == 'F5'
+      Note.new(1975.53).note_string.should == 'B6'
+    end
+  end
+
+  describe "Comparing notes" do
+    it "should compare notes by their frequencies" do
+      Note.new(698.46).should < Note.new(1975.53)
+      Note.new('B5').should > Note.new('B2')
+      Note.new(698.46).should == Note.new('F5')
+    end
+  end
+
+  describe '#note_string' do
+    it 'Should return the letter, accidental, and octave as a string' do
+      Note.new(698.46).note_string.should == 'F5'
+      Note.new('C#6').note_string.should == 'C#6'
+    end
+
+    it 'Should return the flat version if asked' do
+      Note.new('C#6').note_string(true).should == 'Db6'
+    end
+  end
+
+  describe '#letter' do
+    it 'Should return just the letter' do
+      Note.new('E0').letter.should == 'E'
+      Note.new(698.46).letter.should == 'F'
+      Note.new(1975.53).letter.should == 'B'
+    end
+
+    it 'Should return the letter based on if asked for the flat' do
+      Note.new('Bb3').letter.should == 'A'
+      Note.new('Bb3').letter(true).should == 'B'
+    end
+  end
+
+  describe '#accidental' do
+    it 'Should return just the accidental' do
+      Note.new('A#4').accidental.should == '#'
+    end
+
+    it 'Should return the flat if asked for' do
+      Note.new('Bb3').accidental.should == '#'
+      Note.new('Bb3').accidental(true).should == 'b'
+    end
+
+    it 'Should return nil for no accidental' do
+      Note.new('B2').accidental.should == nil
+      Note.new('G2').accidental.should == nil
+    end
+  end
+
+  describe '#octave' do
+    it 'Should return the octave' do
+      Note.new('A#4').octave.should == 4
+      Note.new('B7').octave.should == 7
+      Note.new('Gb1').octave.should == 1
+      Note.new('E0').octave.should == 0
+    end
+  end
+
+  describe ".parse_note_string(note_string)" do
+    it "Should split note letter, accidental, and octave" do
+      Note.parse_note_string('A#1').should == ['A', '#', 1]
+      Note.parse_note_string('Cb4').should == ['C', 'b', 4]
+    end
+
+    it "Should allow for lower case notes" do
+      Note.parse_note_string('g#1').should == ['G', '#', 1]
+    end
+
+    it "Should allow for an assumed octave" do
+      Note.parse_note_string('A', 4).should == ['A', nil, 4]
+      Note.parse_note_string('C#', 6).should == ['C', '#', 6]
+    end
+
+    it "Should ignore the assumed octave if there is a octave" do
+      Note.parse_note_string('B3', 4).should == ['B', nil, 3]
+      Note.parse_note_string('Gb6', 2).should == ['G', 'b', 6]
+    end
+
+    it "Should not allow notes above G" do
+      expect { Note.parse_note_string('HB1') }.to raise_error ArgumentError
+    end
+
+    it "Should not allow extraneous characters" do
+      expect { Note.parse_note_string(' Ab1') }.to raise_error ArgumentError
+      expect { Note.parse_note_string('%Hb1') }.to raise_error ArgumentError
+      expect { Note.parse_note_string('Hb1-') }.to raise_error ArgumentError
+    end
+
+    it "Should not allow for upper case flats" do
+      expect { Note.parse_note_string('AB1') }.to raise_error ArgumentError
+      expect { Note.parse_note_string('aB1') }.to raise_error ArgumentError
+    end
+
+    it "Should return nil when there is no accidental" do
+      Note.parse_note_string('C4').should == ['C', nil, 4]
+    end
+
+    it "Should not allow note above octave 8" do
+      Note.parse_note_string('G#8').should == ['G', '#', 8]
+      expect { Note.parse_note_string('Ab9') }.to raise_error ArgumentError
+      expect { Note.parse_note_string('Ab', 9) }.to raise_error ArgumentError
+    end
+  end
+
+  describe ".note_distance(note_string1, note_string2)" do
+    {
+      ['A4', 'A#4'] => 1,
+      ['A4', 'Ab4'] => -1,
+      ['B0', 'B0'] => 0,
+      ['G#1', 'Ab1'] => 0,
+      ['Bb1', 'A#1'] => 0,
+      ['A3', 'A4'] => 12,
+      ['a3', 'A4'] => 12,
+      ['B1', 'F1'] => -6,
+      ['B1', 'f1'] => -6,
+      ['A4', 'Eb0'] => -54,
+      ['a4', 'eb0'] => -54,
+      ['A2', 'C4'] => 15
+    }.each do |notes, distance|
+      it "Should return #{distance} between #{notes[0]} and #{notes[1]}" do
+        Note.note_distance(*notes).should == distance
+      end
+    end
+
+    it "Should not allow invalid note strings" do
+      expect { Note.note_distance('H0', 'A0') }.to raise_error ArgumentError
+      expect { Note.note_distance('A0', 'I#0') }.to raise_error ArgumentError
+      expect { Note.note_distance('A%0', 'A0') }.to raise_error ArgumentError
+    end
+  end
+
+  describe '#distance_to(note)' do
+    it 'Should find the distance between the subject note object and the note passed in' do
+      Note.new('A2').distance_to(Note.new('C4')).should == 15
+    end
+  end
+
+  describe ".calculate_frequency(letter, accidental, octave)" do
+    {
+      ['C', nil, 0] => 16.35,
+      ['E', 'b', 0] => 19.45,
+      ['A', '#', 1] => 58.27,
+      ['B', 'b', 1] => 58.27,
+      ['A', 'b', 4] => 415.30,
+      ['A', nil, 4] => 440.00,
+      ['A', '#', 4] => 466.16,
+      ['B', nil, 6] => 1975.53,
+      ['C', nil, 7] => 2093.00,
+      ['E', 'b', 8] => 4978.03
+    }.each do |note_array, frequency|
+      it "Should return #{frequency} for #{note_array.join}" do
+        Note.calculate_frequency(*note_array).should == frequency
+      end
+    end
+
+    it "Should take note strings as an argument" do
+      Note.calculate_frequency('A#1').should == 58.27
+      Note.calculate_frequency('A4').should == 440.00
+      Note.calculate_frequency('C7').should == 2093.00
+    end
+
+    it "Should allow lower case notes" do
+      Note.calculate_frequency('a#1').should == 58.27
+      Note.calculate_frequency('db2').should == 69.3
+      Note.calculate_frequency('e', nil, 3).should == 164.81
+    end
+
+    it "Should not take argument lengths above 3" do
+      expect { Note.calculate_frequency('A', nil, 0, 0) }.to raise_error ArgumentError
+    end
+
+    it "Should not allow invalid notes" do
+      expect { Note.calculate_frequency('H', nil, 0) }.to raise_error ArgumentError
+      expect { Note.calculate_frequency('I', nil, 0) }.to raise_error ArgumentError
+    end
+
+    it "Should not allow invalid accidentals" do
+      expect { Note.calculate_frequency('A', 5, 0) }.to raise_error ArgumentError
+      expect { Note.calculate_frequency('A', '&', 0) }.to raise_error ArgumentError
+    end
+
+    it "Should not allow invalid octaves" do
+      expect { Note.calculate_frequency('A', nil, -1) }.to raise_error ArgumentError
+      expect { Note.calculate_frequency('A', nil, 9) }.to raise_error ArgumentError
+    end
+  end
+
+  describe ".calculate_note(frequency)" do
+    test_frequencies = {
+      [16.35] => ['C', nil, 0],
+      [19.45, true] => ['E', 'b', 0],
+      [58.27] => ['A', '#', 1],
+      [58.27, true] => ['B', 'b', 1],
+      [415.30, true] => ['A', 'b', 4],
+      [440.00] => ['A', nil, 4],
+      [466.16] => ['A', '#', 4],
+      [1975.53] => ['B', nil, 6],
+      [2093.00] => ['C', nil, 7],
+      [4978.03, true] => ['E', 'b', 8]
+    }
+
+    test_frequencies.each do |args, note_string|
+      it "Should return #{note_string} for #{args[0]}#{args[1] && ' (giving flat)'}" do
+        Note.calculate_note(*args).should == note_string
+      end
+    end
+
+    it "Should calculate the closest note near to a frequency" do
+      Note.calculate_note(420, true).should == ['A', 'b', 4]
+      Note.calculate_note(430).should == ['A', nil, 4]
+    end
+  end
+
+  describe ".nearest_note_frequency(frequency)" do
+    it 'should return the frequency if it is the frequency of a note' do
+      Note.nearest_note_frequency(2093.00).should == 2093.00
+    end
+
+    it 'should return the nearest frequency which matches a note' do
+      Note.nearest_note_frequency(41.00).should == 41.20
+      Note.nearest_note_frequency(40.50).should == 41.20
+      Note.nearest_note_frequency(40.00).should == 38.89
+      Note.nearest_note_frequency(39.00).should == 38.89
+    end
+  end
+
+  describe ".frequency_adjustment(start_frequency, distance)" do
+    it "Should find frequencies based on start frequency and distance" do
+      Note.frequency_adjustment(440.0, 0).should == 440.0
+      Note.frequency_adjustment(440.0, 15).should == 1046.50
+      Note.frequency_adjustment(440.0, -10).should == 246.94
+
+      Note.frequency_adjustment(1479.98, -6).should == 1046.50
+      Note.frequency_adjustment(1479.98, 7).should == 2217.46
+    end
+  end
+
+  describe "Getting adjacent notes" do
+    it "should allow getting of next note" do
+      Note.new(698.46).next.should == Note.new(739.99)
+      Note.new(698.46).succ.should == Note.new(739.99)
+    end
+
+    it "should allow getting of previous note" do
+      Note.new(739.99).pred.should == Note.new(698.46)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'music'

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'music'
+
+class Test::Unit::TestCase
+end

data/test/test_music.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestMusic < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification 
+name: music
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: 
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Brian Underwood
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 1
+        - 3
+        version: 1.1.3
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 2
+        - 0
+        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: 
+- ml+musicgem@semi-sentient.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .document
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/music.rb
+- lib/music/chord.rb
+- lib/music/note.rb
+- lib/music/patches/hash.rb
+- lib/music/version.rb
+- music.gemspec
+- spec/classes/chord_spec.rb
+- spec/classes/hash_spec.rb
+- spec/classes/note_spec.rb
+- spec/spec_helper.rb
+- test/helper.rb
+- test/test_music.rb
+homepage: http://github.com/cheerfulstoic/music
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 31
+      segments: 
+      - 1
+      - 8
+      version: "1.8"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Library for performing calculations on musical elements
+test_files: 
+- spec/classes/chord_spec.rb
+- spec/classes/hash_spec.rb
+- spec/classes/note_spec.rb
+- spec/spec_helper.rb
+has_rdoc: