motion-music 0.0.2

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/motion-music.gemspec

@@ -0,0 +1,20 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "motion-music/version"
+
+Gem::Specification.new do |s|
+  s.name        = "motion-music"
+  s.version     = MotionMusic::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.license     = "MIT"
+  s.summary     = "Music theory library for RubyMotion"
+  s.description = "This gem wraps the rb-music gem to provide RubyMotion classes for working with musical notes, scales and intervals."
+  s.author      = "Mark Wise"
+  s.authors     = ["Mark Wise"]
+  s.email       = ["markmediadude@mgail.comm"]
+  s.files       = `git ls-files`.split($\)
+  s.homepage    = "https://rubygems.org/mwise/motion-music"
+
+  s.require_paths = ["lib"]
+
+  s.extra_rdoc_files = ['README.md']
+end

data/projections.json

@@ -0,0 +1,12 @@
+{
+  "lib/rb-music/*.rb": {
+    "command": "sources",
+    "alternate": "./spec/rb-music/%s_spec.rb",
+    "reverse_layout": false
+  },
+  "spec/rb-music/*_spec.rb": {
+    "command": "specs",
+    "alternate": "./lib/rb-music/%s.rb",
+    "reverse_layout": true
+  }
+}

data/rb-music.gemspec

@@ -0,0 +1,29 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "rb-music/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rb-music"
+  s.version     = RBMusic::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.license     = "MIT"
+  s.summary     = "Music theory library for Ruby"
+  s.description = "This gem provides Ruby classes for working with musical notes, scales and intervals."
+  s.author      = "Mark Wise"
+  s.authors     = ["Mark Wise"]
+  s.email       = ["markmediadude@mgail.comm"]
+  s.files       = ["lib/rb-music.rb"]
+  s.homepage    = "https://rubygems.org/mwise/rb-music"
+
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 1.8.6"
+  s.files         = `git ls-files -- lib/*`.split("\n")
+  s.files         += %w[README.md LICENSE]
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+
+  s.extra_rdoc_files = ['README.md']
+
+  s.add_development_dependency("guard-rspec")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("simplecov")
+end

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