musical_score 0.1.0

data/lib/musical_score/note/note.rb

@@ -0,0 +1,141 @@
+require 'contracts'
+Dir[File.expand_path('../', __FILE__) << '/**/*.rb'].each do |file|
+    # require file except myself
+    if(file != __FILE__)
+        require file
+    end
+end
+module MusicalScore
+    module Note
+        class Note < MusicalScore::ElementBase
+            attr_accessor  :lyric, :location
+            attr_reader :duration, :tie, :dot, :time_modification, :actual_duration, :pitch, :rest, :type, :notation
+            include Contracts
+
+            # constructor for rest note
+            Contract KeywordArgs[
+                :duration          => Pos,
+                :tie               => Maybe[Enum[*TYPE_START_STOP]],
+                :dot               => Optional[Nat],
+                :lyric             => Optional[nil],
+                :pitch             => Optional[nil],
+                :rest              => true,
+                :type              => MusicalScore::Note::Type,
+                :time_modification => Maybe[MusicalScore::Note::TimeModification],
+                :notation          => Maybe[MusicalScore::Note::Notation::Notation],
+            ] => Any
+            def initialize(
+                duration:,
+                tie: nil,
+                dot: 0,
+                lyric: nil,
+                pitch: nil,
+                rest: true,
+                type:,
+                time_modification: nil,
+                notation: nil,
+                **rest_args
+                )
+                @duration = duration
+                @tie      = tie
+                @dot      = dot
+                @lyric    = lyric
+                @pitch    = pitch
+                @rest     = rest
+                @type     = type
+                @time_modification = time_modification
+                @notation = notation
+
+                set_actual_duration
+            end
+
+            # constructor for pitch note
+            Contract KeywordArgs[
+                :duration          => Pos,
+                :tie               => Maybe[Enum[*TYPE_START_STOP]],
+                :dot               => Optional[Nat],
+                :lyric             => Maybe[MusicalScore::Note::Lyric],
+                :pitch             => MusicalScore::Note::Pitch,
+                :rest              => Optional[false],
+                :type              => MusicalScore::Note::Type,
+                :time_modification => Maybe[MusicalScore::Note::TimeModification],
+                :notation          => Maybe[MusicalScore::Note::Notation::Notation],
+            ] => Any
+            def initialize(
+                duration:,
+                tie: nil,
+                dot: 0,
+                lyric: nil,
+                pitch:,
+                rest: false,
+                type:,
+                time_modification: nil,
+                notation: nil,
+                **rest_args
+                )
+                @duration = duration
+                @tie      = tie
+                @dot      = dot
+                @lyric    = lyric
+                @pitch    = pitch
+                @rest     = rest
+                @type     = type
+                @time_modification = time_modification
+                @notation = notation
+
+                set_actual_duration
+            end
+
+            Contract REXML::Element => MusicalScore::Note::Note
+            def self.create_by_xml(xml_doc)
+                dots = 0
+                xml_doc.elements.each("dot") do |elemet|
+                    dots += 1
+                end
+                duration = xml_doc.elements["duration"].text.to_i
+                type     = MusicalScore::Note::Type.new(xml_doc.elements["type"].text)
+
+                tie = xml_doc.elements["tie"] ? xml_doc.elements["tie"].attributes["type"].to_sym : nil
+
+                notation_doc = xml_doc.elements["notations"]
+                notation     = notation_doc ? MusicalScore::Note::Notation::Notation.create_by_xml(notation_doc) : nil
+
+                time_modification_doc = xml_doc.elements["time-modification"]
+                time_modification = time_modification_doc ? MusicalScore::Note::TimeModification.create_by_xml(time_modification_doc) : nil
+                rest = xml_doc.elements["rest"] ? true : false
+                if (rest)
+                    return MusicalScore::Note::Note.new(duration: duration, tie: tie, dot: dots, rest: rest, type: type, time_modification: time_modification, notation: notation)
+                else
+                    pitch = MusicalScore::Note::Pitch.create_by_xml(xml_doc.elements["pitch"])
+                    lyric_doc = xml_doc.elements["lyric"]
+                    lyric = lyric_doc ? MusicalScore::Note::Lyric.create_by_xml(lyric_doc) : nil
+                    return MusicalScore::Note::Note.new(duration: duration, tie: tie, dot: dots, type: type, lyric: lyric, pitch: pitch, time_modification: time_modification, notation: notation)
+                end
+            end
+
+            def export_xml
+                note_element = REXML::Element.new('note')
+                note_element.add_element('rest') if @rest
+                note_element.add_element(@pitch.export_xml) if @pitch
+                note_element.add_element('duration').add_text(@duration.to_s)
+                note_element.add_element('tie').add_attribute('type', @tie.to_s) if @tie
+                note_element.add_element(@type.export_xml)
+                note_element.add_element(@time_modification.export_xml) if @time_modification
+                note_element.add_element(@lyric.export_xml(1)) if @lyric
+                note_element.add_element(@notation.export_xml) if @notation
+
+                return note_element
+            end
+
+            private
+            def set_actual_duration
+                unless(@time_modification)
+                    @actual_duration = Rational(@duration, 1)
+                else
+                    total_duration = @duration * @time_modification.normal_notes
+                    @actual_duration = Rational(total_duration, @time_modification.actual_notes)
+                end
+            end
+        end
+    end
+end

data/lib/musical_score/note/pitch.rb

@@ -0,0 +1,140 @@
+require 'contracts'
+module MusicalScore
+    module Note
+        class Pitch < MusicalScore::ElementBase
+            include Comparable
+            include Contracts
+            # pitch names
+            @@key = {
+                :C => 0,
+                :D => 2,
+                :E => 4,
+                :F => 5,
+                :G => 7,
+                :A => 9,
+                :B => 11
+            }
+            attr_accessor :step, :alter, :octave
+
+            # constructor
+            #
+            # @example create Pitch object
+            #  MusicalScore::Note::Pitch.new(:C, 0, 3) # => C3
+            #
+            # @param step The key of the pitch described as "C", "D", "E", etc.
+            # @param alter The number of sharp (positive number) or flat (negative number).
+            # @param octave The octave number
+            #
+            Contract Enum[*@@key.keys], Enum[*AVAILABLE_NUMBERS_OF_ALTER], Nat => Any
+            def initialize(step, alter = 0, octave = 0)
+                @step   = step.to_sym
+                @alter  = alter
+                @octave = octave
+            end
+
+            # Pitch is comparable
+            #
+            # @example
+            #  a = MusicalScore::Note::Pitch.new(:C, 0, 3)
+            #  b = MusicalScore::Note::Pitch.new(:D, 0 ,3)
+            #  a < b # => true
+            def <=> (other)
+                self.note_number <=> other.note_number
+            end
+
+            # Given a note_number like MIDI note_number, return the Pitch object with positive number of alter
+            #
+            # @example
+            #  a = MusicalScore::Note::Pitch.new_note_sharp(70)
+            #  a # => [:step => :A, :alter => 1, :octave => 5 ]
+            Contract Nat => MusicalScore::Note::Pitch
+            def self.new_note_sharp(note_number)
+                step_key_num   = note_number % NUMBER_OF_NOTES
+                octave         = note_number / NUMBER_OF_NOTES
+                # calculate step and alter
+                candidate_keys = @@key.keys.select{ |item| step_key_num >= @@key[item] }
+                key            = candidate_keys.max_by{ |item| @@key[item] }
+
+                return MusicalScore::Note::Pitch.new(key, step_key_num-@@key[key], octave)
+            end
+
+            # Given a note_number like MIDI note_number, return the Pitch object with negative number of alter
+            #
+            # @example
+            #  a = MusicalScore::Note::Pitch.new_note_sharp(70)
+            #  a # => [:step => :B, :alter => -1, :octave => 5 ]
+            #
+            Contract Nat => MusicalScore::Note::Pitch
+            def self.new_note_flat(note_number)
+                step_key_num   = note_number % NUMBER_OF_NOTES
+                octave         = note_number / NUMBER_OF_NOTES
+                # calculate step and alter
+                candidate_keys = @@key.keys.select{ |item| step_key_num <= @@key[item] }
+                key            = candidate_keys.min_by{ |item| @@key[item] }
+
+                return MusicalScore::Note::Pitch.new(key, step_key_num-@@key[key], octave)
+            end
+
+            def note_number
+                result = (NUMBER_OF_NOTES * octave) + @@key[step] + alter
+                return result
+            end
+
+            # Given argument true, return note string like "D##"
+            #
+            Contract Maybe[Bool] => String
+            def to_s(is_note_str = false)
+                if is_note_str
+                    result = "%s%s%d" % [@step.to_s, alter_to_s, @octave]
+                    return result
+                else
+                    return self.to_s
+                end
+            end
+
+            Contract REXML::Element => MusicalScore::Note::Pitch
+            def self.create_by_xml(xml_doc)
+                step   = xml_doc.elements["step"].text.to_sym
+                octave = xml_doc.elements["octave"].text.to_i
+                alter  = xml_doc.elements["alter"] ? xml_doc.elements["alter"].text.to_i : 0
+                return MusicalScore::Note::Pitch.new(step, alter, octave)
+            end
+
+            def export_xml
+                pitch_element  = REXML::Element.new('pitch')
+                step_element   = REXML::Element.new('step').add_text(@step.to_s)
+                octave_element = REXML::Element.new('octave').add_text(@octave.to_s)
+
+                pitch_element.add_element(step_element)
+                if (@alter != 0)
+                    alter_element = REXML::Element.new('alter').add_text(@alter.to_s)
+                    pitch_element.add_element(alter_element)
+                end
+                pitch_element.add_element(octave_element)
+
+                return pitch_element
+            end
+
+            private
+
+            def alter_to_s
+                num = @alter.abs
+                if (num == 0)
+                    return ""
+                elsif (@alter < 0)
+                    result = ''
+                    num.times do |i|
+                        result += 'b'
+                    end
+                    return result
+                else
+                    result = ''
+                    num.times do |i|
+                        result += '#'
+                    end
+                    return result
+                end
+            end
+        end
+    end
+end

data/lib/musical_score/note/time_modification.rb

@@ -0,0 +1,33 @@
+require 'contracts'
+module MusicalScore
+    module Note
+        class TimeModification < MusicalScore::ElementBase
+            include Contracts
+            attr_reader :actual_notes, :normal_notes
+
+            Contract Pos, Pos => Any
+            def initialize(actual_notes, normal_notes)
+                @actual_notes = actual_notes
+                @normal_notes = normal_notes
+            end
+
+            Contract REXML::Element => MusicalScore::Note::TimeModification
+            def self.create_by_xml(xml_doc)
+                actual_notes = xml_doc.elements["actual-notes"].text.to_i
+                normal_notes = xml_doc.elements["normal-notes"].text.to_i
+                return MusicalScore::Note::TimeModification.new(actual_notes, normal_notes)
+            end
+
+            def export_xml
+                time_modification_element = REXML::Element.new('time-modification')
+                actual_notes_element      = REXML::Element.new('actual-notes').add_text(@actual_notes.to_s)
+                normal_notes_element      = REXML::Element.new('normal-notes').add_text(@normal_notes.to_s)
+
+                time_modification_element.add_element(actual_notes_element)
+                time_modification_element.add_element(normal_notes_element)
+
+                return time_modification_element
+            end
+        end
+    end
+end

data/lib/musical_score/note/type.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module MusicalScore
+    module Note
+        class Type < MusicalScore::ElementBase
+            include Contracts
+
+            @@size = %w(
+                128th
+                64th
+                32nd
+                16th
+                eighth
+                quarter
+                half
+                whole
+                breve
+            )
+            attr_reader :size
+            Contract Enum[*@@size] => Any
+            def initialize(size)
+                @size = size
+            end
+
+            def export_xml
+                return REXML::Element.new('type').add_text(@size.to_s)
+            end
+        end
+    end
+end

data/lib/musical_score/notes.rb

@@ -0,0 +1,37 @@
+require 'contracts'
+require 'musical_score/note/note'
+module MusicalScore
+    class Notes < MusicalScore::ElementBase
+        include Contracts
+        include Enumerable
+        attr_reader :notes, :duration
+
+        Contract ArrayOf[MusicalScore::Note::Note] => Any
+        def initialize(notes)
+            @notes = notes
+        end
+        def divide_to_notes_and_rests
+            divided_array = @notes.partition { |note| note.rest }
+            return { note: divided_array[1], rest: divided_array[0] }
+        end
+
+        def [](index)
+            return @notes[index]
+        end
+
+        def each
+            @notes.each do |note|
+                yield note
+            end
+        end
+
+        def set_location(location, number)
+            current_location = MusicalScore::Location.new(number, location)
+            @notes.each do |note|
+                note.location = current_location
+                current_location = MusicalScore::Location.new(number, current_location.location + note.actual_duration)
+            end
+            @duration = current_location.location - location
+        end
+    end
+end

data/lib/musical_score/part/measure.rb

@@ -0,0 +1,49 @@
+require 'contracts'
+require 'musical_score/attribute/attribute'
+require 'musical_score/notes'
+
+module MusicalScore
+    module Part
+        class Measure < MusicalScore::ElementBase
+            include Contracts
+            attr_reader :attribute, :number, :notes
+            attr_accessor :length
+            Contract MusicalScore::Notes, Nat, Maybe[MusicalScore::Attribute::Attribute]=> Any
+            def initialize(notes, number, attribute = nil)
+                @notes     = notes
+                @number    = number
+                @attribute = attribute
+            end
+
+            Contract REXML::Element => MusicalScore::Part::Measure
+            def self.create_by_xml(xml_doc)
+                attribute_doc = xml_doc.elements["//attributes"]
+                attributes    = attribute_doc ? MusicalScore::Attribute::Attribute.create_by_xml(attribute_doc) : nil
+                number        = xml_doc.attributes["number"].to_i
+                note_array = Array.new
+                xml_doc.elements.each("//note") do |element|
+                    note = MusicalScore::Note::Note.create_by_xml(element)
+                    note_array.push(note)
+                end
+                notes = MusicalScore::Notes.new(note_array)
+                return MusicalScore::Part::Measure.new(notes, number, attributes)
+            end
+
+            def export_xml
+                measure_element = REXML::Element.new('measure')
+                measure_element.add_attribute('number',@number.to_s)
+                measure_element.add_element(@attribute.export_xml) if @attribute
+
+                @notes.each do |note|
+                    measure_element.add_element(note.export_xml)
+                end
+
+                return measure_element
+            end
+
+            def location
+                return @notes[0].location
+            end
+        end
+    end
+end

data/lib/musical_score/part/part.rb

@@ -0,0 +1,45 @@
+require 'contracts'
+Dir[File.expand_path('../', __FILE__) << '/**/*.rb'].each do |file|
+    # require file except myself
+    if(file != __FILE__)
+        require file
+    end
+end
+module MusicalScore
+    module Part
+        class Part < MusicalScore::ElementBase
+            include Contracts
+            attr_accessor :measures
+            Contract MusicalScore::Measures => Any
+            def initialize(measures)
+                @measures = measures
+            end
+
+            Contract REXML::Element => MusicalScore::Part::Part
+            def self.create_by_xml(xml_doc)
+                measure_array = Array.new
+                xml_doc.elements.each("//measure") do |element|
+                    measure = MusicalScore::Part::Measure.create_by_xml(element)
+                    measure_array.push(measure)
+                end
+                measures = MusicalScore::Measures.new(measure_array)
+                return MusicalScore::Part::Part.new(measures)
+            end
+
+            def export_xml(number)
+                part = REXML::Element.new('part')
+                part.add_attribute('id', "P" + number.to_s)
+
+                @measures.each do |measure|
+                    part.add_element(measure.export_xml)
+                end
+
+                return part
+            end
+
+            def set_location
+                @measures.set_location
+            end
+        end
+    end
+end

data/lib/musical_score/score/identification/creator.rb

@@ -0,0 +1,29 @@
+require 'contracts'
+module MusicalScore
+    module Score
+        module Identification
+            class Creator < MusicalScore::ElementBase
+                attr_reader :name, :type
+                include Contracts
+                Contract String, Enum[*TYPE_CREATOR] => Any
+                def initialize(name, type)
+                    @name = name
+                    @type = type
+                end
+
+                Contract REXML::Element => MusicalScore::Score::Identification::Creator
+                def self.create_by_xml(xml_doc)
+                    type = xml_doc.attributes["type"].to_sym
+                    name = xml_doc.text
+                    return MusicalScore::Score::Identification::Creator.new(name, type)
+                end
+                def export_xml
+                    creator = REXML::Element.new('creator')
+                    creator.add_attribute('type', @type)
+                    creator.add_text(@name)
+                    return creator
+                end
+            end
+        end
+    end
+end

data/lib/musical_score/score/identification/encoding.rb

@@ -0,0 +1,66 @@
+require 'contracts'
+require 'time'
+
+module MusicalScore
+    module Score
+        module Identification
+            class Encoding < MusicalScore::ElementBase
+                include Contracts
+                attr_reader :encoding_date, :encoding_description, :softwares, :supports
+                Contract Time, String, ArrayOf[String], ArrayOf[String] => Any
+                def initialize(encoding_date, encoding_description, softwares, supports)
+                    @encoding_date        = encoding_date
+                    @encoding_description = encoding_description
+                    @softwares            = softwares
+                    @supports             = supports
+                end
+
+                Contract REXML::Element => MusicalScore::Score::Identification::Encoding
+                def self.create_by_xml(xml_doc)
+
+                    encoding_date = Time.new
+                    if (xml_doc.elements["//encoding-date"])
+                        encoding_date = Time.parse(xml_doc.elements["//encoding-date"].text)
+                    end
+                    encoding_description = xml_doc.elements["//encoding-description"] ? xml_doc.elements["//encoding_description"].text : ''
+                    softwares = Array.new
+                    xml_doc.elements.each("//software") do |element|
+                        softwares.push(element.text)
+                    end
+                    supports = Array.new
+                    xml_doc.elements.each("//supports") do |element|
+                        if (element.attributes["type"] == "yes")
+                            supports.push(element.attributes["element"])
+                        end
+                    end
+                    return MusicalScore::Score::Identification::Encoding.new(encoding_date, encoding_description, softwares, supports)
+                end
+
+                def export_xml
+                    encoding = REXML::Element.new('encoding')
+                    @softwares.each do |software|
+                        software_e = REXML::Element.new('software')
+                        software_e.add_text(software)
+                        encoding.add_element(software_e)
+                    end
+                    encoding_date = REXML::Element.new('encoding-date')
+                    encoding_date.add_text(@encoding_date.strftime("%Y-%m-%d"))
+                    encoding.add_element(encoding_date)
+                    @supports.each do |support|
+                        supports_e = REXML::Element.new('supports')
+                        supports_e.add_attribute('type','yes')
+                        supports_e.add_attribute('element',support)
+                        encoding.add_element(supports_e)
+                    end
+                    desc_e = REXML::Element.new('encoding-description')
+                    if (@encoding_description != '')
+                        desc_e.add_text(@encoding_description)
+                        encoding.add_element(desc_e)
+                    end
+
+                    return encoding
+                end
+            end
+        end
+    end
+end

data/lib/musical_score/score/identification/identification.rb

@@ -0,0 +1,47 @@
+require 'contracts'
+Dir[File.expand_path('../', __FILE__) << '/**/*.rb'].each do |file|
+    # require file except myself
+    if(file != __FILE__)
+        require file
+    end
+end
+module MusicalScore
+    module Score
+        module Identification
+            class Identification < MusicalScore::ElementBase
+                include Contracts
+                attr_reader :creators, :encoding
+                Contract ArrayOf[Maybe[MusicalScore::Score::Identification::Creator]], Maybe[MusicalScore::Score::Identification::Encoding] => Any
+                def initialize(creators, encodings)
+                    @creators = creators
+                    @encoding = encodings
+                end
+
+                Contract REXML::Element => MusicalScore::Score::Identification::Identification
+                def self.create_by_xml(xml_doc)
+                    creator_doc  = xml_doc.elements["//creator"]
+                    encoding_doc = xml_doc.elements["//encoding"]
+
+                    creators = Array.new
+                    xml_doc.elements.each("//creator") do |element|
+                        creators.push(MusicalScore::Score::Identification::Creator.create_by_xml(element))
+                    end
+
+                    encoding = encoding_doc ? MusicalScore::Score::Identification::Encoding.create_by_xml(encoding_doc) : nil
+
+                    return MusicalScore::Score::Identification::Identification.new(creators, encoding)
+                end
+
+                def export_xml
+                    identification = REXML::Element.new('identification')
+                    @creators.each do |creator|
+                        identification.add_element(creator.export_xml)
+                    end
+                    identification.add_element(@encoding.export_xml)
+
+                    return identification
+                end
+            end
+        end
+    end
+end

data/lib/musical_score/score/part/part.rb

@@ -0,0 +1,37 @@
+require 'contracts'
+Dir[File.expand_path('../', __FILE__) << '/**/*.rb'].each do |file|
+    # require file except myself
+    if(file != __FILE__)
+        require file
+    end
+end
+module MusicalScore
+    module Score
+        module Part
+            class Part < MusicalScore::ElementBase
+                include Contracts
+                attr_reader :part_name, :part_abbreviation
+
+                Contract String, String => Any
+                def initialize(part_name, part_abbreviation)
+                    @part_name         = part_name
+                    @part_abbreviation = part_abbreviation
+                end
+
+                def export_xml(index)
+                    score_part_element = REXML::Element.new('score-part')
+                    score_part_element.add_attribute('id', "P" + index.to_s)
+
+                    part_name_element  = REXML::Element.new('part-name')
+                    part_name_element.add_text(@part_name)
+                    part_abbreviation_element = REXML::Element.new('part-abbreviation')
+                    part_abbreviation_element.add_text(@part_abbreviation)
+                    score_part_element.add_element(part_name_element)
+                    score_part_element.add_element(part_abbreviation_element)
+
+                    return score_part_element
+                end
+            end
+        end
+    end
+end