NoMethodError in Lag#index

173
174
175
176
177
178
              

    def _nested_structures(block)
      @level += 1
      block.call(self)
    ensure
      @level -= 1
    end

173
174
175
176
177
178
              

    def _nested_structures(block)
      @level += 1
      block.call(self)
    ensure
      @level -= 1
    end

66
67
68
69
70
71
              

        _newline
        begin
          _nested_structures(block)
        ensure
          _indent
          _end_tag(sym)

91
92
93
94
95
96
              

    def method_missing(sym, *args, &block)
      cache_method_call(sym) if ::Builder::XmlBase.cache_method_calls
      tag!(sym, *args, &block)
    end

    # Append text to the output target.  Escape any markup.  May be

36
37
38
39
40
41
              

    for article in @articles
      article.ingress = article.ingress.gsub(/\[\[.*\]\]/, '')
      xml.item do
        xml.title article.headline
        xml.description article.ingress
        xml.tag!("content:encoded") do

34
35
36
37
38
39
              

    xml.link "http://#{@domene}"

    for article in @articles
      article.ingress = article.ingress.gsub(/\[\[.*\]\]/, '')
      xml.item do
        xml.title article.headline

34
35
36
37
38
39
              

    xml.link "http://#{@domene}"

    for article in @articles
      article.ingress = article.ingress.gsub(/\[\[.*\]\]/, '')
      xml.item do
        xml.title article.headline

173
174
175
176
177
178
              

    def _nested_structures(block)
      @level += 1
      block.call(self)
    ensure
      @level -= 1
    end

173
174
175
176
177
178
              

    def _nested_structures(block)
      @level += 1
      block.call(self)
    ensure
      @level -= 1
    end

66
67
68
69
70
71
              

        _newline
        begin
          _nested_structures(block)
        ensure
          _indent
          _end_tag(sym)

91
92
93
94
95
96
              

    def method_missing(sym, *args, &block)
      cache_method_call(sym) if ::Builder::XmlBase.cache_method_calls
      tag!(sym, *args, &block)
    end

    # Append text to the output target.  Escape any markup.  May be

29
30
31
32
33
34
              

            'xmlns:wfw' => "http://wellformedweb.org/CommentAPI/",
            'xmlns:dc' => "http://purl.org/dc/elements/1.1/" do
  xml.channel do
    xml.title @organization + " : " + @groupname
    xml.description "Artikler fra " + @organization
    xml.link "http://#{@domene}"

173
174
175
176
177
178
              

    def _nested_structures(block)
      @level += 1
      block.call(self)
    ensure
      @level -= 1
    end

173
174
175
176
177
178
              

    def _nested_structures(block)
      @level += 1
      block.call(self)
    ensure
      @level -= 1
    end

66
67
68
69
70
71
              

        _newline
        begin
          _nested_structures(block)
        ensure
          _indent
          _end_tag(sym)

91
92
93
94
95
96
              

    def method_missing(sym, *args, &block)
      cache_method_call(sym) if ::Builder::XmlBase.cache_method_calls
      tag!(sym, *args, &block)
    end

    # Append text to the output target.  Escape any markup.  May be

25
26
27
28
29
30
              

# index.rss.builder
xml.instruct! :xml, :version => "1.0", :encoding=>"iso-8859-1"
xml.rss :version => "2.0",
            'xmlns:content' => "http://purl.org/rss/1.0/modules/content/",
            'xmlns:wfw' => "http://wellformedweb.org/CommentAPI/",
            'xmlns:dc' => "http://purl.org/dc/elements/1.1/" do

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

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

47
48
49
50
51
52
              

                                           a.created_on desc",
        temaid, lagid], :page => page, :per_page => 10)
    render :controller => controller, :action => "index"
    #    respond_to do |format|
    #      format.html {render :controller => controller, :action => "index"}
    ##      format.atom {render :controller => "lag", :action => "index"}

36
37
38
39
40
41
              

        @lag = lagtmp.name
      end
      group(id, @lagid, params[:page])
    end
  end

70
71
72
73
74
75
              

    @action_nor = "index" # used by start/_link.rhtml
    if defined?(lag)
      no_lag(lag, id, page, controller)
    elsif id
      lag = Group.find(id)
      no_lag(lag.name, "10", page, controller)

2
3
4
5
6
7
              

  module ImplicitRender
    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