procon_bypass_man 0.1.23 → 0.2.2

data/lib/procon_bypass_man/{device_connector.rb → device_connection/executor.rb}

@@ -1,9 +1,6 @@
 require "timeout"
 
-class ProconBypassMan::DeviceConnector
-  class BytesMismatchError < StandardError; end
-  class NotFoundProconError < StandardError; end
-
+class ProconBypassMan::DeviceConnection::Executer
   class Value
     attr_accessor :read_from, :values, :call_block_if_receive, :block
 
@@ -15,33 +12,41 @@ class ProconBypassMan::DeviceConnector
     end
   end
 
-  def self.connect
-    s = new(throw_error_if_timeout: true)
-    s.add([
+  def self.new_with_default_args
+    new(throw_error_if_timeout: true)
+  end
+
+  def self.execute!
+    s = new_with_default_args
+    s.add(expected_to_receive: [
       ["0000"],
       ["0000"],
       ["8005"],
       ["0000"],
     ], read_from: :switch)
     # 1. Sends current connection status, and if the Joy-Con are connected,
-    s.add([["8001"]], read_from: :switch)
-    s.add([/^8101/], read_from: :procon) # <<< 81010003176d96e7a5480000000, macaddressとコントローラー番号を返す
+    s.add(expected_to_receive: [["8001"]], read_from: :switch)
+    s.add(expected_to_receive: [/^8101/], read_from: :procon) # <<< 81010003176d96e7a5480000000, macaddressとコントローラー番号を返す
     # 2. Sends handshaking packets over UART to the Joy-Con or Pro Controller Broadcom chip. This command can only be called once per session.
-    s.add([["8002"]], read_from: :switch)
-    s.add([/^8102/], read_from: :procon)
+    s.add(expected_to_receive: [["8002"]], read_from: :switch)
+    s.add(expected_to_receive: [/^8102/], read_from: :procon)
     # 3
-    s.add([/^0100/], read_from: :switch)
-    s.add([/^21/], read_from: :procon, call_block_if_receive: /^8101/) do |this|
-      ProconBypassMan.logger.info "(start special route)"
-      this.blocking_read_with_timeout_from_procon # <<< 810100032dbd42e9b698000
-      this.write_to_procon("8002")
-      this.blocking_read_with_timeout_from_procon # <<< 8102
-      this.write_to_procon("01000000000000000000033000000000000000000000000000000000000000000000000000000000000000000000000000")
-      this.blocking_read_with_timeout_from_procon # <<< 21
+    s.add(expected_to_receive: [/^0100/], read_from: :switch)
+    s.add(expected_to_receive: [/^21/], read_from: :procon, call_block_if_receive: /^8101/) do |this|
+      begin
+        ProconBypassMan.logger.info "(start special route)"
+        this.blocking_read_with_timeout_from_procon # <<< 810100032dbd42e9b698000
+        this.write_to_procon("8002")
+        this.blocking_read_with_timeout_from_procon # <<< 8102
+        this.write_to_procon("01000000000000000000033000000000000000000000000000000000000000000000000000000000000000000000000000")
+        this.blocking_read_with_timeout_from_procon # <<< 21
+      rescue ProconBypassMan::SafeTimeout::Timeout, Timeout::Error
+        raise ProconBypassMan::DeviceConnection::TimeoutErrorInConditionalRoute
+      end
     end
 
     # 4. Forces the Joy-Con or Pro Controller to only talk over USB HID without any timeouts. This is required for the Pro Controller to not time out and revert to Bluetooth.
-    s.add([["8004"]], read_from: :switch)
+    s.add(expected_to_receive: [["8004"]], read_from: :switch)
     s.drain_all
     return [s.switch, s.procon]
   end
@@ -53,7 +58,8 @@ class ProconBypassMan::DeviceConnector
     @throw_error_if_mismatch = throw_error_if_mismatch
   end
 
-  def add(values, read_from: , call_block_if_receive: false, &block)
+  def add(expected_to_receive: , read_from: , call_block_if_receive: nil, &block)
+    values = expected_to_receive
     @queue << Value.new(values: values, read_from: read_from, call_block_if_receive: call_block_if_receive, &block)
   end
 
@@ -67,6 +73,7 @@ class ProconBypassMan::DeviceConnector
       item.values.each do |value|
         raw_data = nil
         timer = ProconBypassMan::SafeTimeout.new
+
         begin
           timer.throw_if_timeout!
           raw_data = from_device(item).read_nonblock(64)
@@ -76,8 +83,11 @@ class ProconBypassMan::DeviceConnector
           retry
         end
 
-        if item.call_block_if_receive =~ raw_data.unpack("H*").first
-          raw_data = item.block.call(self)
+        if item.call_block_if_receive
+          ProconBypassMan.logger.info "call block if receive: #{item.call_block_if_receive}, actual: #{raw_data.unpack("H*")} from: #{item.read_from}"
+          if item.call_block_if_receive =~ raw_data.unpack("H*").first
+            raw_data = item.block.call(self)
+          end
         end
 
         result =
@@ -89,13 +99,14 @@ class ProconBypassMan::DeviceConnector
           else
             raise "#{value}は知りません"
           end
+
         if result
-          ProconBypassMan.logger.info "OK(expected: #{value}, got: #{raw_data.unpack("H*")})"
-          debug_log_buffer << "OK(expected: #{value}, got: #{raw_data.unpack("H*")})"
+          ProconBypassMan.logger.info "OK(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
+          debug_log_buffer << "OK(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
         else
-          ProconBypassMan.logger.info "NG(expected: #{value}, got: #{raw_data.unpack("H*")})"
-          debug_log_buffer << "NG(expected: #{value}, got: #{raw_data.unpack("H*")})"
-          raise BytesMismatchError.new(debug_log_buffer) if @throw_error_if_mismatch
+          ProconBypassMan.logger.info "NG(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
+          debug_log_buffer << "NG(expected: #{value}, got: #{raw_data.unpack("H*")}) from: #{item.read_from}"
+          raise ProconBypassMan::DeviceConnection::BytesMismatchError.new(debug_log_buffer) if @throw_error_if_mismatch
         end
         to_device(item).write_nonblock(raw_data)
       end
@@ -103,8 +114,8 @@ class ProconBypassMan::DeviceConnector
   rescue ProconBypassMan::SafeTimeout::Timeout, Timeout::Error => e
     ProconBypassMan.logger.error "timeoutになりました(#{e.message})"
     compressed_buffer_text = ProconBypassMan::CompressArray.new(debug_log_buffer).compress.join("\n")
-    ProconBypassMan::SendErrorCommand.execute(error: compressed_buffer_text)
-    raise if @throw_error_if_timeout
+    ProconBypassMan::SendErrorCommand.execute(error: compressed_buffer_text, stdout: false)
+    raise ProconBypassMan::SafeTimeout::Timeout if @throw_error_if_timeout
   end
 
   def from_device(item)
@@ -143,23 +154,25 @@ class ProconBypassMan::DeviceConnector
       return
     end
     ProconBypassMan::UsbDeviceController.init
+    ProconBypassMan::UsbDeviceController.reset
 
     if path = ProconBypassMan::DeviceProconFinder.find
       @procon = File.open(path, "w+b")
       ProconBypassMan.logger.info "proconのデバイスファイルは#{path}を使います"
     else
-      raise(ProconBypassMan::DeviceConnector::NotFoundProconError)
+      raise(ProconBypassMan::DeviceConnection::NotFoundProconError)
     end
-    @gadget = File.open('/dev/hidg0', "w+b")
 
-    ProconBypassMan::UsbDeviceController.reset
+    begin
+      @gadget = File.open('/dev/hidg0', "w+b")
+    rescue Errno::ENXIO => e
+      # /dev/hidg0 をopenできないときがある
+      ProconBypassMan::SendErrorCommand.execute(error: "Errno::ENXIOが起きたのでresetします.\n #{e.full_message}", stdout: false)
+      ProconBypassMan::UsbDeviceController.reset
+      retry
+    end
 
     @initialized_devices = true
-  rescue Errno::ENXIO => e
-    # /dev/hidg0 をopenできないときがある
-    ProconBypassMan::SendErrorCommand.execute(error: "Errno::ENXIO (No such device or address @ rb_sysopen - /dev/hidg0)が起きました。resetします.\n #{e.full_message}")
-    ProconBypassMan::UsbDeviceController.reset
-    retry
   end
 
   def blocking_read_with_timeout_from_procon

data/lib/procon_bypass_man/device_connection/output_report_generator.rb

@@ -0,0 +1,42 @@
+class ProconBypassMan::DeviceConnection::OutputReportGenerator
+  def initialize
+    @counter = 0
+  end
+
+  # @return [String]
+  def generate_by_step(step)
+    sub_command_with_arg = ProconBypassMan::DeviceConnection::ProconSettingOverrider::ALL_SETTINGS[step]&.join or raise("Unsupport step")
+    raw_data = generate(sub_command_with_arg)
+    count_up
+    raw_data
+  end
+
+  # @return [String]
+  def generate_by_sub_command_with_arg(sub_command_with_arg)
+    raw_data = generate(sub_command_with_arg)
+    count_up
+    raw_data
+  end
+
+  private
+
+  # @return [String]
+  def generate(sub_command_with_arg)
+    [
+      ["01", counter, "00" * 8, sub_command_with_arg].join
+    ].pack("H*")
+  end
+
+  def count_up
+    @counter = @counter + 1
+    if @counter >= 256
+      @counter = 0
+    else
+      @counter
+    end
+  end
+
+  def counter
+    @counter.to_s(16).rjust(2, "0")
+  end
+end

data/lib/procon_bypass_man/device_connection/output_report_markerable.rb

@@ -0,0 +1,28 @@
+module ProconBypassMan::DeviceConnection::OutputReportMarkerable
+  OUTPUT_REPORT_FORMAT = /^01/
+  INPUT_REPORT_FORMAT = /^21/
+
+  # @param [String] raw_data
+  # @return [void]
+  def mark_as_send(raw_data)
+    data = raw_data.unpack("H*").first
+    case data
+    when OUTPUT_REPORT_FORMAT
+      sub_command = data[20..21]
+      sub_command_arg = data[22..23]
+      @hid_sub_command_request_table.mask_as_send(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    end
+  end
+
+  # @param [String] raw_data
+  # @return [void]
+  def mark_as_receive(raw_data)
+    data = raw_data.unpack("H*").first
+    case data
+    when INPUT_REPORT_FORMAT
+      sub_command = data[28..29]
+      sub_command_arg = data[30..31]
+      @hid_sub_command_request_table.mark_as_receive(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    end
+  end
+end

data/lib/procon_bypass_man/device_connection/output_report_sub_command_table.rb

@@ -0,0 +1,133 @@
+class ProconBypassMan::DeviceConnection::OutputReportSubCommandTable
+  class HIDSubCommandResponse
+    attr_accessor :sub_command, :sub_command_arg
+
+    def initialize(sub_command: , sub_command_arg: )
+      @sub_command = sub_command
+      @sub_command_arg = sub_command_arg
+    end
+
+    def sub_command_with_arg
+      case @sub_command
+      when *SPECIAL_SUB_COMMANDS
+        @sub_command
+      else
+        if @sub_command_arg
+          "#{@sub_command}-#{@sub_command_arg}"
+        else
+          @sub_command
+        end
+      end
+    end
+  end
+
+  IGNORE_SUB_COMMANDS = {
+    "48-01" => true,
+    "04-00" => true,
+    "10-28" => true, # 返ってこないことがあった
+  }
+  # レスポンスに引数が含まれない
+  SPECIAL_SUB_COMMANDS = [
+    "01",
+    "02",
+    "03",
+    "30",
+    "38", # home led
+    "40",
+    "48",
+  ]
+
+  EXPECTED_SUB_COMMANDS = [
+    "01-04",
+    "02-",
+    "04-00",
+    "08-00",
+    "10-00",
+    "10-50",
+    "10-80",
+    "10-98",
+    "10-10",
+    "30-",
+    "40-",
+    "48-", # Enable vibration
+  ]
+
+  def initialize
+    @table = {}
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [void]
+  def mask_as_send(sub_command: , sub_command_arg: )
+    case sub_command
+    when *SPECIAL_SUB_COMMANDS
+      @table[sub_command] = false
+    else
+      response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+      @table[response.sub_command_with_arg] = false
+    end
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [void]
+  def mark_as_receive(sub_command: , sub_command_arg: )
+    response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    if @table.key?(response.sub_command_with_arg)
+      @table[response.sub_command_with_arg] = true
+    end
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [Boolean]
+  def has_key?(sub_command: , sub_command_arg: )
+    if IGNORE_SUB_COMMANDS["#{sub_command}-#{sub_command_arg}"]
+      return true
+    end
+
+    case sub_command
+    when *SPECIAL_SUB_COMMANDS
+      @table.key?(sub_command)
+    else
+      response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+      @table.key?(response.sub_command_with_arg)
+    end
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [Boolean]
+  def has_value?(sub_command: , sub_command_arg: )
+    if IGNORE_SUB_COMMANDS["#{sub_command}-#{sub_command_arg}"]
+      return true
+    end
+
+    response = HIDSubCommandResponse.new(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    !!@table[response.sub_command_with_arg]
+  end
+
+  # @return [Boolean]
+  def has_unreceived_command?
+    !@table.values.all?(&:itself)
+  end
+
+  # @return [String, NilClass]
+  def unreceived_sub_command_with_arg
+    sub_command = @table.detect { |_key, value| !value }&.first
+    if(arg = ProconBypassMan::DeviceConnection::ProconSettingOverrider::SPECIAL_SUB_COMMAND_ARGS[sub_command])
+      "#{sub_command}#{arg}"
+    else
+      sub_command
+    end
+  end
+
+  # @return [Boolean]
+  def completed?
+    EXPECTED_SUB_COMMANDS.all? do |key|
+      sub_command, sub_command_arg = key.split("-")
+      has_value?(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    end
+  end
+end

data/lib/procon_bypass_man/device_connection/output_report_watcher.rb

@@ -0,0 +1,41 @@
+class ProconBypassMan::DeviceConnection::OutputReportWatcher
+  include ProconBypassMan::DeviceConnection::OutputReportMarkerable
+
+  def initialize
+    @hid_sub_command_request_table = ProconBypassMan::DeviceConnection::OutputReportSubCommandTable.new
+    @timer = ProconBypassMan::SafeTimeout.new
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [Boolean]
+  def sent?(sub_command: , sub_command_arg: )
+    @hid_sub_command_request_table.has_key?(sub_command: sub_command, sub_command_arg: sub_command_arg)
+  end
+
+  # @param [String] sub_command
+  # @param [String] sub_command_arg
+  # @return [Boolean]
+  def received?(sub_command: , sub_command_arg: )
+    @hid_sub_command_request_table.has_value?(sub_command: sub_command, sub_command_arg: sub_command_arg)
+  end
+
+  # @return [Boolean]
+  def completed?
+    @hid_sub_command_request_table.completed?
+  end
+
+  # @return [Boolean]
+  # @raise [Timeout::Error]
+  def timeout_or_completed?
+    if @timer.timeout?
+      ProconBypassMan::SendErrorCommand.execute(error: "[pre_bypass] pre_bypassフェーズがタイムアウトしました")
+      return true
+    end
+
+    if completed?
+      ProconBypassMan.logger.info "[pre_bypass] pre_bypassフェーズが想定通り終了しました"
+      return true
+    end
+  end
+end

data/lib/procon_bypass_man/device_connection/pre_bypass.rb

@@ -0,0 +1,67 @@
+class ProconBypassMan::DeviceConnection::PreBypass
+  attr_accessor :gadget, :procon, :output_report_watcher
+
+  def initialize(gadget: , procon: )
+    self.gadget = ProconBypassMan::DeviceModel.new(gadget)
+    self.procon = ProconBypassMan::DeviceModel.new(procon)
+    self.output_report_watcher = ProconBypassMan::DeviceConnection::OutputReportWatcher.new
+  end
+
+  # @return [void]
+  def execute!
+    loop do
+      run_once
+
+      if output_report_watcher.timeout_or_completed?
+        break
+      end
+    end
+  end
+
+  # @return [void]
+  def run_once
+    begin
+      raw_data = non_blocking_read_switch
+      output_report_watcher.mark_as_send(raw_data)
+      ProconBypassMan.logger.info "[pre_bypass] >>> #{raw_data.unpack("H*").first}"
+      send_procon(raw_data)
+    rescue IO::EAGAINWaitReadable
+      # no-op
+    end
+
+    3.times do
+      begin
+        raw_data = non_blocking_read_procon
+        output_report_watcher.mark_as_receive(raw_data)
+        ProconBypassMan.logger.info "[pre_bypass] <<< #{raw_data.unpack("H*").first}"
+        send_switch(raw_data)
+      rescue IO::EAGAINWaitReadable
+        # no-op
+      end
+    end
+  end
+
+  private
+
+  # @raise [IO::EAGAINWaitReadable]
+  # @return [String]
+  def non_blocking_read_switch
+    gadget.non_blocking_read
+  end
+
+  # @raise [IO::EAGAINWaitReadable]
+  # @return [String]
+  def non_blocking_read_procon
+    procon.non_blocking_read
+  end
+
+  # @return [void]
+  def send_procon(raw_data)
+    procon.send(raw_data)
+  end
+
+  # @return [void]
+  def send_switch(raw_data)
+    gadget.send(raw_data)
+  end
+end

data/lib/procon_bypass_man/device_connection/procon_setting_overrider.rb

@@ -0,0 +1,78 @@
+class ProconBypassMan::DeviceConnection::ProconSettingOverrider
+  attr_accessor :procon, :output_report_watcher, :output_report_generator
+
+  SUB_COMMAND_HOME_LED_ON = "38"
+  SUB_COMMAND_ARG_HOME_LED_ON = "1FF0FF"
+  SPECIAL_SUB_COMMAND_ARGS =  {
+    SUB_COMMAND_HOME_LED_ON => SUB_COMMAND_ARG_HOME_LED_ON,
+  }
+  SETTING_HOME_LED_ON = { home_led_on: [SUB_COMMAND_HOME_LED_ON, SUB_COMMAND_ARG_HOME_LED_ON] }
+  ALL_SETTINGS = SETTING_HOME_LED_ON
+
+  def initialize(procon: )
+    use_steps = {}
+    if ProconBypassMan.config.enable_home_led_on_connect
+      use_steps.merge!(SETTING_HOME_LED_ON)
+    end
+
+    @setting_steps = use_steps.keys
+    self.procon = ProconBypassMan::DeviceModel.new(procon)
+    self.output_report_watcher = ProconBypassMan::DeviceConnection::SpoofingOutputReportWatcher.new(expected_sub_commands: use_steps.values)
+    self.output_report_generator = ProconBypassMan::DeviceConnection::OutputReportGenerator.new
+  end
+
+  def execute!
+    loop do
+      run_once
+
+      if output_report_watcher.timeout_or_completed?
+        break
+      end
+    end
+  end
+
+  def run_once
+    begin
+      raw_data = non_blocking_read_procon
+    rescue IO::EAGAINWaitReadable
+      return
+    end
+
+    ProconBypassMan.logger.info "[procon_setting_overrider] <<< #{raw_data.unpack("H*").first}"
+    output_report_watcher.mark_as_receive(raw_data)
+    if output_report_watcher.has_unreceived_command?
+      re_override_setting_by_cmd(output_report_watcher.unreceived_sub_command_with_arg)
+    else
+      if(setting_step = @setting_steps.shift)
+        override_setting_by_step(setting_step)
+      else
+        return
+      end
+    end
+  end
+
+  private
+
+  # @return [void]
+  def override_setting_by_step(setting_step)
+    raw_data = output_report_generator.generate_by_step(setting_step)
+    ProconBypassMan.logger.info "[procon_setting_overrider] >>> #{raw_data.unpack("H*").first}"
+    output_report_watcher.mark_as_send(raw_data)
+    send_procon(raw_data)
+  end
+
+  # @return [void]
+  def re_override_setting_by_cmd(sub_command_with_arg)
+    raw_data = output_report_generator.generate_by_sub_command_with_arg(sub_command_with_arg)
+    ProconBypassMan.logger.info "[procon_setting_overrider] >>> #{raw_data.unpack("H*").first}"
+    send_procon(raw_data)
+  end
+
+  def non_blocking_read_procon
+    procon.non_blocking_read
+  end
+
+  def send_procon(raw_data)
+    procon.send(raw_data)
+  end
+end

data/lib/procon_bypass_man/device_connection/spoofing_output_report_watcher.rb

@@ -0,0 +1,39 @@
+class ProconBypassMan::DeviceConnection::SpoofingOutputReportWatcher
+  include ProconBypassMan::DeviceConnection::OutputReportMarkerable
+
+  def initialize(expected_sub_commands: )
+    @timer = ProconBypassMan::SafeTimeout.new
+    @hid_sub_command_request_table = ProconBypassMan::DeviceConnection::OutputReportSubCommandTable.new
+    @expected_sub_commands = expected_sub_commands
+  end
+
+  # @return [Boolean]
+  def has_unreceived_command?
+    @hid_sub_command_request_table.has_unreceived_command?
+  end
+
+  # @return [String, NilClass]
+  def unreceived_sub_command_with_arg
+    @hid_sub_command_request_table.unreceived_sub_command_with_arg
+  end
+
+  # @return [Boolean]
+  def completed?
+    @expected_sub_commands.all? do |sub_command, sub_command_arg|
+      @hid_sub_command_request_table.has_value?(sub_command: sub_command, sub_command_arg: sub_command_arg)
+    end
+  end
+
+  # @return [Boolean]
+  def timeout_or_completed?
+    if @timer.timeout?
+      ProconBypassMan.logger.info "[procon setting override] プロコンの設定上書き処理がタイムアウトしました"
+      return true
+    end
+
+    if completed?
+      ProconBypassMan.logger.info "[procon setting override] プロコンの設定上書き処理が想定通り終了しました"
+      return true
+    end
+  end
+end

data/lib/procon_bypass_man/device_connection.rb

@@ -0,0 +1,16 @@
+module ProconBypassMan::DeviceConnection
+  class BytesMismatchError < StandardError; end
+  class NotFoundProconError < StandardError; end
+  class TimeoutErrorInConditionalRoute < StandardError; end
+  class TimeoutError < StandardError; end
+end
+
+require_relative "device_connection/executor"
+require_relative "device_connection/pre_bypass"
+require_relative "device_connection/command"
+require_relative "device_connection/output_report_markerable"
+require_relative "device_connection/procon_setting_overrider"
+require_relative "device_connection/output_report_generator"
+require_relative "device_connection/output_report_sub_command_table"
+require_relative "device_connection/spoofing_output_report_watcher"
+require_relative "device_connection/output_report_watcher"

data/lib/procon_bypass_man/device_model.rb

@@ -0,0 +1,17 @@
+class ProconBypassMan::DeviceModel
+  # @param [File] device
+  def initialize(device)
+    @device = device
+  end
+
+  # @param [String] raw_data
+  def send(raw_data)
+    @device.write_nonblock(raw_data)
+  end
+
+  # @raise [IO::EAGAINWaitReadable]
+  # @return [String]
+  def non_blocking_read
+    @device.read_nonblock(64)
+  end
+end

data/lib/procon_bypass_man/io_monitor.rb

@@ -1,4 +1,15 @@
 module ProconBypassMan
+  class NullCounter
+    def initialize(label: )
+    end
+
+    def record(_)
+    end
+
+    def shutdown
+    end
+  end
+
   class Counter
     attr_accessor :label, :table, :previous_table, :active
 
@@ -40,7 +51,11 @@ module ProconBypassMan
   end
 
   module IOMonitor
+    @@thread = nil
+
     def self.new(label: )
+      return NullCounter.new(label: label) if not started?
+
       counter = Counter.new(label: label)
       @@list << counter
       counter
@@ -51,9 +66,13 @@ module ProconBypassMan
       @@list
     end
 
+    def self.started?
+      !!@@thread
+    end
+
     # ここで集計する
     def self.start!
-      Thread.start do
+      @@thread = Thread.start do
         max_output_length = 0
         loop do
           list = @@list.select(&:active).dup

data/lib/procon_bypass_man/procon/macro_builder.rb

@@ -5,9 +5,11 @@ class ProconBypassMan::Procon::MacroBuilder
         return subjects.first.to_steps
       end
 
-      base = subjects.first
-      remain = subjects[1..-1]
-      remain.map { |x| base.to_steps.zip(x.to_steps) }.first
+      subjects.inject([[], []]) do |acc, item|
+        acc[0] << item.to_steps[0]
+        acc[1] << item.to_steps[1]
+        acc
+      end
     end
   end