clef 0.1.0

data/lib/clef/ir/timeline.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Clef
+  module Ir
+    class Timeline
+      include Enumerable
+
+      attr_reader :events
+
+      def initialize
+        @events = []
+      end
+
+      # @param event [Event]
+      # @return [Timeline]
+      def add(event)
+        raise ArgumentError, "event must be a Clef::Ir::Event" unless event.is_a?(Event)
+
+        events << event
+        events.sort_by! { |item| item.moment.value }
+        self
+      end
+
+      # @param moment [Moment, Rational, Integer]
+      # @return [Array<Event>]
+      def events_at(moment)
+        target = moment_value(moment)
+        events.select { |event| event.moment.value == target }
+      end
+
+      # @param from [Moment, Rational, Integer]
+      # @param to [Moment, Rational, Integer]
+      # @return [Array<Event>]
+      def events_between(from, to)
+        lower = moment_value(from)
+        upper = moment_value(to)
+        events.select { |event| (lower..upper).cover?(event.moment.value) }
+      end
+
+      # @yield [Moment]
+      # @return [Enumerator]
+      def each_moment
+        return enum_for(:each_moment) unless block_given?
+
+        unique_moments.each { |moment| yield(moment) }
+      end
+
+      def each(&block)
+        events.each(&block)
+      end
+
+      # @return [Rational]
+      def shortest_duration
+        durations = events.filter_map { |event| event.element.length if event.element.respond_to?(:length) }
+        durations.min || Rational(1, 4)
+      end
+
+      private
+
+      def unique_moments
+        events.map(&:moment).uniq.sort
+      end
+
+      def moment_value(value)
+        value.is_a?(Moment) ? value.value : Rational(value)
+      end
+    end
+  end
+end

data/lib/clef/layout/beam_layout.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Clef
+  module Layout
+    class BeamLayout
+      class << self
+        # @param notes [Array<Clef::Core::Note>]
+        # @param time_signature [Clef::Core::TimeSignature]
+        # @return [Array<Array<Clef::Core::Note>>]
+        def auto_beam(notes, time_signature)
+          return [] if notes.empty?
+
+          notes.each_slice(group_size(time_signature)).to_a
+        end
+
+        # @param beam_group [Array<Clef::Core::Note>]
+        # @param _clef [Clef::Core::Clef]
+        # @param _spacing [Hash]
+        # @return [Hash]
+        def compute(beam_group, _clef, _spacing)
+          first_y = pitch_y(beam_group.first.pitch)
+          last_y = pitch_y(beam_group.last.pitch)
+          slope = [[(last_y - first_y) / [beam_group.length - 1, 1].max, -0.5].max, 0.5].min
+          { start_y: first_y, end_y: first_y + slope * (beam_group.length - 1), slope: slope }
+        end
+
+        private
+
+        def group_size(time_signature)
+          return 3 if time_signature.denominator == 8 && (time_signature.numerator % 3).zero?
+          return 4 if time_signature.denominator == 4 && time_signature.numerator == 4
+
+          [time_signature.numerator, 2].max
+        end
+
+        def pitch_y(pitch)
+          pitch.to_midi.to_f / 12.0
+        end
+      end
+    end
+  end
+end

data/lib/clef/layout/line_breaker.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Clef
+  module Layout
+    class LineBreaker
+      # @param columns [Array<Hash>]
+      # @param line_width [Float]
+      # @return [Array<Array<Hash>>]
+      def break_into_lines(columns, line_width)
+        costs, breaks = initialize_dp(columns.length)
+        1.upto(columns.length) { |idx| update_dp_for_index(columns, line_width, idx, costs, breaks) }
+        build_lines(columns, breaks)
+      end
+
+      private
+
+      def initialize_dp(size)
+        costs = Array.new(size + 1, Float::INFINITY)
+        breaks = Array.new(size + 1)
+        costs[0] = 0.0
+        [costs, breaks]
+      end
+
+      def update_dp_for_index(columns, line_width, idx, costs, breaks)
+        width = 0.0
+        idx.downto(1) do |start_idx|
+          width += column_width(columns[start_idx - 1])
+          break if width > line_width && start_idx != idx
+
+          relax_edge(columns, idx, start_idx, width, line_width, costs, breaks)
+        end
+      end
+
+      def relax_edge(columns, idx, start_idx, width, line_width, costs, breaks)
+        badness = (line_width - width).abs**2
+        penalty = (columns[idx - 1][:break_penalty] || 0).to_f
+        next_cost = costs[start_idx - 1] + badness + penalty
+        return unless next_cost < costs[idx]
+
+        costs[idx] = next_cost
+        breaks[idx] = start_idx - 1
+      end
+
+      def build_lines(columns, breaks)
+        slices = []
+        index = columns.length
+        while index.positive?
+          start_index = breaks[index] || 0
+          slices.unshift(columns[start_index...index])
+          index = start_index
+        end
+        slices
+      end
+
+      def column_width(column)
+        column.fetch(:width).to_f
+      end
+    end
+  end
+end

data/lib/clef/layout/page_breaker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Clef
+  module Layout
+    class PageBreaker
+      # @param lines [Array<Array<Hash>>]
+      # @param page_height [Float]
+      # @param line_height [Float]
+      # @return [Array<Array<Array<Hash>>>]
+      def break_into_pages(lines, page_height:, line_height:)
+        max_lines = [(page_height / line_height).floor, 1].max
+        lines.each_slice(max_lines).to_a
+      end
+    end
+  end
+end

data/lib/clef/layout/spacing.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Clef
+  module Layout
+    class Spacing
+      attr_reader :timeline, :style, :stretch_factor
+
+      # @param timeline [Clef::Ir::Timeline]
+      # @param style [Clef::Engraving::Style]
+      def initialize(timeline, style)
+        @timeline = timeline
+        @style = style
+        @stretch_factor = 1.0
+      end
+
+      # @return [Hash{Clef::Ir::Moment=>Float}]
+      def compute
+        moments = timeline.each_moment.to_a.sort
+        return {} if moments.empty?
+
+        build_positions(moments)
+      end
+
+      # @param target_width [Numeric]
+      # @return [Float]
+      def stretch_to_fit(target_width)
+        positions = compute
+        return stretch_factor if positions.empty?
+
+        current_width = positions.values.max
+        return stretch_factor unless current_width.positive?
+
+        @stretch_factor *= target_width.to_f / current_width
+      end
+
+      private
+
+      def build_positions(moments)
+        positions = { moments.first => 0.0 }
+        total = 0.0
+        moments.each_cons(2) do |left, right|
+          total += interval_width(right.value - left.value)
+          positions[right] = total
+        end
+        positions
+      end
+
+      def interval_width(duration)
+        shortest = timeline.shortest_duration
+        ratio = duration.to_f / shortest.to_f
+        base = style.min_note_spacing
+        base * Math.log2(ratio + 1.0) * stretch_factor
+      end
+    end
+  end
+end

data/lib/clef/layout/stem.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Clef
+  module Layout
+    class Stem
+      B4_MIDI = 71
+
+      class << self
+        # @param note_or_notes [Clef::Core::Note, Array<Clef::Core::Note>]
+        # @param _clef [Clef::Core::Clef]
+        # @return [Symbol]
+        def direction(note_or_notes, _clef)
+          notes = Array(note_or_notes)
+          down_votes = notes.count { |note| note.pitch.to_midi > B4_MIDI }
+          down_votes > (notes.length / 2.0) ? :down : :up
+        end
+
+        # @param note [Clef::Core::Note]
+        # @param _clef [Clef::Core::Clef]
+        # @param _direction [Symbol]
+        # @return [Float]
+        def length(note, _clef, _direction)
+          extra = ledger_extension(note.pitch)
+          Clef::Engraving::Rules::STEM_LENGTH + extra
+        end
+
+        private
+
+        def ledger_extension(pitch)
+          return 1.5 if pitch.to_midi > 84
+          return 1.5 if pitch.to_midi < 48
+
+          0.0
+        end
+      end
+    end
+  end
+end

data/lib/clef/midi/channel_map.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Clef
+  module Midi
+    class ChannelMap
+      # @param staff_index [Integer]
+      # @return [Integer]
+      def channel_for(staff_index)
+        base = staff_index % 15
+        base >= 9 ? base + 1 : base
+      end
+    end
+  end
+end

data/lib/clef/midi/exporter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "midilib/sequence"
+require "midilib/consts"
+
+module Clef
+  module Midi
+    class Exporter
+      include MIDI
+
+      # @param score [Clef::Core::Score]
+      # @param channel_map [ChannelMap]
+      def initialize(score, channel_map: ChannelMap.new)
+        @score = score
+        @channel_map = channel_map
+      end
+
+      # @param path [String]
+      # @return [String]
+      def export(path)
+        sequence = Sequence.new
+        track = Track.new(sequence)
+        sequence.tracks << track
+        track.events << Tempo.new(Tempo.bpm_to_mpq(tempo_bpm))
+
+        append_score(track, sequence.ppqn)
+        File.open(path, "wb") { |file| sequence.write(file) }
+        path
+      end
+
+      private
+
+      def append_score(track, ppqn)
+        @score.staves.each_with_index do |staff, index|
+          channel = @channel_map.channel_for(index)
+          track.events << ProgramChange.new(channel, 1, 0)
+          append_staff(track, staff, channel, ppqn)
+        end
+      end
+
+      def append_staff(track, staff, channel, ppqn)
+        delta = 0
+        staff.measures.each do |measure|
+          voice = measure.voices.values.first
+          delta = append_voice(track, voice, channel, ppqn, delta) if voice
+        end
+      end
+
+      def append_voice(track, voice, channel, ppqn, delta)
+        voice.elements.each do |element|
+          delta = append_element(track, element, channel, ppqn, delta)
+        end
+        delta
+      end
+
+      def append_element(track, element, channel, ppqn, delta)
+        ticks = (element.length * ppqn * 4).to_i
+        return delta + ticks if element.is_a?(Clef::Core::Rest)
+
+        pitches = element.is_a?(Clef::Core::Chord) ? element.pitches : [element.pitch]
+        write_note_events(track, channel, pitches, ticks, delta)
+        0
+      end
+
+      def write_note_events(track, channel, pitches, ticks, delta)
+        pitches.each_with_index do |pitch, index|
+          note_delta = index.zero? ? delta : 0
+          track.events << NoteOn.new(channel, pitch.to_midi, 90, note_delta)
+        end
+        pitches.each_with_index do |pitch, index|
+          note_delta = index.zero? ? ticks : 0
+          track.events << NoteOff.new(channel, pitch.to_midi, 90, note_delta)
+        end
+      end
+
+      def tempo_bpm
+        @score.tempo&.bpm || 120
+      end
+    end
+  end
+end

data/lib/clef/notation/articulation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Clef
+  module Notation
+    class Articulation
+      TYPES = %i[staccato tenuto accent marcato fermata].freeze
+
+      attr_reader :type
+
+      # @param type [Symbol]
+      def initialize(type)
+        raise ArgumentError, "unsupported articulation type" unless TYPES.include?(type)
+
+        @type = type
+      end
+    end
+  end
+end

data/lib/clef/notation/barline.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Clef
+  module Notation
+    class Barline
+      TYPES = %i[single double final repeat_start repeat_end repeat_both].freeze
+
+      attr_reader :type
+
+      # @param type [Symbol]
+      def initialize(type = :single)
+        raise ArgumentError, "unsupported barline type" unless TYPES.include?(type)
+
+        @type = type
+      end
+
+      # @return [String]
+      def to_symbol
+        {
+          single: "|",
+          double: "||",
+          final: "|.",
+          repeat_start: ".|:",
+          repeat_end: ":|.",
+          repeat_both: ":|.|:"
+        }.fetch(type)
+      end
+    end
+  end
+end

data/lib/clef/notation/beam.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Clef
+  module Notation
+    class Beam
+      attr_reader :notes
+
+      # @param notes [Array<Clef::Core::Note>]
+      def initialize(notes)
+        raise ArgumentError, "beam requires at least two notes" if notes.length < 2
+
+        @notes = notes
+      end
+
+      # @return [Integer]
+      def level
+        shortest = notes.map { |note| note.duration.base_value }.min
+        return 1 if shortest >= Rational(1, 8)
+        return 2 if shortest >= Rational(1, 16)
+
+        3
+      end
+    end
+  end
+end

data/lib/clef/notation/dynamic.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Clef
+  module Notation
+    class Dynamic
+      TYPES = %i[pp p mp mf f ff fff sfz fp cresc dim].freeze
+
+      attr_reader :type
+
+      # @param type [Symbol]
+      def initialize(type)
+        raise ArgumentError, "unsupported dynamic type" unless TYPES.include?(type)
+
+        @type = type
+      end
+    end
+  end
+end

data/lib/clef/notation/lyric.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Clef
+  module Notation
+    class Lyric
+      attr_reader :voice_id, :text, :syllables
+
+      # @param voice_id [Symbol]
+      # @param text [String]
+      def initialize(voice_id, text)
+        raise ArgumentError, "text must be String" unless text.is_a?(String)
+
+        @voice_id = voice_id
+        @text = text
+        @syllables = parse_syllables(text)
+      end
+
+      private
+
+      def parse_syllables(input)
+        input
+          .split(/\s+/)
+          .flat_map { |token| token.split("-") }
+          .reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/clef/notation/slur.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Clef
+  module Notation
+    class Slur
+      attr_reader :start_note, :end_note
+
+      # @param start_note [Clef::Core::Note]
+      # @param end_note [Clef::Core::Note]
+      def initialize(start_note, end_note)
+        @start_note = start_note
+        @end_note = end_note
+      end
+
+      # @param start_point [Array<Float>]
+      # @param end_point [Array<Float>]
+      # @return [Array<Array<Float>>]
+      def control_points(start_point, end_point)
+        midpoint_x = (start_point[0] + end_point[0]) / 2.0
+        lift = [((end_point[0] - start_point[0]).abs / 4.0), 6.0].max
+        [
+          [midpoint_x - 8, start_point[1] - lift],
+          [midpoint_x + 8, end_point[1] - lift]
+        ]
+      end
+    end
+  end
+end

data/lib/clef/notation/tie.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Clef
+  module Notation
+    class Tie
+      attr_reader :start_note, :end_note
+
+      # @param start_note [Clef::Core::Note]
+      # @param end_note [Clef::Core::Note]
+      def initialize(start_note, end_note)
+        raise ArgumentError, "tie requires notes with same pitch" unless start_note.pitch.enharmonic?(end_note.pitch)
+
+        @start_note = start_note
+        @end_note = end_note
+      end
+
+      # @param start_point [Array<Float>]
+      # @param end_point [Array<Float>]
+      # @return [Array<Array<Float>>]
+      def control_points(start_point, end_point)
+        midpoint_x = (start_point[0] + end_point[0]) / 2.0
+        lift = [((end_point[0] - start_point[0]).abs / 8.0), 3.0].max
+        [
+          [midpoint_x - 6, start_point[1] - lift],
+          [midpoint_x + 6, end_point[1] - lift]
+        ]
+      end
+    end
+  end
+end