6923056701

Committed 19 Nov 2023 09:31PM UTC coverage: 99.051%. Remained the same

Build # 6923056701

Build Type

Pull #2370

github

Committed by

web-flow

Commit Message

Merge feb39607d into 34f90f8e8

Pull Request Pull Request #2370: method missing to_ary

Run Details

15128 of 15273 relevant lines covered (99.05%)

1013.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.31

/lib/grape/middleware/stack.rb

# frozen_string_literal: true

module Grape
  module Middleware
    # Class to handle the stack of middlewares based on ActionDispatch::MiddlewareStack
    # It allows to insert and insert after
    class Stack
      class Middleware
        attr_reader :args, :block, :klass

        def initialize(klass, *args, &block)
          @klass = klass
          @args = args
          @block = block
        end

        def name
          klass.name
        end

        def ==(other)
          case other
          when Middleware
            klass == other.klass
          when Class
            klass == other || (name.nil? && klass.superclass == other)
          end
        end

        def inspect
          klass.to_s
        end

        def use_in(builder)
          builder.use(@klass, *@args, &@block)
        end
      end

      include Enumerable

      attr_accessor :middlewares, :others

      def initialize
        @middlewares = []
        @others = []
      end

      def each(&block)
        @middlewares.each(&block)
      end

      def size
        middlewares.size
      end

      def last
        middlewares.last
      end

      def [](i)
        middlewares[i]
      end

      def insert(index, *args, &block)
        index = assert_index(index, :before)
        middleware = self.class::Middleware.new(*args, &block)
        middlewares.insert(index, middleware)
      end
      ruby2_keywords :insert if respond_to?(:ruby2_keywords, true)

      alias insert_before insert

      def insert_after(index, *args, &block)
        index = assert_index(index, :after)
        insert(index + 1, *args, &block)
      end
      ruby2_keywords :insert_after if respond_to?(:ruby2_keywords, true)

      def use(*args, &block)
        middleware = self.class::Middleware.new(*args, &block)
        middlewares.push(middleware)
      end
      ruby2_keywords :use if respond_to?(:ruby2_keywords, true)

      def merge_with(middleware_specs)
        middleware_specs.each do |operation, *args|
          if args.last.is_a?(Proc)
            last_proc = args.pop
            public_send(operation, *args, &last_proc)
          else
            public_send(operation, *args)
          end
        end
      end

      # @return [Rack::Builder] the builder object with our middlewares applied
      def build(builder = Rack::Builder.new)
        others.shift(others.size).each { |m| merge_with(m) }
        middlewares.each do |m|
          m.use_in(builder)
        end
        builder
      end

      # @description Add middlewares with :use operation to the stack. Store others with :insert_* operation for later
      # @param [Array] other_specs An array of middleware specifications (e.g. [[:use, klass], [:insert_before, *args]])
      def concat(other_specs)
        @others << Array(other_specs).reject { |o| o.first == :use }
        merge_with(Array(other_specs).select { |o| o.first == :use })
      end

      protected

      def assert_index(index, where)
        i = index.is_a?(Integer) ? index : middlewares.index(index)
        i || raise("No such middleware to insert #{where}: #{index.inspect}")
      end
    end
  end
end

1	# frozen_string_literal: true
2
3	module Grape	18✔
4	module Middleware	18✔
5	# Class to handle the stack of middlewares based on ActionDispatch::MiddlewareStack
6	# It allows to insert and insert after
7	class Stack	18✔
8	class Middleware	18✔
9	attr_reader :args, :block, :klass	18✔
10
11	def initialize(klass, *args, &block)	18✔
12	@klass = klass	69,852✔
13	@args = args	69,852✔
14	@block = block	69,852✔
15	end
16
17	def name	18✔
18	klass.name	252✔
19	end
20
21	def ==(other)	18✔
22	case other	666✔
23	when Middleware
24	klass == other.klass	×
25	when Class
26	klass == other \|\| (name.nil? && klass.superclass == other)	666✔
27	end
28	end
29
30	def inspect	18✔
31	klass.to_s	×
32	end
33
34	def use_in(builder)	18✔
35	builder.use(@klass, *@args, &@block)	69,366✔
36	end
37	end
38
39	include Enumerable	18✔
40
41	attr_accessor :middlewares, :others	18✔
42
43	def initialize	18✔
44	@middlewares = []	22,408✔
45	@others = []	22,408✔
46	end
47
48	def each(&block)	18✔
49	@middlewares.each(&block)	×
50	end
51
52	def size	18✔
53	middlewares.size	324✔
54	end
55
56	def last	18✔
57	middlewares.last	108✔
58	end
59
60	def [](i)	18✔
61	middlewares[i]	288✔
62	end
63
64	def insert(index, *args, &block)	18✔
65	index = assert_index(index, :before)	216✔
66	middleware = self.class::Middleware.new(*args, &block)	198✔
67	middlewares.insert(index, middleware)	198✔
68	end
69	ruby2_keywords :insert if respond_to?(:ruby2_keywords, true)	18✔
70
71	alias insert_before insert	18✔
72
73	def insert_after(index, *args, &block)	18✔
74	index = assert_index(index, :after)	90✔
75	insert(index + 1, *args, &block)	72✔
76	end
77	ruby2_keywords :insert_after if respond_to?(:ruby2_keywords, true)	18✔
78
79	def use(*args, &block)	18✔
80	middleware = self.class::Middleware.new(*args, &block)	69,654✔
81	middlewares.push(middleware)	69,654✔
82	end
83	ruby2_keywords :use if respond_to?(:ruby2_keywords, true)	18✔
84
85	def merge_with(middleware_specs)	18✔
86	middleware_specs.each do \|operation, *args\|	44,330✔
87	if args.last.is_a?(Proc)	558✔
88	last_proc = args.pop	72✔
89	public_send(operation, *args, &last_proc)	72✔
90	else
91	public_send(operation, *args)	486✔
92	end
93	end
94	end
95
96	# @return [Rack::Builder] the builder object with our middlewares applied
97	def build(builder = Rack::Builder.new)	18✔
98	others.shift(others.size).each { \|m\| merge_with(m) }	44,294✔
99	middlewares.each do \|m\|	22,156✔
100	m.use_in(builder)	69,366✔
101	end
102	builder	22,156✔
103	end
104
105	# @description Add middlewares with :use operation to the stack. Store others with :insert_* operation for later
106	# @param [Array] other_specs An array of middleware specifications (e.g. [[:use, klass], [:insert_before, *args]])
107	def concat(other_specs)	18✔
108	@others << Array(other_specs).reject { \|o\| o.first == :use }	22,732✔
109	merge_with(Array(other_specs).select { \|o\| o.first == :use })	22,732✔
110	end
111
112	protected	18✔
113
114	def assert_index(index, where)	18✔
115	i = index.is_a?(Integer) ? index : middlewares.index(index)	306✔
116	i \|\| raise("No such middleware to insert #{where}: #{index.inspect}")	306✔
117	end
118	end
119	end
120	end

ruby-grape / grape / 6923056701

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous