anytls 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 614c54295c75168e63b13a6c1cb9703321cc70bbaa672a5a3d064ed630b014ad
-  data.tar.gz: 51446c2245624537d53fb9fcd8b49f51b3a57f3241bcfe5785eaa5206404c02e
+  metadata.gz: c797edcda4beba1d06a85d522a65ba7c4a3b7079955ea5640cc6f4320078e05b
+  data.tar.gz: e0d213605c4574257a28a0231b11dee4484db37aae667dda501532955fc4abf3
 SHA512:
-  metadata.gz: 1da8ddbc879a82a96263c991f27cbdaf8f9ae2b4ff90a112a811ad42ab63b102e09078af8fff6b8893c121c8b5683c68a65b942907181ffe464a0c8674e012f7
-  data.tar.gz: b3cece03e15e6593db595b7ca78e3291fecaf8eae3a1e4bc71cd73ba1b08ff22aab8a3cec5891e3eb8851e4af56b8cdfde760fc1c52197e88fa95cb79e58ddee
+  metadata.gz: d8d10834c474ffd7e04c325dcf00b187c2b68984af406591b947cc8dd2ec390d7cd425024d24af87d17de62e1e8217926faae0cb12e9cfc55355a54f85609052
+  data.tar.gz: 7799f998dd9825273c1de1dd045e64d7cfad11816f8dd1d594a105386e312a630c1cbd5ae62951d575079733048b36ca215726ab7119edb987125d9b9c33d4b1

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.5 (2026-10-06)
+
+- 修复 v1 多流集中报告目标就绪时，操作队列未排空却进入等待导致整条会话超时的问题。
+- 服务端停止时继续回收其余资源，完成全部清理尝试后再报告首个关闭或线程异常。
+- UoT 与 SOCKS5 UDP ASSOCIATE 在全部必需 worker 创建成功后才报告就绪，准备失败会回滚资源。
+- Client 关闭时可取消已经创建、仍在 TLS 握手或认证阶段的会话。
+- 大块 Stream 写入与 Relay 使用最多 65,535 字节的片段，减少同步提交次数。
+- 有界合并 HTTP chunk 包装写入，保留流式 flush、提前响应和 trailer 边界。
+- UoT 非固定模式复用最近一个数字目标的解析结果，减少重复调用；域名仍逐包解析。
+
 ## 0.1.4 (2026-10-05)
 
 - 临时接入网络错误后继续接受连接，保留已有代理会话。

data/README.md

@@ -4,7 +4,7 @@ Ruby 3.4+ 的 AnyTLS gem 与命令行客户端、服务端。参考版本固定
 [`anytls-go` 的 `fd6167a`](https://github.com/anytls/anytls-go/tree/fd6167acd6d73b9fa3e607659951847fbc9e6c50)。
 核心代码不依赖 Rails。
 
-当前版本为 `0.1.4`，Ruby 实现使用 [MIT 许可证](LICENSE)。项目及参考代码的许可边界见
+当前版本为 `0.1.5`，Ruby 实现使用 [MIT 许可证](LICENSE)。项目及参考代码的许可边界见
 [SOURCES](docs/SOURCES.md)。
 
 ## 使用
@@ -71,6 +71,7 @@ end
 发送，不证明目标应用已处理。错误或超时后的数据不自动重放。Stream 没有独立 fd，
 不提供 `to_io` 或真正的 TCP half-close。
 远端结束后可继续排空接收数据；显式 `close` 会丢弃未读数据，即使远端已经结束。
+大块写入按最多 65,535 字节分片，每片完成后才提交下一片；排队与发送共用本次 write 的超时预算。
 
 AnyTLS 没有独立的认证成功回执；首次连接或 v1 peer 可能先返回尚未确认目标连接的
 Stream。`connection_status` 区分 `:unconfirmed`、`:confirmed`、`:failed`。远端拒绝、认证
@@ -90,6 +91,7 @@ end
 字段可承载最多 65,535 字节，空 datagram 有效。实际 UDP socket 还受地址族与系统发送
 上限约束，可能以 `EMSGSIZE` 拒绝较大的包；线协议上限不是网络发送保证。
 SOCKS5 UDP ASSOCIATE 通过同一 UoT 能力实现。
+转发资源与必需线程全部创建后才报告就绪；准备失败不会先回复成功。
 
 ```ruby
 tls = AnyTLS::TLSConfig.new(server: true, cert: "fullchain.pem", key: "private-key.pem")
@@ -102,6 +104,8 @@ session 的数量，不会主动创建连接填满池。默认最多 128 个 ses
 各 30 秒；归还 session 不提前触发空闲扫描。客户端租用空闲 session；并发请求需要时
 建立新的 session。服务端默认最多
 256 个活动 stream。`Client#stats`、`Server#stats` 返回冻结的计数快照。
+`Client#close` 会取消已创建会话的在途 TLS 握手与认证；尚处于 DNS 解析或 TCP 拨号的创建操作
+仍按既有连接预算结束，迟到的结果不会交给调用者。
 
 ## 功能与边界
 

data/docs/ARCHITECTURE.md

@@ -39,12 +39,17 @@ Client pool 同一时刻将一个 session 租给一条业务 stream，完成后
 服务端 Session 解码器支持多条 stream 的帧，入站数量另受 session 和 server 限制。
 旧空闲连接检测、心跳和 peer stream-ID 限制都在 session 生命周期中处理，不由应用代理层重试。
 池容量等待与定时回收使用独立通知；租用、归还不触发全池回收扫描，关闭会立即唤醒两类等待者。
+工厂取得 Session 后、等待 TLS 就绪前，通过登记回调交出取消句柄。池关闭时也唤醒这些
+在途 owner；它们仍计入 creating 容量，成功租出或失败回收后才退出创建计数。
+DNS 与 TCP 拨号阶段尚无 Session，继续受原连接预算约束。
 
 ## 线程与 TLS 所有权
 
 Session owner 唯一持有 TLS IO 使用权；应用线程通过同步提交请求与 completion 等待写入结果。
 owner 运行具体的 AnyTLS 事件循环：处理请求、选择待发片段、推进 TLS write/read、dispatch
 完整帧、根据方向和最近 deadline 等待 TLS fd 或 wakeup socket。它不是通用调度器。
+每轮最多处理 16 个提交操作；wake 字节可合并，队列仍非空时不得进入阻塞等待。
+即使 v1 目标就绪报告无需发送帧，也必须继续处理剩余操作，同时保留每轮 TLS 读写机会。
 
 同一 `SSLSocket` 不由 reader/writer 两线程直接共用。待重试的 `SSL_write` 保持完全相同
 的数据和长度；只有成功返回正整数后才推进偏移。write 返回 WANT_WRITE 时，下一次 TLS
@@ -79,10 +84,11 @@ Session 状态锁只保护短操作；锁内不等待网络、不回调调用者
 | 单 stream 接收缓冲 | 256 KiB |
 | 单 session 接收缓冲 | 4 MiB |
 | 单 session 提交发送预算 | 1 MiB，计入编码和 padding 预留 |
-| Stream 数据写片段 | 16 KiB |
+| Stream 数据写片段与 Relay 读取上限 | 65,535 字节 |
 | UoT 包长度字段 | 65,535 字节；实际 UDP socket 另受地址族/系统大小限制 |
 | CLI 混合入站连接 | 256 |
 
+Stream 的实际写片段还会扣除帧头与 padding 预留，适配小于默认值的 session 发送预算。
 接收 owner 不能阻塞等待单个 Stream 消费。超过接收预算时终止对应 stream，并通知 peer；
 控制帧预算也不能无限增长。发送预算不足时让提交者等待。限制按 bytes 计费，不能只用
 队列条目数代表内存大小。上限约束 Ruby 可见缓冲，不宣称它是进程 RSS 的精确上界。
@@ -102,7 +108,14 @@ AnyTLS Stream，否则已接收的响应体会被丢弃。
 预算从上传完成开始，到最终响应头结束；临时响应不延长预算，响应体不受此预算限制。
 超时先记录原因再关闭上游，唤醒已经阻塞的读取者；提前响应与清理均解除等待并回收上传线程。
 HTTP 字段值仅修剪 SP/HTAB，保持重复字段及定界冲突检查。头字段写入以最多 16 KiB
-缓冲合并，保留依赖的校验和字段顺序，返回前发送；消息体仍直接流式转发。
+缓冲合并，保留依赖的校验和字段顺序，返回前发送。chunked body 同样有界合并包装字节；
+沿用依赖的 flush 边界，在下一次可能阻塞的 body.read 前发送已有数据，并在 body.close
+前发送终止块与 trailer。异常退出丢弃尚未发送的包装缓冲，不重放部分发送的数据。
+
+UoT 与 SOCKS5 UDP association 使用启动门：全部必需线程取得后才报告成功并放行转发；
+创建失败则唤醒尚未启动的线程退出、回收 socket/stream，并报告失败。后续延迟创建地址族
+资源失败也会结束转发并触发统一清理。UoT 非固定模式在每条流内最多保留一个数字 IP 与
+端口对应的解析结果，目标改变时更新；域名结果不缓存，继续逐包解析。
 
 同一 TCP 连接天然存在队首阻塞；有限缓冲只能限制 Ruby 自身的资源占用和慢消费者影响。
 当前没有扩展协议增加 per-stream credit，不承诺无限慢消费者仍可无损持续接收。

data/docs/VALIDATION.md

@@ -25,7 +25,7 @@
 
 CI 的 Ubuntu / Ruby 4.0 任务在验证通过后上传 `anytls-gem` artifact，包含 gem 和 `SHA256SUMS`。
 发布前须确认同一提交的完整 Ruby 矩阵和 Go 互通任务均通过，下载该 artifact 并核对校验和。
-运行 `bundle exec ruby script/verify_package.rb /path/to/anytls-0.1.4.gem` 可验证已有包与当前源码
+运行 `bundle exec ruby script/verify_package.rb /path/to/anytls-0.1.5.gem` 可验证已有包与当前源码
 的文件内容、元数据和依赖一致，并隔离安装该包；提供路径时不会重新构建 gem。
 GitHub Release 和 RubyGems 必须使用这一份验证过的包，发布后下载两处产物并核对 SHA256。
 

data/lib/anytls/client.rb

@@ -28,8 +28,8 @@ module AnyTLS
       @scheme_mutex = Mutex.new
       @pool = SessionPool.new(max_sessions: max_sessions, min_idle_sessions: min_idle_sessions,
                               idle_timeout: idle_timeout, idle_check_interval: idle_check_interval,
-                              reuse: reuse) do |sequence, timeout|
-        create_session(sequence, timeout)
+                              reuse: reuse) do |sequence, timeout, &register|
+        create_session(sequence, timeout, &register)
       end
     end
 
@@ -120,6 +120,7 @@ module AnyTLS
                                     on_idle: ->(item) { @pool.release(item) },
                                     on_close: ->(item) { @pool.remove(item) },
                                     on_padding: ->(scheme) { @scheme_mutex.synchronize { @scheme = scheme } })
+      yield session
       session.wait_ready(timeout: deadline.remaining)
     rescue StandardError
       session ? session.close : socket&.close

data/lib/anytls/inbound/http_proxy.rb

@@ -50,33 +50,55 @@ module AnyTLS
           super
         end
 
-        # 仅在同步写出头字段期间合并小写入；不缓存消息体，结束时即发送。
-        # 继续使用依赖的字段校验、顺序和重复字段语义。
+        # 头字段和 chunk 包装共用有界缓冲；字段校验、顺序和消息定界仍由依赖处理。
         def write_headers(headers)
-          @header_buffer = +"".b
+          return super if @write_buffer
+
+          begin
+            @write_buffer = +"".b
+            super
+            flush_write_buffer
+          ensure
+            @write_buffer = nil
+          end
+        end
+
+        def write_chunked_body(...)
+          @write_buffer = +"".b
+          # 沿用依赖的 flush 边界：下一次 body.read 可能阻塞前，先发送已取得的字节。
           super
-          bytes = @header_buffer
-          @header_buffer = nil
-          write_stream(bytes) unless bytes.empty?
         ensure
-          @header_buffer = nil
+          @write_buffer = nil
         end
 
         private
 
         def write_stream(bytes)
-          return super unless @header_buffer
+          return super unless @write_buffer
 
-          if @header_buffer.bytesize + bytes.bytesize > 16_384
-            super(@header_buffer) unless @header_buffer.empty?
-            @header_buffer.clear
+          if @write_buffer.bytesize + bytes.bytesize > 16_384
+            super(@write_buffer) unless @write_buffer.empty?
+            @write_buffer.clear
           end
           if bytes.bytesize > 16_384
             super
           else
-            @header_buffer << bytes
+            @write_buffer << bytes
           end
         end
+
+        def flush_stream
+          flush_write_buffer if @write_buffer
+          super
+        end
+
+        def flush_write_buffer
+          bytes = @write_buffer
+          @write_buffer = nil
+          write_stream(bytes) unless bytes.empty?
+        ensure
+          @write_buffer = +"".b
+        end
       end
 
       # 复用上传线程守候最终响应头，不增加每请求的定时器线程。

data/lib/anytls/inbound/socks5.rb

@@ -72,15 +72,14 @@ module AnyTLS
         socket = UDPSocket.new(io.addr[0] == "AF_INET6" ? Socket::AF_INET6 : Socket::AF_INET)
         socket.bind(io.addr[3], 0)
         packets = @client.open_datagrams(timeout: @handshake_timeout)
-        reply(io, 0, Address.new(host: socket.addr[3], port: socket.addr[1]))
-        io.timeout = nil
         source_ip = IPAddr.new(io.peeraddr[3]).native.to_s
         source_port = requested_source.port.zero? ? nil : requested_source.port
         peer = nil
         peer_lock = Mutex.new
         done = Queue.new
         workers = []
-        workers << packet_worker(done) do
+        started = Queue.new
+        workers << packet_worker(done, started) do
           loop do
             wire, sender = socket.recvfrom(UoT::Connection::MAX_PACKET_SIZE + 263)
             next unless IPAddr.new(sender[3]).native.to_s == source_ip
@@ -105,7 +104,7 @@ module AnyTLS
             end
           end
         end
-        workers << packet_worker(done) do
+        workers << packet_worker(done, started) do
           loop do
             payload, destination = packets.receive_packet
             target = peer_lock.synchronize { peer }
@@ -115,17 +114,27 @@ module AnyTLS
             socket.send(wire, 0, target[0], target[1])
           end
         end
-        workers << packet_worker(done) { loop { io.readpartial(1024) } }
+        workers << packet_worker(done, started) { loop { io.readpartial(1024) } }
+        # 成功回复提交完整的转发资源；部分创建失败时尚未放行任何 worker。
+        return unless reply(io, 0, Address.new(host: socket.addr[3], port: socket.addr[1]))
+
+        io.timeout = nil
+        workers.size.times { started << true }
         done.pop
+      rescue ThreadError
+        reply(io, 1)
       ensure
+        started&.close
         socket&.close
         packets&.close
         io.close
         workers&.each(&:join)
       end
 
-      def packet_worker(done, &block)
+      def packet_worker(done, started, &block)
         Thread.new do
+          next unless started.pop
+
           block.call
         rescue IOError, SystemCallError, Error, SocketError
           nil

data/lib/anytls/relay.rb

@@ -4,7 +4,7 @@ module AnyTLS
   # 使用有界片段进行双向转发，并负责关闭两个端点。
   # 任一方向首先结束时启动清理，并等待两个转发线程退出。
   module Relay
-    BUFFER_SIZE = 16_384
+    BUFFER_SIZE = Protocol::MAX_PAYLOAD
 
     # FIN 关闭整条 AnyTLS 流；任一方向 EOF 都会关闭两个端点。
     # 此处不能模拟 TCP 半关闭，否则会丢失协议状态。

data/lib/anytls/server.rb

@@ -84,6 +84,7 @@ module AnyTLS
     def stop(grace: 5)
       deadline = Deadline.new(grace)
       owns_stop = false
+      failure = nil
       sessions = @mutex.synchronize do
         return if @stopped || @stop_owner == Thread.current
 
@@ -96,7 +97,11 @@ module AnyTLS
         @stop_owner = Thread.current
         @stopping = true
         @changed.broadcast
-        @listener&.close unless @listener&.closed?
+        begin
+          @listener&.close unless @listener&.closed?
+        rescue StandardError => error
+          failure ||= error
+        end
         while @active_streams.positive?
           remaining = deadline.remaining
           break if remaining&.zero?
@@ -105,11 +110,30 @@ module AnyTLS
         end
         @sessions.keys
       end
-      sessions.each { |session| session.close(wait: false) }
-      sessions.each(&:close)
+      # 单个 close/join 的异常不能跳过其他资源；完成全部回收尝试后再报告首错。
+      sessions.each do |session|
+        session.close(wait: false)
+      rescue StandardError => error
+        failure ||= error
+      end
       workers, targets = @mutex.synchronize { [@workers.dup, @targets.keys] }
-      targets.each { |socket| IOHelpers.close(socket) unless socket.closed? }
-      workers.each { |thread| thread.join unless thread == Thread.current }
+      targets.each do |socket|
+        IOHelpers.close(socket) unless socket.closed?
+      rescue StandardError => error
+        failure ||= error
+      end
+      sessions.each do |session|
+        session.close
+      rescue StandardError => error
+        failure ||= error
+      end
+      workers.each do |thread|
+        thread.join unless thread == Thread.current
+      rescue StandardError => error
+        failure ||= error
+      end
+      raise failure if failure
+
       nil
     ensure
       if owns_stop
@@ -175,7 +199,7 @@ module AnyTLS
         @workers.select!(&:alive?)
         @workers << Thread.new do
           handle_stream(stream, session)
-        rescue Error, IOError, SystemCallError, SocketError => error
+        rescue Error, IOError, SystemCallError, SocketError, ThreadError => error
           Log.emit(@logger, :debug, "AnyTLS outbound ended: #{error.class}")
         ensure
           begin
@@ -217,7 +241,7 @@ module AnyTLS
         reported = true
         Relay.copy(stream, target)
       end
-    rescue Error, IOError, SystemCallError, SocketError => error
+    rescue Error, IOError, SystemCallError, SocketError, ThreadError => error
       session.report_connected(stream.id, error: error) unless reported || stream.closed?
       raise
     ensure

data/lib/anytls/session.rb

@@ -247,6 +247,10 @@ module AnyTLS
     end
 
     def wait_for_work(read_wait)
+      # wake 字节可以被合并排空，不能把它当作每个操作各有一次的通知。
+      # 每轮仍只处理有限操作并推进 TLS；队列未空时直接进入下一轮。
+      return if @mutex.synchronize { !@operations.empty? || @stopping }
+
       readers = [@wake_reader]
       writers = []
       if @current && @transport.write_wait == :wait_writable
@@ -542,7 +546,11 @@ module AnyTLS
     end
 
     def register_stream(id)
-      stream = Stream.new(self, id, receive_limit: @receive_limit, receive_budget: @receive_budget)
+      # 大帧仍须容纳于会话预算；较小的自定义预算保留原有分片发送能力。
+      payload_limit = @send_limit - Protocol::HEADER_SIZE - (@server ? 0 : @scheme.max_padding_bytes)
+      write_limit = payload_limit.clamp(1, Protocol::MAX_PAYLOAD)
+      stream = Stream.new(self, id, receive_limit: @receive_limit, receive_budget: @receive_budget,
+                                    write_limit: write_limit)
       @mutex.synchronize do
         @streams[id] = stream
         @active_count = @streams.size

data/lib/anytls/session_pool.rb

@@ -31,6 +31,7 @@ module AnyTLS
       @changed = ConditionVariable.new
       @maintenance_changed = ConditionVariable.new
       @sessions = {}
+      @pending_sessions = {}
       @idle = {}
       @creating = 0
       @sequence = 0
@@ -68,10 +69,18 @@ module AnyTLS
 
       session = nil
       begin
-        session = @factory.call(sequence, deadline.remaining)
+        session = @factory.call(sequence, deadline.remaining) do |pending|
+          # 工厂一旦取得 TLS session 就登记取消句柄；握手完成前也能由 close 唤醒 owner。
+          @mutex.synchronize do
+            raise ClosedError, "client closed during dial" if @closed
+
+            @pending_sessions[sequence] = pending
+          end
+        end
         @mutex.synchronize do
           raise ClosedError, "client closed during dial" if @closed || session.closed?
 
+          @pending_sessions.delete(sequence)
           @sessions[session] = :leased
         end
         session
@@ -80,6 +89,7 @@ module AnyTLS
         raise
       ensure
         @mutex.synchronize do
+          @pending_sessions.delete(sequence)
           @creating -= 1
           @changed.broadcast
         end
@@ -125,8 +135,9 @@ module AnyTLS
         @closed = true
         @changed.broadcast
         @maintenance_changed.broadcast
-        result = @sessions.keys
+        result = (@sessions.keys + @pending_sessions.values).uniq
         @sessions.clear
+        @pending_sessions.clear
         @idle.clear
         result
       end

data/lib/anytls/stream.rb

@@ -7,10 +7,15 @@ module AnyTLS
   class Stream
     attr_reader :id
 
-    def initialize(session, id, receive_limit: 262_144, receive_budget: nil)
+    def initialize(session, id, receive_limit: 262_144, receive_budget: nil, write_limit: Protocol::MAX_PAYLOAD)
+      unless write_limit.is_a?(Integer) && write_limit.between?(1, Protocol::MAX_PAYLOAD)
+        raise ArgumentError, "write limit must be between 1 and 65535"
+      end
+
       @session = session
       @id = id
       @buffer = ByteBuffer.new(limit: receive_limit, budget: receive_budget)
+      @write_limit = write_limit
       @mutex = Mutex.new
       @changed = ConditionVariable.new
       @closed = false
@@ -63,7 +68,7 @@ module AnyTLS
         offset = 0
         while offset < bytes.bytesize
           ensure_open!
-          chunk = bytes.byteslice(offset, 16_384).b.freeze
+          chunk = bytes.byteslice(offset, @write_limit).b.freeze
           @session.write_stream(id, chunk, deadline: deadline)
           offset += chunk.bytesize
         end

data/lib/anytls/uot/server.rb

@@ -20,6 +20,7 @@ module AnyTLS
         lock = Mutex.new
         finished = Queue.new
         workers = []
+        started = Queue.new
         stopping = false
         create_socket = lambda do |family|
           lock.synchronize do
@@ -33,6 +34,9 @@ module AnyTLS
                                connected_address.ip_port)
               end
               workers << Thread.new do
+                started.pop
+                next unless ready_reported
+
                 loop do
                   payload, sender = socket.recvfrom(Connection::MAX_PACKET_SIZE + 1)
                   address = connection.destination || Address.new(host: sender[3], port: sender[1])
@@ -48,20 +52,37 @@ module AnyTLS
             end
           end
         end
-        # 确认流连接成功前，先建立真实出站 socket。
+        # 所有必需线程创建成功后才确认就绪；启动门防止部分准备完成时提前转发。
         create_socket.call(connected_address ? connected_address.afamily : Socket::AF_INET)
-        on_ready&.call
-        ready_reported = true
         workers << Thread.new do
+          started.pop
+          next unless ready_reported
+
+          cached_destination = cached_address = nil
           loop do
             payload, destination = connection.receive_packet
-            address = connected_address || resolve(destination)
+            address = connected_address
+            unless address
+              if destination == cached_destination
+                address = cached_address
+              else
+                address = resolve(destination)
+                # 每条流只保留一个数字目标，包含端口；域名继续逐包解析，不引入 DNS 过期语义。
+                if destination.ip?
+                  cached_destination = destination
+                  cached_address = address
+                end
+              end
+            end
             socket = create_socket.call(address.afamily)
             connected_address ? socket.send(payload, 0) : socket.send(payload, 0, address.to_sockaddr)
           end
-        rescue IOError, SystemCallError, Error, SocketError => error
+        rescue IOError, SystemCallError, Error, SocketError, ThreadError => error
           finished << error
         end
+        on_ready&.call
+        ready_reported = true
+        started.close
         finished.pop
         nil
       rescue StandardError => error
@@ -75,6 +96,8 @@ module AnyTLS
         end
         raise
       ensure
+        # 准备失败时同样唤醒已创建的线程；未确认就绪的线程直接退出。
+        started&.close
         lock&.synchronize do
           stopping = true
           sockets&.each_value(&:close)

data/lib/anytls/version.rb

@@ -2,5 +2,5 @@
 
 module AnyTLS
   # gemspec、命令行和对端标识共用的唯一版本来源。
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: anytls
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - AnyTLS Ruby contributors