musical_score 0.1.0

data/lib/musical_score/attribute/attribute.rb

@@ -0,0 +1,69 @@
+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 Attribute
+        class Attribute < MusicalScore::ElementBase
+            include Contracts
+            attr_accessor :divisions, :key, :time, :instruments, :clef
+
+            # initialize the attibute
+            #
+            Contract KeywordArgs[
+                :divisions   => Num,
+                :clef        => Optional[MusicalScore::Attribute::Clef],
+                :key         => Optional[MusicalScore::Attribute::Key],
+                :time        => Optional[MusicalScore::Attribute::Time],
+                :instruments => Optional[String],
+            ] => Any
+            def initialize(
+                divisions:,
+                clef: MusicalScore::Attribute::Clef.new(:G),
+                key: MusicalScore::Attribute::Key.new(0, :major),
+                time: MusicalScore::Attribute::Time.new(4, 4),
+                instruments: 'Piano',
+                **rest_args
+                )
+                @divisions   = divisions
+                @clef        = clef
+                @key         = key
+                @time        = time
+                @instruments = instruments
+            end
+
+            Contract REXML::Element => MusicalScore::Attribute::Attribute
+            def self.create_by_xml(xml_doc)
+                divisions = xml_doc.elements["//divisions"].text.to_i
+                clef_doc  = xml_doc.elements["//clef"]
+                time_doc  = xml_doc.elements["//time"]
+                key_doc   = xml_doc.elements["//key"]
+
+                clef = clef_doc ? MusicalScore::Attribute::Clef.create_by_xml(clef_doc) : nil
+                time = time_doc ? MusicalScore::Attribute::Time.create_by_xml(time_doc) : nil
+                key  = key_doc ? MusicalScore::Attribute::Key.create_by_xml(key_doc) : nil
+
+                attributes = MusicalScore::Attribute::Attribute.new(divisions: divisions, clef: clef, time: time)
+                return attributes
+            end
+
+            def export_xml
+                attribute_element = REXML::Element.new('attributes')
+                divisions_element = REXML::Element.new('divisions').add_text(@divisions.to_s)
+                key_element       = @key.export_xml
+                time_element      = @time.export_xml
+                clef_element      = @clef.export_xml
+
+                attribute_element.add_element(divisions_element)
+                attribute_element.add_element(key_element)
+                attribute_element.add_element(time_element)
+                attribute_element.add_element(clef_element)
+
+                return attribute_element
+            end
+        end
+    end
+end

data/lib/musical_score/attribute/clef.rb

@@ -0,0 +1,44 @@
+require "contracts"
+module MusicalScore
+    module Attribute
+        class Clef < MusicalScore::ElementBase
+            include Contracts
+            @@sign = %i(G F C percussion TAB jianpu none)
+            attr_reader :sign, :line, :clef_octave_change
+
+            # constructor
+            #
+            # @param sign The sign of clef, such as treble, bass. It is described by the @@sign symbols
+            # @param line The number of line from the bottom of the staff, which the sign note is defined at the line.
+            # @param clef_octave_change The number of clef changes, which is written either an octave higher or lower than sounding pitch
+            Contract Enum[*@@sign], Pos, Num => Any
+            def initialize(sign, line = 0, clef_octave_change = 0)
+                @sign               = sign.to_sym
+                @line               = line
+                @clef_octave_change = clef_octave_change
+            end
+
+            Contract REXML::Element => MusicalScore::Attribute::Clef
+            def self.create_by_xml(xml_doc)
+                sign = xml_doc.elements["sign"].text.to_sym
+                line = xml_doc.elements["line"] ? xml_doc.elements["line"].text.to_i : 0
+                clef_octave_change = xml_doc.elements["clef-octave-change"] ? xml_doc.elements["clef-octave-change"].text.to_i : 0
+                clef = MusicalScore::Attribute::Clef.new(sign, line, clef_octave_change)
+                return clef
+            end
+
+            def export_xml
+                clef_element  = REXML::Element.new('clef')
+                sign_element = REXML::Element.new('sign').add_text(@sign.to_s)
+                line_element = @line != 0 ? REXML::Element.new('line').add_text(@line.to_s) : nil
+                clef_octave_change_element = @clef_octave_change != 0 ? REXML::Element.new('clef-octave-change').add_text(@clef_octave_change.to_s) : nil
+
+                clef_element.add_element(sign_element)
+                clef_element.add_element(line_element) if line_element
+                clef_element.add_element(clef_octave_change_element) if clef_octave_change_element
+
+                return clef_element
+            end
+        end
+    end
+end

data/lib/musical_score/attribute/key.rb

@@ -0,0 +1,74 @@
+require "contracts"
+module MusicalScore
+    module Attribute
+        class Key < MusicalScore::ElementBase
+            include Contracts
+            @@mode = %i(major :minor)
+            @@circle_of_fifths = [0, 7, 2, 9, 4, 11, 6, 1, 8, 3, 10, 5]
+
+            attr_reader :fifths, :mode
+            # constructor
+            #
+            # @param fifths The number of sharps (positive) or flats (negative)
+            # @param mode major or minor
+            Contract Enum[*-NUMBER_OF_FIFTHS..NUMBER_OF_FIFTHS], Enum[*@@mode] => Any
+            def initialize(fifths, mode)
+                @fifths = fifths
+                @mode   = mode.to_sym
+            end
+
+            # detect tonic in major scale and minor scale, and pithes that has sharp or flat
+            #
+            Contract None => HashOf[Any, Any]
+            def tonic_key_and_altered_pitches
+                if @fifths >= 0
+                    pitch_number = @@circle_of_fifths[@fifths]
+                    major_pitch = MusicalScore::Note::Pitch.new_note_sharp(pitch_number)
+
+                    minor_number = (pitch_number + RELATED_KEY_SLIDE_NUMBER) % NUMBER_OF_NOTES
+                    minor_pitch  = MusicalScore::Note::Pitch.new_note_sharp(minor_number)
+
+                    altered_pitches  = Array.new
+                    @fifths.times do |i|
+                        count = (i + SHARP_START_INDEX) % NUMBER_OF_NOTES
+                        altered_pitches.push(MusicalScore::Note::Pitch.new_note_sharp(@@circle_of_fifths[count]))
+                    end
+                    return { :major_pitch => major_pitch, :minor_pitch => minor_pitch, :altered_pitches => altered_pitches }
+                else
+                    reversed = @@circle_of_fifths.reverse
+                    fif      = @fifths.abs
+                    pitch_number = reversed[fif-1]
+                    major_pitch = MusicalScore::Note::Pitch.new_note_flat(pitch_number)
+
+                    minor_number = (pitch_number + RELATED_KEY_SLIDE_NUMBER) % NUMBER_OF_NOTES
+                    minor_pitch  = MusicalScore::Note::Pitch.new_note_flat(minor_number)
+
+                    altered_pitches  = Array.new
+                    fif.times do |i|
+                        count = (i + FLAT_START_INDEX) % NUMBER_OF_NOTES
+                        altered_pitches.push(MusicalScore::Note::Pitch.new_note_flat(reversed[count]))
+                    end
+                    return { :major_pitch => major_pitch, :minor_pitch => minor_pitch, :altered_pitches => altered_pitches }
+                end
+            end
+
+            Contract REXML::Element => MusicalScore::Attribute::Key
+            def self.create_by_xml(xml_doc)
+                fifths = xml_doc.elements["fifths"].text.to_i
+                mode   = xml_doc.elements["mode"].text.to_sym
+                return MusicalScore::Attribute::Key.new(fifths, mode)
+            end
+
+            def export_xml
+                key_element    = REXML::Element.new('key')
+                fifths_element = REXML::Element.new('fifths').add_text(@fifths.to_s)
+                mode_element   = REXML::Element.new('mode').add_text(@mode.to_s)
+
+                key_element.add_element(fifths_element)
+                key_element.add_element(mode_element)
+
+                return key_element
+            end
+        end
+    end
+end

data/lib/musical_score/attribute/time.rb

@@ -0,0 +1,43 @@
+require 'contracts'
+module MusicalScore
+    module Attribute
+        class Time < MusicalScore::ElementBase
+            include Contracts
+            attr_reader :beats, :beat_type
+
+            # constructor
+            #
+            Contract Num, Num => Any
+            def initialize(beats, beat_type)
+                @beats     = beats
+                @beat_type = beat_type
+            end
+
+            # @return [String] describe the time object in a fraction style
+            def to_s
+                return "%d/%d" % [@beats, @beat_type]
+            end
+
+            Contract REXML::Element => MusicalScore::Attribute::Time
+            def self.create_by_xml(xml_doc)
+                beats     = xml_doc.elements["beats"].text.to_i
+                beat_type = xml_doc.elements["beat-type"].text.to_i
+                return MusicalScore::Attribute::Time.new(beats, beat_type)
+            end
+
+            def export_xml
+                time      = REXML::Element.new('time')
+                beats     = REXML::Element.new('beats')
+                beat_type = REXML::Element.new('beat-type')
+
+                beats.add_text(@beats.to_s)
+                beat_type.add_text(@beat_type.to_s)
+
+                time.add_element(beats)
+                time.add_element(beat_type)
+
+                return time
+            end
+        end
+    end
+end

data/lib/musical_score/const.rb

@@ -0,0 +1,16 @@
+module MusicalScore
+    SHARP = :sharp
+    FLAT  = :flat
+
+    NUMBER_OF_NOTES   = 12
+    NUMBER_OF_FIFTHS  = 7
+    SHARP_START_INDEX = 11
+    FLAT_START_INDEX  = 6
+
+    RELATED_KEY_SLIDE_NUMBER = 9
+
+    AVAILABLE_NUMBERS_OF_ALTER = [-2, -1, 0, 1, 2]
+    TYPE_START_STOP          = %i(start stop)
+    TYPE_START_STOP_CONTINUE = %i(start stop continue)
+    TYPE_CREATOR             = %i(composer lyricist arranger)
+end

data/lib/musical_score/element_base.rb

@@ -0,0 +1,17 @@
+require 'contracts'
+require 'rexml/document'
+
+module MusicalScore
+    class ElementBase
+        include Contracts
+
+        Contract Or[REXML::Document, REXML::Element] => Any
+        def self.create_by_xml(element)
+            raise "Called abstract method: create_by_xml"
+        end
+
+        def export_xml
+            raise "Called abstract method: export_xml"
+        end
+    end
+end

data/lib/musical_score/errors.rb

@@ -0,0 +1,3 @@
+module MusicalScore
+    class InvalidFileType < StandardError; end
+end

data/lib/musical_score/io/importer.rb

@@ -0,0 +1,22 @@
+require 'musical_score'
+require 'rexml/document'
+module MusicalScore
+    module IO
+        def import(file)
+            extname = File.extname(file)
+            case extname
+            when ".xml"
+                return import_xml(file)
+            else
+                raise MusicalScore::InvalidFileType
+            end
+        end
+        def import_xml(file_path)
+            doc = REXML::Document.new(File.new(file_path))
+            score = MusicalScore::Score::Score.create_by_xml(doc, file_path)
+            return score
+        end
+
+        module_function :import, :import_xml
+    end
+end

data/lib/musical_score/location.rb

@@ -0,0 +1,13 @@
+require 'contracts'
+
+module MusicalScore
+    class Location
+        attr_reader :measure_number, :location
+        include Contracts
+        Contract Nat, Rational => Any
+        def initialize(measure_number, location)
+            @measure_number = measure_number
+            @location       = location
+        end
+    end
+end

data/lib/musical_score/measures.rb

@@ -0,0 +1,42 @@
+require 'contracts'
+require 'musical_score/part/measure'
+module MusicalScore
+    class Measures < MusicalScore::ElementBase
+        include Contracts
+        include Enumerable
+        attr_reader :measures
+
+        Contract ArrayOf[MusicalScore::Part::Measure] => Any
+        def initialize(measures)
+            @measures = measures
+        end
+
+        def [](index)
+            return @measures[index]
+        end
+
+        def each
+            @measures.each do |measure|
+                yield measure
+            end
+        end
+
+        def all_notes
+            result = Array.new
+            @measures.each do |measure|
+                result.concat(measure)
+            end
+            return result
+        end
+
+        def set_location
+            current_location = Rational(0)
+            @measures.each do |measure|
+                number = measure.number
+                measure.notes.set_location(current_location, number)
+                current_location += measure.notes.duration
+                measure.length = measure.notes.duration
+            end
+        end
+    end
+end

data/lib/musical_score/note/lyric.rb

@@ -0,0 +1,43 @@
+require 'contracts'
+module MusicalScore
+    module Note
+        class Lyric < MusicalScore::ElementBase
+            include Contracts
+            @@syllabic = %i(single begin end middle)
+            attr_accessor :text, :syllabic, :is_extend
+
+            # constructor
+            #
+            # @param text
+            # @param syllabic
+            # @param is_extend
+            Contract String, Maybe[Enum[*@@syllabic]], Bool => Any
+            def initialize(text, syllabic, is_extend = false)
+                @text      = text
+                @syllabic  = syllabic
+                @is_extend = is_extend
+            end
+            Contract REXML::Element => MusicalScore::Note::Lyric
+            def self.create_by_xml(xml_doc)
+                syllabic  = xml_doc.elements["syllabic"] ? xml_doc.elements["syllabic"].text.to_sym : nil
+                text      = xml_doc.elements["text"].text
+                is_extend = xml_doc.elements["extend"] ? true : false
+                return MusicalScore::Note::Lyric.new(text, syllabic, is_extend)
+            end
+
+            def export_xml(number)
+                lyric_element = REXML::Element.new('lyric')
+                lyric_element.add_attribute('number', number.to_s)
+                text_element  = REXML::Element.new('text').add_text(@text.to_s)
+
+                if (@syllabic)
+                    syllabic_element = REXML::Element.new('syllabic').add_text(@syllabic.to_s)
+                    lyric_element.add_element(syllabic_element)
+                end
+                lyric_element.add_element(text_element)
+
+                return lyric_element
+            end
+        end
+    end
+end

data/lib/musical_score/note/notation/notation.rb

@@ -0,0 +1,105 @@
+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
+        module Notation
+            class Notation < MusicalScore::ElementBase
+                include Contracts
+                @@articulation = %i(
+                    accent
+                    breath_mark
+                    caesura
+                    detached_legato
+                    doit
+                    falloff
+                    plop
+                    scoop
+                    spiccato
+                    staccatissimo
+                    staccato
+                    stress
+                    strong_accent
+                    tenuto
+                    unstress
+                )
+                @@dynamics = %i(
+                    f
+                    ff
+                    fff
+                    ffff
+                    fffff
+                    fp
+                    fz
+                    mf
+                    mp
+                    p
+                    pp
+                    ppp
+                    pppp
+                    ppppp
+                    rf
+                    rfz
+                    sf
+                    sffz
+                    sfpp
+                    sfz
+                )
+                attr_accessor :articulation, :dynamics, :tie, :tuplet
+                Contract KeywordArgs[
+                    :articulation => Maybe[Enum[*@@articulation]],
+                    :dynamics     => Maybe[Enum[*@@dynamics]],
+                    :tie          => Maybe[MusicalScore::Note::Notation::Tie],
+                    :tuplet       => Maybe[MusicalScore::Note::Notation::Tuplet],
+                ] => Any
+                def initialize(
+                    articulation: nil,
+                    dynamics: nil,
+                    tie: nil,
+                    tuplet: nil,
+                    **rest_args
+                    )
+                    @articulation = articulation
+                    @dynamics     = dynamics
+                    @tie          = tie
+                    @tuplet       = tuplet
+                end
+
+                Contract REXML::Element => MusicalScore::Note::Notation::Notation
+                def self.create_by_xml(xml_doc)
+                    articulation = xml_doc.elements["articulations"] ? xml_doc.elements["articulations"].elements[1].name.to_sym : nil
+                    dynamics     = xml_doc.elements["dynamics"] ? xml_doc.elements["dynamics"].elements[1].name.to_sym : nil
+                    tie_arg      = xml_doc.elements["tied"] ? xml_doc.elements["tied"].attributes["type"].to_sym : nil
+                    tie = tie_arg ? MusicalScore::Note::Notation::Tie.new(tie_arg) : nil
+                    tuplet_arg   = xml_doc.elements["tuplet"] ? xml_doc.elements["tuplet"].attributes["type"].to_sym : nil
+                    tuplet = tuplet_arg ? MusicalScore::Note::Notation::Tuplet.new(tuplet_arg) : nil
+                    return MusicalScore::Note::Notation::Notation.new(articulation: articulation, dynamics: dynamics, tie: tie, tuplet: tuplet)
+                end
+
+                def export_xml
+                    notations_element    = REXML::Element.new('notations')
+                    articulation_element = REXML::Element.new('articulations')
+                    dynamics_element     = REXML::Element.new('dynamics')
+
+                    if (@articulation)
+                        articulation_element.add_element(REXML::Element.new(@articulation.to_s))
+                        notations_element.add_element(articulation_element)
+                    end
+                    if (@dynamics)
+                        dynamics_element.add_element(REXML::Element.new(@dynamics.to_s))
+                        notations_element.add_element(dynamics_element)
+                    end
+
+                    notations_element.add_element(@tie.export_xml) if @tie
+                    notations_element.add_element(@tuplet.export_xml) if @tuplet
+
+                    return notations_element
+                end
+            end
+        end
+    end
+end

data/lib/musical_score/note/notation/tie.rb

@@ -0,0 +1,22 @@
+require 'contracts'
+module MusicalScore
+    module Note
+        module Notation
+            class Tie < MusicalScore::ElementBase
+                include Contracts
+                attr_accessor :type
+                Contract Enum[*TYPE_START_STOP_CONTINUE] => Any
+                def initialize(type)
+                    @type = type.to_sym
+                end
+
+                def export_xml
+                    tie_element = REXML::Element.new('tied')
+                    tie_element.add_attribute('type',@type.to_s)
+
+                    return tie_element
+                end
+            end
+        end
+    end
+end

data/lib/musical_score/note/notation/tuplet.rb

@@ -0,0 +1,22 @@
+require 'contracts'
+module MusicalScore
+    module Note
+        module Notation
+            class Tuplet < MusicalScore::ElementBase
+                include Contracts
+                attr_accessor :type
+                Contract Enum[*TYPE_START_STOP] => Any
+                def initialize(type)
+                    @type = type
+                end
+
+                def export_xml
+                    tuplet_element = REXML::Element.new('tuplet')
+                    tuplet_element.add_attribute('type', @type.to_s)
+
+                    return tuplet_element
+                end
+            end
+        end
+    end
+end