ruby-mcp-client 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5249d2aeec436453cf92fb92a9d84468a3042d046d663d03eebffb734b16abd2
-  data.tar.gz: 30ece04171450241424fd81a95ef2f69d73e53300044d28d98796ecea88ba20b
+  metadata.gz: fe40b5481b8c0b59201585bfe54fb912c71235d4f02ada0c8a32a908155c319d
+  data.tar.gz: a378e9f8bd616e92739d371dfb458fc9385a6f2bbc62287cdf1e705742cfa6e0
 SHA512:
-  metadata.gz: 2c002ae531ff4ebfdb733638b9fe0a40ed4452a33bda9a7fac82b69395c662749b937f21d155bf9b9a6702a50c38bfa172c2ba59c3adad241a37495aa8d654d9
-  data.tar.gz: 4664e938db65412dc5aa7847dc7914b1e423d1f0a96e3dea65565138b494cb44b5449fd0be49be505e4170792a68e239b80da9a969fec9e620748b578a16c3c6
+  metadata.gz: 19cb60e6ebf6693a3ee312e592b94e891b568bb67fc675b732d3c32c6452260486fe3f7197a4626e933096cbb52ae4afae8aaed763906fba3041adcadb7ee8ce
+  data.tar.gz: c4c9d8a8b7aaf40d277bd20cb7aa50caf1ade083d6569e9825bb6dc53378d1359ef40e7dab84397416df950887b705abca7738179f639bd965ecb23e3d8186ea

data/README.md

@@ -30,7 +30,6 @@ via different transport mechanisms:
 
 - **Standard I/O**: Local processes implementing the MCP protocol
 - **Server-Sent Events (SSE)**: Remote MCP servers over HTTP with streaming support
-- **HTTP JSON-RPC**: Remote MCP servers over standard HTTP
 
 The core client resides in `MCPClient::Client` and provides helper methods for integrating
 with popular AI services with built-in conversions:
@@ -53,15 +52,10 @@ client = MCPClient.create_client(
     MCPClient.sse_config(
       base_url: 'https://api.example.com/sse',
       headers: { 'Authorization' => 'Bearer YOUR_TOKEN' },
-      read_timeout: 30 # Optional timeout in seconds (default: 30)
-    ),
-    # Remote HTTP JSON-RPC server
-    MCPClient.http_config(
-      base_url: 'https://api.example.com/jsonrpc',
-      headers: { 'Authorization' => 'Bearer YOUR_TOKEN' },
       read_timeout: 30, # Optional timeout in seconds (default: 30)
       retries: 3,       # Optional number of retry attempts (default: 0)
       retry_backoff: 1  # Optional backoff delay in seconds (default: 1)
+      # Native support for tool streaming via call_tool_streaming method
     )
   ]
 )
@@ -82,7 +76,8 @@ results = client.call_tools([
   { name: 'tool2', parameters: { key2: 'value2' } }
 ])
 
-# Stream results (for supported transports like SSE)
+# Stream results (supported by the SSE transport)
+# Returns an Enumerator that yields results as they become available
 client.call_tool_streaming('streaming_tool', { param: 'value' }).each do |chunk|
   # Process each chunk as it arrives
   puts chunk
@@ -92,6 +87,18 @@ end
 openai_tools = client.to_openai_tools
 anthropic_tools = client.to_anthropic_tools
 
+# Register for server notifications
+client.on_notification do |server, method, params|
+  puts "Server notification: #{server.class} - #{method} - #{params}"
+  # Handle specific notifications based on method name
+  # 'notifications/tools/list_changed' is handled automatically by the client
+end
+
+# Send custom JSON-RPC requests or notifications
+client.send_rpc('custom_method', params: { key: 'value' }, server: :sse) # Uses specific server
+result = client.send_rpc('another_method', params: { data: 123 }) # Uses first available server
+client.send_notification('status_update', params: { status: 'ready' })
+
 # Clear cached tools to force fresh fetch on next list
 client.clear_cache
 # Clean up connections
@@ -199,20 +206,15 @@ This client works with any MCP-compatible server, including:
 
 The SSE client implementation provides these key features:
 
-- **Robust connection handling**: Properly manages HTTP/HTTPS connections with configurable timeouts
+- **Robust connection handling**: Properly manages HTTP/HTTPS connections with configurable timeouts and retries
 - **Thread safety**: All operations are thread-safe using monitors and synchronized access
 - **Reliable error handling**: Comprehensive error handling for network issues, timeouts, and malformed responses
-- **JSON-RPC over SSE**: Full implementation of JSON-RPC 2.0 over SSE transport
-- **Streaming support**: Native streaming for real-time updates
-
-### HTTP JSON-RPC Implementation
-
-The HTTP client implementation provides these key features:
-
-- **Resilient connection handling**: Manages HTTP/HTTPS connections with configurable timeouts
-- **Retry mechanism**: Configurable retry attempts with exponential backoff for transient errors
-- **Error handling**: Comprehensive error handling for network issues, timeouts, and malformed responses
-- **JSON-RPC over HTTP**: Standard JSON-RPC 2.0 implementation
+- **JSON-RPC over SSE**: Full implementation of JSON-RPC 2.0 over SSE transport with initialize handshake
+- **Streaming support**: Native streaming for real-time updates via the `call_tool_streaming` method, which returns an Enumerator for processing results as they arrive
+- **Notification support**: Built-in handling for JSON-RPC notifications with automatic tool cache invalidation and custom notification callback support
+- **Custom RPC methods**: Send any custom JSON-RPC method or notification through `send_rpc` and `send_notification`
+- **Configurable retries**: All RPC requests support configurable retries with exponential backoff
+- **Consistent logging**: Tagged, leveled logging across all components for better debugging
 
 ## Requirements
 
@@ -227,6 +229,16 @@ To implement a compatible MCP server you must:
 - Respond to `list_tools` requests with a JSON list of tools
 - Respond to `call_tool` requests by executing the specified tool
 - Return results (or errors) in JSON format
+- Optionally send JSON-RPC notifications for events like tool updates
+
+### JSON-RPC Notifications
+
+The client supports JSON-RPC notifications from the server:
+
+- Default notification handler for `notifications/tools/list_changed` to automatically clear the tool cache
+- Custom notification handling via the `on_notification` method
+- Callbacks receive the server instance, method name, and parameters
+- Multiple notification listeners can be registered
 
 ## Tool Schema
 

data/lib/mcp_client/client.rb

@@ -19,11 +19,24 @@ module MCPClient
     # @param logger [Logger, nil] optional logger, defaults to STDOUT
     def initialize(mcp_server_configs: [], logger: nil)
       @logger = logger || Logger.new($stdout, level: Logger::WARN)
+      @logger.progname = self.class.name
+      @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
       @servers = mcp_server_configs.map do |config|
         @logger.debug("Creating server with config: #{config.inspect}")
         MCPClient::ServerFactory.create(config)
       end
       @tool_cache = {}
+      # JSON-RPC notification listeners
+      @notification_listeners = []
+      # Register default and user-defined notification handlers on each server
+      @servers.each do |server|
+        server.on_notification do |method, params|
+          # Default handling: clear tool cache on tools list change
+          clear_cache if method == 'notifications/tools/list_changed'
+          # Invoke user listeners
+          @notification_listeners.each { |cb| cb.call(server, method, params) }
+        end
+      end
     end
 
     # Lists all available tools from all connected MCP servers
@@ -92,6 +105,13 @@ module MCPClient
       @tool_cache.clear
     end
 
+    # Register a callback for JSON-RPC notifications from servers
+    # @yield [server, method, params]
+    # @return [void]
+    def on_notification(&block)
+      @notification_listeners << block
+    end
+
     # Find all tools whose name matches the given pattern (String or Regexp)
     # @param pattern [String, Regexp] pattern to match tool names
     # @return [Array<MCPClient::Tool>] matching tools

data/lib/mcp_client/server_base.rb

@@ -27,5 +27,29 @@ module MCPClient
     def cleanup
       raise NotImplementedError, 'Subclasses must implement cleanup'
     end
+
+    # Send a JSON-RPC request and return the result
+    # @param method [String] JSON-RPC method name
+    # @param params [Hash] parameters for the request
+    # @return [Object] result field from the JSON-RPC response
+    # @raise [MCPClient::Errors::ServerError, MCPClient::Errors::TransportError, MCPClient::Errors::ToolCallError]
+    def rpc_request(method, params = {})
+      raise NotImplementedError, 'Subclasses must implement rpc_request'
+    end
+
+    # Send a JSON-RPC notification (no response expected)
+    # @param method [String] JSON-RPC method name
+    # @param params [Hash] parameters for the notification
+    # @return [void]
+    def rpc_notify(method, params = {})
+      raise NotImplementedError, 'Subclasses must implement rpc_notify'
+    end
+
+    # Register a callback to receive JSON-RPC notifications
+    # @yield [method, params] invoked when a notification is received
+    # @return [void]
+    def on_notification(&block)
+      @notification_callback = block
+    end
   end
 end

data/lib/mcp_client/server_factory.rb

@@ -9,18 +9,15 @@ module MCPClient
     def self.create(config)
       case config[:type]
       when 'stdio'
-        MCPClient::ServerStdio.new(command: config[:command])
-      when 'sse'
-        MCPClient::ServerSSE.new(
-          base_url: config[:base_url],
-          headers: config[:headers] || {},
-          read_timeout: config[:read_timeout] || 30,
+        MCPClient::ServerStdio.new(
+          command: config[:command],
           retries: config[:retries] || 0,
           retry_backoff: config[:retry_backoff] || 1,
+          read_timeout: config[:read_timeout] || MCPClient::ServerStdio::READ_TIMEOUT,
           logger: config[:logger]
         )
-      when 'http'
-        MCPClient::ServerHTTP.new(
+      when 'sse'
+        MCPClient::ServerSSE.new(
           base_url: config[:base_url],
           headers: config[:headers] || {},
           read_timeout: config[:read_timeout] || 30,

data/lib/mcp_client/server_sse.rb

@@ -11,7 +11,7 @@ module MCPClient
   # Implementation of MCP server that communicates via Server-Sent Events (SSE)
   # Useful for communicating with remote MCP servers over HTTP
   class ServerSSE < ServerBase
-    attr_reader :base_url, :tools, :session_id, :http_client
+    attr_reader :base_url, :tools, :session_id, :http_client, :server_info, :capabilities
 
     # @param base_url [String] The base URL of the MCP server
     # @param headers [Hash] Additional headers to include in requests
@@ -22,6 +22,8 @@ module MCPClient
     def initialize(base_url:, headers: {}, read_timeout: 30, retries: 0, retry_backoff: 1, logger: nil)
       super()
       @logger = logger || Logger.new($stdout, level: Logger::WARN)
+      @logger.progname = self.class.name
+      @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
       @max_retries = retries
       @retry_backoff = retry_backoff
       @base_url = base_url.end_with?('/') ? base_url : "#{base_url}/"
@@ -42,6 +44,7 @@ module MCPClient
       @sse_connected = false
       @connection_established = false
       @connection_cv = @mutex.new_cond
+      @initialized = false
     end
 
     # Stream tool call fallback for SSE transport (yields single result)
@@ -64,7 +67,7 @@ module MCPClient
         return @tools if @tools
       end
 
-      connect
+      ensure_initialized
 
       begin
         tools_data = request_tools_list
@@ -93,7 +96,7 @@ module MCPClient
     # @raise [MCPClient::Errors::TransportError] if response isn't valid JSON
     # @raise [MCPClient::Errors::ToolCallError] for other errors during tool execution
     def call_tool(tool_name, parameters)
-      connect
+      ensure_initialized
 
       begin
         request_id = @mutex.synchronize { @request_id += 1 }
@@ -179,8 +182,84 @@ module MCPClient
       end
     end
 
+    # Generic JSON-RPC request: send method with params and return result
+    # @param method [String] JSON-RPC method name
+    # @param params [Hash] parameters for the request
+    # @return [Object] result from JSON-RPC response
+    def rpc_request(method, params = {})
+      ensure_initialized
+      with_retry do
+        request_id = @mutex.synchronize { @request_id += 1 }
+        request = { jsonrpc: '2.0', id: request_id, method: method, params: params }
+        send_jsonrpc_request(request)
+      end
+    end
+
+    # Send a JSON-RPC notification (no response expected)
+    # @param method [String] JSON-RPC method name
+    # @param params [Hash] parameters for the notification
+    # @return [void]
+    def rpc_notify(method, params = {})
+      ensure_initialized
+      url_base = @base_url.sub(%r{/sse/?$}, '')
+      uri = URI.parse("#{url_base}/messages?sessionId=#{@session_id}")
+      rpc_http = Net::HTTP.new(uri.host, uri.port)
+      if uri.scheme == 'https'
+        rpc_http.use_ssl = true
+        rpc_http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+      rpc_http.open_timeout = 10
+      rpc_http.read_timeout = @read_timeout
+      rpc_http.keep_alive_timeout = 60
+      rpc_http.start do |http|
+        http_req = Net::HTTP::Post.new(uri)
+        http_req.content_type = 'application/json'
+        http_req.body = { jsonrpc: '2.0', method: method, params: params }.to_json
+        headers = @headers.dup
+        headers.except('Accept', 'Cache-Control').each { |k, v| http_req[k] = v }
+        response = http.request(http_req)
+        unless response.is_a?(Net::HTTPSuccess)
+          raise MCPClient::Errors::ServerError, "Notification failed: #{response.code} #{response.message}"
+        end
+      end
+    rescue StandardError => e
+      raise MCPClient::Errors::TransportError, "Failed to send notification: #{e.message}"
+    ensure
+      rpc_http.finish if rpc_http&.started?
+    end
+
     private
 
+    # Ensure handshake initialization has been performed
+    def ensure_initialized
+      return if @initialized
+
+      connect
+      perform_initialize
+      @initialized = true
+    end
+
+    # Perform JSON-RPC initialize handshake with the MCP server
+    def perform_initialize
+      request_id = @mutex.synchronize { @request_id += 1 }
+      json_rpc_request = {
+        jsonrpc: '2.0',
+        id: request_id,
+        method: 'initialize',
+        params: {
+          'protocolVersion' => MCPClient::VERSION,
+          'capabilities' => {},
+          'clientInfo' => { 'name' => 'ruby-mcp-client', 'version' => MCPClient::VERSION }
+        }
+      }
+      @logger.debug("Performing initialize RPC: #{json_rpc_request}")
+      result = send_jsonrpc_request(json_rpc_request)
+      return unless result.is_a?(Hash)
+
+      @server_info = result['serverInfo'] if result.key?('serverInfo')
+      @capabilities = result['capabilities'] if result.key?('capabilities')
+    end
+
     # Start the SSE thread to listen for events
     def start_sse_thread
       return if @sse_thread&.alive?
@@ -272,6 +351,11 @@ module MCPClient
       when 'message'
         begin
           data = JSON.parse(event[:data])
+          # Dispatch JSON-RPC notifications (no id, has method)
+          if data['method'] && !data.key?('id')
+            @notification_callback&.call(data['method'], data['params'])
+            return
+          end
 
           @mutex.synchronize do
             @tools_data = data['result']['tools'] if data['result'] && data['result']['tools']

data/lib/mcp_client/server_stdio.rb

@@ -16,8 +16,9 @@ module MCPClient
     # @param command [String, Array] the stdio command to launch the MCP JSON-RPC server
     # @param retries [Integer] number of retry attempts on transient errors
     # @param retry_backoff [Numeric] base delay in seconds for exponential backoff
+    # @param read_timeout [Numeric] timeout in seconds for reading responses
     # @param logger [Logger, nil] optional logger
-    def initialize(command:, retries: 0, retry_backoff: 1, logger: nil)
+    def initialize(command:, retries: 0, retry_backoff: 1, read_timeout: READ_TIMEOUT, logger: nil)
       super()
       @command = command.is_a?(Array) ? command.join(' ') : command
       @mutex = Mutex.new
@@ -26,8 +27,11 @@ module MCPClient
       @pending = {}
       @initialized = false
       @logger = logger || Logger.new($stdout, level: Logger::WARN)
+      @logger.progname = self.class.name
+      @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
       @max_retries = retries
       @retry_backoff = retry_backoff
+      @read_timeout = read_timeout
     end
 
     # Connect to the MCP server by launching the command process via stdout/stdin
@@ -57,6 +61,12 @@ module MCPClient
     def handle_line(line)
       msg = JSON.parse(line)
       @logger.debug("Received line: #{line.chomp}")
+      # Dispatch JSON-RPC notifications (no id, has method)
+      if msg['method'] && !msg.key?('id')
+        @notification_callback&.call(msg['method'], msg['params'])
+        return
+      end
+      # Handle standard JSON-RPC responses
       id = msg['id']
       return unless id
 
@@ -188,7 +198,7 @@ module MCPClient
     end
 
     def wait_response(id)
-      deadline = Time.now + READ_TIMEOUT
+      deadline = Time.now + @read_timeout
       @mutex.synchronize do
         until @pending.key?(id)
           remaining = deadline - Time.now
@@ -213,5 +223,45 @@ module MCPClient
         yielder << call_tool(tool_name, parameters)
       end
     end
+
+    # Generic JSON-RPC request: send method with params and wait for result
+    # @param method [String] JSON-RPC method
+    # @param params [Hash] parameters for the request
+    # @return [Object] result from JSON-RPC response
+    def rpc_request(method, params = {})
+      ensure_initialized
+      attempts = 0
+      begin
+        req_id = next_id
+        req = { 'jsonrpc' => '2.0', 'id' => req_id, 'method' => method, 'params' => params }
+        send_request(req)
+        res = wait_response(req_id)
+        if (err = res['error'])
+          raise MCPClient::Errors::ServerError, err['message']
+        end
+
+        res['result']
+      rescue MCPClient::Errors::ServerError, MCPClient::Errors::TransportError, IOError, Errno::ETIMEDOUT,
+             Errno::ECONNRESET => e
+        attempts += 1
+        if attempts <= @max_retries
+          delay = @retry_backoff * (2**(attempts - 1))
+          @logger.debug("Retry attempt #{attempts} after error: #{e.message}, sleeping #{delay}s")
+          sleep(delay)
+          retry
+        end
+        raise
+      end
+    end
+
+    # Send a JSON-RPC notification (no response expected)
+    # @param method [String] JSON-RPC method
+    # @param params [Hash] parameters for the notification
+    # @return [void]
+    def rpc_notify(method, params = {})
+      ensure_initialized
+      notif = { 'jsonrpc' => '2.0', 'method' => method, 'params' => params }
+      @stdin.puts(notif.to_json)
+    end
   end
 end

data/lib/mcp_client/version.rb

@@ -2,5 +2,5 @@
 
 module MCPClient
   # Current version of the MCP client gem
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

data/lib/mcp_client.rb

@@ -6,7 +6,6 @@ require_relative 'mcp_client/tool'
 require_relative 'mcp_client/server_base'
 require_relative 'mcp_client/server_stdio'
 require_relative 'mcp_client/server_sse'
-require_relative 'mcp_client/server_http'
 require_relative 'mcp_client/server_factory'
 require_relative 'mcp_client/client'
 require_relative 'mcp_client/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mcp-client
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Szymon Kurcab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -81,7 +81,6 @@ files:
 - lib/mcp_client/errors.rb
 - lib/mcp_client/server_base.rb
 - lib/mcp_client/server_factory.rb
-- lib/mcp_client/server_http.rb
 - lib/mcp_client/server_sse.rb
 - lib/mcp_client/server_stdio.rb
 - lib/mcp_client/tool.rb

data/lib/mcp_client/server_http.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-require 'net/http'
-require 'json'
-require 'openssl'
-require 'logger'
-
-module MCPClient
-  # Implementation of MCP server over HTTP JSON-RPC
-  class ServerHTTP < ServerBase
-    attr_reader :base_url, :headers, :read_timeout, :max_retries, :retry_backoff, :logger
-
-    # @param base_url [String] The base URL of the MCP HTTP server
-    # @param headers [Hash] HTTP headers to include in requests
-    # @param read_timeout [Integer] Read timeout in seconds
-    # @param retries [Integer] number of retry attempts on transient errors
-    # @param retry_backoff [Numeric] base delay in seconds for exponential backoff
-    # @param logger [Logger, nil] optional logger
-    def initialize(base_url:, headers: {}, read_timeout: 30, retries: 0, retry_backoff: 1, logger: nil)
-      super()
-      @base_url = base_url
-      @headers = headers
-      @read_timeout = read_timeout
-      @max_retries = retries
-      @retry_backoff = retry_backoff
-      @logger = logger || Logger.new($stdout, level: Logger::WARN)
-      @request_id = 0
-    end
-
-    # List available tools
-    # @return [Array<MCPClient::Tool>]
-    def list_tools
-      request_json = jsonrpc_request('tools/list', {})
-      result = send_request(request_json)
-      (result['tools'] || []).map { |td| MCPClient::Tool.from_json(td) }
-    rescue MCPClient::Errors::MCPError
-      raise
-    rescue StandardError => e
-      raise MCPClient::Errors::ToolCallError, "Error listing tools: #{e.message}"
-    end
-
-    # Call a tool with given parameters
-    # @param tool_name [String]
-    # @param parameters [Hash]
-    # @return [Object] result of invocation
-    def call_tool(tool_name, parameters)
-      request_json = jsonrpc_request('tools/call', { 'name' => tool_name, 'arguments' => parameters })
-      send_request(request_json)
-    rescue MCPClient::Errors::MCPError
-      raise
-    rescue StandardError => e
-      raise MCPClient::Errors::ToolCallError, "Error calling tool '#{tool_name}': #{e.message}"
-    end
-
-    # Streaming is not supported over simple HTTP transport; fallback to single response
-    # @param tool_name [String]
-    # @param parameters [Hash]
-    # @return [Enumerator]
-    def call_tool_streaming(tool_name, parameters)
-      Enumerator.new do |yielder|
-        yielder << call_tool(tool_name, parameters)
-      end
-    end
-
-    private
-
-    def jsonrpc_request(method, params)
-      @request_id += 1
-      {
-        'jsonrpc' => '2.0',
-        'id' => @request_id,
-        'method' => method,
-        'params' => params
-      }
-    end
-
-    def send_request(request)
-      attempts = 0
-      begin
-        attempts += 1
-        uri = URI.parse(base_url)
-        http = Net::HTTP.new(uri.host, uri.port)
-        if uri.scheme == 'https'
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        end
-        http.open_timeout = 10
-        http.read_timeout = read_timeout
-
-        @logger.debug("Sending HTTP JSONRPC request: #{request.to_json}")
-        response = http.post(uri.path, request.to_json, default_headers)
-        @logger.debug("Received HTTP response: #{response.code} #{response.body}")
-
-        unless response.is_a?(Net::HTTPSuccess)
-          raise MCPClient::Errors::ServerError, "Server returned error: #{response.code} #{response.message}"
-        end
-
-        data = JSON.parse(response.body)
-        raise MCPClient::Errors::ServerError, data['error']['message'] if data['error']
-
-        data['result']
-      rescue MCPClient::Errors::ServerError, MCPClient::Errors::TransportError, IOError, Timeout::Error => e
-        raise unless attempts <= max_retries
-
-        delay = retry_backoff * (2**(attempts - 1))
-        @logger.debug("Retry attempt #{attempts} after error: #{e.message}, sleeping #{delay}s")
-        sleep(delay)
-        retry
-      rescue JSON::ParserError => e
-        raise MCPClient::Errors::TransportError, "Invalid JSON response: #{e.message}"
-      end
-    end
-
-    def default_headers
-      h = headers.dup
-      h['Content-Type'] = 'application/json'
-      h
-    end
-  end
-end