clef 0.1.0

data/lib/clef/core/pitch.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class Pitch
+      include Comparable
+
+      NOTE_VALUES = {
+        c: 0,
+        d: 2,
+        e: 4,
+        f: 5,
+        g: 7,
+        a: 9,
+        b: 11
+      }.freeze
+      VALID_NOTE_NAMES = NOTE_VALUES.keys.freeze
+      ALTERATION_SUFFIX = {
+        -2 => "eses",
+        -1 => "es",
+        0 => "",
+        1 => "is",
+        2 => "isis"
+      }.freeze
+      SUFFIX_ALTERATION = ALTERATION_SUFFIX.invert.freeze
+      MIDI_CLASS_TO_PITCH = {
+        0 => [:c, 0],
+        1 => [:c, 1],
+        2 => [:d, 0],
+        3 => [:d, 1],
+        4 => [:e, 0],
+        5 => [:f, 0],
+        6 => [:f, 1],
+        7 => [:g, 0],
+        8 => [:g, 1],
+        9 => [:a, 0],
+        10 => [:a, 1],
+        11 => [:b, 0]
+      }.freeze
+
+      attr_reader :note_name, :octave, :alteration
+
+      # @param note_name [Symbol]
+      # @param octave [Integer]
+      # @param alteration [Integer]
+      def initialize(note_name, octave, alteration: 0)
+        validate_note_name!(note_name)
+        validate_octave!(octave)
+        validate_alteration!(alteration)
+
+        @note_name = note_name
+        @octave = octave
+        @alteration = alteration
+        freeze
+      end
+
+      # @return [Integer]
+      def to_midi
+        semitones + 12
+      end
+
+      # @return [Integer]
+      def semitones
+        octave * 12 + NOTE_VALUES.fetch(note_name) + alteration
+      end
+
+      # @param tuning [Float]
+      # @return [Float]
+      def to_frequency(tuning: 440.0)
+        tuning * (2.0**((to_midi - 69) / 12.0))
+      end
+
+      # @param semitones_or_interval [Integer, #semitones]
+      # @return [Pitch]
+      def transpose(semitones_or_interval)
+        target_midi = to_midi + normalize_semitones(semitones_or_interval)
+        octave = (target_midi / 12) - 1
+        note_name, alteration = MIDI_CLASS_TO_PITCH.fetch(target_midi % 12)
+        self.class.new(note_name, octave, alteration: alteration)
+      end
+
+      # @param other [Pitch]
+      # @return [Boolean]
+      def enharmonic?(other)
+        other.is_a?(self.class) && semitones == other.semitones
+      end
+
+      # @param other [Pitch]
+      # @return [Integer, nil]
+      def <=>(other)
+        return nil unless other.is_a?(self.class)
+
+        semitones <=> other.semitones
+      end
+
+      # @return [String]
+      def to_lilypond
+        [note_name, ALTERATION_SUFFIX.fetch(alteration), octave_marks].join
+      end
+
+      # @param str [String]
+      # @return [Pitch]
+      def self.parse(str)
+        raise ArgumentError, "pitch string must be a String" unless str.is_a?(String)
+
+        match = /\A([a-g])(eses|isis|es|is)?([',]*)\z/.match(str)
+        raise ArgumentError, "invalid lilypond pitch: #{str}" unless match
+
+        note_name = match[1].to_sym
+        suffix = match[2] || ""
+        octave = 3 + match[3].count("'") - match[3].count(",")
+        new(note_name, octave, alteration: SUFFIX_ALTERATION.fetch(suffix))
+      end
+
+      private
+
+      def octave_marks
+        delta = octave - 3
+        return "'" * delta if delta.positive?
+
+        "," * delta.abs
+      end
+
+      def normalize_semitones(arg)
+        return arg.semitones if arg.respond_to?(:semitones)
+
+        Integer(arg)
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "transpose expects Integer or object responding to #semitones"
+      end
+
+      def validate_note_name!(note_name)
+        return if VALID_NOTE_NAMES.include?(note_name)
+
+        raise ArgumentError, "invalid note name: #{note_name.inspect}"
+      end
+
+      def validate_octave!(octave)
+        return if octave.is_a?(Integer)
+
+        raise ArgumentError, "octave must be an Integer"
+      end
+
+      def validate_alteration!(alteration)
+        return if (-2..2).cover?(alteration)
+
+        raise ArgumentError, "alteration must be between -2 and 2"
+      end
+    end
+  end
+end

data/lib/clef/core/rest.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class Rest
+      attr_reader :duration
+
+      # @param duration [Duration]
+      def initialize(duration)
+        raise ArgumentError, "duration must be a Clef::Core::Duration" unless duration.is_a?(Duration)
+
+        @duration = duration
+      end
+
+      # @return [Rational]
+      def length
+        duration.length
+      end
+    end
+  end
+end

data/lib/clef/core/score.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class Score
+      attr_reader :staff_groups, :metadata
+      attr_accessor :title, :composer, :tempo
+
+      # @param metadata [Hash]
+      def initialize(metadata: {})
+        @staff_groups = []
+        @metadata = metadata
+      end
+
+      # @param staff_group [StaffGroup]
+      # @return [Score]
+      def add_staff_group(staff_group)
+        raise ArgumentError, "staff_group must be a Clef::Core::StaffGroup" unless staff_group.is_a?(StaffGroup)
+
+        staff_groups << staff_group
+        self
+      end
+
+      # @param staff [Staff]
+      # @return [Score]
+      def add_staff(staff)
+        default_group.add_staff(staff)
+        self
+      end
+
+      # @return [Array<Staff>]
+      def staves
+        staff_groups.flat_map(&:staves)
+      end
+
+      # @param path [String]
+      # @param options [Hash]
+      def to_pdf(path, **options)
+        ::Clef::Compiler.new(self, **options).compile_to_pdf(path)
+      end
+
+      # @param path [String]
+      # @param options [Hash]
+      def to_svg(path, **options)
+        ::Clef::Compiler.new(self, **options).compile_to_svg(path)
+      end
+
+      # @param path [String]
+      def to_midi(path, **_options)
+        ::Clef::Midi::Exporter.new(self).export(path)
+      end
+
+      private
+
+      def default_group
+        staff_groups.first || add_staff_group(StaffGroup.new)
+        staff_groups.first
+      end
+    end
+  end
+end

data/lib/clef/core/staff.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class Staff
+      attr_reader :id, :name, :clef, :measures
+      attr_accessor :key_signature, :time_signature
+      attr_accessor :metadata
+
+      # @param id [Symbol]
+      # @param name [String, nil]
+      # @param clef [Clef]
+      def initialize(id, name: nil, clef: Clef.new(:treble))
+        raise ArgumentError, "id must be provided" if id.nil?
+        raise ArgumentError, "clef must be a Clef::Core::Clef" unless clef.is_a?(Clef)
+
+        @id = id
+        @name = name || id.to_s
+        @clef = clef
+        @measures = []
+        @metadata = {}
+      end
+
+      # @param measure [Measure]
+      # @return [Staff]
+      def add_measure(measure)
+        raise ArgumentError, "measure must be a Clef::Core::Measure" unless measure.is_a?(Measure)
+
+        measures << measure
+        self
+      end
+    end
+  end
+end

data/lib/clef/core/staff_group.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class StaffGroup
+      BRACKETS = %i[bracket brace none].freeze
+
+      attr_reader :staves, :bracket_type
+
+      # @param staves [Array<Staff>]
+      # @param bracket_type [Symbol]
+      def initialize(staves = [], bracket_type: :none)
+        raise ArgumentError, "unsupported bracket type" unless BRACKETS.include?(bracket_type)
+
+        @staves = []
+        @bracket_type = bracket_type
+        staves.each { |staff| add_staff(staff) }
+      end
+
+      # @param staff [Staff]
+      # @return [StaffGroup]
+      def add_staff(staff)
+        raise ArgumentError, "staff must be a Clef::Core::Staff" unless staff.is_a?(Staff)
+
+        staves << staff
+        self
+      end
+    end
+  end
+end

data/lib/clef/core/tempo.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class Tempo
+      attr_reader :beat_unit, :bpm
+
+      # @param beat_unit [Duration]
+      # @param bpm [Integer]
+      def initialize(beat_unit:, bpm:)
+        raise ArgumentError, "beat_unit must be a Clef::Core::Duration" unless beat_unit.is_a?(Duration)
+        raise ArgumentError, "bpm must be a positive Integer" unless bpm.is_a?(Integer) && bpm.positive?
+
+        @beat_unit = beat_unit
+        @bpm = bpm
+      end
+    end
+  end
+end

data/lib/clef/core/time_signature.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class TimeSignature
+      attr_reader :numerator, :denominator
+
+      # @param numerator [Integer]
+      # @param denominator [Integer]
+      def initialize(numerator, denominator)
+        validate_numerator!(numerator)
+        validate_denominator!(denominator)
+
+        @numerator = numerator
+        @denominator = denominator
+      end
+
+      # @return [Rational]
+      def measure_length
+        Rational(numerator, denominator)
+      end
+
+      private
+
+      def validate_numerator!(value)
+        return if value.is_a?(Integer) && value.positive?
+
+        raise ArgumentError, "numerator must be a positive Integer"
+      end
+
+      def validate_denominator!(value)
+        return if value.is_a?(Integer) && value.positive? && (value & (value - 1)).zero?
+
+        raise ArgumentError, "denominator must be a positive power of two"
+      end
+    end
+  end
+end

data/lib/clef/core/voice.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Clef
+  module Core
+    class Voice
+      attr_reader :id, :elements
+
+      # @param id [Symbol]
+      def initialize(id: :default)
+        @id = id
+        @elements = []
+      end
+
+      # @param element [#length]
+      # @return [Voice]
+      def add(element)
+        raise ArgumentError, "element must respond to #length" unless element.respond_to?(:length)
+
+        elements << element
+        self
+      end
+
+      # @return [Rational]
+      def total_length
+        elements.reduce(Rational(0, 1)) { |memo, element| memo + element.length }
+      end
+    end
+  end
+end

data/lib/clef/engraving/font_manager.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Clef
+  module Engraving
+    class FontManager
+      attr_reader :font_path
+
+      # @param font_path [String]
+      def initialize(font_path: default_font_path)
+        @font_path = font_path
+      end
+
+      # @return [Boolean]
+      def font_available?
+        File.exist?(font_path)
+      end
+
+      # @param pdf [Prawn::Document]
+      # @param family_name [String]
+      # @return [String]
+      def register_with(pdf, family_name: "Bravura")
+        return "Helvetica" unless font_available?
+
+        pdf.font_families.update(family_name => { normal: font_path })
+        family_name
+      end
+
+      private
+
+      def default_font_path
+        File.expand_path("../../../fonts/bravura/Bravura.otf", __dir__)
+      end
+    end
+  end
+end

data/lib/clef/engraving/glyph_table.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Clef
+  module Engraving
+    class GlyphTable
+      GLYPHS = {
+        notehead_black: "\uE0A4",
+        notehead_half: "\uE0A3",
+        notehead_whole: "\uE0A2",
+        stem: "\uE210",
+        flag_8th_up: "\uE240",
+        flag_8th_down: "\uE241",
+        flag_16th_up: "\uE242",
+        flag_16th_down: "\uE243",
+        rest_whole: "\uE4E3",
+        rest_half: "\uE4E4",
+        rest_quarter: "\uE4E5",
+        rest_8th: "\uE4E6",
+        rest_16th: "\uE4E7",
+        clef_treble: "\uE050",
+        clef_bass: "\uE062",
+        clef_alto: "\uE05C",
+        accidental_sharp: "\uE262",
+        accidental_flat: "\uE260",
+        accidental_double_sharp: "\uE263",
+        accidental_double_flat: "\uE264",
+        accidental_natural: "\uE261",
+        dynamic_p: "\uE520",
+        dynamic_f: "\uE522",
+        fermata: "\uE4C0"
+      }.merge((0..9).to_h { |n| [:"time_#{n}", (0xE080 + n).chr(Encoding::UTF_8)] }).freeze
+
+      # @param name [Symbol]
+      # @return [String]
+      def fetch(name)
+        GLYPHS.fetch(name)
+      end
+
+      # @param name [Symbol]
+      # @return [String, nil]
+      def [](name)
+        GLYPHS[name]
+      end
+
+      # @param name [Symbol]
+      # @return [Boolean]
+      def key?(name)
+        GLYPHS.key?(name)
+      end
+    end
+  end
+end

data/lib/clef/engraving/rules.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Clef
+  module Engraving
+    module Rules
+      STEM_LENGTH = 3.5
+      BEAM_THICKNESS = 0.5
+      MIN_NOTE_SPACING = 1.8
+      STAFF_LINE_COUNT = 5
+      STAFF_LINE_WEIGHT = 0.7
+      LEDGER_LINE_WEIGHT = 0.8
+    end
+  end
+end

data/lib/clef/engraving/style.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Clef
+  module Engraving
+    class Style
+      attr_reader :page_size, :margin, :staff_size, :staff_space, :min_note_spacing
+
+      # @param page_size [String, Array]
+      # @param margin [Numeric]
+      # @param staff_size [Numeric]
+      # @param staff_space [Numeric]
+      # @param min_note_spacing [Numeric]
+      def initialize(page_size: "A4", margin: 36, staff_size: 20, staff_space: 10, min_note_spacing: 24)
+        @page_size = page_size
+        @margin = margin
+        @staff_size = staff_size
+        @staff_space = staff_space
+        @min_note_spacing = min_note_spacing
+      end
+
+      # @return [Style]
+      def self.default
+        new
+      end
+    end
+  end
+end

data/lib/clef/ir/event.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Clef
+  module Ir
+    class Event
+      attr_reader :moment, :element, :staff_id, :voice_id
+
+      # @param moment [Moment]
+      # @param element [Object]
+      # @param staff_id [Symbol, String, nil]
+      # @param voice_id [Symbol, String, nil]
+      def initialize(moment:, element:, staff_id: nil, voice_id: nil)
+        raise ArgumentError, "moment must be a Clef::Ir::Moment" unless moment.is_a?(Moment)
+
+        @moment = moment
+        @element = element
+        @staff_id = staff_id
+        @voice_id = voice_id
+      end
+    end
+  end
+end

data/lib/clef/ir/moment.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Clef
+  module Ir
+    class Moment
+      include Comparable
+
+      attr_reader :value
+
+      # @param value [Rational, Integer]
+      def initialize(value)
+        @value = Rational(value)
+      rescue TypeError
+        raise ArgumentError, "moment value must be Rational-compatible"
+      end
+
+      # @param duration [Rational, #length]
+      # @return [Moment]
+      def +(duration)
+        self.class.new(value + normalize_duration(duration))
+      end
+
+      # @param other [Moment, Rational, Integer]
+      # @return [Rational]
+      def -(other)
+        value - normalize_other(other)
+      end
+
+      # @param other [Moment]
+      # @return [Integer, nil]
+      def <=>(other)
+        return nil unless other.is_a?(self.class)
+
+        value <=> other.value
+      end
+
+      def hash
+        value.hash
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && value.eql?(other.value)
+      end
+
+      private
+
+      def normalize_duration(duration)
+        return duration.length if duration.respond_to?(:length)
+
+        Rational(duration)
+      rescue TypeError
+        raise ArgumentError, "duration must be Rational-compatible or respond to #length"
+      end
+
+      def normalize_other(other)
+        return other.value if other.is_a?(self.class)
+
+        Rational(other)
+      rescue TypeError
+        raise ArgumentError, "other must be a Moment or Rational-compatible"
+      end
+    end
+  end
+end

data/lib/clef/ir/music_tree.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Clef
+  module Ir
+    class MusicTree
+      class << self
+        # @param score [Clef::Core::Score]
+        # @return [Timeline]
+        def build(score)
+          timeline = Timeline.new
+          score.staves.each { |staff| append_staff_events(timeline, staff) }
+          timeline
+        end
+
+        private
+
+        def append_staff_events(timeline, staff)
+          current = Moment.new(0)
+          staff.measures.each do |measure|
+            append_measure_metadata(timeline, measure, staff, current)
+            append_measure_voices(timeline, measure, staff, current)
+            current = current + measure_length_for(measure)
+          end
+        end
+
+        def append_measure_metadata(timeline, measure, staff, current)
+          [measure.clef, measure.key_signature, measure.time_signature].compact.each do |element|
+            timeline.add(Event.new(moment: current, element: element, staff_id: staff.id, voice_id: :meta))
+          end
+        end
+
+        def append_measure_voices(timeline, measure, staff, current)
+          measure.voices.each do |voice_id, voice|
+            append_voice_events(timeline, voice, current, staff.id, voice_id)
+          end
+        end
+
+        def append_voice_events(timeline, voice, start_moment, staff_id, voice_id)
+          cursor = Moment.new(start_moment.value)
+          voice.elements.each do |element|
+            timeline.add(Event.new(moment: cursor, element: element, staff_id: staff_id, voice_id: voice_id))
+            cursor = cursor + element.length
+          end
+        end
+
+        def measure_length_for(measure)
+          return measure.time_signature.measure_length if measure.time_signature
+
+          measure.voices.values.map(&:total_length).max || Rational(0, 1)
+        end
+      end
+    end
+  end
+end