ruby-utcp 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c041cd63497e9162042ccdd75ef1adad0bd1b3e8c7fe13ca67d84519bcced0c8
-  data.tar.gz: 2ff6634e287d5b313f58de19de4c70c64c626d894e939cad2246339f2683c12a
+  metadata.gz: 1869c15823d927455e8339580df8200a4eae60a1313a1384b2d98f793786e78d
+  data.tar.gz: 3f63ab346e1316dd5ba26e367637f3a1c39d8b7202d1b5c117c3885cf0c8405a
 SHA512:
-  metadata.gz: 37b298c327a546cfa35799045ad2450c76cdfba4ad3cd8aee9d6fa79206d70667bfdec596654bb37cbdc4a25029732eb116943ce06cffbbd75c977dc18d3a5c5
-  data.tar.gz: 1b131b7c326f7eeb8f4e100d11160dac9d56e0f766cbb315ae4d2916f1351364b3f2cc39a81183e7b766634a06b2f9cecff1b49f26cb10b22f24c6ecdad88e40
+  metadata.gz: 0bb88097ddb4f9170b8aeec82fb14d34fc708abc15ac7cfed54df9c03737105183c0fd09ca202c2ae53fbd276e85221393c4d8adfa36f80f5e05296b1c4ca860
+  data.tar.gz: 4c9c0147d82493982d2717bc56b4f5b0486b09fa1c37b4a2a5d4ebf7b04dd0859b28ef4361eb6d7e8458d27b6a1975073b9af68784401695a300f97f2fa7ecfd

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+- Split Code Mode into focused components while preserving the public API; fix `do...end` block results.
+- Add branch-focused interpreter tests, concurrent request tests, and local HTTP/TCP/WebSocket fault injection.
+- Isolate WebRTC peers between clients, close failed registrations, and align native offer/answer negotiation with `webrtc-ruby`.
+- Close WebSocket sockets when the opening handshake fails.
+- Add an opt-in real gRPC/WebRTC integration suite and raise coverage gates to 80% lines / 60% branches.
+- Bound native integration runs with a subprocess watchdog. Include an opt-in source patch for `webrtc-ruby` 1.0.0 shutdown deadlocks, pointer-lifetime protection, and real callback/concurrent-shutdown regression tests.
+
 - Isolate MCP sessions and resource mappings between clients and clean up failed registrations.
 - Follow MCP tool/resource pagination and raise `ToolCallError` for tool failures, preserving the original payload.
 - Enforce stdio deadlines across partial reads, notifications, and blocked writes; bound message and stderr buffers.

data/examples/servers/webrtc_server.rb

@@ -35,7 +35,7 @@ ExampleHTTP.server(port) do |server|
   server.mount_proc("/connect") do |request, response|
     payload = ExampleHTTP.request_json(request)
     candidates = []
-    peer = WebRTC::RTCPeerConnection.new
+    peer = WebRTC::RTCPeerConnection.new({ disable_auto_negotiation: true })
     peer.on_ice_candidate { |candidate| candidates << candidate if candidate }
     peer.on_data_channel do |channel|
       channel.on_message do |event|
@@ -50,11 +50,11 @@ ExampleHTTP.server(port) do |server|
     offer = WebRTC::RTCSessionDescription.new(type: :offer, sdp: payload.fetch("sdp"))
     peer.set_remote_description(offer).await
     answer = peer.create_answer.await
-    peer.set_local_description(answer).await
+    # The native binding already installs the answer while creating it.
     wait_for_ice(peer)
     peers_mutex.synchronize { peers[payload.fetch("peer_id")] = peer }
     ExampleHTTP.json(response, {
-      sdp: peer.local_description.sdp,
+      sdp: answer.sdp,
       candidates: candidates.map(&:to_h),
       tools: [{ name: "echo", description: "Echo over a WebRTC DataChannel" }]
     })

data/lib/utcp/code_mode/client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module UTCP
+  class CodeModeUtcpClient < Client
+    AGENT_PROMPT_TEMPLATE = <<~PROMPT.freeze
+      Use `codemode.search_tools` before writing a Code Mode program when tool names are unknown.
+      Call tools as `codemode.call_tool("manual.tool", key: value)`. Use the exact qualified name.
+      Code Mode accepts a constrained Ruby subset: local variables, JSON-like literals, arithmetic,
+      conditionals, bounded loops, and common Array/Hash/String transforms. The final expression or an
+      explicit `return` is the result. Use `puts`, `print`, `p`, or `warn` for captured logs. The values
+      `codemode.interfaces` and `codemode.get_tool_interface("manual.tool")` describe registered tools. Filesystem,
+      process, constants, imports, reflection, eval, and direct network access are unavailable.
+    PROMPT
+
+    def call_tool_chain(code, timeout_value = nil, timeout: nil, max_steps: CodeMode::DEFAULT_MAX_STEPS)
+      selected_timeout = timeout || timeout_value || CodeMode::DEFAULT_TIMEOUT
+      CodeMode.new(self).execute(code, timeout: selected_timeout, max_steps: max_steps)
+    end
+
+    def get_all_tools_ruby_interfaces
+      CodeMode.new(self).interfaces
+    end
+
+    def get_tool_interface(name)
+      CodeMode.new(self).tool_interface(name)
+    end
+  end
+
+  CodeModeClient = CodeModeUtcpClient
+end

data/lib/utcp/code_mode/control_flow.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module UTCP
+  class CodeMode
+    class Evaluator
+      private
+
+      def truthy?(value)
+        !value.nil? && value != false
+      end
+
+      def evaluate_if(condition, truthy_statements, alternative)
+        if truthy?(evaluate(condition))
+          evaluate_statements(truthy_statements)
+        elsif alternative&.first == :else
+          evaluate_statements(alternative[1])
+        elsif alternative&.first == :elsif
+          evaluate_if(alternative[1], alternative[2], alternative[3])
+        end
+      end
+
+      def evaluate_unless(condition, statements, alternative)
+        unless truthy?(evaluate(condition))
+          evaluate_statements(statements)
+        else
+          evaluate_statements(alternative[1]) if alternative&.first == :else
+        end
+      end
+
+      def evaluate_body_statement(node)
+        statements, rescue_clause, else_clause, ensure_clause = node.drop(1)
+        completed = false
+        result = begin
+          value = evaluate_statements(statements)
+          completed = true
+          value
+        rescue ReturnSignal, BreakSignal, NextSignal, CodeModeTimeoutError, CodeModeLimitError, CodeModeSyntaxError
+          raise
+        rescue StandardError => error
+          raise unless rescue_clause
+          evaluate_rescue_clause(rescue_clause, error)
+        ensure
+          evaluate_statements(ensure_clause[1]) if ensure_clause&.first == :ensure
+        end
+        completed && else_clause ? evaluate_statements(else_clause) : result
+      end
+
+      def evaluate_rescue_clause(node, error)
+        unsupported!(node) unless node.first == :rescue
+        raise CodeModeSyntaxError, "Code Mode rescue does not accept exception classes" if node[1]
+
+        scope = {}
+        assign_rescue_variable(scope, node[2], error) if node[2]
+        with_scope(scope) { evaluate_statements(node[3]) }
+      rescue ReturnSignal, BreakSignal, NextSignal, CodeModeTimeoutError, CodeModeLimitError, CodeModeSyntaxError
+        raise
+      rescue StandardError => nested
+        next_clause = node[4]
+        raise nested unless next_clause&.first == :rescue
+        evaluate_rescue_clause(next_clause, nested)
+      end
+
+      def assign_rescue_variable(scope, target, error)
+        unsupported!(target) unless target.first == :var_field
+        scope[token_value(target[1])] = {
+          "message" => error.message,
+          "type" => error.class.name
+        }
+      end
+
+      def evaluate_rescue_modifier(node)
+        evaluate(node[1])
+      rescue ReturnSignal, BreakSignal, NextSignal, CodeModeTimeoutError, CodeModeLimitError, CodeModeSyntaxError
+        raise
+      rescue StandardError
+        evaluate(node[2])
+      end
+
+      def evaluate_loop(condition, statements, until_condition:)
+        result = nil
+        loop do
+          matches = truthy?(evaluate(condition))
+          break if until_condition ? matches : !matches
+
+          begin
+            result = evaluate_statements(statements)
+          rescue NextSignal => signal
+            result = signal.value
+          rescue BreakSignal => signal
+            return signal.value
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/utcp/code_mode/evaluator.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module UTCP
+  class CodeMode
+    class Evaluator
+      ReturnSignal = Class.new(StandardError) do
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+          super()
+        end
+      end
+      BreakSignal = Class.new(StandardError) do
+        attr_reader :value
+
+        def initialize(value = nil)
+          @value = value
+          super()
+        end
+      end
+      NextSignal = Class.new(StandardError) do
+        attr_reader :value
+
+        def initialize(value = nil)
+          @value = value
+          super()
+        end
+      end
+
+      RuntimeAPI = Class.new
+      Block = Struct.new(:evaluator, :parameters, :body) do
+        def call(*values)
+          scope = {}
+          if parameters.length == 1 && values.length > 1
+            scope[parameters.first] = values
+          else
+            parameters.each_with_index { |name, index| scope[name] = values[index] }
+          end
+          evaluator.with_scope(scope) { evaluator.evaluate(body) }
+        rescue NextSignal => signal
+          signal.value
+        end
+      end
+
+      SAFE_ENUMERABLE_METHODS = %w[
+        all? any? collect count each filter find map none? reduce inject reject select sort_by
+      ].freeze
+      SAFE_VALUE_METHODS = %w[
+        abs ceil compact dig downcase drop empty? end_with? even? fetch first flatten floor
+        has_key? include? inspect join key? keys last length max merge min negative? odd? positive?
+        nil? reverse round size slice sort split start_with? strip sum take to_a to_f to_h to_i to_s
+        uniq upcase values zero?
+      ].freeze
+
+      attr_reader :logs
+
+      def initialize(client, interfaces:, timeout:, max_steps:)
+        raise CodeModeLimitError, "max_steps must be greater than zero" unless max_steps.positive?
+
+        @client = client
+        @interfaces = interfaces
+        @deadline = monotonic_now + timeout
+        @max_steps = max_steps
+        @steps = 0
+        @logs = []
+        @log_bytes = 0
+        @scopes = [{ "codemode" => RuntimeAPI.new }]
+      end
+
+      def execute(source)
+        tree = Ripper.sexp(source)
+        raise CodeModeSyntaxError, "Invalid Ruby syntax" unless tree
+
+        safe_tool_value(evaluate(tree))
+      rescue ReturnSignal => signal
+        safe_tool_value(signal.value)
+      end
+
+      def evaluate(node)
+        tick!
+        return nil if node.nil?
+        return node unless node.is_a?(Array)
+        return evaluate_statements(node) unless node.first.is_a?(Symbol)
+
+        type = node.first
+        case type
+        when :program then evaluate_statements(node[1])
+        when :void_stmt then nil
+        when :assign then assign(node[1], evaluate(node[2]))
+        when :opassign then evaluate_opassign(node)
+        when :var_ref then evaluate_variable_token(node[1])
+        when :vcall then evaluate_vcall(node[1])
+        when :fcall then call_function(token_value(node[1]), [], nil)
+        when :@int then Integer(node[1], 10)
+        when :@float then Float(node[1])
+        when :@kw then evaluate_keyword(node[1])
+        when :string_literal then evaluate(node[1]).to_s
+        when :string_content then node.drop(1).map { |part| evaluate_string_part(part) }.join
+        when :symbol_literal then evaluate_symbol(node[1])
+        when :array then Array(node[1]).map { |item| evaluate(item) }
+        when :hash then evaluate_hash(node[1])
+        when :bare_assoc_hash then evaluate_associations(node[1])
+        when :paren then evaluate_statements(node[1])
+        when :binary then evaluate_binary(node[1], node[2], node[3])
+        when :unary then evaluate_unary(node[1], node[2])
+        when :dot2 then Range.new(evaluate(node[1]), evaluate(node[2]), false)
+        when :dot3 then Range.new(evaluate(node[1]), evaluate(node[2]), true)
+        when :aref then safe_index(evaluate(node[1]), extract_arguments(node[2]))
+        when :call, :method_add_arg, :command, :command_call then evaluate_call(node)
+        when :method_add_block then evaluate_call(node[1], build_block(node[2]))
+        when :begin then evaluate(node[1])
+        when :bodystmt then evaluate_body_statement(node)
+        when :rescue_mod then evaluate_rescue_modifier(node)
+        when :if then evaluate_if(node[1], node[2], node[3])
+        when :unless then evaluate_unless(node[1], node[2], node[3])
+        when :if_mod then truthy?(evaluate(node[1])) ? evaluate(node[2]) : nil
+        when :unless_mod then truthy?(evaluate(node[1])) ? nil : evaluate(node[2])
+        when :while then evaluate_loop(node[1], node[2], until_condition: false)
+        when :until then evaluate_loop(node[1], node[2], until_condition: true)
+        when :return then raise ReturnSignal, return_value(node[1])
+        when :return0 then raise ReturnSignal, nil
+        when :break then raise BreakSignal, return_value(node[1])
+        when :next then raise NextSignal, return_value(node[1])
+        else
+          unsupported!(node)
+        end
+      end
+
+      def evaluate_statements(statements)
+        Array(statements).reduce(nil) { |_result, statement| evaluate(statement) }
+      end
+
+      def with_scope(scope)
+        @scopes << scope
+        yield
+      ensure
+        @scopes.pop
+      end
+
+      private
+
+      def tick!
+        @steps += 1
+        raise CodeModeLimitError, "Code Mode step limit exceeded" if @steps > @max_steps
+        raise CodeModeTimeoutError, "Code Mode execution timed out" if monotonic_now >= @deadline
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def unsupported!(node)
+        line = find_line(node)
+        suffix = line ? " at line #{line}" : ""
+        raise CodeModeSyntaxError, "Unsupported Ruby construct #{node.first.inspect}#{suffix}"
+      end
+
+      def find_line(node)
+        return node[2][0] if node.is_a?(Array) && node.first.to_s.start_with?("@") && node[2].is_a?(Array)
+        return nil unless node.is_a?(Array)
+
+        node.each do |child|
+          line = find_line(child)
+          return line if line
+        end
+        nil
+      end
+
+      def token_value(token)
+        token.is_a?(Array) ? token[1].to_s : token.to_s
+      end
+
+    end
+  end
+end

data/lib/utcp/code_mode/expressions.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module UTCP
+  class CodeMode
+    class Evaluator
+      private
+
+      def evaluate_keyword(keyword)
+        case keyword
+        when "true" then true
+        when "false" then false
+        when "nil" then nil
+        else raise CodeModeSyntaxError, "Unsupported keyword #{keyword.inspect}"
+        end
+      end
+
+      def evaluate_string_part(part)
+        return part[1] if part.first == :@tstring_content
+        return evaluate_statements(part[1]).to_s if part.first == :string_embexpr
+
+        unsupported!(part)
+      end
+
+      def evaluate_symbol(node)
+        token = node.first == :symbol ? node[1] : node
+        token_value(token).to_sym
+      end
+
+      def evaluate_hash(contents)
+        return {} unless contents
+        return evaluate_associations(contents[1]) if contents.first == :assoclist_from_args
+
+        unsupported!(contents)
+      end
+
+      def evaluate_associations(associations)
+        Array(associations).each_with_object({}) do |association, result|
+          unsupported!(association) unless association.first == :assoc_new
+          key_node = association[1]
+          key = key_node.first == :@label ? key_node[1].sub(/:\z/, "") : evaluate(key_node)
+          result[key] = evaluate(association[2])
+        end
+      end
+
+      def evaluate_variable_token(token)
+        return evaluate_keyword(token[1]) if token.first == :@kw
+        lookup(token_value(token))
+      end
+
+      def evaluate_vcall(token)
+        name = token_value(token)
+        value = lookup(name, missing: :sentinel)
+        return value unless value == :sentinel
+
+        call_function(name, [], nil)
+      end
+
+      def lookup(name, missing: nil)
+        @scopes.reverse_each { |scope| return scope[name] if scope.key?(name) }
+        return missing if missing == :sentinel
+
+        raise CodeModeExecutionError, "Undefined local variable #{name.inspect}"
+      end
+
+      def assign(target, value)
+        case target.first
+        when :var_field
+          name = token_value(target[1])
+          scope = @scopes.reverse.find { |candidate| candidate.key?(name) } || @scopes.last
+          scope[name] = value
+        when :aref_field
+          receiver = evaluate(target[1])
+          arguments = extract_arguments(target[2])
+          raise CodeModeSyntaxError, "Indexed assignment requires exactly one key" unless arguments.length == 1
+          raise CodeModeSyntaxError, "Indexed assignment is only allowed on arrays and hashes" unless receiver.is_a?(Array) || receiver.is_a?(Hash)
+
+          receiver[arguments.first] = value
+        else
+          unsupported!(target)
+        end
+        value
+      end
+
+      def evaluate_opassign(node)
+        target = node[1]
+        operator = token_value(node[2]).sub(/=\z/, "").to_sym
+        current = read_assignment_target(target)
+        assign(target, apply_binary(current, operator, evaluate(node[3])))
+      end
+
+      def read_assignment_target(target)
+        case target.first
+        when :var_field then lookup(token_value(target[1]))
+        when :aref_field then safe_index(evaluate(target[1]), extract_arguments(target[2]))
+        else unsupported!(target)
+        end
+      end
+
+      def evaluate_binary(left_node, operator, right_node)
+        left = evaluate(left_node)
+        return left unless truthy?(left) if [:'&&', :and].include?(operator)
+        return left if truthy?(left) if [:'||', :or].include?(operator)
+
+        apply_binary(left, operator, evaluate(right_node))
+      end
+
+      def apply_binary(left, operator, right)
+        preflight_binary_size!(left, operator, right)
+        value = case operator
+                when :+ then left + right
+                when :- then left - right
+                when :* then left * right
+                when :/ then left / right
+                when :% then left % right
+                when :** then left**right
+                when :== then left == right
+                when :!= then left != right
+                when :< then left < right
+                when :<= then left <= right
+                when :> then left > right
+                when :>= then left >= right
+                when :<=> then left <=> right
+                when :'&&', :and, :'||', :or then right
+                else raise CodeModeSyntaxError, "Unsupported operator #{operator.inspect}"
+                end
+        bounded_value!(value)
+      rescue NoMethodError, TypeError, ArgumentError, ZeroDivisionError => error
+        raise CodeModeExecutionError, "Invalid #{operator} operation: #{error.message}"
+      end
+
+      def evaluate_unary(operator, operand_node)
+        operand = evaluate(operand_node)
+        case operator
+        when :! then !truthy?(operand)
+        when :+@ then +operand
+        when :-@ then -operand
+        else raise CodeModeSyntaxError, "Unsupported unary operator #{operator.inspect}"
+        end
+      end
+
+      def return_value(arguments_node)
+        arguments = extract_arguments(arguments_node)
+        arguments.length <= 1 ? arguments.first : arguments
+      end
+
+      def extract_arguments(node)
+        return [] if node.nil?
+        case node.first
+        when :arg_paren then extract_arguments(node[1])
+        when :args_add_block then Array(node[1]).map { |argument| evaluate(argument) }
+        when :args_new then []
+        when :args_add then extract_arguments(node[1]) + [evaluate(node[2])]
+        else [evaluate(node)]
+        end
+      end
+
+      def build_block(node)
+        unsupported!(node) unless %i[brace_block do_block].include?(node.first)
+        parameters = extract_block_parameters(node[1])
+        Block.new(self, parameters, node[2])
+      end
+
+      def extract_block_parameters(node)
+        return [] unless node
+        params = node.first == :block_var ? node[1] : node
+        unsupported!(params) unless params&.first == :params
+        required = Array(params[1])
+        unsupported!(params) unless params.drop(2).all?(&:nil?)
+
+        required.map { |token| token_value(token) }
+      end
+
+      def evaluate_call(node, block = nil)
+        case node.first
+        when :method_add_arg
+          invoke_call_target(node[1], extract_arguments(node[2]), block)
+        when :call
+          invoke_method(evaluate(node[1]), token_value(node[3]), [], block)
+        when :fcall
+          call_function(token_value(node[1]), [], block)
+        when :vcall
+          evaluate_vcall(node[1])
+        when :command
+          call_function(token_value(node[1]), extract_arguments(node[2]), block)
+        when :command_call
+          invoke_method(evaluate(node[1]), token_value(node[3]), extract_arguments(node[4]), block)
+        else
+          unsupported!(node)
+        end
+      end
+
+      def invoke_call_target(target, arguments, block)
+        case target.first
+        when :call
+          invoke_method(evaluate(target[1]), token_value(target[3]), arguments, block)
+        when :fcall
+          call_function(token_value(target[1]), arguments, block)
+        when :vcall
+          call_function(token_value(target[1]), arguments, block)
+        else
+          unsupported!(target)
+        end
+      end
+
+      def call_function(name, arguments, block)
+        case name
+        when "puts", "print", "p", "warn"
+          log(name, arguments)
+          nil
+        else
+          hint = name == "call_tool" ? "; use codemode.call_tool(...)" : ""
+          raise CodeModeSyntaxError, "Function #{name.inspect} is not available in Code Mode#{hint}"
+        end
+      end
+    end
+  end
+end

data/lib/utcp/code_mode/interface_generator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module UTCP
+  class CodeMode
+    class InterfaceGenerator
+      RUBY_KEYWORDS = %w[
+        BEGIN END alias and begin break case class def defined? do else elsif end ensure false
+        for if in module next nil not or redo rescue retry return self super then true undef
+        unless until when while yield
+      ].freeze
+
+      class << self
+        def tool_descriptor(tool)
+          {
+            "name" => tool.name,
+            "description" => tool.description,
+            "inputs" => tool.inputs.to_h,
+            "outputs" => tool.outputs.to_h,
+            "tags" => tool.tags.dup
+          }
+        end
+
+        def identifier(value)
+          name = value.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+          name = "_#{name}" if name.match?(/\A\d/)
+          name = "_#{name}" if RUBY_KEYWORDS.include?(name)
+          name.empty? ? "_" : name
+        end
+
+        def ruby_type(schema)
+          value = schema.is_a?(Hash) ? schema : {}
+          case value["type"] || value[:type]
+          when "string" then "String"
+          when "integer" then "Integer"
+          when "number" then "Numeric"
+          when "boolean" then "Boolean"
+          when "array" then "Array"
+          when "object" then "Hash"
+          when Array then (value["type"] || value[:type]).map { |type| ruby_type("type" => type) }.join(" | ")
+          else "Object"
+          end
+        end
+      end
+
+      def initialize(tools)
+        @tools = tools.sort_by(&:name)
+      end
+
+      def render
+        return "# No UTCP tools are registered." if @tools.empty?
+
+        @tools.map { |tool| render_tool(tool) }.join("\n\n")
+      end
+
+      private
+
+      def render_tool(tool)
+        descriptor = self.class.tool_descriptor(tool)
+        schema = descriptor["inputs"]
+        properties = schema.fetch("properties", {})
+        required = Array(schema["required"])
+        parameters = properties.map do |name, property|
+          suffix = required.include?(name.to_s) ? ":" : ": nil"
+          "#{self.class.identifier(name)}#{suffix}"
+        end
+        signature = parameters.empty? ? "" : parameters.join(", ")
+        description = descriptor["description"].to_s.strip
+        lines = []
+        lines << "# #{description}" unless description.empty?
+        unless properties.empty?
+          parameter_docs = properties.map do |name, property|
+            requirement = required.include?(name.to_s) ? "required" : "optional"
+            "#{self.class.identifier(name)} (#{self.class.ruby_type(property)}, #{requirement})"
+          end
+          lines << "# Parameters: #{parameter_docs.join(', ')}"
+        end
+        lines << "# Returns: #{self.class.ruby_type(descriptor["outputs"])}"
+        separator = signature.empty? ? "" : ", "
+        lines << "codemode.call_tool(#{descriptor["name"].inspect}#{separator}#{signature})"
+        lines.join("\n")
+      end
+    end
+  end
+end