motion-music 0.0.2 → 0.0.3

data/spec/rb-music/note_spec.rb

@@ -1,318 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,14 +0,0 @@
-$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'