Haml::Error in Kurs#sirkel

18
19
20
21
22
23
              

      @node = node
      if node.children.empty?
        send(:"compile_#{node.type}")
      else
        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
      end

20
21
22
23
24
25
              

        send(:"compile_#{node.type}")
      else
        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
      end
    ensure
      @node = parent

20
21
22
23
24
25
              

        send(:"compile_#{node.type}")
      else
        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
      end
    ensure
      @node = parent

20
21
22
23
24
25
              

        send(:"compile_#{node.type}")
      else
        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
      end
    ensure
      @node = parent

93
94
95
96
97
98
              

      @output_line = 1
      @indentation = nil
      yield
      flush_merged_text
    end

20
21
22
23
24
25
              

        send(:"compile_#{node.type}")
      else
        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
      end
    ensure
      @node = parent

64
65
66
67
68
69
              

      @compiler = @options.compiler_class.new(@options)

      @compiler.compile(@parser.parse)
    end

    # Processes the template and returns the result as a string.

23
24
25
26
27
28
              

      end
      options[:filename] = template.identifier
      Haml::Engine.new(template.source, options).compiler.precompiled_with_ambles([])
    end

    # In Rails 3.1+, #call takes the place of #compile

23
24
25
26
27
28
              

      end
      options[:filename] = template.identifier
      Haml::Engine.new(template.source, options).compiler.precompiled_with_ambles([])
    end

    # In Rails 3.1+, #call takes the place of #compile

28
29
30
31
32
33
              

    # In Rails 3.1+, #call takes the place of #compile
    def self.call(template)
      new.compile(template)
    end

    def cache_fragment(block, name = {}, options = nil)

268
269
270
271
272
273
              

        encode!
        method_name = self.method_name
        code = @handler.call(self)

        # Make sure that the resulting String to be eval'd is in the
        # encoding of the code

243
244
245
246
247
248
              

          instrument("!compile_template") do
            compile(mod)
          end

          # Just discard the source if we have a virtual path. This

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

242
243
244
245
246
247
              

          end

          instrument("!compile_template") do
            compile(mod)
          end

230
231
232
233
234
235
              

        # so compilation and any instance variable modification must
        # be synchronized
        @compile_mutex.synchronize do
          # Any thread holding this lock will be compiling the template needed
          # by the threads waiting. So re-check the @compiled flag to avoid
          # re-compilation

230
231
232
233
234
235
              

        # so compilation and any instance variable modification must
        # be synchronized
        @compile_mutex.synchronize do
          # Any thread holding this lock will be compiling the template needed
          # by the threads waiting. So re-check the @compiled flag to avoid
          # re-compilation

142
143
144
145
146
147
              

    def render(view, locals, buffer=nil, &block)
      instrument("!render_template") do
        compile!(view)
        view.send(method_name, locals, buffer, &block)
      end
    rescue => 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

52
53
54
55
56
57
              

      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
      end
    end

37
38
39
40
41
42
              

    def instrument(name, options={})
      ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }
    end

    def prepend_formats(formats)

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

37
38
39
40
41
42
              

    def instrument(name, options={})
      ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }
    end

    def prepend_formats(formats)

51
52
53
54
55
56
              

      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
      end

59
60
61
62
63
64
              

    def render_with_layout(path, locals) #:nodoc:
      layout  = path && find_layout(path, locals.keys)
      content = yield(layout)

      if layout
        view = @view

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

40
41
42
43
44
45
              

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

    # Direct access to partial rendering.

21
22
23
24
25
26
              

        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

113
114
115
116
117
118
              

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

113
114
115
116
117
118
              

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

551
552
553
554
555
556
              

      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

501
502
503
504
505
506
              

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

501
502
503
504
505
506
              

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

86
87
88
89
90
91
              

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

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

74
75
76
77
78
79
              

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

        def normalize_controller!(params)

74
75
76
77
78
79
              

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

        def normalize_controller!(params)

43
44
45
46
47
48
              

          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

819
820
821
822
823
824
              

        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

27
28
29
30
31
32
              

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

82
83
84
85
86
87
              

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

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)

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

7
8
9
10
11
12
              

    def call(env)
      RequestStore.begin!
      @app.call(env)
    ensure
      RequestStore.end!
      RequestStore.clear!

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

114
115
116
117
118
119
              

      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.

192
193
194
195
196
197
              

        def method_missing(name, *args, &block)
          if instance.respond_to?(name)
            instance.public_send(name, *args, &block)
          else
            super
          end

192
193
194
195
196
197
              

        def method_missing(name, *args, &block)
          if instance.respond_to?(name)
            instance.public_send(name, *args, &block)
          else
            super
          end

95
96
97
98
99
100
              

          begin
            status, headers, body = @app.call(env)
          rescue => e
            if !should_swallow_app_error?(e, socket_wrapper)
              # It's a good idea to catch application exceptions here because

147
148
149
150
151
152
              

          begin
            if headers[REQUEST_METHOD] == GET
              process_request(headers, connection, socket_wrapper, @protocol == :http)
            elsif headers[REQUEST_METHOD] == PING
              process_ping(headers, connection)
              false

108
109
110
111
112
113
              

          finish_callback.call
          while true
            hijacked = accept_and_process_next_request(socket_wrapper, channel, buffer)
            socket_wrapper = Utils::UnseekableSocket.new if hijacked
          end
        rescue Interrupted

413
414
415
416
417
418
              

              handler = thread_handler.new(self, main_socket_options)
              handler.install
              handler.main_loop(set_initialization_state_to_true)
            ensure
              set_initialization_state.call(false)
              unregister_current_thread

111
112
113
114
115
116
              

        Thread.current.abort_on_exception = true
        begin
          yield(*args)
        rescue SystemExit
          raise
        rescue Exception => e