webmidi 0.1.0

data/lib/webmidi/middleware/transpose.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Transpose < Base
+      def initialize(app, semitones: 0, **options)
+        super(app, **options)
+        @semitones = semitones
+      end
+
+      def call(message)
+        if note_message?(message)
+          new_note = (message.note + @semitones).clamp(0, 127)
+          transposed = message.with(note: new_note)
+          @app.call(transposed)
+        else
+          @app.call(message)
+        end
+      end
+
+      private
+
+      def note_message?(msg)
+        msg.is_a?(Message::Channel::NoteOn) ||
+          msg.is_a?(Message::Channel::NoteOff) ||
+          msg.is_a?(Message::Channel::PolyphonicPressure)
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/velocity_clamp.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class VelocityClamp < Base
+      def initialize(app, min: 0, max: 127, include_note_off: true, **options)
+        super(app, **options)
+        validate_velocity!(min, "min")
+        validate_velocity!(max, "max")
+        raise InvalidMessageError, "min cannot be greater than max" if min > max
+
+        @min = min
+        @max = max
+        @include_note_off = include_note_off
+      end
+
+      def call(message)
+        return @app.call(message) unless velocity_message?(message)
+
+        @app.call(message.with(velocity: message.velocity.clamp(@min, @max)))
+      end
+
+      private
+
+      def velocity_message?(message)
+        message.is_a?(Message::Channel::NoteOn) ||
+          (@include_note_off && message.is_a?(Message::Channel::NoteOff))
+      end
+
+      def validate_velocity!(velocity, name)
+        return if velocity.is_a?(Integer) && velocity.between?(0, 127)
+
+        raise InvalidMessageError, "#{name} must be between 0 and 127, got #{velocity.inspect}"
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/velocity_scale.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class VelocityScale < Base
+      def initialize(app, factor: 1.0, min: 0, max: 127, curve: :linear, **options)
+        super(app, **options)
+        validate_options!(factor, min, max, curve)
+        @factor = factor
+        @min = min
+        @max = max
+        @curve = curve
+        @include_note_off = options.fetch(:include_note_off, true)
+      end
+
+      def call(message)
+        if velocity_message?(message)
+          scaled = apply_curve(message.velocity)
+          scaled_msg = message.with(velocity: scaled)
+          @app.call(scaled_msg)
+        else
+          @app.call(message)
+        end
+      end
+
+      private
+
+      def velocity_message?(msg)
+        msg.is_a?(Message::Channel::NoteOn) || (@include_note_off && msg.is_a?(Message::Channel::NoteOff))
+      end
+
+      def apply_curve(velocity)
+        normalized = velocity / 127.0
+        result = case @curve
+        when :linear
+          normalized * @factor
+        when :exponential
+          (normalized**2) * @factor
+        when :logarithmic
+          Math.sqrt(normalized) * @factor
+        end
+        (result * 127).round.clamp(@min, @max)
+      end
+
+      def validate_options!(factor, min, max, curve)
+        raise InvalidMessageError, "Velocity factor must be non-negative" unless factor.is_a?(Numeric) && factor >= 0
+        unless min.is_a?(Integer) && min.between?(0, 127) && max.is_a?(Integer) && max.between?(0, 127)
+          raise InvalidMessageError, "Velocity min/max must be MIDI data bytes"
+        end
+        raise InvalidMessageError, "Velocity min cannot be greater than max" if min > max
+        raise InvalidMessageError, "Unknown velocity curve: #{curve.inspect}" unless %i[linear exponential logarithmic].include?(curve)
+      end
+    end
+  end
+end

data/lib/webmidi/middleware.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "middleware/base"
+require_relative "middleware/stack"
+require_relative "middleware/logger"
+require_relative "middleware/filter"
+require_relative "middleware/transpose"
+require_relative "middleware/velocity_scale"
+require_relative "middleware/channel_map"
+require_relative "middleware/note_range_filter"
+require_relative "middleware/velocity_clamp"
+require_relative "middleware/timing_gate"
+require_relative "middleware/panic"
+require_relative "middleware/split_by_channel"
+require_relative "middleware/recorder"
+require_relative "middleware/pipeline"
+
+module Webmidi
+  module Middleware
+  end
+end

data/lib/webmidi/music/chord.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Music
+    module Chord
+      TYPES = {
+        major: [0, 4, 7],
+        minor: [0, 3, 7],
+        dim: [0, 3, 6],
+        aug: [0, 4, 8],
+        sus2: [0, 2, 7],
+        sus4: [0, 5, 7],
+        dom7: [0, 4, 7, 10],
+        maj7: [0, 4, 7, 11],
+        min7: [0, 3, 7, 10],
+        dim7: [0, 3, 6, 9],
+        half_dim7: [0, 3, 6, 10],
+        aug7: [0, 4, 8, 10],
+        min_maj7: [0, 3, 7, 11],
+        dom9: [0, 4, 7, 10, 14],
+        maj9: [0, 4, 7, 11, 14],
+        min9: [0, 3, 7, 10, 14],
+        dom11: [0, 4, 7, 10, 14, 17],
+        dom13: [0, 4, 7, 10, 14, 17, 21],
+        add9: [0, 4, 7, 14],
+        six: [0, 4, 7, 9],
+        min6: [0, 3, 7, 9],
+        power: [0, 7]
+      }.freeze
+
+      @custom_types = {}
+
+      module_function
+
+      def build(root, type = :major, inversion: 0, range: :strict)
+        validate_inversion!(inversion)
+        root_midi = Note.to_midi(root)
+        intervals = TYPES[type] || @custom_types[type]
+        raise InvalidMessageError, "Unknown chord type: #{type}" unless intervals
+
+        notes = intervals.map { |i| root_midi + i }
+
+        inversion.times do
+          notes.push(notes.shift + 12)
+        end
+
+        apply_range_policy(notes, range)
+      end
+
+      def define(name, intervals = nil, &block)
+        intervals = block.call(0) if block
+        validate_intervals!(intervals)
+        @custom_types[name] = intervals.dup.freeze
+        self
+      end
+
+      def types
+        TYPES.keys + @custom_types.keys
+      end
+
+      def validate_inversion!(inversion)
+        return if inversion.is_a?(Integer) && inversion >= 0
+
+        raise InvalidMessageError, "Chord inversion must be a non-negative integer, got #{inversion.inspect}"
+      end
+
+      def validate_intervals!(intervals)
+        unless intervals.respond_to?(:each) && intervals.all? { |interval| interval.is_a?(Integer) }
+          raise InvalidMessageError, "Chord intervals must be integers"
+        end
+      end
+
+      def apply_range_policy(notes, range)
+        case range
+        when :strict
+          notes.each { |note| Note.validate_midi!(note) }
+          notes
+        when :clamp
+          notes.map { |note| note.clamp(0, 127) }
+        when :allow_out_of_range
+          notes
+        else
+          raise InvalidMessageError, "Unknown range policy: #{range.inspect}"
+        end
+      end
+
+      private_class_method :validate_inversion!, :validate_intervals!, :apply_range_policy
+    end
+  end
+end

data/lib/webmidi/music/note.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Music
+    module Note
+      NOTE_NAMES = {
+        "C" => 0, "D" => 2, "E" => 4, "F" => 5,
+        "G" => 7, "A" => 9, "B" => 11
+      }.freeze
+
+      MIDI_TO_NAME = %w[C Cs D Ds E F Fs G Gs A As B].freeze
+      MIDI_RANGE = 0..127
+
+      module_function
+
+      def to_midi(input, validate: true)
+        midi = case input
+        when Integer
+          input
+        when Symbol
+          parse_note_name(input.to_s)
+        when String
+          parse_note_name(input)
+        else
+          raise InvalidMessageError, "Cannot convert #{input.class} to MIDI note"
+        end
+        validate_midi!(midi) if validate
+        midi
+      end
+
+      def to_name(midi_number, sharps: true)
+        validate_midi!(midi_number)
+        octave = (midi_number / 12) - 1
+        note_index = midi_number % 12
+        name = if sharps
+          MIDI_TO_NAME[note_index]
+        else
+          %w[C Db D Eb E F Gb G Ab A Bb B][note_index]
+        end
+        "#{name}#{octave}"
+      end
+
+      def to_frequency(midi_number, a4: 440.0)
+        validate_midi!(midi_number)
+        validate_frequency_reference!(a4)
+        a4 * (2.0**((midi_number - 69) / 12.0))
+      end
+
+      def from_frequency(freq, a4: 440.0)
+        validate_frequency!(freq)
+        validate_frequency_reference!(a4)
+        (12 * Math.log2(freq / a4) + 69).round
+      end
+
+      def parse_note_name(str)
+        match = str.match(/\A([A-Ga-g])(ss|\#\#|s|\#|bb|b)?(-?\d+)\z/)
+        raise InvalidMessageError, "Invalid note name: #{str}" unless match
+
+        name = match[1].upcase
+        accidental = match[2]
+        octave = match[3].to_i
+
+        base = NOTE_NAMES[name]
+        raise InvalidMessageError, "Unknown note: #{name}" unless base
+
+        midi = base + ((octave + 1) * 12)
+        case accidental
+        when "s", "#"
+          midi += 1
+        when "ss", "##"
+          midi += 2
+        when "b"
+          midi -= 1
+        when "bb"
+          midi -= 2
+        end
+
+        midi
+      end
+
+      def validate_midi!(midi_number)
+        return if midi_number.is_a?(Integer) && MIDI_RANGE.cover?(midi_number)
+
+        raise InvalidMessageError, "MIDI note must be between 0 and 127, got #{midi_number.inspect}"
+      end
+
+      def validate_frequency!(freq)
+        return if freq.is_a?(Numeric) && freq.positive?
+
+        raise InvalidMessageError, "Frequency must be positive, got #{freq.inspect}"
+      end
+
+      def validate_frequency_reference!(a4)
+        return if a4.is_a?(Numeric) && a4.positive?
+
+        raise InvalidMessageError, "A4 reference frequency must be positive, got #{a4.inspect}"
+      end
+
+      private_class_method :parse_note_name, :validate_frequency!, :validate_frequency_reference!
+    end
+  end
+end

data/lib/webmidi/music/rhythm.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Music
+    module Rhythm
+      DURATIONS = {
+        whole: 4.0,
+        half: 2.0,
+        quarter: 1.0,
+        eighth: 0.5,
+        sixteenth: 0.25,
+        thirty_second: 0.125,
+        dotted_whole: 6.0,
+        dotted_half: 3.0,
+        dotted_quarter: 1.5,
+        dotted_eighth: 0.75,
+        triplet_quarter: 2.0 / 3.0,
+        triplet_eighth: 1.0 / 3.0,
+        triplet_sixteenth: 1.0 / 6.0
+      }.freeze
+
+      module_function
+
+      def duration_in_beats(name)
+        DURATIONS[name] || raise(InvalidMessageError, "Unknown duration: #{name}")
+      end
+
+      def duration_in_ticks(name, ppqn: 480)
+        validate_ppqn!(ppqn)
+        (duration_in_beats(name) * ppqn).round
+      end
+
+      def duration_in_seconds(name, bpm: 120)
+        validate_bpm!(bpm)
+        duration_in_beats(name) * (60.0 / bpm)
+      end
+
+      def beats_to_ticks(beats, ppqn: 480)
+        validate_beats!(beats)
+        validate_ppqn!(ppqn)
+        (beats * ppqn).round
+      end
+
+      def ticks_to_beats(ticks, ppqn: 480)
+        validate_ticks!(ticks)
+        validate_ppqn!(ppqn)
+        ticks.to_f / ppqn
+      end
+
+      def dotted(name, dots: 1)
+        raise InvalidMessageError, "dots must be a non-negative integer" unless dots.is_a?(Integer) && dots >= 0
+
+        base = duration_in_beats(name)
+        dots.times.reduce(base) { |sum, index| sum + (base / (2**(index + 1))) }
+      end
+
+      def tuplet(name, in_time_of:, notes:)
+        unless in_time_of.is_a?(Integer) && in_time_of.positive? && notes.is_a?(Integer) && notes.positive?
+          raise InvalidMessageError, "Tuplet values must be positive integers"
+        end
+
+        duration_in_beats(name) * (in_time_of.to_f / notes)
+      end
+
+      def validate_ppqn!(ppqn)
+        return if ppqn.is_a?(Integer) && ppqn.positive?
+
+        raise InvalidMessageError, "PPQN must be positive, got #{ppqn.inspect}"
+      end
+
+      def validate_bpm!(bpm)
+        return if bpm.is_a?(Numeric) && bpm.positive?
+
+        raise InvalidMessageError, "BPM must be positive, got #{bpm.inspect}"
+      end
+
+      def validate_beats!(beats)
+        return if beats.is_a?(Numeric) && beats >= 0
+
+        raise InvalidMessageError, "Beats must be non-negative, got #{beats.inspect}"
+      end
+
+      def validate_ticks!(ticks)
+        return if ticks.is_a?(Numeric) && ticks >= 0
+
+        raise InvalidMessageError, "Ticks must be non-negative, got #{ticks.inspect}"
+      end
+
+      private_class_method :validate_ppqn!, :validate_bpm!, :validate_beats!, :validate_ticks!
+    end
+  end
+end

data/lib/webmidi/music/scale.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Music
+    module Scale
+      TYPES = {
+        major: [0, 2, 4, 5, 7, 9, 11],
+        minor: [0, 2, 3, 5, 7, 8, 10],
+        harmonic_minor: [0, 2, 3, 5, 7, 8, 11],
+        melodic_minor: [0, 2, 3, 5, 7, 9, 11],
+        dorian: [0, 2, 3, 5, 7, 9, 10],
+        phrygian: [0, 1, 3, 5, 7, 8, 10],
+        lydian: [0, 2, 4, 6, 7, 9, 11],
+        mixolydian: [0, 2, 4, 5, 7, 9, 10],
+        locrian: [0, 1, 3, 5, 6, 8, 10],
+        pentatonic: [0, 2, 4, 7, 9],
+        minor_pentatonic: [0, 3, 5, 7, 10],
+        blues: [0, 3, 5, 6, 7, 10],
+        chromatic: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        whole_tone: [0, 2, 4, 6, 8, 10],
+        diminished: [0, 2, 3, 5, 6, 8, 9, 11]
+      }.freeze
+
+      @custom_types = {}
+
+      module_function
+
+      def build(root, type = :major, range: :strict)
+        root_midi = Note.to_midi(root)
+        intervals = TYPES[type] || @custom_types[type]
+        raise InvalidMessageError, "Unknown scale type: #{type}" unless intervals
+
+        apply_range_policy(intervals.map { |i| root_midi + i }, range)
+      end
+
+      def define(name, intervals)
+        validate_intervals!(intervals)
+        @custom_types[name] = intervals
+        self
+      end
+
+      def types
+        TYPES.keys + @custom_types.keys
+      end
+
+      def degree(root, type, degree_num)
+        unless degree_num.is_a?(Integer) && degree_num.positive?
+          raise InvalidMessageError, "Scale degree must be a positive integer, got #{degree_num.inspect}"
+        end
+
+        root_midi = Note.to_midi(root)
+        intervals = TYPES[type] || @custom_types[type]
+        raise InvalidMessageError, "Unknown scale type: #{type}" unless intervals
+
+        index = (degree_num - 1) % intervals.size
+        octave = (degree_num - 1) / intervals.size
+        note = root_midi + intervals[index] + (octave * 12)
+        Note.validate_midi!(note)
+        note
+      end
+
+      def validate_intervals!(intervals)
+        unless intervals.respond_to?(:each) && intervals.all? { |interval| interval.is_a?(Integer) }
+          raise InvalidMessageError, "Scale intervals must be integers"
+        end
+      end
+
+      def apply_range_policy(notes, range)
+        case range
+        when :strict
+          notes.each { |note| Note.validate_midi!(note) }
+          notes
+        when :clamp
+          notes.map { |note| note.clamp(0, 127) }
+        when :allow_out_of_range
+          notes
+        else
+          raise InvalidMessageError, "Unknown range policy: #{range.inspect}"
+        end
+      end
+
+      private_class_method :validate_intervals!, :apply_range_policy
+    end
+  end
+end

data/lib/webmidi/music.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "music/note"
+require_relative "music/chord"
+require_relative "music/scale"
+require_relative "music/rhythm"
+
+module Webmidi
+  module Music
+    def note(name_or_number)
+      Note.to_midi(name_or_number)
+    end
+
+    def chord(root, type = :major, inversion: 0)
+      Chord.build(root, type, inversion: inversion)
+    end
+
+    def scale(root, type = :major)
+      Scale.build(root, type)
+    end
+
+    module_function :note, :chord, :scale
+  end
+end