motion-music 0.0.2

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,124 @@
+--- !ruby/object:Gem::Specification
+name: motion-music
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Mark Wise
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-18 00:00:00.000000000 Z
+dependencies: []
+description: This gem wraps the rb-music gem to provide RubyMotion classes for working
+  with musical notes, scales and intervals.
+email:
+- markmediadude@mgail.comm
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- doc/Gemfile.html
+- doc/Gemfile_lock.html
+- doc/Guardfile.html
+- doc/LICENSE.html
+- doc/Object.html
+- doc/RBMusic.html
+- doc/RBMusic/Interval.html
+- doc/RBMusic/Note.html
+- doc/RBMusic/NoteSet.html
+- doc/RBMusic/Scale.html
+- doc/README_md.html
+- doc/created.rid
+- doc/fonts.css
+- doc/fonts/Lato-Light.ttf
+- doc/fonts/Lato-LightItalic.ttf
+- doc/fonts/Lato-Regular.ttf
+- doc/fonts/Lato-RegularItalic.ttf
+- doc/fonts/SourceCodePro-Bold.ttf
+- doc/fonts/SourceCodePro-Regular.ttf
+- doc/images/add.png
+- doc/images/arrow_up.png
+- doc/images/brick.png
+- doc/images/brick_link.png
+- doc/images/bug.png
+- doc/images/bullet_black.png
+- doc/images/bullet_toggle_minus.png
+- doc/images/bullet_toggle_plus.png
+- doc/images/date.png
+- doc/images/delete.png
+- doc/images/find.png
+- doc/images/loadingAnimation.gif
+- doc/images/macFFBgHack.png
+- doc/images/package.png
+- doc/images/page_green.png
+- doc/images/page_white_text.png
+- doc/images/page_white_width.png
+- doc/images/plugin.png
+- doc/images/ruby.png
+- doc/images/tag_blue.png
+- doc/images/tag_green.png
+- doc/images/transparent.png
+- doc/images/wrench.png
+- doc/images/wrench_orange.png
+- doc/images/zoom.png
+- doc/index.html
+- doc/js/darkfish.js
+- doc/js/jquery.js
+- doc/js/navigation.js
+- doc/js/search.js
+- doc/js/search_index.js
+- doc/js/searcher.js
+- doc/projections_json.html
+- doc/rb-music_gemspec.html
+- doc/rdoc.css
+- doc/table_of_contents.html
+- 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
+- motion-music.gemspec
+- projections.json
+- rb-music.gemspec
+- 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/motion-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: '0'
+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 RubyMotion
+test_files: []