476
477
478
479
480
481
              

        object.to_partial_path
      else
        raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
      end

      if @view.prefix_partial_path_with_controller_namespace

380
381
382
383
384
385
              

          @path = paths.uniq.one? ? paths.first : nil
        else
          @path = partial_path
        end
      end

291
292
293
294
295
296
              

    def render(context, options, block)
      setup(context, options, block)
      identifier = (@template = find_partial) ? @template.identifier : @path

      @lookup_context.rendered_format ||= begin

49
50
51
52
53
54
              

    # Direct access to partial rendering.
    def render_partial(context, options, &block) #:nodoc:
      PartialRenderer.new(@lookup_context).render(context, options, block)
    end
  end
end

33
34
35
36
37
38
              

          end
        else
          view_renderer.render_partial(self, :partial => options, :locals => locals)
        end
      end

143
144
145
146
147
148
              

      instrument("!render_template") do
        compile!(view)
        view.send(method_name, locals, buffer, &block)
      end
    rescue => e
      handle_render_error(view, e)

164
165
166
167
168
169
              

          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end
      end

331
332
333
334
335
336
              

      def instrument(action, &block)
        payload = { virtual_path: @virtual_path, identifier: @identifier }
        ActiveSupport::Notifications.instrument("#{action}.action_view", payload, &block)
      end
  end
end

141
142
143
144
145
146
              

    # consume this in production. This is only slow if it's being listened to.
    def render(view, locals, buffer=nil, &block)
      instrument("!render_template") do
        compile!(view)
        view.send(method_name, locals, buffer, &block)
      end

64
65
66
67
68
69
              

        view = @view
        view.view_flow.set(:layout, content)
        layout.render(view, locals){ |*name| view._layout_for(*name) }
      else
        content
      end

50
51
52
53
54
55
              

      view, locals = @view, locals || {}

      render_with_layout(layout_name, locals) do |layout|
        instrument(:template, :identifier => template.identifier, :layout => layout.try(:virtual_path)) do
          template.render(view, locals) { |*name| view._layout_for(*name) }
        end

12
13
14
15
16
17
              

      @lookup_context.rendered_format ||= (template.formats.first || formats.first)

      render_template(template, options[:layout], options[:locals])
    end

    private

44
45
46
47
48
49
              

    # Direct accessor to template rendering.
    def render_template(context, options) #:nodoc:
      TemplateRenderer.new(@lookup_context).render(context, options)
    end

    # Direct access to partial rendering.

25
26
27
28
29
30
              

        render_partial(context, options)
      else
        render_template(context, options)
      end
    end

98
99
100
101
102
103
              

        lookup_context.variants = variant if variant

        view_renderer.render(view_context, options)
      end

      # Assign the rendered format to lookup context.

215
216
217
218
219
220
              

          Rack::Chunked::Body.new view_renderer.render_body(view_context, options)
        else
          super
        end
      end
  end

81
82
83
84
85
86
              

    def render_to_body(options = {})
      _process_options(options)
      _render_template(options)
    end

    def rendered_format

30
31
32
33
34
35
              

    def render_to_body(options = {})
      super || _render_in_priorities(options) || ' '
    end

    private

35
36
37
38
39
40
              

    def render_to_body(options)
      _render_to_body_with_renderer(options) || super
    end

    def _render_to_body_with_renderer(options)

23
24
25
26
27
28
              

    def render(*args, &block)
      options = _normalize_render(*args, &block)
      self.response_body = render_to_body(options)
      _process_format(rendered_format, options) if rendered_format
      self.response_body
    end

14
15
16
17
18
19
              

    def render(*args) #:nodoc:
      raise ::AbstractController::DoubleRenderError if self.response_body
      super
    end

    # Overwrite render_to_string because body can now be set to a rack body.

42
43
44
45
46
47
              

      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output
    end

10
11
12
13
14
              

  #   # => 0.074
  def ms
    1000 * realtime { yield }
  end
end

301
302
303
304
305
306
              

  def realtime # :yield:
    r0 = Process.clock_gettime(BENCHMARK_CLOCK)
    yield
    Process.clock_gettime(BENCHMARK_CLOCK) - r0
  end

10
11
12
13
14
              

  #   # => 0.074
  def ms
    1000 * realtime { yield }
  end
end

42
43
44
45
46
47
              

      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output
    end

85
86
87
88
89
90
              

    # :api: plugin
    def cleanup_view_runtime #:nodoc:
      yield
    end

    # Every time after an action is processed, this method is invoked

23
24
25
26
27
28
              

          db_rt_before_render = ActiveRecord::LogSubscriber.reset_runtime
          self.db_runtime = (db_runtime || 0) + db_rt_before_render
          runtime = super
          db_rt_after_render = ActiveRecord::LogSubscriber.reset_runtime
          self.db_runtime += db_rt_after_render
          runtime - db_rt_after_render

41
42
43
44
45
46
              

    def render(*args)
      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output

8
9
10
11
12
13
              

    def default_render(*args)
      render(*args)
    end

    def method_for_action(action_name)

3
4
5
6
7
8
              

    def send_action(method, *args)
      ret = super
      default_render unless performed?
      ret
    end

196
197
198
199
200
201
              

      # which is *not* necessarily the same as the action name.
      def process_action(method_name, *args)
        send_action(method_name, *args)
      end

      # Actually call the method associated with the action. Override

8
9
10
11
12
13
              

    def process_action(*) #:nodoc:
      self.formats = request.formats.map(&:ref).compact
      super
    end

    # Check for double render errors and set the content_type after rendering.

18
19
20
21
22
23
              

    def process_action(*args)
      run_callbacks(:process_action) do
        super
      end
    end

115
116
117
118
119
120
              

        def call(env)
          block = env.run_block
          env.value = !env.halted && (!block || block.call)
          env
        end
      end

115
116
117
118
119
120
              

        def call(env)
          block = env.run_block
          env.value = !env.halted && (!block || block.call)
          env
        end
      end

553
554
555
556
557
558
              

      def compile
        @callbacks || @mutex.synchronize do
          final_sequence = CallbackSequence.new { |env| Filters::ENDING.call(env) }
          @callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
            callback.apply callback_sequence
          end

503
504
505
506
507
508
              

      def call(*args)
        @before.each { |b| b.call(*args) }
        value = @call.call(*args)
        @after.each { |a| a.call(*args) }
        value
      end

503
504
505
506
507
508
              

      def call(*args)
        @before.each { |b| b.call(*args) }
        value = @call.call(*args)
        @after.each { |a| a.call(*args) }
        value
      end

90
91
92
93
94
95
              

        runner = callbacks.compile
        e = Filters::Environment.new(self, false, nil, block)
        runner.call(e).value
      end
    end

776
777
778
779
780
781
              

          module_eval <<-RUBY, __FILE__, __LINE__ + 1
            def _run_#{name}_callbacks(&block)
              __run_callbacks__(_#{name}_callbacks, &block)
            end
          RUBY
        end

79
80
81
82
83
84
              

    #   end
    def run_callbacks(kind, &block)
      send "_run_#{kind}_callbacks", &block
    end

    private

17
18
19
20
21
22
              

    # process_action callbacks around the normal behavior.
    def process_action(*args)
      run_callbacks(:process_action) do
        super
      end
    end

27
28
29
30
31
32
              

    private
      def process_action(*args)
        super
      rescue Exception => exception
        request.env['action_dispatch.show_detailed_exceptions'] ||= show_detailed_exceptions?
        rescue_with_handler(exception) || raise(exception)

30
31
32
33
34
35
              

      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
        begin
          result = super
          payload[:status] = response.status
          result
        ensure

162
163
164
165
166
167
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

18
19
20
21
22
23
              

        start name, payload
        begin
          yield payload
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          raise e

162
163
164
165
166
167
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

28
29
30
31
32
33
              

      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)

      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
        begin
          result = super
          payload[:status] = response.status

248
249
250
251
252
253
              

        request.filtered_parameters.merge! wrapped_filtered_hash
      end
      super
    end

    private

16
17
18
19
20
21
              

        # and it won't be cleaned up by the method below.
        ActiveRecord::LogSubscriber.reset_runtime
        super
      end

      def cleanup_view_runtime

135
136
137
138
139
140
              

      @_response_body = nil

      process_action(action_name, *args)
    end

    # Delegates to the class' #controller_path

28
29
30
31
32
33
              

    def process(*) #:nodoc:
      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
      super
    ensure
      I18n.config = old_config
    end

194
195
196
197
198
199
              

      @_env = request.env
      @_env['action_controller.instance'] = self
      process(name)
      to_a
    end

11
12
13
14
15
16
              

    def dispatch(action, request)
      set_response!(request)
      super(action, request)
    end

    def response_body=(body)

235
236
237
238
239
240
              

        end
      else
        lambda { |env| new.dispatch(name, klass.new(env)) }
      end
    end
  end

72
73
74
75
76
77
              

        def dispatch(controller, action, env)
          controller.action(action).call(env)
        end

        def normalize_controller!(params)

72
73
74
75
76
77
              

        def dispatch(controller, action, env)
          controller.action(action).call(env)
        end

        def normalize_controller!(params)

41
42
43
44
45
46
              

          end

          dispatch(controller, params[:action], req.env)
        end

        def prepare_params!(params)

41
42
43
44
45
46
              

          req.path_parameters = set_params.merge parameters

          status, headers, body = route.app.serve(req)

          if 'pass' == headers['X-Cascade']
            req.script_name     = script_name

28
29
30
31
32
33
              

      def serve(req)
        find_routes(req).each do |match, parameters, route|
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

28
29
30
31
32
33
              

      def serve(req)
        find_routes(req).each do |match, parameters, route|
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

815
816
817
818
819
820
              

        req = request_class.new(env)
        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
        @router.serve(req)
      end

      def recognize_path(path, environment = {})

22
23
24
25
26
27
              

    def call(env)
      status, headers, body = @app.call(env)

      if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)
        original_body = body

23
24
25
26
27
28
              

      case env[REQUEST_METHOD]
      when "GET", "HEAD"
        status, headers, body = @app.call(env)
        headers = Utils::HeaderHash.new(headers)
        if status == 200 && fresh?(env, headers)
          status = 304

11
12
13
14
15
16
              

  def call(env)
    status, headers, body = @app.call(env)

    if env[REQUEST_METHOD] == HEAD
      [

25
26
27
28
29
30
              

      end

      @app.call(env)
    end

    private

258
259
260
261
262
263
              

    def call(env)
      @app.call(env)
    ensure
      session    = Request::Session.find(env) || {}
      flash_hash = env[KEY]

223
224
225
226
227
228
              

        def context(env, app=@app)
          prepare_session(env)
          status, headers, body = app.call(env)
          commit_session(env, status, headers, body)
        end

218
219
220
221
222
223
              

        def call(env)
          context(env)
        end

        def context(env, app=@app)

558
559
560
561
562
563
              

    def call(env)
      status, headers, body = @app.call(env)

      if cookie_jar = env['action_dispatch.cookies']
        unless cookie_jar.committed?

34
35
36
37
38
39
              

      connection.enable_query_cache!

      response = @app.call(env)
      response[2] = Rack::BodyProxy.new(response[2]) do
        restore_query_cache_settings(connection_id, enabled)
      end

651
652
653
654
655
656
              

        testing = env['rack.test']

        response = @app.call(env)
        response[2] = ::Rack::BodyProxy.new(response[2]) do
          ActiveRecord::Base.clear_active_connections! unless testing
        end

375
376
377
378
379
380
              

          end
        end
        @app.call(env)
      end

      private

27
28
29
30
31
32
              

      result = run_callbacks :call do
        begin
          @app.call(env)
        rescue => error
        end
      end

86
87
88
89
90
91
              

    def __run_callbacks__(callbacks, &block)
      if callbacks.empty?
        yield if block_given?
      else
        runner = callbacks.compile
        e = Filters::Environment.new(self, false, nil, block)

776
777
778
779
780
781
              

          module_eval <<-RUBY, __FILE__, __LINE__ + 1
            def _run_#{name}_callbacks(&block)
              __run_callbacks__(_#{name}_callbacks, &block)
            end
          RUBY
        end

79
80
81
82
83
84
              

    #   end
    def run_callbacks(kind, &block)
      send "_run_#{kind}_callbacks", &block
    end

    private

25
26
27
28
29
30
              

    def call(env)
      error = nil
      result = run_callbacks :call do
        begin
          @app.call(env)
        rescue => error

71
72
73
74
75
76
              

      prepare!

      response = @app.call(env)
      response[2] = ::Rack::BodyProxy.new(response[2]) { cleanup! }

      response

76
77
78
79
80
81
              

    def call(env)
      env["action_dispatch.remote_ip"] = GetIp.new(env, self)
      @app.call(env)
    end

    # The GetIp class exists as a way to defer processing of the request data

15
16
17
18
19
20
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if headers['X-Cascade'] == 'pass'
        body.close if body.respond_to?(:close)

26
27
28
29
30
31
              

        end

        status, headers, body = @app.call(env)

        if exception = env['web_console.exception']
          session = Session.from_exception(exception)

16
17
18
19
20
21
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return @app.call(env) unless request.from_whitelited_ip?

16
17
18
19
20
21
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return @app.call(env) unless request.from_whitelited_ip?

28
29
30
31
32
33
              

    def call(env)
      @app.call(env)
    rescue Exception => exception
      if env['action_dispatch.show_exceptions'] == false
        raise exception

36
37
38
39
40
41
              

        instrumenter.start 'request.action_dispatch', request: request
        logger.info { started_request_message(request) }
        resp = @app.call(env)
        resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }
        resp
      rescue Exception

18
19
20
21
22
23
              

        if logger.respond_to?(:tagged)
          logger.tagged(compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

66
67
68
69
70
71
              

    def tagged(*tags)
      formatter.tagged(*tags) { yield self }
    end

    def flush

24
25
26
27
28
29
              

      def tagged(*tags)
        new_tags = push_tags(*tags)
        yield self
      ensure
        pop_tags(new_tags.size)
      end

66
67
68
69
70
71
              

    def tagged(*tags)
      formatter.tagged(*tags) { yield self }
    end

    def flush

18
19
20
21
22
23
              

        if logger.respond_to?(:tagged)
          logger.tagged(compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

19
20
21
22
23
24
              

    def call(env)
      env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id
      @app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = env["action_dispatch.request_id"] }
    end

    private

20
21
22
23
24
25
              

      end

      @app.call(env)
    end

    def method_override(env)

16
17
18
19
20
21
              

    def call(env)
      start_time = clock_time
      status, headers, body = @app.call(env)
      request_time = clock_time - start_time

      if !headers.has_key?(@header_name)

26
27
28
29
30
31
              

          def call(env)
            LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
            response = @app.call(env)
            response[2] = ::Rack::BodyProxy.new(response[2]) do
              LocalCacheRegistry.set_cache_for(local_cache_key, nil)
            end

15
16
17
18
19
20
              

      old, env[FLAG] = env[FLAG], false
      @mutex.lock
      response = @app.call(env)
      body = BodyProxy.new(response[2]) { @mutex.unlock }
      response[2] = body
      response

118
119
120
121
122
123
              

      end

      @app.call(env)
    end
  end
end

111
112
113
114
115
116
              

    def call(env)
      status, headers, body = @app.call(env)
      if body.respond_to?(:to_path)
        case type = variation(env)
        when 'X-Accel-Redirect'

516
517
518
519
520
521
              

        env["ROUTES_#{routes.object_id}_SCRIPT_NAME"] = env['SCRIPT_NAME'].dup
      end
      app.call(env)
    end

    # Defines additional Rack env configuration that is added on each call.

163
164
165
166
167
168
              

      env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)
      env["ORIGINAL_SCRIPT_NAME"] = env["SCRIPT_NAME"]
      super(env)
    end

    # Reload application routes regardless if they changed or not.

15
16
17
18
19
20
              

      old, env[FLAG] = env[FLAG], false
      @mutex.lock
      response = @app.call(env)
      body = BodyProxy.new(response[2]) { @mutex.unlock }
      response[2] = body
      response

13
14
15
16
17
18
              

    def call(env)
      status, headers, body = @app.call(env)
      headers = HeaderHash.new(headers)

      if !STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i) &&

86
87
88
89
90
91
              

        env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env[PATH_INFO]].join

        status, headers, body = @app.call(env)
        begin
          res.status = status.to_i
          headers.each { |k, vs|

136
137
138
139
140
141
              

      si = servlet.get_instance(self, *options)
      @logger.debug(format("%s is invoked.", si.class.name))
      si.service(req, res)
    end

    ##

92
93
94
95
96
97
              

            callback.call(req, res)
          end
          server.service(req, res)
        rescue HTTPStatus::EOFError, HTTPStatus::RequestTimeout => ex
          res.set_error(ex)
        rescue HTTPStatus::Error => ex

292
293
294
295
296
297
              

          end
          call_callback(:AcceptCallback, sock)
          block ? block.call(sock) : run(sock)
        rescue Errno::ENOTCONN
          @logger.debug "Errno::ENOTCONN raised"
        rescue ServerError => ex