clef 0.1.0 → 1.0.0

data/lib/clef/parser/dsl.rb

@@ -5,11 +5,33 @@ module Clef
     module DSL
       class Error < StandardError; end
 
+      module BlockEvaluation
+        private
+
+        def evaluate_block(target, &block)
+          return unless block
+          return block.call(target) if block.arity == 1
+
+          target.instance_eval(&block)
+        end
+
+        def method_missing(name, *_args, &_block)
+          raise Error, "invalid DSL method: #{name}"
+        end
+
+        def respond_to_missing?(_name, _include_private = false)
+          false
+        end
+      end
+
       class ScoreBuilder
+        include BlockEvaluation
+
         attr_reader :score
 
-        def initialize
+        def initialize(plugins: Clef.plugins)
           @score = Clef::Core::Score.new
+          @score.plugins = plugins
           @default_group = Clef::Core::StaffGroup.new([], bracket_type: :none)
           score.add_staff_group(@default_group)
         end
@@ -36,38 +58,30 @@ module Clef
         # @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)
+          evaluate_block(StaffBuilder.new(staff), &block)
+          score.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)
+          raise Error, "staff_group requires a block" unless block
+
           group = Clef::Core::StaffGroup.new([], bracket_type: bracket_type)
-          GroupBuilder.new(group).instance_eval(&block)
+          evaluate_block(GroupBuilder.new(group), &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
+        include BlockEvaluation
+
         def initialize(group)
           @group = group
         end
@@ -77,13 +91,15 @@ module Clef
         # @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
+          evaluate_block(StaffBuilder.new(staff), &block)
           @group.add_staff(staff)
           staff
         end
       end
 
       class StaffBuilder
+        include BlockEvaluation
+
         def initialize(staff)
           @staff = staff
           @current_measure = nil
@@ -91,7 +107,7 @@ module Clef
           @lyrics = []
         end
 
-        # @param tonic [Symbol, Clef::Core::Pitch]
+        # @param tonic [Symbol, String, Clef::Core::Pitch]
         # @param mode [Symbol]
         def key(tonic, mode = :major)
           @staff.key_signature = Clef::Core::KeySignature.new(tonic, mode)
@@ -103,34 +119,54 @@ module Clef
           @staff.time_signature = Clef::Core::TimeSignature.new(numerator, denominator)
         end
 
+        # @param program [Integer]
+        def instrument(program)
+          @staff.set_metadata(:midi_program, program)
+        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)
+          evaluate_block(VoiceBuilder.new(voice), &block)
+          validate_measure_overflow!(measure)
           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)
+          voice_builder = nil
           segments.each_with_index do |segment, idx|
             measure = ensure_measure
-            VoiceBuilder.new(measure.voice(:default)).notes(segment)
+            voice_builder ||= VoiceBuilder.new(measure.voice(:default))
+            voice_builder.use_voice(measure.voice(:default)).notes(segment)
+            validate_measure_overflow!(measure)
             advance_measure if idx < segments.length - 1
           end
         end
 
+        def bar
+          advance_measure
+        end
+
+        # @param number [Integer, nil]
+        def measure(number = nil, &block)
+          target_number = number || @next_measure_number
+          @current_measure = existing_measure(target_number) || new_measure(target_number)
+          evaluate_block(self, &block)
+          @current_measure
+        ensure
+          advance_measure
+        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
+          @staff.set_metadata(:lyrics, @lyrics)
         end
 
         private
@@ -138,12 +174,20 @@ module Clef
         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
+          @current_measure = new_measure(@next_measure_number)
+        end
+
+        def existing_measure(number)
+          @staff.measures.find { |measure| measure.number == number }
+        end
+
+        def new_measure(number)
+          measure = Clef::Core::Measure.new(number, time_signature: @staff.time_signature)
+          measure.key_signature = @staff.key_signature
+          measure.clef = @staff.clef
+          @staff.add_measure(measure)
+          @next_measure_number = measure.number + 1
+          measure
         end
 
         def advance_measure
@@ -153,11 +197,33 @@ module Clef
         def split_measures(input)
           input.to_s.split("|").map(&:strip).reject(&:empty?)
         end
+
+        def validate_measure_overflow!(measure)
+          ids = measure.overflowing_voice_ids
+          return if ids.empty?
+
+          raise Error, "measure #{measure.number} voice #{ids.join(", ")} exceeds time signature length"
+        end
       end
 
       class VoiceBuilder
+        include BlockEvaluation
+
         def initialize(voice)
           @voice = voice
+          @last_duration = Clef::Core::Duration.quarter
+          @pending_tie = false
+          @pending_articulations = []
+          @open_slur = false
+          @open_beam = false
+          @last_note = nil
+        end
+
+        # @param voice [Clef::Core::Voice]
+        # @return [VoiceBuilder]
+        def use_voice(voice)
+          @voice = voice
+          self
         end
 
         # @param pitch_str [String]
@@ -174,7 +240,7 @@ module Clef
         # @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))
+          @voice.add(Clef::Core::Rest.new(duration, kind: opts.fetch(:kind, :visible), measures: opts.fetch(:measures, 1)))
         end
 
         # @param pitch_strs [Array<String>]
@@ -186,6 +252,18 @@ module Clef
           @voice.add(Clef::Core::Chord.new(pitches, duration))
         end
 
+        # @param type [Symbol]
+        def dynamic(type)
+          @voice.add(Clef::Notation::Dynamic.new(type))
+        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)
+          @voice.add(Clef::Core::Tempo.new(beat_unit: duration, bpm: bpm))
+        end
+
         # @param lilypond_string [String]
         def notes(lilypond_string)
           parse_tokens(lilypond_string).each { |token| add_token(token) }
@@ -193,71 +271,184 @@ module Clef
 
         # @param actual [Integer]
         # @param normal [Integer]
-        def tuplet(actual, normal)
+        def tuplet(actual, normal, &block)
           raise ArgumentError, "tuplet values must be positive" unless actual.positive? && normal.positive?
-
           return unless block_given?
 
-          yield
+          voice = Clef::Core::Voice.new(id: @voice.id)
+          evaluate_block(self.class.new(voice), &block)
+          @voice.add(Clef::Core::Tuplet.new(actual, normal, voice.elements))
         end
 
         private
 
         def parse_tokens(input)
-          input.to_s.split(/\s+/).reject(&:empty?)
+          Clef::Parser::LilypondLexer.new.tokenize_with_locations(input)
         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)
+          value = token.to_s
+          return if value == "|"
+          return start_slur if value == "("
+          return end_slur if value == ")"
+          return start_beam if value == "["
+          return end_beam if value == "]"
+          return tie_next if value == "~"
+          return add_pending_articulation(value) if articulation_token?(value)
+          return add_command_token(value) if value.start_with?("\\")
+
+          if value.start_with?("r")
+            add_rest_token(value)
+          elsif value.start_with?("<")
+            add_chord_token(value)
           else
-            add_note_token(token)
+            add_note_token(value)
           end
-        rescue StandardError => e
-          raise Error, "failed to parse token '#{token}': #{e.message}"
+        rescue => e
+          raise Error, "failed to parse token '#{value}'#{token_location(token)}: #{e.message}"
+        end
+
+        def token_location(token)
+          return "" unless token.respond_to?(:line) && token.respond_to?(:column)
+
+          " at line #{token.line}, column #{token.column}"
         end
 
         def add_rest_token(token)
-          match = /\Ar(\d+)(\.*)\z/.match(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)
+          duration = duration_from_match(match[1], match[2])
           @voice.add(Clef::Core::Rest.new(duration))
         end
 
         def add_chord_token(token)
-          match = /\A<([^>]+)>(\d+)(\.*)\z/.match(token)
+          token, tied = split_tie_suffix(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)
+          duration = duration_from_match(match[2], match[3])
           @voice.add(Clef::Core::Chord.new(pitches, duration))
+          tie_next if tied
         end
 
         def add_note_token(token)
-          match = /\A([a-g](?:isis|eses|is|es)?[',]*)(\d+)(\.*)\z/.match(token)
+          token, tied = split_tie_suffix(token)
+          token, articulations = split_articulation_suffixes(token)
+          @pending_articulations.concat(articulations)
+          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))
+          duration = duration_from_match(match[2], match[3])
+          note = Clef::Core::Note.new(pitch, duration,
+            articulations: consume_articulations,
+            tied: consume_tie_state)
+          note.slur_start = consume_slur_start
+          note.beam_start = consume_beam_start
+          @voice.add(note)
+          @last_note = note
+          tie_next if tied
         end
 
         def parse_pitch(value)
-          parse_scientific_pitch(value) || Clef::Core::Pitch.parse(value.downcase)
+          Clef::Core::Pitch.parse_any(value)
+        end
+
+        def duration_from_match(number, dots)
+          duration = if number.empty?
+            @last_duration
+          else
+            Clef::Core::Duration.from_lilypond(number.to_i, dots.length)
+          end
+          @last_duration = duration
+          duration
+        end
+
+        def split_tie_suffix(token)
+          return [token.delete_suffix("~"), true] if token.end_with?("~")
+
+          [token, false]
+        end
+
+        def split_articulation_suffixes(token)
+          articulations = []
+          loop do
+            suffix = {"-." => :staccato, "->" => :accent, "--" => :tenuto}.find { |marker, _| token.end_with?(marker) }
+            break unless suffix
+
+            marker, articulation = suffix
+            token = token.delete_suffix(marker)
+            articulations << articulation
+          end
+          [token, articulations.reverse]
+        end
+
+        def articulation_token?(token)
+          %w[-. -> --].include?(token)
+        end
+
+        def add_pending_articulation(token)
+          articulation = {"-." => :staccato, "->" => :accent, "--" => :tenuto}.fetch(token)
+          if @last_note
+            @last_note.add_articulation(articulation)
+          else
+            @pending_articulations << articulation
+          end
+        end
+
+        def add_command_token(token)
+          dynamic_name = token.delete_prefix("\\").to_sym
+          return dynamic(dynamic_name) if Clef::Notation::Dynamic::TYPES.include?(dynamic_name)
+
+          raise ArgumentError, "unsupported command token: #{token}"
+        end
+
+        def consume_articulations
+          @pending_articulations.tap { @pending_articulations = [] }
+        end
+
+        def tie_next
+          @last_note.tied = :start if @last_note
+          @pending_tie = true
+        end
+
+        def consume_tie_state
+          return false unless @pending_tie
+
+          @pending_tie = false
+          :stop
+        end
+
+        def start_slur
+          @open_slur = true
+        end
+
+        def end_slur
+          @last_note.slur_end = true if @last_note
+        end
+
+        def start_beam
+          @open_beam = true
+        end
+
+        def end_beam
+          @last_note.beam_end = true if @last_note
+        end
+
+        def consume_slur_start
+          return false unless @open_slur
+
+          @open_slur = false
+          true
         end
 
-        def parse_scientific_pitch(value)
-          match = /\A([A-Ga-g])([#b]{0,2})(-?\d+)\z/.match(value)
-          return nil unless match
+        def consume_beam_start
+          return false unless @open_beam
 
-          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)
+          @open_beam = false
+          true
         end
       end
     end

data/lib/clef/parser/lilypond_lexer.rb

@@ -3,19 +3,59 @@
 module Clef
   module Parser
     class LilypondLexer
-      TOKEN_REGEX = /\\[a-zA-Z]+|\{\}|\{|\}|<[^>]+>\d+\.*|[a-g](?:isis|eses|is|es)?[',]*\d+\.*|r\d+\.*|\|/m
+      Token = Struct.new(:value, :line, :column, keyword_init: true) do
+        def to_s
+          value
+        end
+
+        def match?(*args)
+          value.match?(*args)
+        end
+
+        def ==(other)
+          value == other || super
+        end
+      end
+
+      TOKEN_REGEX = /
+        \\[a-zA-Z]+ |
+        << | >> |
+        \{\} | \{ | \} |
+        <[^>]+>\d*\.*~? |
+        [a-g](?:isis|eses|is|es)?[',]*\d*\.*~? |
+        r\d*\.* |
+        -- | -> | -\. |
+        [~()\[\]|]
+      /mx
 
       # @param input [String]
       # @return [Array<String>]
       def tokenize(input)
+        tokenize_with_locations(input).map(&:value)
+      end
+
+      # @param input [String]
+      # @return [Array<Token>]
+      def tokenize_with_locations(input)
         sanitized = strip_comments(input)
-        sanitized.scan(TOKEN_REGEX)
+        sanitized.enum_for(:scan, TOKEN_REGEX).map do
+          value = Regexp.last_match[0]
+          line, column = location_for(sanitized, Regexp.last_match.begin(0))
+          Token.new(value: value, line: line, column: column)
+        end
       end
 
       private
 
       def strip_comments(input)
-        input.to_s.each_line.map { |line| line.sub(/%.*/, "") }.join
+        input.to_s.gsub(/%\{.*?%\}/m, "").each_line.map { |line| line.sub(/%.*/, "") }.join
+      end
+
+      def location_for(input, offset)
+        prefix = input[0...offset]
+        line = prefix.count("\n") + 1
+        column = offset - (prefix.rindex("\n") || -1)
+        [line, column]
       end
     end
   end