clef 0.1.0 → 1.0.0

data/lib/clef/engraving/font_manager.rb

@@ -21,7 +21,7 @@ module Clef
       def register_with(pdf, family_name: "Bravura")
         return "Helvetica" unless font_available?
 
-        pdf.font_families.update(family_name => { normal: font_path })
+        pdf.font_families.update(family_name => {normal: font_path})
         family_name
       end
 

data/lib/clef/engraving/glyph_table.rb

@@ -30,22 +30,37 @@ module Clef
         fermata: "\uE4C0"
       }.merge((0..9).to_h { |n| [:"time_#{n}", (0xE080 + n).chr(Encoding::UTF_8)] }).freeze
 
+      # @param glyphs [Hash]
+      def initialize(glyphs: GLYPHS)
+        @glyphs = glyphs.dup
+      end
+
       # @param name [Symbol]
       # @return [String]
       def fetch(name)
-        GLYPHS.fetch(name)
+        @glyphs.fetch(name)
       end
 
       # @param name [Symbol]
       # @return [String, nil]
       def [](name)
-        GLYPHS[name]
+        @glyphs[name]
       end
 
       # @param name [Symbol]
       # @return [Boolean]
       def key?(name)
-        GLYPHS.key?(name)
+        @glyphs.key?(name)
+      end
+
+      # @param name [Symbol]
+      # @param glyph [String]
+      # @return [String]
+      def register(name, glyph)
+        raise ArgumentError, "glyph name must be a Symbol" unless name.is_a?(Symbol)
+        raise ArgumentError, "glyph must be a String" unless glyph.is_a?(String)
+
+        @glyphs[name] = glyph
       end
     end
   end

data/lib/clef/engraving/style.rb

@@ -3,25 +3,64 @@
 module Clef
   module Engraving
     class Style
-      attr_reader :page_size, :margin, :staff_size, :staff_space, :min_note_spacing
+      attr_reader :page_size, :margin, :staff_size, :staff_space, :min_note_spacing,
+        :line_width, :system_gap, :staff_gap, :measure_padding,
+        :notehead_width, :beam_thickness
 
       # @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)
+      # @param line_width [Numeric]
+      # @param system_gap [Numeric]
+      # @param staff_gap [Numeric]
+      # @param measure_padding [Numeric]
+      # @param notehead_width [Numeric]
+      # @param beam_thickness [Numeric]
+      def initialize(page_size: "A4", margin: 36, staff_size: 20, staff_space: 10, min_note_spacing: nil,
+        line_width: 820, system_gap: 72, staff_gap: 90, measure_padding: 14,
+        notehead_width: 7, beam_thickness: nil)
+        min_note_spacing ||= Rules::MIN_NOTE_SPACING * staff_space
+        beam_thickness ||= Rules::BEAM_THICKNESS * staff_space
+
+        validate_positive!(
+          margin: margin,
+          staff_size: staff_size,
+          staff_space: staff_space,
+          min_note_spacing: min_note_spacing,
+          line_width: line_width,
+          system_gap: system_gap,
+          staff_gap: staff_gap,
+          measure_padding: measure_padding,
+          notehead_width: notehead_width,
+          beam_thickness: beam_thickness
+        )
+
         @page_size = page_size
         @margin = margin
         @staff_size = staff_size
         @staff_space = staff_space
         @min_note_spacing = min_note_spacing
+        @line_width = line_width
+        @system_gap = system_gap
+        @staff_gap = staff_gap
+        @measure_padding = measure_padding
+        @notehead_width = notehead_width
+        @beam_thickness = beam_thickness
       end
 
       # @return [Style]
       def self.default
         new
       end
+
+      private
+
+      def validate_positive!(values)
+        invalid = values.filter_map { |name, value| name unless value.is_a?(Numeric) && value.positive? }
+        raise ArgumentError, "style values must be positive: #{invalid.join(", ")}" unless invalid.empty?
+      end
     end
   end
 end

data/lib/clef/ir/moment.rb

@@ -16,8 +16,8 @@ module Clef
 
       # @param duration [Rational, #length]
       # @return [Moment]
-      def +(duration)
-        self.class.new(value + normalize_duration(duration))
+      def +(other)
+        self.class.new(value + normalize_duration(other))
       end
 
       # @param other [Moment, Rational, Integer]

data/lib/clef/ir/music_tree.rb

@@ -19,7 +19,7 @@ module Clef
           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)
+            current += measure_length_for(measure)
           end
         end
 
@@ -39,7 +39,7 @@ module Clef
           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
+            cursor += element.length
           end
         end
 

data/lib/clef/ir/timeline.rb

@@ -17,6 +17,11 @@ module Clef
         raise ArgumentError, "event must be a Clef::Ir::Event" unless event.is_a?(Event)
 
         events << event
+        self
+      end
+
+      # @return [Timeline]
+      def sort!
         events.sort_by! { |item| item.moment.value }
         self
       end
@@ -25,7 +30,7 @@ module Clef
       # @return [Array<Event>]
       def events_at(moment)
         target = moment_value(moment)
-        events.select { |event| event.moment.value == target }
+        sorted_events.select { |event| event.moment.value == target }
       end
 
       # @param from [Moment, Rational, Integer]
@@ -34,7 +39,16 @@ module Clef
       def events_between(from, to)
         lower = moment_value(from)
         upper = moment_value(to)
-        events.select { |event| (lower..upper).cover?(event.moment.value) }
+        sorted_events.select { |event| (lower..upper).cover?(event.moment.value) }
+      end
+
+      # @param from [Moment, Rational, Integer]
+      # @param to [Moment, Rational, Integer]
+      # @return [Array<Event>]
+      def events_in_range(from, to)
+        lower = moment_value(from)
+        upper = moment_value(to)
+        sorted_events.select { |event| event.moment.value >= lower && event.moment.value < upper }
       end
 
       # @yield [Moment]
@@ -46,19 +60,25 @@ module Clef
       end
 
       def each(&block)
-        events.each(&block)
+        sorted_events.each(&block)
       end
 
       # @return [Rational]
       def shortest_duration
-        durations = events.filter_map { |event| event.element.length if event.element.respond_to?(:length) }
+        durations = events.filter_map do |event|
+          event.element.length if event.element.respond_to?(:length) && event.element.length.positive?
+        end
         durations.min || Rational(1, 4)
       end
 
       private
 
       def unique_moments
-        events.map(&:moment).uniq.sort
+        sorted_events.map(&:moment).uniq
+      end
+
+      def sorted_events
+        events.sort_by { |item| item.moment.value }
       end
 
       def moment_value(value)

data/lib/clef/layout/beam_layout.rb

@@ -20,8 +20,8 @@ module Clef
         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 }
+          slope = ((last_y - first_y) / [beam_group.length - 1, 1].max).clamp(-0.5, 0.5)
+          {start_y: first_y, end_y: first_y + slope * (beam_group.length - 1), slope: slope}
         end
 
         private

data/lib/clef/layout/item.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Clef
+  module Layout
+    class Item
+      attr_reader :type, :moment, :staff_id, :measure_number, :payload
+
+      # @param type [Symbol]
+      # @param moment [Clef::Ir::Moment]
+      # @param staff_id [Symbol, String, nil]
+      # @param measure_number [Integer, nil]
+      # @param payload [Hash]
+      def initialize(type:, moment:, staff_id: nil, measure_number: nil, payload: {})
+        raise ArgumentError, "type must be a Symbol" unless type.is_a?(Symbol)
+        raise ArgumentError, "moment must be a Clef::Ir::Moment" unless moment.is_a?(Clef::Ir::Moment)
+        raise ArgumentError, "payload must be a Hash" unless payload.is_a?(Hash)
+
+        @type = type
+        @moment = moment
+        @staff_id = staff_id
+        @measure_number = measure_number
+        @payload = payload.dup
+      end
+    end
+  end
+end

data/lib/clef/layout/spacing.rb

@@ -3,19 +3,21 @@
 module Clef
   module Layout
     class Spacing
-      attr_reader :timeline, :style, :stretch_factor
+      attr_reader :timeline, :style, :stretch_factor, :extra_moments
 
       # @param timeline [Clef::Ir::Timeline]
       # @param style [Clef::Engraving::Style]
-      def initialize(timeline, style)
+      # @param extra_moments [Array<Clef::Ir::Moment>]
+      def initialize(timeline, style, extra_moments: [])
         @timeline = timeline
         @style = style
+        @extra_moments = extra_moments
         @stretch_factor = 1.0
       end
 
       # @return [Hash{Clef::Ir::Moment=>Float}]
       def compute
-        moments = timeline.each_moment.to_a.sort
+        moments = (timeline.each_moment.to_a + extra_moments).uniq.sort
         return {} if moments.empty?
 
         build_positions(moments)
@@ -36,7 +38,7 @@ module Clef
       private
 
       def build_positions(moments)
-        positions = { moments.first => 0.0 }
+        positions = {moments.first => 0.0}
         total = 0.0
         moments.each_cons(2) do |left, right|
           total += interval_width(right.value - left.value)

data/lib/clef/layout/stem.rb

@@ -3,16 +3,15 @@
 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]
+        # @param clef [Clef::Core::Clef]
         # @return [Symbol]
-        def direction(note_or_notes, _clef)
+        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
+          middle = diatonic_step(clef.reference_pitch)
+          down_votes = notes.count { |note| diatonic_step(note.pitch) > middle }
+          (down_votes > (notes.length / 2.0)) ? :down : :up
         end
 
         # @param note [Clef::Core::Note]
@@ -26,6 +25,11 @@ module Clef
 
         private
 
+        def diatonic_step(pitch)
+          note_index = Clef::Core::Pitch::VALID_NOTE_NAMES.index(pitch.note_name)
+          (pitch.octave * 7) + note_index
+        end
+
         def ledger_extension(pitch)
           return 1.5 if pitch.to_midi > 84
           return 1.5 if pitch.to_midi < 48

data/lib/clef/layout/system_layout.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Clef
+  module Layout
+    class SystemLayout
+      System = Struct.new(:page_index, :line_index, :line_top, :start_moment, :end_moment,
+        :position_offset, :x_origin, :y_origin, :staff_offsets, keyword_init: true) do
+        def staff_offset(staff_id)
+          staff_offsets.fetch(staff_id)
+        end
+
+        def staff_origin(staff_id)
+          [x_origin, y_origin + staff_offset(staff_id)]
+        end
+
+        def include_moment?(moment)
+          value = moment.is_a?(Clef::Ir::Moment) ? moment.value : Rational(moment)
+          value.between?(start_moment.value, end_moment.value)
+        end
+      end
+
+      attr_reader :score, :pages, :positions, :style
+
+      # @param score [Clef::Core::Score]
+      # @param pages [Array<Array<Array<Hash>>>]
+      # @param positions [Hash]
+      # @param style [Clef::Engraving::Style]
+      def initialize(score, pages:, positions:, style:)
+        @score = score
+        @pages = pages
+        @positions = positions
+        @style = style
+      end
+
+      # @return [Array<System>]
+      def build
+        pages.flat_map.with_index do |page, page_index|
+          page.map.with_index do |line, line_index|
+            build_system(line, page_index, line_index)
+          end
+        end
+      end
+
+      private
+
+      def build_system(line, page_index, line_index)
+        start_moment = line.first.fetch(:moment)
+        end_moment = line.last.fetch(:moment)
+        System.new(
+          page_index: page_index,
+          line_index: line_index,
+          line_top: line_index * system_height,
+          start_moment: start_moment,
+          end_moment: end_moment,
+          position_offset: positions.fetch(start_moment, 0.0),
+          x_origin: -positions.fetch(start_moment, 0.0),
+          y_origin: line_index * system_height,
+          staff_offsets: staff_offsets
+        )
+      end
+
+      def staff_offsets
+        score.staves.each_with_index.to_h { |staff, index| [staff.id, index * style.staff_gap] }
+      end
+
+      def system_height
+        [(score.staves.length - 1), 0].max * style.staff_gap + style.system_gap
+      end
+    end
+  end
+end

data/lib/clef/midi/channel_map.rb

@@ -4,10 +4,13 @@ module Clef
   module Midi
     class ChannelMap
       # @param staff_index [Integer]
+      # @param percussion [Boolean]
       # @return [Integer]
-      def channel_for(staff_index)
+      def channel_for(staff_index, percussion: false)
+        return 9 if percussion
+
         base = staff_index % 15
-        base >= 9 ? base + 1 : base
+        (base >= 9) ? base + 1 : base
       end
     end
   end