itsi 0.2.15 → 0.2.17

data/gems/server/lib/ruby_lsp/itsi/addon.rb

@@ -5,8 +5,8 @@ require "itsi/server"
 
 module RubyLsp
   module Itsi
-    class Addon < ::RubyLsp::Addon
-      def activate(global_state, message_queue)
+    class Addon < ::RubyLsp::Addon # rubocop:disable Style/Documentation
+      def activate(_global_state, message_queue)
         @message_queue = message_queue
       end
 
@@ -20,33 +20,34 @@ module RubyLsp
         "0.1.0"
       end
 
-
       def create_completion_listener(response_builder, node_context, dispatcher, uri)
-        return unless uri.to_s.end_with?("Itsi.rb")
+        return unless uri.to_s =~ /itsi.rb$/i
+
         @in_itsi_file = true
         CompletionListener.new(response_builder, node_context, dispatcher, uri)
       end
 
       def create_hover_listener(response_builder, node_context, dispatcher)
         hl = dispatcher.listeners[:on_call_node_enter].find { |c| c.is_a?(RubyLsp::Listeners::Hover) }
-        return unless hl.instance_variable_get("@path").to_s.end_with?("Itsi.rb")
+        return unless hl.instance_variable_get("@path").to_s =~ /itsi.rb$/i
+
         HoverListener.new(response_builder, node_context, dispatcher)
       end
     end
 
-    class HoverListener
+    class HoverListener # rubocop:disable Style/Documentation
       def initialize(response_builder, node_context, dispatcher)
         @response_builder = response_builder
         @node_context = node_context
         @dispatcher = dispatcher
 
-        @options_by_name = ::Itsi::Server::Config::Option.subclasses.group_by(&:option_name).map{|k,v| [k,v.first]}.to_h
-        @middlewares_by_name = ::Itsi::Server::Config::Middleware.subclasses.group_by(&:middleware_name).map{|k,v| [k,v.first]}.to_h
+        @options_by_name = ::Itsi::Server::Config::Option.subclasses.group_by(&:option_name).transform_values(&:first)
+        @middlewares_by_name = ::Itsi::Server::Config::Middleware.subclasses.group_by(&:middleware_name).transform_values(&:first)
         # Register for call nodes for hover events
         dispatcher.register(self, :on_call_node_enter)
       end
 
-      def on_call_node_enter(node)
+      def on_call_node_enter(node) # rubocop:disable Metrics/MethodLength
         if (matched_class = @options_by_name[node.message.to_sym])
           @response_builder.push(
             matched_class.documentation,
@@ -61,7 +62,7 @@ module RubyLsp
       end
     end
 
-    class CompletionListener
+    class CompletionListener # rubocop:disable Style/Documentation
       def initialize(response_builder, node_context, dispatcher, uri)
         @response_builder = response_builder
         @node_context = node_context
@@ -74,7 +75,7 @@ module RubyLsp
         dispatcher.register(self, :completion_item_resolve)
       end
 
-      def on_call_node_enter(node)
+      def on_call_node_enter(node) # rubocop:disable Metrics/AbcSize
         # Only handle method calls that are being typed (i.e. no arguments yet)
         return unless node.arguments.nil?
 
@@ -122,8 +123,6 @@ module RubyLsp
           end
         end
       end
-
-
     end
   end
 end

data/gems/server/test/helpers/test_helper.rb

@@ -25,17 +25,10 @@ def free_bind(protocol = "http", unix_socket: false)
   end
 end
 
-def server(app: nil, app_with_lint: nil, protocol: "http", bind: free_bind(protocol), itsi_rb: nil, cleanup: true,
-           timeout: 5, &blk)
+def server(
+  app: nil, app_with_lint: nil, protocol: "http", bind: free_bind(protocol), itsi_rb: nil, cleanup: true,
+           &blk)
   app ||= Rack::Lint.new(app_with_lint) if app_with_lint
-  itsi_rb ||= lambda do
-    # Inline Itsi.rb
-    bind bind
-    workers 1
-    threads 1
-    log_level :warn
-    run app if app
-  end
 
   cli_params = {}
   cli_params[:binds] = [bind] if bind
@@ -46,13 +39,18 @@ def server(app: nil, app_with_lint: nil, protocol: "http", bind: free_bind(proto
     sync.push(true)
   end
 
-  Itsi::Server.start_in_background_thread(cli_params, &itsi_rb)
+  Itsi::Server.start_in_background_thread(cli_params) do
+    bind bind
+    workers 1
+    threads 1
+    log_level :warn
+    run app if app
+    instance_exec(&itsi_rb) if itsi_rb
+  end
 
   sync.pop
   uri = URI(bind)
-  # Timeout.timeout(timeout) do
   RequestContext.new(uri, self).instance_exec(uri, &blk)
-  # end
 rescue StandardError => e
   puts e
   # puts e.message
@@ -119,6 +117,7 @@ class RequestContext
   def patch(path, data = "", headers = {})
     request = Net::HTTP::Patch.new(uri_for(path))
     request.body = data
+    headers.each { |k, v| request[k] = v }
     client.request(request)
   end
 

data/gems/server/test/middleware/etag.rb

@@ -4,7 +4,7 @@ class TestETag < Minitest::Test
   def test_strong_etag_added
     server(
       itsi_rb: lambda do
-        etag type: "strong", algorithm: "sha256", min_body_size: 0, handle_if_none_match: false
+        etag type: "strong", algorithm: "sha256", min_body_size: 0
         get("/foo") { |r| r.ok "etag-body" }
       end
     ) do
@@ -17,7 +17,7 @@ class TestETag < Minitest::Test
   def test_weak_etag_added_with_md5
     server(
       itsi_rb: lambda do
-        etag type: "weak", algorithm: "md5", min_body_size: 0, handle_if_none_match: false
+        etag type: "weak", algorithm: "md5", min_body_size: 0
         get("/foo") { |r| r.ok "etag-weak-md5" }
       end
     ) do
@@ -42,7 +42,7 @@ class TestETag < Minitest::Test
     body = "etag-content"
     server(
       itsi_rb: lambda do
-        etag type: "strong", min_body_size: 0, handle_if_none_match: true
+        etag type: "strong", min_body_size: 0
         get("/foo") { |r| r.ok body }
       end
     ) do

data/gems/server/test/middleware/grpc/grpc.rb

@@ -5,14 +5,13 @@ class TestGrpc < Minitest::Test
   Stub = Test::TestService::Stub
 
   def new_stub(uri)
-    address = uri.to_s[/\/\/(.*)/,1]    # e.g. "127.0.0.1:12345"
+    address = uri.to_s[%r{//(.*)}, 1] # e.g. "127.0.0.1:12345"
     channel = GRPC::Core::Channel.new(address,
-                                      {},              # channel_args hash
-                                      :this_channel_is_insecure,
-    )
+                                      {}, # channel_args hash
+                                      :this_channel_is_insecure)
     stub = Stub.new(nil,
-                                 nil,
-                                 channel_override: channel)
+                    nil,
+                    channel_override: channel)
   end
 
   def test_unary_echo
@@ -46,7 +45,7 @@ class TestGrpc < Minitest::Test
       req = Test::EchoRequest.new(message: "xy")
       # expect two StreamResponse frames, one per character
       chars = stub.server_stream(req).map(&:messages).flatten
-      assert_equal ["x", "y"], chars
+      assert_equal %w[x y], chars
     end
   end
 
@@ -58,7 +57,7 @@ class TestGrpc < Minitest::Test
       inputs = %w[test1 test2].map { |m| Test::EchoRequest.new(message: m) }
       # each response uppercases its incoming message
       results = stub.bidi_stream(inputs.each).map(&:message)
-      assert_equal ["TEST1", "TEST2"], results
+      assert_equal %w[TEST1 TEST2], results
     end
   end
 
@@ -82,7 +81,6 @@ class TestGrpc < Minitest::Test
     end
   end
 
-
   def test_unary_echo_json
     server(itsi_rb: lambda do
       grpc TestServiceImpl.new
@@ -99,7 +97,7 @@ class TestGrpc < Minitest::Test
     server(itsi_rb: lambda do
       grpc TestServiceImpl.new
     end) do
-      input = [{"message" => "a"}, {"message" => "b"}, {"message" => "c"}]
+      input = [{ "message" => "a" }, { "message" => "b" }, { "message" => "c" }]
       res = post("test.TestService/ClientStream", input.to_json, { "Content-Type" => "application/json" })
       json = JSON.parse(res.body)
       assert_equal 200, res.code.to_i
@@ -117,7 +115,7 @@ class TestGrpc < Minitest::Test
       # service streams back one JSON object per character
       messages = arr.flat_map { |frame| frame["messages"] }
       assert_equal 200, res.code.to_i
-      assert_equal ["x","y"], messages
+      assert_equal %w[x y], messages
     end
   end
 
@@ -125,13 +123,13 @@ class TestGrpc < Minitest::Test
     server(itsi_rb: lambda do
       grpc TestServiceImpl.new
     end) do
-      inputs = [{"message":"foo"}, {"message":"Bar"}]
+      inputs = [{ "message": "foo" }, { "message": "Bar" }]
       res = post("test.TestService/BidiStream", inputs.to_json, { "Content-Type" => "application/json" })
       arr = JSON.parse(res.body)
       # bidi uppercases each incoming message
       results = arr.map { |frame| frame["message"] }
       assert_equal 200, res.code.to_i
-      assert_equal ["FOO","BAR"], results
+      assert_equal %w[FOO BAR], results
     end
   end
 
@@ -145,7 +143,8 @@ class TestGrpc < Minitest::Test
       assert_nil json1["messages"]
 
       # empty server-stream
-      res2 = post("test.TestService/ServerStream", { "message" => "" }.to_json, { "Content-Type" => "application/json" })
+      res2 = post("test.TestService/ServerStream", { "message" => "" }.to_json,
+                  { "Content-Type" => "application/json" })
       arr2 = JSON.parse(res2.body)
       assert arr2.empty?
 

data/gems/server/test/middleware/grpc/test_service_impl.rb

@@ -1,12 +1,12 @@
-require_relative 'test_service_services_pb'  # generated by grpc_tools_ruby_protoc
+require_relative "test_service_services_pb" # generated by grpc_tools_ruby_protoc
 
 class TestServiceImpl < Test::TestService::Service
   def unary_echo(req, _unused_call)
     Test::EchoResponse.new(message: req.message)
   end
 
-  def client_stream(stream, _call)
-    msgs = stream.map(&:message)
+  def client_stream(call)
+    msgs = call.each_remote_read.map(&:message)
     Test::StreamResponse.new(messages: msgs)
   end