webmidi 0.1.0

data/lib/webmidi/message.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "message/base"
+require_relative "message/channel"
+require_relative "message/system"
+require_relative "message/parser"
+require_relative "message/ump"
+require_relative "music/note"
+
+module Webmidi
+  module Message
+    DEFAULT_ARGUMENT = Object.new.freeze
+
+    # Factory methods
+    def self.note_on(note, velocity: DEFAULT_ARGUMENT, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::NoteOn.new(
+        note: coerce_note(note),
+        velocity: default_value(velocity, Webmidi.configuration.default_velocity),
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.note_off(note, velocity: 0, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::NoteOff.new(
+        note: coerce_note(note),
+        velocity: velocity,
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.control_change(cc, value, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::ControlChange.new(
+        cc: cc,
+        value: value,
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.program_change(program, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::ProgramChange.new(
+        program: program,
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.channel_pressure(pressure, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::ChannelPressure.new(
+        pressure: pressure,
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.polyphonic_pressure(note, pressure, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::PolyphonicPressure.new(
+        note: coerce_note(note),
+        pressure: pressure,
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.pitch_bend(value = Channel::PitchBend::CENTER, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::PitchBend.new(
+        value: value,
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.pitch_bend_signed(value, channel: DEFAULT_ARGUMENT, timestamp: nil)
+      Channel::PitchBend.from_signed(
+        value,
+        channel: default_value(channel, Webmidi.configuration.default_channel),
+        timestamp: timestamp
+      )
+    end
+
+    def self.sysex(*data, timestamp: nil)
+      System::SysEx.new(data: data, timestamp: timestamp)
+    end
+
+    def self.clock(timestamp: nil)
+      System::Clock.new(timestamp: timestamp)
+    end
+
+    def self.start(timestamp: nil)
+      System::Start.new(timestamp: timestamp)
+    end
+
+    def self.continue(timestamp: nil)
+      System::Continue.new(timestamp: timestamp)
+    end
+
+    def self.stop(timestamp: nil)
+      System::Stop.new(timestamp: timestamp)
+    end
+
+    def self.active_sensing(timestamp: nil)
+      System::ActiveSensing.new(timestamp: timestamp)
+    end
+
+    def self.system_reset(timestamp: nil)
+      System::SystemReset.new(timestamp: timestamp)
+    end
+
+    def self.time_code(type, value, timestamp: nil)
+      System::TimeCode.new(type: type, value: value, timestamp: timestamp)
+    end
+
+    def self.song_position(position, timestamp: nil)
+      System::SongPosition.new(position: position, timestamp: timestamp)
+    end
+
+    def self.song_select(song, timestamp: nil)
+      System::SongSelect.new(song: song, timestamp: timestamp)
+    end
+
+    def self.tune_request(timestamp: nil)
+      System::TuneRequest.new(timestamp: timestamp)
+    end
+
+    def self.from_bytes(*bytes, normalize_note_on_zero: true)
+      bytes = bytes.flatten
+      Parser.parse_single(bytes, normalize_note_on_zero: normalize_note_on_zero)
+    end
+
+    def self.parse_many(bytes, normalize_note_on_zero: true)
+      Parser.parse_many(bytes, normalize_note_on_zero: normalize_note_on_zero)
+    end
+
+    def self.upgrade(midi1_message, group: DEFAULT_ARGUMENT)
+      UMP.upgrade(midi1_message, group: default_value(group, Webmidi.configuration.default_group))
+    end
+
+    def self.downgrade(midi2_message)
+      UMP.downgrade(midi2_message)
+    end
+
+    def self.coerce_note(note)
+      Music::Note.to_midi(note)
+    end
+    private_class_method :coerce_note
+
+    def self.default_value(value, default)
+      value.equal?(DEFAULT_ARGUMENT) ? default : value
+    end
+    private_class_method :default_value
+  end
+end

data/lib/webmidi/middleware/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Base
+      def initialize(app, **options)
+        @app = app
+        @options = options
+      end
+
+      def call(message)
+        @app.call(message)
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/channel_map.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class ChannelMap < Base
+      def initialize(app, map: nil, from: nil, to: nil, **options)
+        super(app, **options)
+        @map = normalize_map(map, from, to)
+      end
+
+      def call(message)
+        return @app.call(message) unless message.channel
+
+        target = @map.fetch(message.channel, message.channel)
+        @app.call(message.with(channel: target))
+      end
+
+      private
+
+      def normalize_map(map, from, to)
+        mapping = map || ((from.nil? || to.nil?) ? {} : {from => to})
+        mapping.each_with_object({}) do |(source, target), result|
+          validate_channel!(source, "source channel")
+          validate_channel!(target, "target channel")
+          result[source] = target
+        end
+      end
+
+      def validate_channel!(channel, name)
+        return if channel.is_a?(Integer) && channel.between?(0, 15)
+
+        raise InvalidMessageError, "#{name} must be between 0 and 15, got #{channel.inspect}"
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Filter < Base
+      def initialize(app, channels: nil, types: nil, include_system: true, **options)
+        super(app, **options)
+        @channels = channels
+        @types = types
+        @include_system = include_system
+      end
+
+      def call(message)
+        return nil if @channels && !message.channel && !@include_system
+        return nil if @channels && message.channel && !@channels.include?(message.channel)
+        return nil if @types && !@types.any? { |t| message.is_a?(t) }
+
+        @app.call(message)
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/logger.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Logger < Base
+      def initialize(app, output: $stderr, **options)
+        super(app, **options)
+        @output = output
+      end
+
+      def call(message)
+        @output.puts "[MIDI] #{message.class.name.split("::").last}: #{message.to_hex}"
+        @app.call(message)
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/note_range_filter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class NoteRangeFilter < Base
+      def initialize(app, min: 0, max: 127, **options)
+        super(app, **options)
+        validate_note!(min, "min")
+        validate_note!(max, "max")
+        raise InvalidMessageError, "min cannot be greater than max" if min > max
+
+        @range = min..max
+      end
+
+      def call(message)
+        return nil if note_message?(message) && !@range.cover?(message.note)
+
+        @app.call(message)
+      end
+
+      private
+
+      def note_message?(message)
+        message.respond_to?(:note)
+      end
+
+      def validate_note!(note, name)
+        return if note.is_a?(Integer) && note.between?(0, 127)
+
+        raise InvalidMessageError, "#{name} must be between 0 and 127, got #{note.inspect}"
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/panic.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Panic < Base
+      DEFAULT_CONTROLS = [:all_sound_off, :all_notes_off].freeze
+      DEFAULT_TRIGGER = Message::System::SystemReset
+
+      def initialize(app, channels: 0..15, controls: DEFAULT_CONTROLS, trigger: DEFAULT_TRIGGER,
+        pass_trigger: false, **options)
+        super(app, **options)
+        @channels = self.class.send(:normalize_channels, channels)
+        @controls = self.class.send(:normalize_controls, controls)
+        @trigger = trigger
+        @pass_trigger = pass_trigger
+      end
+
+      def call(message)
+        return @app.call(message) unless trigger?(message)
+
+        results = self.class.messages(channels: @channels, controls: @controls, timestamp: message.timestamp)
+          .filter_map { |panic_message| @app.call(panic_message) }
+        results << @app.call(message) if @pass_trigger
+        results.compact
+      end
+
+      def self.all_notes_off(channels: 0..15, timestamp: nil)
+        messages(channels: channels, controls: [:all_notes_off], timestamp: timestamp)
+      end
+
+      def self.messages(channels: 0..15, controls: DEFAULT_CONTROLS, timestamp: nil)
+        normalize_channels(channels).flat_map do |channel|
+          normalize_controls(controls).map do |control|
+            Message.control_change(control, 0, channel: channel, timestamp: timestamp)
+          end
+        end
+      end
+
+      def self.normalize_channels(channels)
+        Array(channels).each_with_object([]) do |channel, result|
+          unless channel.is_a?(Integer) && channel.between?(0, 15)
+            raise InvalidMessageError, "Channel must be between 0 and 15, got #{channel.inspect}"
+          end
+
+          result << channel
+        end
+      end
+
+      def self.normalize_controls(controls)
+        Array(controls).map do |control|
+          Message::Channel::ControlChange.controller_number(control)
+        end
+      end
+
+      private_class_method :normalize_channels, :normalize_controls
+
+      private
+
+      def trigger?(message)
+        case @trigger
+        when nil
+          false
+        when Proc
+          @trigger.call(message)
+        when Class, Module
+          message.is_a?(@trigger)
+        else
+          message == @trigger
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/pipeline.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Pipeline
+      def initialize(input, stack = nil)
+        @input = input
+        @stack = stack || Stack.new
+      end
+
+      def to(output)
+        @input.on_message do |message|
+          processed = @stack.call(message)
+          output.send(processed) if processed
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/recorder.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Recorder < Base
+      attr_reader :tape
+
+      def initialize(app = nil, **options)
+        super(app || ->(msg) { msg }, **options)
+        @tape = Tape.new
+        @recording = false
+        @mutex = Mutex.new
+      end
+
+      def call(message)
+        tape = @mutex.synchronize { @recording ? @tape : nil }
+        tape&.add(message)
+        @app.call(message)
+      end
+
+      def record
+        @mutex.synchronize do
+          @tape = Tape.new
+          @recording = true
+        end
+        if block_given?
+          begin
+            yield
+          ensure
+            @mutex.synchronize { @recording = false }
+          end
+        end
+        @mutex.synchronize { @tape }
+      end
+
+      def stop
+        @mutex.synchronize do
+          @recording = false
+          @tape
+        end
+      end
+
+      def recording?
+        @mutex.synchronize { @recording }
+      end
+
+      class Tape
+        def initialize(entries: [], start_time: nil)
+          @messages = entries.map(&:dup)
+          @start_time = start_time
+          @mutex = Mutex.new
+        end
+
+        def add(message)
+          @mutex.synchronize do
+            @start_time ||= message.timestamp
+            @messages << {message: message, time: message.timestamp - @start_time}
+          end
+        end
+
+        def messages
+          snapshot.lazy.map { |entry| entry[:message] }
+        end
+
+        def message_count
+          @mutex.synchronize { @messages.size }
+        end
+
+        def duration
+          entries = snapshot
+          return 0.0 if entries.empty?
+
+          entries.last[:time]
+        end
+
+        def play(output, speed: 1.0)
+          play_from(0.0, output, speed: speed)
+        end
+
+        def play_from(time, output, speed: 1.0)
+          validate_speed!(speed)
+          entries = snapshot.select { |e| e[:time] >= time }
+          last_time = time
+
+          entries.each do |entry|
+            delay = (entry[:time] - last_time) / speed
+            sleep(delay) if delay > 0.001
+            output.send(entry[:message])
+            last_time = entry[:time]
+          end
+        end
+
+        def rewind(seconds)
+          target = duration - seconds
+          target = 0.0 if target < 0
+          snapshot.select { |e| e[:time] >= target }.map { |e| e[:message] }
+        end
+
+        def slice(from, to)
+          entries = snapshot.select { |e| e[:time].between?(from, to) }.map do |entry|
+            {
+              message: entry[:message],
+              time: entry[:time] - from
+            }
+          end
+          Tape.new(entries: entries, start_time: 0.0)
+        end
+
+        private
+
+        def snapshot
+          @mutex.synchronize { @messages.map(&:dup) }
+        end
+
+        def validate_speed!(speed)
+          return if speed.is_a?(Numeric) && speed.positive?
+
+          raise InvalidMessageError, "Playback speed must be positive, got #{speed.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/split_by_channel.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class SplitByChannel < Base
+      SYSTEM_ROUTE = :system
+
+      def initialize(app, routes:, passthrough: false, **options)
+        super(app, **options)
+        @routes = normalize_routes(routes)
+        @passthrough = passthrough
+      end
+
+      def call(message)
+        targets = @routes[route_key(message)]
+        return @app.call(message) unless targets
+
+        targets.each { |target| deliver(target, message) }
+        return @app.call(message) if @passthrough
+
+        nil
+      end
+
+      private
+
+      def route_key(message)
+        message.channel || SYSTEM_ROUTE
+      end
+
+      def normalize_routes(routes)
+        unless routes.respond_to?(:each)
+          raise InvalidMessageError, "routes must be enumerable, got #{routes.class}"
+        end
+
+        routes.each_with_object({}) do |(channel, targets), result|
+          key = normalize_route_key(channel)
+          result[key] = Array(targets).tap { |list| list.each { |target| validate_target!(target) } }
+        end
+      end
+
+      def normalize_route_key(channel)
+        return SYSTEM_ROUTE if channel == SYSTEM_ROUTE
+
+        unless channel.is_a?(Integer) && channel.between?(0, 15)
+          raise InvalidMessageError, "Route channel must be between 0 and 15, got #{channel.inspect}"
+        end
+
+        channel
+      end
+
+      def validate_target!(target)
+        return if target.respond_to?(:call) || target.respond_to?(:<<)
+
+        raise InvalidMessageError, "Route target must respond to call or <<, got #{target.class}"
+      end
+
+      def deliver(target, message)
+        if target.respond_to?(:call)
+          target.call(message)
+        else
+          target << message
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/stack.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Stack
+      def initialize(&block)
+        @middlewares = []
+        @app_cache = nil
+        instance_eval(&block) if block
+      end
+
+      def use(middleware_class_or_proc, **options)
+        @middlewares << [middleware_class_or_proc, options]
+        @app_cache = nil
+        self
+      end
+
+      def call(message)
+        build.call(message)
+      end
+
+      def build
+        return @app_cache if @app_cache
+
+        endpoint = ->(msg) { msg }
+        @middlewares.reverse_each do |middleware, options|
+          current_app = endpoint
+          endpoint = if middleware.is_a?(Proc)
+            lambda_adapter(middleware, current_app)
+          else
+            middleware.new(current_app, **options)
+          end
+        end
+        @app_cache = endpoint
+      end
+
+      private
+
+      def lambda_adapter(proc, app)
+        LambdaMiddleware.new(app, proc)
+      end
+
+      class LambdaMiddleware
+        def initialize(app, proc)
+          @app = app
+          @proc = proc
+        end
+
+        def call(message)
+          @proc.call(message, @app)
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/middleware/timing_gate.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Middleware
+    class Debounce < Base
+      def initialize(app, interval:, key: nil, **options)
+        super(app, **options)
+        validate_interval!(interval)
+        @interval = interval
+        @key = key || ->(message) { message.to_bytes }
+        @last_seen = {}
+      end
+
+      def call(message)
+        key = @key.call(message)
+        now = message.timestamp
+        last = @last_seen[key]
+        return nil if last && (now - last) < @interval
+
+        @last_seen[key] = now
+        @app.call(message)
+      end
+
+      private
+
+      def validate_interval!(interval)
+        return if interval.is_a?(Numeric) && interval.positive?
+
+        raise InvalidMessageError, "interval must be positive, got #{interval.inspect}"
+      end
+    end
+
+    class Throttle < Base
+      def initialize(app, interval:, **options)
+        super(app, **options)
+        validate_interval!(interval)
+        @interval = interval
+        @last_sent = nil
+      end
+
+      def call(message)
+        now = message.timestamp
+        return nil if @last_sent && (now - @last_sent) < @interval
+
+        @last_sent = now
+        @app.call(message)
+      end
+
+      private
+
+      def validate_interval!(interval)
+        return if interval.is_a?(Numeric) && interval.positive?
+
+        raise InvalidMessageError, "interval must be positive, got #{interval.inspect}"
+      end
+    end
+  end
+end