rb-music 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53f397b83b876fe6811b1244eb54176e4235abdb
+  data.tar.gz: ae41a88a15cf8aa76fb0fff1c955b29408d7daa4
+SHA512:
+  metadata.gz: 0aeaace498dede1b9c25c28094d7b94ab0f4dec3f37435844fc3f9f1338e278924d0f0543615e9859344d876323b94c01fc0b8e26066cb22044a60ddb2a3cbda
+  data.tar.gz: 3831325e305d9df64dca46d01809ae8d9c52c65ec31f52a2ce4912af6b5a572dbed3a3702d50596762500709f98f8db3d8ab293d763e7aabd140a81d015299c3

data/LICENSE

@@ -0,0 +1,23 @@
+LICENSE
+
+The MIT License
+
+Copyright (c) 2014 Mark Wise
+
+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,53 @@
+# rb-music
+
+**rb-music** is a Ruby gem for working with musical notes, scales and intervals. It is basically a direct port of the wonderful [music.js](https://github.com/gregjopa/music.js) library by Greg Jopa.
+
+## Installation
+
+In your Gemfile:
+
+```
+gem 'rb-music', git: 'https://github.com/mwise/rb-music', branch: 'master'
+```
+
+In your Ruby code:
+
+```
+require 'rb-music'
+```
+
+## Overview
+
+### Note
+
+`Note.from_latin(name)`: Note by latin name and octave
+
+```ruby
+n = Note.from_latin('A4');  # single note
+n.frequency  # 440
+n.latin  # "A"
+n.octave # 4
+n.midi_note_number # 69
+
+n = Note.from_latin('C4')  # base note for scale
+n.scale('major') #  NoteSet built from the given note and scale
+```
+
+### Interval
+
+`Interval.from_name(name)`: Interval by name
+
+`Interval.from_semitones(num)`: Interval by semitones
+
+```ruby
+Interval.from_name('fifth') # define by name
+whole_step = Interval.from_semitones(2) # define by # of semitones
+
+c = Note.from_latin('C3')
+
+# use intervals to transpose notes
+d = c.add(whole_step)
+
+# use intervals to define chords
+cmaj = c.add(['unison','major third','fifth'])
+```

data/lib/motion-music/version.rb

@@ -0,0 +1,3 @@
+module MotionMusic
+  VERSION = "0.0.0" unless defined? MotionMusic::VERSION
+end

data/lib/motion-music.rb

@@ -0,0 +1,9 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'rb-music/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/lib/rb-music/constants.rb

@@ -0,0 +1,105 @@
+module RBMusic
+  Error = Class.new(StandardError)
+  ArgumentError = Class.new(ArgumentError)
+
+  NOTE_NAMES = ["F", "C", "G", "D", "A", "E", "B"]
+  ACCIDENTALS = ["bb", "b", "", "#", "x"]
+
+  # notes - two dimensional [octave, fifth] - relative to the 'main' note
+  NOTES = {
+    "Fbb" => [10, -17],
+    "Cbb" => [10, -16],
+    "Gbb" => [9, -15],
+    "Dbb" => [8, -14],
+    "Abb" => [8, -13],
+    "Ebb" => [7, -12],
+    "Bbb" => [7, -11],
+
+    "Fb" => [6, -10],
+    "Cb" => [5, -9],
+    "Gb" => [5, -8],
+    "Db" => [4, -7],
+    "Ab" => [4, -6],
+    "Eb" => [3, -5],
+    "Bb" => [3, -4],
+
+    "F" => [2, -3],
+    "C" => [1, -2],
+    "G" => [1, -1],
+    "D" => [0, 0],
+    "A" => [0, 1],
+    "E" => [-1, 2],
+    "B" => [-1, 3],
+
+    "F#" => [-2, 4],
+    "C#" => [-3, 5],
+    "G#" => [-3, 6],
+    "D#" => [-4, 7],
+    "A#" => [-4, 8],
+    "E#" => [-5, 9],
+    "B#" => [-5, 10],
+
+    "Fx" => [-6, 11],
+    "Cx" => [-7, 12],
+    "Gx" => [-7, 13],
+    "Dx" => [-8, 14],
+    "Ax" => [-8, 15],
+    "Ex" => [-9, 16],
+    "Bx" => [-10, 17]
+  }
+
+  BASE_FREQ = 440  # A4 'main' note
+  BASE_OFFSET = [4, 1]  # offset of base note from D0
+
+  # intervals - two dimensional [octave, fifth] - relative to the 'main' note
+  INTERVALS = {
+    unison:           [0, 0],
+    minor_second:     [3, -5],
+    major_second:     [-1, 2],
+    minor_third:      [2, -3],
+    major_third:      [-2, 4],
+    fourth:           [1, -1],
+    augmented_fourth: [-3, 6],
+    tritone:          [-3, 6],
+    diminished_fifth: [4, -6],
+    fifth:            [0, 1],
+    minor_sixth:      [3, -4],
+    major_sixth:      [-1, 3],
+    minor_seventh:    [2, -2],
+    major_seventh:    [-2, 5],
+    octave:           [1, 0]
+  }
+
+  INTERVALS_SEMITONES = {
+    0 =>  [0, 0],
+    1 =>  [3, -5],
+    2 =>  [-1, 2],
+    3 =>  [2, -3],
+    4 =>  [-2, 4],
+    5 =>  [1, -1],
+    6 =>  [-3, 6],
+    7 =>  [0, 1],
+    8 =>  [3, -4],
+    9 =>  [-1, 3],
+    10 => [2, -2],
+    11 => [-2, 5],
+    12 => [1, 0]
+  }
+
+  SCALES = {
+    major: [:major_second, :major_third, :fourth, :fifth, :major_sixth, :major_seventh],
+    natural_minor: [:major_second, :minor_third, :fourth, :fifth, :minor_sixth, :minor_seventh],
+    harmonic_minor: [:major_second, :minor_third, :fourth, :fifth, :minor_sixth, :major_seventh],
+    major_pentatonic: [:major_second, :major_third, :fifth, :major_sixth],
+    minor_pentatonic: [:minor_third, :fourth, :fifth, :minor_seventh],
+    blues: [:minor_third, :fourth, :augmented_fourth, :fifth, :minor_seventh],
+    dorian: [:major_second, :minor_third, :fourth, :fifth, :major_sixth, :minor_seventh],
+    phrygian: [:minor_second, :minor_third, :fourth, :fifth, :major_sixth, :minor_seventh],
+    lydian: [:major_second, :major_third, :augmented_fourth, :fifth, :major_sixth, :major_seventh],
+    mixolydian: [:major_second, :major_third, :fourth, :fifth, :major_sixth, :minor_seventh],
+    locrian: [:minor_second, :minor_third, :fourth, :diminished_fifth, :minor_sixth, :minor_seventh],
+  }
+  SCALES[:ionian] = SCALES[:major]
+  SCALES[:aeolian] = SCALES[:natural_minor]
+
+end

data/lib/rb-music/interval.rb

@@ -0,0 +1,50 @@
+module RBMusic
+
+  class Interval
+    attr_accessor :coord
+
+    def initialize(coord)
+      self.coord = coord
+    end
+
+    def self.from_name(name)
+      Interval.new(INTERVALS[name.to_sym])
+    end
+
+    def self.from_semitones(num)
+      Interval.new(INTERVALS_SEMITONES[num])
+    end
+
+    def self.from_tones_semitones(tone_semitone)
+      # multiply [tones, semitones] vector with [-1 2;3 -5] to get coordinate from tones and semitones
+      Interval.new([tone_semitone[0] * -1 + tone_semitone[1] * 3, tone_semitone[0] * 2 + tone_semitone[1] * -5])
+    end
+
+    def tone_semitone
+      # multiply coord vector with [5 2;3 1] to get coordinate in tones and semitones
+      # [5 2;3 1] is the inverse of [-1 2;3 -5], which is the coordinates of [tone; semitone]
+      @tone_semitone ||= [coord[0] * 5 + coord[1] * 3, coord[0] * 2 + coord[1] * 1]
+    end
+
+    def semitone
+      # number of semitones of interval = tones * 2 + semitones
+      tone_semitone[0] * 2 + tone_semitone[1]
+    end
+
+    def add(interval)
+      if interval.is_a?(String)
+        interval = Interval.from_name(interval)
+      end
+      Interval.new([coord[0] + interval.coord[0], coord[1] + interval.coord[1]])
+    end
+
+    def subtract(interval)
+      if interval.is_a?(String)
+        interval = Interval.from_name(interval)
+      end
+      Interval.new([coord[0] - interval.coord[0], coord[1] - interval.coord[1]])
+    end
+
+  end
+
+end

data/lib/rb-music/note.rb

@@ -0,0 +1,107 @@
+module RBMusic
+
+  class Note
+    attr_accessor :coord
+
+    def initialize(coord)
+      self.coord = coord
+    end
+
+    def self.from_latin(name)
+      raise ArgumentError unless name.is_a?(String)
+
+      note_parts = name.split(/(\d+)/)
+      note_name = note_parts.first
+      octave = note_parts.last.to_i
+
+      unless NOTES.has_key?(note_name) && note_parts.size < 3
+        raise ArgumentError
+      end
+
+      coordinate = [NOTES[note_name][0] + octave, NOTES[note_name][1]]
+
+      coordinate[0] -= BASE_OFFSET[0]
+      coordinate[1] -= BASE_OFFSET[1]
+
+      Note.new(coordinate)
+    end
+
+    def frequency
+      BASE_FREQ * (2.0 ** ((coord[0] * 1200 + coord[1] * 700.0) / 1200.0))
+    end
+
+    def accidental
+      @accidental ||= ((coord[1] + BASE_OFFSET[1]) / 7.0).round
+    end
+
+    def octave
+      # calculate octave of base note without accidentals
+      @octave ||= coord[0] + BASE_OFFSET[0] + 4 * accidental + ((coord[1] + BASE_OFFSET[1] - 7 * accidental) / 2).floor
+    end
+
+    def latin
+      return @latin if @latin
+      accidentalName = ACCIDENTALS[accidental + 2]
+      @latin ||= base_note_name + accidentalName
+    end
+
+    def ==(other)
+      other.is_a?(Note) && other.latin == latin && other.octave == octave
+    end
+
+    def enharmonic?(other)
+      raise ArgumentError unless other.is_a?(Note)
+
+      other.frequency == frequency
+    end
+    alias_method :enharmonically_equivalent_to?, :enharmonic?
+
+    def midi_note_number
+      # see http://www.phys.unsw.edu.au/jw/notes.html
+      12 * Math.log2(frequency / 440) + 69
+    end
+
+    def scale(name, octaves = 1)
+      NoteSet.from_scale(Scale.new(latin, name), octave, octaves)
+    end
+
+    def add(that)
+      # if input is an array return an array
+      if that.is_a?(Array)
+        notes = that.map { |thing| add(thing) }
+        return NoteSet.new(notes)
+      end
+
+      # if input is string/symbol try to parse it as interval
+      if that.is_a?(String) || that.is_a?(Symbol)
+        that = Interval.from_name(that)
+      end
+
+      Note.new([coord[0] + that.coord[0], coord[1] + that.coord[1]])
+    end
+
+    def subtract(that)
+      if that.is_a?(Array)
+        notes = that.map { |thing| subtract(thing) }
+        return NoteSet.new(notes)
+      end
+
+      # if input is string try to parse it as interval
+      if that.is_a?(String) || that.is_a?(Symbol)
+        that = Interval.from_name(that)
+      end
+
+      coordinate = [coord[0] - that.coord[0], coord[1] - that.coord[1]]
+
+      # if input is another note return the difference as an Interval
+      that.is_a?(Note) ? Interval.new(coordinate) : Note.new(coordinate)
+    end
+
+    private
+
+    def base_note_name
+      @base_note_name ||= NOTE_NAMES[coord[1] + BASE_OFFSET[1] - accidental * 7 + 3]
+    end
+  end
+
+end

data/lib/rb-music/note_set.rb

@@ -0,0 +1,61 @@
+module RBMusic
+
+  class NoteSet
+    include Enumerable
+
+    attr_accessor :notes
+
+    def initialize(notes = [])
+      @notes = notes
+    end
+
+    def self.from_scale(scale, octave=0, octaves=1)
+      raise ArgumentError unless scale.is_a?(Scale) && octaves > 0
+
+      root_note = Note.from_latin("#{scale.key}#{octave}")
+      notes = []
+      octaves.times do |i|
+        notes += scale.degrees.map do |interval_name|
+          note = root_note.add(interval_name)
+          i.times do |octave_offset|
+            note = note.add(:octave)
+          end
+          note
+        end
+      end
+
+      self.new(notes)
+    end
+
+    def each(&block)
+      @notes.each(&block)
+    end
+
+    def [](index)
+      @notes[index]
+    end
+
+    def <<(other)
+      @notes << other
+    end
+
+    def map(&block)
+      @notes.map(&block)
+    end
+
+    def ==(other)
+      @notes == other.notes
+    end
+    alias_method :eql?, :==
+
+    def add(that)
+      NoteSet.new(@notes.map { |note| note.add(that) })
+    end
+
+    def subtract(that)
+      NoteSet.new(@notes.map { |note| note.subtract(that) })
+    end
+
+  end
+
+end

data/lib/rb-music/scale.rb

@@ -0,0 +1,30 @@
+module RBMusic
+
+  class Scale
+    attr_reader :key
+    attr_reader :degrees
+
+    def initialize(key, name)
+      @scale_name = name.to_sym
+      raise ArgumentError unless NOTES.has_key?(key)
+      raise ArgumentError unless SCALES.has_key?(@scale_name)
+      @key = key
+      @degrees = [:unison] + SCALES[@scale_name]
+    end
+
+    def degree_count
+      @degree_count ||= @degrees.size
+    end
+    alias_method :size, :degree_count
+
+    def name
+      @name ||= "#{key} #{human_scale_name}"
+    end
+
+    private
+    def human_scale_name
+      @scale_name.to_s.split("_").map { |word| word.capitalize }.join(" ")
+    end
+  end
+
+end

data/lib/rb-music/version.rb

@@ -0,0 +1,3 @@
+module RBMusic
+  VERSION = "0.0.1" unless defined? RBMusic::VERSION
+end

data/lib/rb-music.rb

@@ -0,0 +1,8 @@
+dir = File.dirname(__FILE__) + '/rb-music'
+require dir + '/constants'
+require dir + '/note'
+require dir + '/scale'
+require dir + '/note_set'
+require dir + '/interval'
+
+include RBMusic

data/spec/rb-music/constants_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../spec_helper'
+
+describe "RBMusic Constants" do
+
+  describe RBMusic::NOTE_NAMES do
+    it "is correct" do
+      subject.should == ["F", "C", "G", "D", "A", "E", "B"]
+    end
+  end
+
+  describe RBMusic::ACCIDENTALS do
+    it "is correct" do
+      subject.should == ["bb", "b", "", "#", "x"]
+    end
+  end
+
+  describe RBMusic::NOTES do
+    it "contains a key for each note/accidental combination" do
+      RBMusic::NOTE_NAMES.each do |note_name|
+        ACCIDENTALS.each do |accidental|
+          NOTES.should have_key("#{note_name}#{accidental}")
+        end
+      end
+    end
+  end
+
+end

data/spec/rb-music/interval_spec.rb

@@ -0,0 +1,90 @@
+require_relative '../spec_helper'
+
+describe RBMusic::Interval do
+
+  context "after initialization" do
+    let(:subject) { described_class.new("some coord") }
+
+    it "assigns the coord argument" do
+      subject.coord.should == "some coord"
+    end
+  end
+
+  describe "class methods" do
+    describe "#from_name" do
+      it "looks up the correct coordinates" do
+        subject = described_class.from_name("major_second")
+
+        subject.coord.should == described_class::INTERVALS[:major_second]
+      end
+    end
+
+    describe "#from_semitones" do
+      it "looks up the correct coordinates" do
+        subject = described_class.from_semitones(3)
+
+        subject.coord.should == described_class::INTERVALS_SEMITONES[3]
+      end
+    end
+
+    describe "#from_tones_semitones" do
+      it "looks up the correct coordinates" do
+        subject = described_class.from_tones_semitones([0, 3])
+
+        subject.coord.should == [9, -15]
+      end
+    end
+  end
+
+  describe "instance methods" do
+    let(:subject) { described_class.from_name("major_second") }
+
+    describe "#tone_semitone" do
+      it "returns the tone / semitone vector" do
+        subject.tone_semitone.should == [1, 0]
+      end
+    end
+
+    describe "#semitone" do
+      it "returns number of semitones" do
+        subject.semitone.should == 2
+      end
+    end
+
+    describe "#add" do
+      context "when given a string" do
+        it "adds the string as an Interval" do
+          result = subject.add("major_second")
+          result.coord.should == Interval.from_name("major_third").coord
+        end
+      end
+
+      context "when given an Interval" do
+        it "adds the given Interval's coordinates and returns a new Interval" do
+          result = subject.add(described_class.from_name("minor_second"))
+          result.coord.should == Interval.from_name("minor_third").coord
+        end
+      end
+    end
+
+    describe "#subtract" do
+      context "when given a string" do
+        it "returns a Interval with the given string as Interval subtracted" do
+          result = subject.subtract("major_second")
+          result.coord.should == Interval.from_name("unison").coord
+        end
+      end
+
+      context "when given an Interval" do
+        it "subtracts the coordinates of the given Interval and returns a new Interval" do
+          subject = described_class.from_name("major_third")
+          result = subject.subtract(described_class.from_name("major_second"))
+
+          result.coord.should == Interval.from_name("major_second").coord
+        end
+      end
+    end
+
+  end
+
+end

data/spec/rb-music/note_set_spec.rb

@@ -0,0 +1,191 @@
+require_relative '../spec_helper'
+
+describe RBMusic::NoteSet do
+
+  describe "class methods" do
+    describe "#from_scale" do
+      let(:scale) { RBMusic::Scale.new("C", "major") }
+
+      context "without any arguments" do
+        it "raises an ArgumentError"  do
+          lambda {
+            described_class.from_scale
+          }.should raise_error(ArgumentError)
+        end
+      end
+
+      context "without a valid RBMusic::Scale" do
+        it "raises an ArgumentError"  do
+          lambda {
+            described_class.from_scale("foo")
+          }.should raise_error(RBMusic::ArgumentError)
+        end
+      end
+
+      context "with a RBMusic::Scale only" do
+        let(:subject) { described_class.from_scale(scale) }
+
+        it "returns a #{described_class}" do
+          subject.should be_a(described_class)
+        end
+
+        it "builds a note for each scale degree in the default octave ranage (1)" do
+          subject.notes.length.should == scale.degree_count
+        end
+
+        it "builds notes from the default octave (0)" do
+          subject.notes[0].should == Note.from_latin("#{scale.key}0")
+        end
+      end
+
+      context "with a RBMusic::Scale and an octave" do
+        let(:octave) { 3 }
+        let(:subject) { described_class.from_scale(scale, octave) }
+
+        it "builds notes for the scale from the given octave" do
+          subject.notes[0].should == Note.from_latin("#{scale.key}#{octave}")
+          subject.notes.length.should == scale.degree_count
+        end
+      end
+
+      context "with a RBMusic::Scale, octave and octave range" do
+        let(:octave) { 3 }
+        let(:octaves) { 2 }
+        let(:subject) { described_class.from_scale(scale, octave, octaves) }
+
+        it "builds notes for the given octave range" do
+          degrees = scale.degree_count
+
+          subject.notes[0].should == Note.from_latin("#{scale.key}#{octave}")
+          subject.notes[degrees].should == Note.from_latin("#{scale.key}#{octave + 1}")
+          subject.notes.length.should == scale.degree_count * octaves
+        end
+      end
+
+      context "with an invalid octave range" do
+        it "raises an ArgumentError" do
+          lambda {
+            described_class.from_scale(scale, 3, -1)
+          }.should raise_exception(RBMusic::ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe "instance methods" do
+
+    describe "#initialize" do
+      let(:notes_array) { ["foo", "bar"] }
+
+      it "assigns the notes array" do
+        subject = described_class.new(notes_array)
+
+        subject.notes.should == notes_array
+      end
+    end
+
+    describe "#==" do
+      let(:notes) { ["foo", "bar"] }
+
+      context "when all the notes are equal" do
+        it "is true" do
+          described_class.new(notes).should == described_class.new(notes)
+        end
+      end
+
+      context "when note all the notes are equal" do
+        it "is false" do
+          described_class.new(notes).should_not == described_class.new([1, 2])
+        end
+      end
+    end
+
+    describe "#add" do
+      let(:f4) { Note.from_latin("F4") }
+      let(:g4) { Note.from_latin("G4") }
+      let(:subject) { NoteSet.new([f4, g4]) }
+
+      context "when adding an interval string" do
+        let(:operand) { "major_second" }
+
+        it "retuns a new NoteSet with the operand added to each element of the original" do
+          result = subject.add(operand)
+
+          result.should be_a(NoteSet)
+          result[0].frequency.should == subject[0].add(operand).frequency
+          result[1].frequency.should == subject[1].add(operand).frequency
+        end
+      end
+
+      context "when adding an interval symbol" do
+        let(:operand) { :major_second }
+
+        it "retuns a new NoteSet with the operand added to each element of the original" do
+          result = subject.add(operand)
+
+          result.should be_a(NoteSet)
+          result[0].frequency.should == subject[0].add(operand).frequency
+          result[1].frequency.should == subject[1].add(operand).frequency
+        end
+      end
+
+      context "when adding an note" do
+        let(:operand) { Note.from_latin("C4") }
+
+        it "retuns a new NoteSet with the operand added to each element of the original" do
+          result = subject.add(operand)
+
+          result.should be_a(NoteSet)
+          result[0].frequency.should == subject[0].add(operand).frequency
+          result[1].frequency.should == subject[1].add(operand).frequency
+        end
+      end
+
+    end
+
+    describe "#subtract" do
+      let(:f4) { Note.from_latin("F4") }
+      let(:g4) { Note.from_latin("G4") }
+      let(:subject) { NoteSet.new([f4, g4]) }
+
+      context "when subtracting an interval string" do
+        let(:operand) { "major_second" }
+
+        it "retuns a new NoteSet with the operand subtracted to each element of the original" do
+          result = subject.subtract(operand)
+
+          result.should be_a(NoteSet)
+          result[0].frequency.should == subject[0].subtract(operand).frequency
+          result[1].frequency.should == subject[1].subtract(operand).frequency
+        end
+      end
+
+      context "when subtracting an interval symbol" do
+        let(:operand) { :major_second }
+
+        it "retuns a new NoteSet with the operand subtracted to each element of the original" do
+          result = subject.subtract(operand)
+
+          result.should be_a(NoteSet)
+          result[0].frequency.should == subject[0].subtract(operand).frequency
+          result[1].frequency.should == subject[1].subtract(operand).frequency
+        end
+      end
+
+      context "when subtracting an note" do
+        let(:operand) { Note.from_latin("C4") }
+
+        it "retuns a new NoteSet with the operand subtracted to each element of the original" do
+          result = subject.subtract(operand)
+
+          result.should be_a(NoteSet)
+          result[0].coord.should == subject[0].subtract(operand).coord
+          result[1].coord.should == subject[1].subtract(operand).coord
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/rb-music/note_spec.rb

@@ -0,0 +1,318 @@
+require_relative '../spec_helper'
+
+describe RBMusic::Note do
+
+  describe "class methods" do
+
+    describe "#from_latin" do
+
+      context "when given a single-character valid note name" do
+        let(:note_name) { RBMusic::NOTE_NAMES[0] }
+        let(:subject) { described_class.from_latin(note_name) }
+
+        it "returns a #{described_class}" do
+          subject.should be_a(described_class)
+        end
+
+        it "assigns the correct latin name" do
+          subject.latin.should == note_name
+        end
+
+        it "assigns a default octave of 0" do
+          subject.octave.should == 0
+        end
+      end
+
+      context "when given a single-character valid note name with octave" do
+        let(:note_name) { RBMusic::NOTE_NAMES[0] }
+        let(:octave) { 2 }
+        let(:subject) { described_class.from_latin("#{note_name}#{octave}") }
+
+        it "returns a #{described_class}" do
+          subject.should be_a(described_class)
+        end
+
+        it "assigns the correct latin name" do
+          subject.latin.should == note_name
+        end
+
+        it "assigns the correct octave" do
+          subject.octave.should == 2
+        end
+      end
+
+      context "when given a two-character valid note name with octave" do
+        let(:note_name) { "C#" }
+        let(:octave) { 3 }
+        let(:subject) { described_class.from_latin("#{note_name}#{octave}") }
+
+        it "returns a #{described_class}" do
+          subject.should be_a(described_class)
+        end
+
+        it "assigns the correct latin name" do
+          subject.latin.should == note_name
+        end
+
+        it "assigns the correct octave" do
+          subject.octave.should == 3
+        end
+      end
+
+      context "when given a single-character invalid note name" do
+        let(:note_name) { "Z" }
+
+        it "raises an exception" do
+          lambda {
+            described_class.from_latin(note_name)
+          }.should raise_error(RBMusic::ArgumentError)
+        end
+      end
+
+      context "when given an invalid note name / octave string" do
+        it "raises an exception" do
+          lambda {
+            described_class.from_latin("C0E3")
+          }.should raise_error(RBMusic::ArgumentError)
+        end
+      end
+
+      context "when given an empty string" do
+        it "raises an exception" do
+          lambda {
+            described_class.from_latin("")
+          }.should raise_error(RBMusic::ArgumentError)
+        end
+      end
+
+      context "when a non-string" do
+        it "raises an exception" do
+          lambda {
+            described_class.from_latin(1)
+          }.should raise_error(RBMusic::ArgumentError)
+        end
+      end
+
+    end
+
+  end
+
+  describe "instance methods" do
+    let(:subject) { Note.from_latin("A4") }
+
+    describe "#frequency" do
+      [
+        ["A4", 440],
+        ["A#4", 466.16],
+        ["C4", 261.63],
+        ["B3", 246.94],
+        ["Ax3", 246.94]
+      ].each do |pair|
+
+        it "is #{pair[1]} for #{pair[0]}" do
+          Note.from_latin(pair[0]).frequency.round(2).should == pair[1]
+        end
+
+      end
+
+    end
+
+    it "has a latin name" do
+      subject.latin.should == "A"
+    end
+
+    it "has an octave" do
+      subject.octave.should == 4
+    end
+
+    describe "#==" do
+      context "when the argument is a note with the same latin name and octave" do
+        it "is true" do
+          subject.should == Note.from_latin("A4")
+        end
+      end
+
+      context "when the argument is a note with a different latin name and same octave" do
+        it "is false" do
+          subject.should_not == Note.from_latin("B4")
+        end
+      end
+
+      context "when the argument is a note with the same latin name and a different octave" do
+        it "is false" do
+          subject.should_not == Note.from_latin("A5")
+        end
+      end
+
+      context "when the argument is not a note" do
+        it "is false" do
+          subject.should_not == "foo"
+        end
+      end
+    end
+
+    describe "#enharmonic?" do
+      context "when the argument is a note with the same latin name and octave" do
+        it "is true" do
+          subject.should be_enharmonic(Note.from_latin("A4"))
+        end
+      end
+
+      context "when the argument is a note with same frequency but a different latin name and/or octave" do
+        it "is true" do
+          Note.from_latin("E4").should be_enharmonic(Note.from_latin("Fb4"))
+          Note.from_latin("Fbb4").should be_enharmonic(Note.from_latin("Eb4"))
+        end
+      end
+
+      context "when the argument is a note with a different latin name and same octave" do
+        it "is false" do
+          subject.should_not be_enharmonic(Note.from_latin("B4"))
+          subject.should_not be_enharmonically_equivalent_to(Note.from_latin("B4"))
+        end
+      end
+
+      context "when the argument is a note with the same latin name and a different octave" do
+        it "is false" do
+          subject.should_not be_enharmonic(Note.from_latin("A5"))
+        end
+      end
+
+      context "when the argument is not a note" do
+        it "raises an exception" do
+          lambda {
+            subject.enharmonic?("foo")
+          }.should raise_exception(RBMusic::ArgumentError)
+        end
+      end
+    end
+
+    describe "#add" do
+      context "when given a string" do
+        it "adds an interval from the string" do
+          b4 = Note.from_latin("B4")
+          result = subject.add("major_second")
+
+          result.frequency.should == b4.frequency
+          result.latin.should == b4.latin
+          result.octave.should == b4.octave
+        end
+      end
+
+      context "when given a symbol" do
+        it "adds an interval from the symbol" do
+          c5 = Note.from_latin("C5")
+          result = subject.add(:minor_third)
+
+          result.frequency.should == c5.frequency
+          result.latin.should == c5.latin
+          result.octave.should == c5.octave
+        end
+      end
+
+      context "when given an array" do
+        it "returns an NoteSet" do
+          b4 = Note.from_latin("B4")
+          c5 = Note.from_latin("C5")
+          result = subject.add(["major_second", :minor_third])
+
+          result.should be_a(NoteSet)
+
+          result[0].frequency.should == b4.frequency
+          result[0].latin.should == b4.latin
+          result[0].octave.should == b4.octave
+
+          result[1].frequency.should == c5.frequency
+          result[1].latin.should == c5.latin
+          result[1].octave.should == c5.octave
+        end
+      end
+    end
+
+    describe "#subtract" do
+
+      context "when given a string" do
+        it "returns a note with an interval from the string subtracted" do
+          g4 = Note.from_latin("G4")
+          result = subject.subtract("major_second")
+
+          result.frequency.should == g4.frequency
+          result.latin.should == g4.latin
+          result.octave.should == g4.octave
+        end
+      end
+
+      context "when given a symbol" do
+        it "returns a note with an interval from the symbol subtracted" do
+          f4 = Note.from_latin("F4")
+          result = subject.subtract(:major_third)
+
+          result.frequency.should == f4.frequency
+          result.latin.should == f4.latin
+          result.octave.should == f4.octave
+        end
+      end
+
+      context "when given an array" do
+        it "returns a NoteSet" do
+          f4 = Note.from_latin("F4")
+          g4 = Note.from_latin("G4")
+          result = subject.subtract(["major_third", :major_second])
+
+          result.should be_a(NoteSet)
+          result[0].frequency.should == f4.frequency
+          result[0].latin.should == f4.latin
+          result[0].octave.should == f4.octave
+
+          result[1].frequency.should == g4.frequency
+          result[1].latin.should == g4.latin
+          result[1].octave.should == g4.octave
+        end
+      end
+
+      context "when given a Note" do
+        it "returns the difference as an Interval" do
+          f4 = Note.from_latin("F4")
+          result = subject.subtract(f4)
+
+          result.coord.should == Interval.from_name("major_third").coord
+        end
+      end
+    end
+  end
+
+  describe "#midi_note_number" do
+    [
+      ["C3", 48],
+      ["B2", 47],
+      ["Ax2", 47],
+      ["C4", 60],
+      ["Cb4", 59],
+      ["C#4", 61],
+      ["Db4", 61]
+    ].each do |pair|
+      it "maps #{pair[0]} to #{pair[1]}" do
+        Note.from_latin(pair[0]).midi_note_number.should == pair[1]
+      end
+    end
+  end
+
+  describe "#scale" do
+    let(:subject) { Note.from_latin("C4") }
+    let(:scale_name) { "major" }
+    let(:scale) { Scale.new(subject.latin, scale_name) }
+
+    it "is a note set with the default octave and range" do
+      result = subject.scale(scale_name)
+
+      result.should == NoteSet.from_scale(scale, subject.octave, 1)
+    end
+
+    it "accepts an octave range" do
+      result = subject.scale(scale_name, 2)
+
+      result.should == NoteSet.from_scale(scale, subject.octave, 2)
+    end
+  end
+
+end

data/spec/rb-music/scale_spec.rb

@@ -0,0 +1,88 @@
+require_relative '../spec_helper'
+
+describe RBMusic::Scale do
+
+  describe "initializer" do
+
+    context "when called with no arguments" do
+      it "raises an ArgumentError"  do
+        lambda {
+          described_class.new
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context "when called without a valid note name as key" do
+      it "raises an ArgumentError" do
+        lambda {
+          described_class.new("foo", "bar")
+        }.should raise_error(RBMusic::ArgumentError)
+      end
+    end
+
+    context "when called without a valid key and scale name" do
+      it "raises an ArgumentError" do
+        lambda {
+          described_class.new("C", "bar")
+        }.should raise_error(RBMusic::ArgumentError)
+      end
+    end
+
+    context "when called with a valid key and scale" do
+      let(:key) { "C" }
+      let(:name) { "major" }
+      let(:subject) { described_class.new(key, name) }
+
+      it "assigns the key attribute" do
+        subject.key.should == key
+      end
+
+      it "assigns the degrees based on the name" do
+        subject.degrees.should == [:unison] + SCALES[name.to_sym]
+      end
+    end
+  end
+
+  describe "instance methods" do
+    let(:subject) { described_class.new("C", "major") }
+
+    describe "#degree_count" do
+      it "is the number of scale degrees" do
+        subject.degree_count.should == subject.degrees.size
+      end
+    end
+
+    describe "#name" do
+      it "is the human-readable name" do
+        subject.name.should == "C Major"
+        Scale.new("D#", "harmonic_minor").name.should == "D# Harmonic Minor"
+      end
+    end
+  end
+
+  describe "scale types" do
+    let(:note) { Note.from_latin("C4") }
+
+    {
+      "major" => ["C", "D", "E", "F", "G", "A", "B"],
+      "natural_minor" => ["C", "D", "Eb", "F", "G", "Ab", "Bb"],
+      "natural_minor" => ["C", "D", "Eb", "F", "G", "Ab", "Bb"],
+      "harmonic_minor" => ["C", "D", "Eb", "F", "G", "Ab", "B"],
+      "major_pentatonic" => ["C", "D", "E", "G", "A"],
+      "minor_pentatonic" => ["C", "Eb", "F", "G", "Bb"],
+      "blues" => ["C", "Eb", "F", "F#", "G", "Bb"],
+      "ionian" => ["C", "D", "E", "F", "G", "A", "B"],
+      "dorian" => ["C", "D", "Eb", "F", "G", "A", "Bb"],
+      "phrygian" => ["C", "Db", "Eb", "F", "G", "A", "Bb"],
+      "lydian" => ["C", "D", "E", "F#", "G", "A", "B"],
+      "mixolydian" => ["C", "D", "E", "F", "G", "A", "Bb"],
+      "aeolian" => ["C", "D", "Eb", "F", "G", "Ab", "Bb"],
+      "locrian" => ["C", "Db", "Eb", "F", "Gb", "Ab", "Bb"],
+    }.each_pair do |key, value|
+      it "calculates a #{key} scale" do
+        note.scale(key).map(&:latin).should == value
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start
+end
+
+RSpec.configure do |c|
+  c.filter_run focus: true
+  c.run_all_when_everything_filtered = true
+end
+
+require 'rb-music'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: rb-music
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mark Wise
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides Ruby classes for working with musical notes, scales
+  and intervals.
+email:
+- markmediadude@mgail.comm
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/motion-music.rb
+- lib/motion-music/version.rb
+- lib/rb-music.rb
+- lib/rb-music/constants.rb
+- lib/rb-music/interval.rb
+- lib/rb-music/note.rb
+- lib/rb-music/note_set.rb
+- lib/rb-music/scale.rb
+- lib/rb-music/version.rb
+- spec/rb-music/constants_spec.rb
+- spec/rb-music/interval_spec.rb
+- spec/rb-music/note_set_spec.rb
+- spec/rb-music/note_spec.rb
+- spec/rb-music/scale_spec.rb
+- spec/spec_helper.rb
+homepage: https://rubygems.org/mwise/rb-music
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Music theory library for Ruby
+test_files:
+- spec/rb-music/constants_spec.rb
+- spec/rb-music/interval_spec.rb
+- spec/rb-music/note_set_spec.rb
+- spec/rb-music/note_spec.rb
+- spec/rb-music/scale_spec.rb
+- spec/spec_helper.rb