clef 0.1.0

data/lib/clef/parser/dsl.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+module Clef
+  module Parser
+    module DSL
+      class Error < StandardError; end
+
+      class ScoreBuilder
+        attr_reader :score
+
+        def initialize
+          @score = Clef::Core::Score.new
+          @default_group = Clef::Core::StaffGroup.new([], bracket_type: :none)
+          score.add_staff_group(@default_group)
+        end
+
+        # @param value [String]
+        def title(value)
+          score.title = value.to_s
+        end
+
+        # @param value [String]
+        def composer(value)
+          score.composer = value.to_s
+        end
+
+        # @param beat_unit [Symbol, Clef::Core::Duration]
+        # @param bpm [Integer]
+        def tempo(beat_unit:, bpm:)
+          duration = beat_unit.is_a?(Clef::Core::Duration) ? beat_unit : Clef::Core::Duration.new(beat_unit)
+          score.tempo = Clef::Core::Tempo.new(beat_unit: duration, bpm: bpm)
+        end
+
+        # @param id [Symbol]
+        # @param name [String, nil]
+        # @param clef [Symbol]
+        def staff(id, name: nil, clef: :treble, &block)
+          staff = Clef::Core::Staff.new(id, name: name, clef: Clef::Core::Clef.new(clef))
+          build_staff(staff, &block)
+          @default_group.add_staff(staff)
+          staff
+        rescue NoMethodError => e
+          raise Error, "invalid DSL method in staff block: #{e.name}"
+        end
+
+        # @param bracket_type [Symbol]
+        def staff_group(bracket_type, &block)
+          group = Clef::Core::StaffGroup.new([], bracket_type: bracket_type)
+          GroupBuilder.new(group).instance_eval(&block)
+          score.add_staff_group(group)
+          group
+        rescue NoMethodError => e
+          raise Error, "invalid DSL method in staff_group block: #{e.name}"
+        end
+
+        # @return [Clef::Core::Score]
+        def build
+          score
+        end
+
+        private
+
+        def build_staff(staff, &block)
+          return unless block
+
+          StaffBuilder.new(staff).instance_eval(&block)
+        end
+      end
+
+      class GroupBuilder
+        def initialize(group)
+          @group = group
+        end
+
+        # @param id [Symbol]
+        # @param name [String, nil]
+        # @param clef [Symbol]
+        def staff(id, name: nil, clef: :treble, &block)
+          staff = Clef::Core::Staff.new(id, name: name, clef: Clef::Core::Clef.new(clef))
+          StaffBuilder.new(staff).instance_eval(&block) if block
+          @group.add_staff(staff)
+          staff
+        end
+      end
+
+      class StaffBuilder
+        def initialize(staff)
+          @staff = staff
+          @current_measure = nil
+          @next_measure_number = 1
+          @lyrics = []
+        end
+
+        # @param tonic [Symbol, Clef::Core::Pitch]
+        # @param mode [Symbol]
+        def key(tonic, mode = :major)
+          @staff.key_signature = Clef::Core::KeySignature.new(tonic, mode)
+        end
+
+        # @param numerator [Integer]
+        # @param denominator [Integer]
+        def time(numerator, denominator)
+          @staff.time_signature = Clef::Core::TimeSignature.new(numerator, denominator)
+        end
+
+        # @param id [Symbol]
+        def voice(id = :default, &block)
+          measure = ensure_measure
+          voice = measure.voice(id)
+          return voice unless block
+
+          VoiceBuilder.new(voice).instance_eval(&block)
+          voice
+        rescue NoMethodError => e
+          raise Error, "invalid DSL method in voice block: #{e.name}"
+        end
+
+        # @param lilypond_string [String]
+        def play(lilypond_string)
+          segments = split_measures(lilypond_string)
+          segments.each_with_index do |segment, idx|
+            measure = ensure_measure
+            VoiceBuilder.new(measure.voice(:default)).notes(segment)
+            advance_measure if idx < segments.length - 1
+          end
+        end
+
+        # @param voice_id [Symbol]
+        # @param text [String]
+        def lyrics(voice_id, text)
+          @lyrics << Clef::Notation::Lyric.new(voice_id, text)
+          @staff.metadata ||= {}
+          @staff.metadata[:lyrics] = @lyrics
+        end
+
+        private
+
+        def ensure_measure
+          return @current_measure if @current_measure
+
+          @current_measure = Clef::Core::Measure.new(@next_measure_number, time_signature: @staff.time_signature)
+          @current_measure.key_signature = @staff.key_signature
+          @current_measure.clef = @staff.clef
+          @staff.add_measure(@current_measure)
+          @next_measure_number += 1
+          @current_measure
+        end
+
+        def advance_measure
+          @current_measure = nil
+        end
+
+        def split_measures(input)
+          input.to_s.split("|").map(&:strip).reject(&:empty?)
+        end
+      end
+
+      class VoiceBuilder
+        def initialize(voice)
+          @voice = voice
+        end
+
+        # @param pitch_str [String]
+        # @param duration_sym [Symbol]
+        # @param opts [Hash]
+        def note(pitch_str, duration_sym, **opts)
+          pitch = parse_pitch(pitch_str)
+          duration = Clef::Core::Duration.new(duration_sym, dots: opts.fetch(:dots, 0))
+          articulations = Array(opts.fetch(:articulations, []))
+          @voice.add(Clef::Core::Note.new(pitch, duration, articulations: articulations, tied: opts[:tied]))
+        end
+
+        # @param duration_sym [Symbol]
+        # @param opts [Hash]
+        def rest(duration_sym, **opts)
+          duration = Clef::Core::Duration.new(duration_sym, dots: opts.fetch(:dots, 0))
+          @voice.add(Clef::Core::Rest.new(duration))
+        end
+
+        # @param pitch_strs [Array<String>]
+        # @param duration_sym [Symbol]
+        # @param opts [Hash]
+        def chord(pitch_strs, duration_sym, **opts)
+          duration = Clef::Core::Duration.new(duration_sym, dots: opts.fetch(:dots, 0))
+          pitches = pitch_strs.map { |pitch| parse_pitch(pitch) }
+          @voice.add(Clef::Core::Chord.new(pitches, duration))
+        end
+
+        # @param lilypond_string [String]
+        def notes(lilypond_string)
+          parse_tokens(lilypond_string).each { |token| add_token(token) }
+        end
+
+        # @param actual [Integer]
+        # @param normal [Integer]
+        def tuplet(actual, normal)
+          raise ArgumentError, "tuplet values must be positive" unless actual.positive? && normal.positive?
+
+          return unless block_given?
+
+          yield
+        end
+
+        private
+
+        def parse_tokens(input)
+          input.to_s.split(/\s+/).reject(&:empty?)
+        end
+
+        def add_token(token)
+          return if token == "|"
+
+          if token.start_with?("r")
+            add_rest_token(token)
+          elsif token.start_with?("<")
+            add_chord_token(token)
+          else
+            add_note_token(token)
+          end
+        rescue StandardError => e
+          raise Error, "failed to parse token '#{token}': #{e.message}"
+        end
+
+        def add_rest_token(token)
+          match = /\Ar(\d+)(\.*)\z/.match(token)
+          raise ArgumentError, "invalid rest token" unless match
+
+          duration = Clef::Core::Duration.from_lilypond(match[1].to_i, match[2].length)
+          @voice.add(Clef::Core::Rest.new(duration))
+        end
+
+        def add_chord_token(token)
+          match = /\A<([^>]+)>(\d+)(\.*)\z/.match(token)
+          raise ArgumentError, "invalid chord token" unless match
+
+          pitches = match[1].split(/\s+/).map { |value| parse_pitch(value) }
+          duration = Clef::Core::Duration.from_lilypond(match[2].to_i, match[3].length)
+          @voice.add(Clef::Core::Chord.new(pitches, duration))
+        end
+
+        def add_note_token(token)
+          match = /\A([a-g](?:isis|eses|is|es)?[',]*)(\d+)(\.*)\z/.match(token)
+          raise ArgumentError, "invalid note token" unless match
+
+          pitch = parse_pitch(match[1])
+          duration = Clef::Core::Duration.from_lilypond(match[2].to_i, match[3].length)
+          @voice.add(Clef::Core::Note.new(pitch, duration))
+        end
+
+        def parse_pitch(value)
+          parse_scientific_pitch(value) || Clef::Core::Pitch.parse(value.downcase)
+        end
+
+        def parse_scientific_pitch(value)
+          match = /\A([A-Ga-g])([#b]{0,2})(-?\d+)\z/.match(value)
+          return nil unless match
+
+          note_name = match[1].downcase.to_sym
+          alteration = { "" => 0, "#" => 1, "##" => 2, "b" => -1, "bb" => -2 }.fetch(match[2])
+          Clef::Core::Pitch.new(note_name, match[3].to_i, alteration: alteration)
+        end
+      end
+    end
+  end
+end

data/lib/clef/parser/lilypond_lexer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Clef
+  module Parser
+    class LilypondLexer
+      TOKEN_REGEX = /\\[a-zA-Z]+|\{\}|\{|\}|<[^>]+>\d+\.*|[a-g](?:isis|eses|is|es)?[',]*\d+\.*|r\d+\.*|\|/m
+
+      # @param input [String]
+      # @return [Array<String>]
+      def tokenize(input)
+        sanitized = strip_comments(input)
+        sanitized.scan(TOKEN_REGEX)
+      end
+
+      private
+
+      def strip_comments(input)
+        input.to_s.each_line.map { |line| line.sub(/%.*/, "") }.join
+      end
+    end
+  end
+end

data/lib/clef/parser/lilypond_parser.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Clef
+  module Parser
+    class LilypondParser
+      # @param input [String]
+      # @return [Clef::Core::Score]
+      def parse(input)
+        cleaned = input.to_s
+        clef = extract_clef(cleaned)
+        key_tonic = extract_key_tonic(cleaned)
+        mode = extract_mode(cleaned)
+        time_numerator, time_denominator = extract_time(cleaned)
+        note_stream = extract_note_stream(cleaned)
+
+        Clef.score do
+          staff :staff1, clef: clef do
+            key key_tonic, mode
+            time time_numerator, time_denominator
+            play note_stream
+          end
+        end
+      end
+
+      private
+
+      def extract_note_stream(input)
+        body = input[/\{(.+)\}/m, 1] || ""
+        tokens = LilypondLexer.new.tokenize(body)
+        tokens.select { |token| token.match?(/\A<|\A[a-g]|\Ar|\A\|/) }.join(" ")
+      end
+
+      def extract_key_tonic(input)
+        match = /\\key\s+([a-g](?:is|es)?)/.match(input)
+        tonic = (match && match[1]) || "c"
+        Clef::Core::Pitch.parse(tonic)
+      end
+
+      def extract_mode(input)
+        match = /\\key\s+[a-g](?:is|es)?\s+\\(major|minor)/.match(input)
+        (match && match[1]&.to_sym) || :major
+      end
+
+      def extract_time(input)
+        match = /\\time\s+(\d+)\/(\d+)/.match(input)
+        return [4, 4] unless match
+
+        [match[1].to_i, match[2].to_i]
+      end
+
+      def extract_clef(input)
+        match = /\\clef\s+"?([a-z_]+)"?/.match(input)
+        (match && match[1]&.to_sym) || :treble
+      end
+    end
+  end
+end

data/lib/clef/plugins/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Clef
+  module Plugins
+    class Base
+      class << self
+        # @return [String]
+        def plugin_name
+          name.split("::").last.downcase
+        end
+      end
+
+      # @param _score [Clef::Core::Score]
+      def on_before_layout(_score); end
+
+      # @param _layout_result [Hash]
+      def on_after_layout(_layout_result); end
+
+      # @param _renderer [Object]
+      def on_before_render(_renderer); end
+
+      # @param _glyph_table [Clef::Engraving::GlyphTable]
+      def register_glyphs(_glyph_table); end
+    end
+  end
+end

data/lib/clef/plugins/registry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Clef
+  module Plugins
+    class Registry
+      attr_reader :plugins
+
+      def initialize
+        @plugins = []
+      end
+
+      # @param plugin_class [Class]
+      # @return [Plugins::Base]
+      def register(plugin_class)
+        raise ArgumentError, "plugin must inherit Clef::Plugins::Base" unless plugin_class < Base
+
+        plugin = plugin_class.new
+        plugins << plugin
+        plugin
+      end
+
+      # @param hook_name [Symbol]
+      # @param args [Array<Object>]
+      # @return [Array<Object>]
+      def run_hook(hook_name, *args)
+        plugins.each_with_object([]) do |plugin, results|
+          next unless plugin.respond_to?(hook_name)
+
+          results << plugin.public_send(hook_name, *args)
+        end
+      end
+    end
+  end
+end

data/lib/clef/renderer/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Clef
+  module Renderer
+    class Base
+      attr_reader :style, :glyph_table, :font_manager
+
+      # @param style [Clef::Engraving::Style]
+      # @param glyph_table [Clef::Engraving::GlyphTable]
+      # @param font_manager [Clef::Engraving::FontManager]
+      def initialize(style: Clef::Engraving::Style.default,
+                     glyph_table: Clef::Engraving::GlyphTable.new,
+                     font_manager: Clef::Engraving::FontManager.new)
+        @style = style
+        @glyph_table = glyph_table
+        @font_manager = font_manager
+      end
+
+      # @param _score [Clef::Core::Score]
+      # @param _path [String]
+      def render(_score, _path, **_options)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/clef/renderer/notation_helpers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Clef
+  module Renderer
+    module NotationHelpers
+      ACCIDENTAL_GLYPH_KEYS = {
+        -2 => :accidental_double_flat,
+        -1 => :accidental_flat,
+        1 => :accidental_sharp,
+        2 => :accidental_double_sharp
+      }.freeze
+      ACCIDENTAL_FALLBACK = {
+        -2 => "bb",
+        -1 => "b",
+        1 => "#",
+        2 => "##"
+      }.freeze
+
+      private
+
+      def filled_notehead?(duration)
+        !%i[whole half].include?(duration.base)
+      end
+
+      def stem_required?(duration)
+        duration.base != :whole
+      end
+
+      def duration_spacing(element)
+        style.min_note_spacing * (element.length.to_f / Rational(1, 4).to_f)
+      end
+
+      def diatonic_step(pitch)
+        note_index = Clef::Core::Pitch::VALID_NOTE_NAMES.index(pitch.note_name)
+        (pitch.octave * 7) + note_index
+      end
+
+      # The staff baseline is the top line.
+      # vertical_axis: +1 for PDF coordinates, -1 for SVG coordinates.
+      def calculate_pitch_y(pitch, baseline, clef, vertical_axis:)
+        reference = clef.reference_pitch
+        diatonic = diatonic_step(pitch) - diatonic_step(reference)
+        bottom_line = baseline - (vertical_axis * style.staff_space * 4)
+        reference_y = bottom_line + (clef.reference_line * vertical_axis * style.staff_space)
+        reference_y - (diatonic * (style.staff_space / 2.0))
+      end
+
+      def accidental_glyph_key(alteration)
+        ACCIDENTAL_GLYPH_KEYS[alteration]
+      end
+
+      def accidental_text(alteration)
+        ACCIDENTAL_FALLBACK.fetch(alteration)
+      end
+
+      def chord_notes(chord)
+        chord.pitches.map { |pitch| Clef::Core::Note.new(pitch, chord.duration) }
+      end
+
+      def chord_stem_anchor_note(notes, direction)
+        return notes.min_by { |note| note.pitch.to_midi } if direction == :up
+
+        notes.max_by { |note| note.pitch.to_midi }
+      end
+
+      def chord_stem_length(notes, clef, direction)
+        notes.map { |note| Clef::Layout::Stem.length(note, clef, direction) }.max
+      end
+    end
+  end
+end