clef 0.1.0 → 1.0.0

data/lib/clef/parser/lilypond_parser.rb

@@ -3,41 +3,156 @@
 module Clef
   module Parser
     class LilypondParser
+      SUPPORTED_COMMANDS = %w[\\clef \\key \\major \\minor \\time \\tempo \\relative \\new \\with].freeze
+      DYNAMIC_COMMANDS = Clef::Notation::Dynamic::TYPES.map { |type| "\\#{type}" }.freeze
+      STAFF_COMMAND = /\\new\s+(?:Staff|PianoStaff|StaffGroup)/
+
+      attr_reader :warnings, :plugins
+
+      # @param plugins [Clef::Plugins::Registry]
+      def initialize(plugins: Clef.plugins)
+        @plugins = plugins
+        @warnings = []
+      end
+
       # @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
+        cleaned = strip_comments(input)
+        @warnings = unsupported_command_warnings(cleaned)
+        score = build_score(cleaned)
+        plugins.run_hook(:on_after_parse, score)
+        score
+      end
+
+      private
+
+      def build_score(input)
+        staff_blocks = extract_staff_blocks(input)
+        return build_single_staff_score(input) if staff_blocks.empty?
+
+        global_tempo_unit, global_tempo_bpm = extract_tempo(input)
+        use_staff_group = staff_group_input?(input)
+        parser = self
+        Clef.score(plugins: plugins) do
+          tempo beat_unit: global_tempo_unit, bpm: global_tempo_bpm if global_tempo_bpm
+          if use_staff_group
+            staff_group :bracket do
+              staff_blocks.each_with_index { |block, index| parser.send(:build_staff_from_block, self, block, index) }
+            end
+          else
+            staff_blocks.each_with_index { |block, index| parser.send(:build_staff_from_block, self, block, index) }
+          end
+        end
+      end
+
+      def build_single_staff_score(input)
+        clef = extract_clef(input)
+        key_tonic = extract_key_tonic(input)
+        mode = extract_mode(input)
+        time_numerator, time_denominator = extract_time(input)
+        tempo_unit, tempo_bpm = extract_tempo(input)
+        voice_streams = extract_voice_streams(first_braced_body(input), context: input)
+        parser = self
+
+        Clef.score(plugins: plugins) do
+          tempo beat_unit: tempo_unit, bpm: tempo_bpm if tempo_bpm
           staff :staff1, clef: clef do
             key key_tonic, mode
             time time_numerator, time_denominator
-            play note_stream
+            parser.send(:add_voice_streams, self, voice_streams)
           end
         end
       end
 
-      private
+      def build_staff_from_block(builder, block, index)
+        context = "#{block[:header]}\n#{block[:body]}"
+        clef = extract_clef(context)
+        key_tonic = extract_key_tonic(context)
+        mode = extract_mode(context)
+        time_numerator, time_denominator = extract_time(context)
+        voice_streams = extract_voice_streams(block[:body], context: context)
+        staff_id = :"staff#{index + 1}"
+        parser = self
+
+        builder.staff staff_id, clef: clef do
+          key key_tonic, mode
+          time time_numerator, time_denominator
+          parser.send(:add_voice_streams, self, voice_streams)
+        end
+      end
+
+      def add_voice_streams(builder, voice_streams)
+        streams = voice_streams.map { |stream| measure_segments(stream) }
+        measure_count = streams.map(&:length).max.to_i
+        measure_count.times do |measure_index|
+          builder.measure(measure_index + 1) do |staff_builder|
+            streams.each_with_index do |segments, voice_index|
+              segment = segments[measure_index]
+              next if segment.to_s.empty?
+
+              staff_builder.voice(voice_id_for(voice_index)) { notes segment }
+            end
+          end
+        end
+      end
+
+      def measure_segments(stream)
+        stream.to_s.split("|").map(&:strip).reject(&:empty?)
+      end
+
+      def voice_id_for(index)
+        index.zero? ? :default : :"voice#{index + 1}"
+      end
+
+      def extract_staff_blocks(input)
+        blocks = []
+        scanner_index = 0
+        while (match = input.match(STAFF_COMMAND, scanner_index))
+          command_start = match.begin(0)
+          brace_start = input.index("{", match.end(0))
+          break unless brace_start
+
+          body, body_end = braced_body_at(input, brace_start)
+          header = input[command_start...brace_start]
+          blocks << {header: header, body: body}
+          scanner_index = body_end + 1
+        end
+        blocks
+      end
+
+      def staff_group_input?(input)
+        input.match?(/\\new\s+(?:StaffGroup|PianoStaff)\b/) || input.include?("<<")
+      end
+
+      def extract_voice_streams(body, context: body)
+        simultaneous = first_simultaneous_body(body)
+        streams = if simultaneous
+          braced_bodies(simultaneous)
+        elsif (inner = braced_bodies(body).first)
+          [inner]
+        else
+          [body]
+        end
+        streams.map { |stream| note_stream(stream, context: context) }.reject(&:empty?)
+      end
 
-      def extract_note_stream(input)
-        body = input[/\{(.+)\}/m, 1] || ""
+      def note_stream(input, context:)
+        body = context.match?(/\\relative\b/) ? relativize_body(context, input) : input
         tokens = LilypondLexer.new.tokenize(body)
-        tokens.select { |token| token.match?(/\A<|\A[a-g]|\Ar|\A\|/) }.join(" ")
+        tokens.select do |token|
+          token.match?(/\A<|\A[a-g]|\Ar|\A\||\A[()~\[\]]|\A(?:--|->|-\.)\z/) || DYNAMIC_COMMANDS.include?(token)
+        end.join(" ")
       end
 
       def extract_key_tonic(input)
-        match = /\\key\s+([a-g](?:is|es)?)/.match(input)
+        match = /\\key\s+([a-g](?:isis|eses|is|es)?)/.match(input)
         tonic = (match && match[1]) || "c"
-        Clef::Core::Pitch.parse(tonic)
+        Clef::Core::Pitch.parse_any(tonic)
       end
 
       def extract_mode(input)
-        match = /\\key\s+[a-g](?:is|es)?\s+\\(major|minor)/.match(input)
+        match = /\\key\s+[a-g](?:isis|eses|is|es)?\s+\\(major|minor)/.match(input)
         (match && match[1]&.to_sym) || :major
       end
 
@@ -50,7 +165,106 @@ module Clef
 
       def extract_clef(input)
         match = /\\clef\s+"?([a-z_]+)"?/.match(input)
-        (match && match[1]&.to_sym) || :treble
+        clef = (match && match[1]&.to_sym) || :treble
+        return clef if Clef::Core::Clef::TYPES.include?(clef)
+
+        warnings << "unsupported clef ignored: #{clef}"
+        :treble
+      end
+
+      def extract_tempo(input)
+        match = /\\tempo\s+(\d+)\s*=\s*(\d+)/.match(input)
+        return [nil, nil] unless match
+
+        [Clef::Core::Duration.from_lilypond(match[1].to_i), match[2].to_i]
+      end
+
+      def unsupported_command_warnings(input)
+        seen = {}
+        LilypondLexer.new.tokenize_with_locations(input).select { |token| token.value.start_with?("\\") }.filter_map do |token|
+          command = token.value
+          next if SUPPORTED_COMMANDS.include?(command) || DYNAMIC_COMMANDS.include?(command)
+          next if seen[command]
+
+          seen[command] = true
+          "unsupported LilyPond command ignored at line #{token.line}, column #{token.column}: #{command}"
+        end
+      end
+
+      def strip_comments(input)
+        input.to_s.gsub(/%\{.*?%\}/m, "").each_line.map { |line| line.sub(/%.*/, "") }.join
+      end
+
+      def first_braced_body(input)
+        start_index = input.index("{")
+        return "" unless start_index
+
+        braced_body_at(input, start_index).first
+      end
+
+      def braced_body_at(input, start_index)
+        depth = 0
+        index = start_index
+        while index < input.length
+          char = input[index]
+          depth += 1 if char == "{"
+          depth -= 1 if char == "}"
+          return [input[(start_index + 1)...index], index] if depth.zero?
+
+          index += 1
+        end
+        ["", input.length]
+      end
+
+      def first_simultaneous_body(input)
+        start_index = input.index("<<")
+        return nil unless start_index
+
+        depth = 0
+        index = start_index
+        while index < input.length - 1
+          token = input[index, 2]
+          depth += 1 if token == "<<"
+          depth -= 1 if token == ">>"
+          return input[(start_index + 2)...index] if depth.zero?
+
+          index += 1
+        end
+        nil
+      end
+
+      def braced_bodies(input)
+        bodies = []
+        scanner_index = 0
+        while (brace_start = input.index("{", scanner_index))
+          body, body_end = braced_body_at(input, brace_start)
+          bodies << body
+          scanner_index = body_end + 1
+        end
+        bodies
+      end
+
+      def relativize_body(input, body)
+        match = /\\relative\s+([a-g](?:isis|eses|is|es)?[',]*)/.match(input)
+        return body unless match
+
+        previous = Clef::Core::Pitch.parse(match[1])
+        LilypondLexer.new.tokenize(body).map do |token|
+          if (note_match = /\A([a-g](?:isis|eses|is|es)?)(\d*\.*~?)\z/.match(token))
+            previous = closest_relative_pitch(note_match[1], previous)
+            "#{previous.to_lilypond}#{note_match[2]}"
+          else
+            token
+          end
+        end.join(" ")
+      end
+
+      def closest_relative_pitch(note_name, previous)
+        base = Clef::Core::Pitch.parse(note_name)
+        candidates = ((previous.octave - 2)..(previous.octave + 2)).map do |octave|
+          Clef::Core::Pitch.new(base.note_name, octave, alteration: base.alteration)
+        end
+        candidates.min_by { |candidate| (candidate.semitones - previous.semitones).abs }
       end
     end
   end

data/lib/clef/plugins/base.rb

@@ -11,16 +11,36 @@ module Clef
       end
 
       # @param _score [Clef::Core::Score]
-      def on_before_layout(_score); end
+      def on_before_layout(_score)
+      end
 
       # @param _layout_result [Hash]
-      def on_after_layout(_layout_result); end
+      def on_after_layout(_layout_result)
+      end
+
+      # @param _items [Array<Clef::Layout::Item>]
+      def on_layout_items(_items)
+      end
 
       # @param _renderer [Object]
-      def on_before_render(_renderer); end
+      def on_before_render(_renderer)
+      end
+
+      # @param _path [String, #write]
+      def on_after_render(_path)
+      end
+
+      # @param _score [Clef::Core::Score]
+      def on_after_parse(_score)
+      end
+
+      # @param _exporter [Clef::Midi::Exporter]
+      def on_before_midi(_exporter)
+      end
 
       # @param _glyph_table [Clef::Engraving::GlyphTable]
-      def register_glyphs(_glyph_table); end
+      def register_glyphs(_glyph_table)
+      end
     end
   end
 end

data/lib/clef/plugins/registry.rb

@@ -3,22 +3,53 @@
 module Clef
   module Plugins
     class Registry
-      attr_reader :plugins
+      ERROR_POLICIES = %i[raise warn collect].freeze
 
-      def initialize
-        @plugins = []
+      attr_reader :errors
+
+      # @param error_policy [Symbol]
+      def initialize(error_policy: :raise)
+        raise ArgumentError, "unsupported hook error policy" unless ERROR_POLICIES.include?(error_policy)
+
+        @entries = []
+        @next_order = 0
+        @error_policy = error_policy
+        @errors = []
       end
 
-      # @param plugin_class [Class]
-      # @return [Plugins::Base]
-      def register(plugin_class)
-        raise ArgumentError, "plugin must inherit Clef::Plugins::Base" unless plugin_class < Base
+      # @return [Array<Plugins::Base>]
+      def plugins
+        @entries.map { |entry| entry[:plugin] }
+      end
 
-        plugin = plugin_class.new
-        plugins << plugin
+      # @param plugin_or_class [Class, Plugins::Base]
+      # @param args [Array]
+      # @param priority [Integer]
+      # @param kwargs [Hash]
+      # @return [Plugins::Base]
+      def register(plugin_or_class, *args, priority: 0, **kwargs)
+        plugin = build_plugin(plugin_or_class, *args, **kwargs)
+        @entries << {plugin: plugin, priority: priority, order: @next_order}
+        @next_order += 1
+        @entries.sort_by! { |entry| [entry[:priority], entry[:order]] }
         plugin
       end
 
+      # @param plugin_or_class [Class, Plugins::Base, String, Symbol]
+      # @return [Plugins::Base, nil]
+      def unregister(plugin_or_class)
+        entry = @entries.find { |candidate| plugin_match?(candidate[:plugin], plugin_or_class) }
+        return unless entry
+
+        @entries.delete(entry)
+        entry[:plugin]
+      end
+
+      # @return [Array]
+      def clear
+        @entries.clear
+      end
+
       # @param hook_name [Symbol]
       # @param args [Array<Object>]
       # @return [Array<Object>]
@@ -26,7 +57,46 @@ module Clef
         plugins.each_with_object([]) do |plugin, results|
           next unless plugin.respond_to?(hook_name)
 
-          results << plugin.public_send(hook_name, *args)
+          results << run_plugin_hook(plugin, hook_name, args)
+        end
+      end
+
+      private
+
+      def build_plugin(plugin_or_class, *args, **kwargs)
+        if plugin_or_class.is_a?(Class)
+          raise ArgumentError, "plugin must inherit Clef::Plugins::Base" unless plugin_or_class < Base
+
+          return plugin_or_class.new(*args, **kwargs)
+        end
+        return plugin_or_class if plugin_or_class.is_a?(Base)
+
+        raise ArgumentError, "plugin must inherit Clef::Plugins::Base"
+      end
+
+      def plugin_match?(plugin, candidate)
+        return plugin.equal?(candidate) if candidate.is_a?(Base)
+        return plugin.is_a?(candidate) if candidate.is_a?(Class)
+
+        plugin.class.plugin_name.to_s == candidate.to_s
+      end
+
+      def run_plugin_hook(plugin, hook_name, args)
+        plugin.public_send(hook_name, *args)
+      rescue => e
+        handle_hook_error(plugin, hook_name, e)
+      end
+
+      def handle_hook_error(plugin, hook_name, error)
+        case @error_policy
+        when :raise
+          raise error
+        when :warn
+          warn("Clef plugin #{plugin.class.plugin_name} #{hook_name} failed: #{error.message}")
+          nil
+        when :collect
+          errors << {plugin: plugin, hook: hook_name, error: error}
+          nil
         end
       end
     end

data/lib/clef/renderer/base.rb

@@ -9,8 +9,8 @@ module Clef
       # @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)
+        glyph_table: Clef::Engraving::GlyphTable.new,
+        font_manager: Clef::Engraving::FontManager.new)
         @style = style
         @glyph_table = glyph_table
         @font_manager = font_manager

data/lib/clef/renderer/drawing_context.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Clef
+  module Renderer
+    class DrawingContext
+      attr_reader :vertical_axis
+
+      # @param vertical_axis [Integer]
+      def initialize(vertical_axis:)
+        raise ArgumentError, "vertical_axis must be 1 or -1" unless [1, -1].include?(vertical_axis)
+
+        @vertical_axis = vertical_axis
+      end
+
+      # @return [DrawingContext]
+      def self.pdf
+        new(vertical_axis: 1)
+      end
+
+      # @return [DrawingContext]
+      def self.svg
+        new(vertical_axis: -1)
+      end
+    end
+  end
+end

data/lib/clef/renderer/notation_helpers.rb

@@ -6,15 +6,30 @@ module Clef
       ACCIDENTAL_GLYPH_KEYS = {
         -2 => :accidental_double_flat,
         -1 => :accidental_flat,
+        0 => :accidental_natural,
         1 => :accidental_sharp,
         2 => :accidental_double_sharp
       }.freeze
       ACCIDENTAL_FALLBACK = {
         -2 => "bb",
         -1 => "b",
+        0 => "n",
         1 => "#",
         2 => "##"
       }.freeze
+      SHARP_ORDER = %i[f c g d a e b].freeze
+      FLAT_ORDER = %i[b e a d g c f].freeze
+      REST_LABELS = {
+        whole: "W",
+        half: "H",
+        quarter: "r",
+        eighth: "8",
+        sixteenth: "16",
+        thirty_second: "32",
+        sixty_fourth: "64",
+        one_twenty_eighth: "128",
+        two_fifty_sixth: "256"
+      }.freeze
 
       private
 
@@ -26,6 +41,14 @@ module Clef
         duration.base != :whole
       end
 
+      def flag_required?(duration)
+        %i[eighth sixteenth thirty_second sixty_fourth one_twenty_eighth two_fifty_sixth].include?(duration.base)
+      end
+
+      def beamable?(element)
+        element.is_a?(Clef::Core::Note) && flag_required?(element.duration)
+      end
+
       def duration_spacing(element)
         style.min_note_spacing * (element.length.to_f / Rational(1, 4).to_f)
       end
@@ -54,7 +77,7 @@ module Clef
       end
 
       def chord_notes(chord)
-        chord.pitches.map { |pitch| Clef::Core::Note.new(pitch, chord.duration) }
+        chord.sorted_pitches.map { |pitch| Clef::Core::Note.new(pitch, chord.duration) }
       end
 
       def chord_stem_anchor_note(notes, direction)
@@ -66,6 +89,74 @@ module Clef
       def chord_stem_length(notes, clef, direction)
         notes.map { |note| Clef::Layout::Stem.length(note, clef, direction) }.max
       end
+
+      def key_signature_alterations(key_signature)
+        return {} unless key_signature
+
+        accidentals = key_signature.accidentals
+        order = (accidentals[:type] == :sharp) ? SHARP_ORDER : FLAT_ORDER
+        alteration = (accidentals[:type] == :sharp) ? 1 : -1
+        order.first(accidentals[:count].to_i).to_h { |note_name| [note_name, alteration] }
+      end
+
+      def accidental_for_pitch(pitch, key_signature, state)
+        expected = key_signature_alterations(key_signature)[pitch.note_name] || 0
+        current = state.fetch(pitch.note_name, expected)
+        return nil if current == pitch.alteration
+
+        state[pitch.note_name] = pitch.alteration
+        pitch.alteration
+      end
+
+      def rest_label(duration)
+        REST_LABELS.fetch(duration.base)
+      end
+
+      def element_notes(element)
+        case element
+        when Clef::Core::Note then [element]
+        when Clef::Core::Chord then chord_notes(element)
+        when Clef::Core::Tuplet then element.elements.flat_map { |child| element_notes(child) }
+        else []
+        end
+      end
+
+      def dynamic_text(dynamic)
+        dynamic.type.to_s
+      end
+
+      def flatten_elements(elements)
+        elements.flat_map do |element|
+          element.is_a?(Clef::Core::Tuplet) ? flatten_elements(element.elements) : element
+        end
+      end
+
+      def lyric_elements(elements)
+        flatten_elements(elements).select do |element|
+          element.is_a?(Clef::Core::Note) || element.is_a?(Clef::Core::Chord)
+        end
+      end
+
+      def lyric_events(lyric, elements)
+        note_index = 0
+        previous_element = nil
+        lyric.syllables.filter_map do |syllable|
+          if Clef::Notation::Lyric.hyphen?(syllable)
+            next {type: :hyphen, from: previous_element, to: elements[note_index]}
+          end
+
+          element = elements[note_index]
+          note_index += 1
+          if Clef::Notation::Lyric.extender?(syllable)
+            event = {type: :extender, from: previous_element, to: element}
+            previous_element = element if element
+            next event
+          end
+
+          previous_element = element if element
+          {type: :text, syllable: syllable, element: element}
+        end
+      end
     end
   end
 end