Sprockets::Rails::Helper::AssetNotPrecompiledError in Pages#show

370
371
372
373
374
375
              

          def raise_unless_precompiled_asset(path)
            raise Helper::AssetNotPrecompiledError.new(path) if @check_precompiled_asset && !precompiled?(path)
          end
      end
    end

336
337
338
339
340
341
              

        def digest_path(path, allow_non_precompiled = false)
          if asset = find_asset(path)
            raise_unless_precompiled_asset asset.logical_path unless allow_non_precompiled
            asset.digest_path
          end
        end

324
325
326
327
328
329
              

          # Digests enabled? Do the work to calculate the full asset path.
          if digest
            digest_path path, allow_non_precompiled

          # Otherwise, ask the Sprockets environment whether the asset exists
          # and check whether it's also precompiled for production deploys.

101
102
103
104
105
106
              

      def resolve_asset_path(path, allow_non_precompiled = false) #:nodoc:
        resolve_asset do |resolver|
          resolver.asset_path path, digest_assets, allow_non_precompiled
        end
      end

241
242
243
244
245
246
              

        def resolve_asset
          asset_resolver_strategies.detect do |resolver|
            if result = yield(resolver)
              break result
            end
          end

240
241
242
243
244
245
              

        # Try each asset resolver and return the first non-nil result.
        def resolve_asset
          asset_resolver_strategies.detect do |resolver|
            if result = yield(resolver)
              break result
            end

240
241
242
243
244
245
              

        # Try each asset resolver and return the first non-nil result.
        def resolve_asset
          asset_resolver_strategies.detect do |resolver|
            if result = yield(resolver)
              break result
            end

240
241
242
243
244
245
              

        # Try each asset resolver and return the first non-nil result.
        def resolve_asset
          asset_resolver_strategies.detect do |resolver|
            if result = yield(resolver)
              break result
            end

100
101
102
103
104
105
              

      # Returns nil if it's an asset we don't know about.
      def resolve_asset_path(path, allow_non_precompiled = false) #:nodoc:
        resolve_asset do |resolver|
          resolver.asset_path path, digest_assets, allow_non_precompiled
        end
      end

78
79
80
81
82
83
              

        debug = options[:debug]

        if asset_path = resolve_asset_path(path, debug)
          File.join(assets_prefix || "/", legacy_debug_path(asset_path, debug))
        else
          message =  "The asset #{ path.inspect } is not present in the asset pipeline.\n"

202
203
204
205
206
207
              

            source = public_compute_asset_path(source, options)
          else
            source = compute_asset_path(source, options)
          end
        end

262
263
264
265
266
267
              

        end
      else
        public_send(method, locals, buffer, &block)
      end
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template

262
263
264
265
266
267
              

        end
      else
        public_send(method, locals, buffer, &block)
      end
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template

259
260
261
262
263
264
              

          nil
        else
          view._run(method_name, self, locals, OutputBuffer.new, add_to_stack: add_to_stack, has_strict_locals: strict_locals?, &block)&.to_s
        end
      end
    rescue => e

206
207
208
209
210
211
              

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

547
548
549
550
551
552
              

      def instrument_render_template(&block)
        ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
      end

      def instrument_payload

247
248
249
250
251
252
              

    # consume this in production. This is only slow if it's being listened to.
    def render(view, locals, buffer = nil, implicit_locals: [], add_to_stack: true, &block)
      instrument_render_template do
        compile!(view)

        if strict_locals? && @strict_local_keys && !implicit_locals.empty?

64
65
66
67
68
69
              

            locals: locals
          ) do
            template.render(view, locals) { |*name| view._layout_for(*name) }
          end
        end
      end

204
205
206
207
208
209
              

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

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

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

58
59
60
61
62
63
              

      def render_template(view, template, layout_name, locals)
        render_with_layout(view, template, layout_name, locals) do |layout|
          ActiveSupport::Notifications.instrument(
            "render_template.action_view",
            identifier: template.identifier,
            layout: layout && layout.virtual_path,

74
75
76
77
78
79
              

        body = if layout
          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
            view.view_flow.set(:layout, yield(layout))
            layout.render(view, locals) { |*name| view._layout_for(*name) }
          end
        else

204
205
206
207
208
209
              

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

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

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

73
74
75
76
77
78
              

        body = if layout
          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
            view.view_flow.set(:layout, yield(layout))
            layout.render(view, locals) { |*name| view._layout_for(*name) }
          end

57
58
59
60
61
62
              

      # supplied as well.
      def render_template(view, template, layout_name, locals)
        render_with_layout(view, template, layout_name, locals) do |layout|
          ActiveSupport::Notifications.instrument(
            "render_template.action_view",
            identifier: template.identifier,

9
10
11
12
13
14
              

      prepend_formats(template.format)

      render_template(context, template, options[:layout], options[:locals] || {})
    end

    private

61
62
63
64
65
66
              

    def render_template_to_object(context, options) # :nodoc:
      TemplateRenderer.new(@lookup_context).render(context, options)
    end

    def render_partial_to_object(context, options, &block) # :nodoc:

29
30
31
32
33
34
              

        render_partial_to_object(context, options)
      else
        render_template_to_object(context, options)
      end
    end

133
134
135
136
137
138
              

        rendered_template = context.in_rendering_context(options) do |renderer|
          renderer.render_to_object(context, options)
        end

        rendered_format = rendered_template.format || lookup_context.formats.first

289
290
291
292
293
294
              

      end

      yield @view_renderer
    ensure
      @view_renderer = old_view_renderer
      @lookup_context = old_lookup_context

132
133
134
135
136
137
              

        lookup_context.variants = variant if variant

        rendered_template = context.in_rendering_context(options) do |renderer|
          renderer.render_to_object(context, options)
        end

254
255
256
257
258
259
              

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

119
120
121
122
123
124
              

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

    private

156
157
158
159
160
161
              

    def render_to_body(options = {}) # :nodoc:
      super || _render_in_priorities(options) || " "
    end

    private

139
140
141
142
143
144
              

    # <tt>ActionView::Rendering.render_to_body</tt>, if present.
    def render_to_body(options)
      _render_to_body_with_renderer(options) || super
    end

    def _render_to_body_with_renderer(options)

25
26
27
28
29
30
              

    def render(*args, &block)
      options = _normalize_render(*args, &block)
      rendered_body = render_to_body(options)
      if options[:html]
        _set_html_content_type
      else

137
138
139
140
141
142
              

    def render(*args)
      raise ::AbstractController::DoubleRenderError if response_body
      super
    end

    # Similar to #render, but only returns the rendered template as a string,

27
28
29
30
31
32
              

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

309
310
311
312
313
314
              

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

12
13
14
15
16
              

  #   # => 0.074
  def ms(&block)
    1000 * realtime(&block)
  end
end

27
28
29
30
31
32
              

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

96
97
98
99
100
101
              

      #   end
      def cleanup_view_runtime # :doc:
        yield
      end

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

37
38
39
40
41
42
              

            db_rt_before_render = ActiveRecord::RuntimeRegistry.reset
            self.db_runtime = (db_runtime || 0) + db_rt_before_render
            runtime = super
            queries_rt = ActiveRecord::RuntimeRegistry.sql_runtime - ActiveRecord::RuntimeRegistry.async_sql_runtime
            db_rt_after_render = ActiveRecord::RuntimeRegistry.reset
            self.db_runtime += db_rt_after_render

26
27
28
29
30
31
              

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

29
30
31
32
33
34
              

  def show
    render "pages/#{@page[:path]}"
  end

  def get_instance_variable name, default_value

4
5
6
7
8
9
              

  module BasicImplicitRender # :nodoc:
    def send_action(method, *args)
      ret = super
      default_render unless performed?
      ret
    end

222
223
224
225
226
227
              

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

      # Actually call the method associated with the action. Override

163
164
165
166
167
168
              

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

      def _process_variant(options)

257
258
259
260
261
262
              

      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end
  end

119
120
121
122
123
124
              

              current.invoke_before(env)
              if current.final?
                env.value = !env.halted && (!block_given? || yield)
              elsif current.skip?(env)
                (skipped ||= []) << current
                next_sequence = next_sequence.nested

21
22
23
24
25
26
              

        previous_renderer = self.renderer
        self.renderer = renderer
        yield
      ensure
        self.renderer = previous_renderer
      end

67
68
69
70
71
72
              

        ActiveSupport.on_load(base) do
          around_action do |controller, action|
            ActionText::Content.with_renderer(controller, &action)
          end
        end
      end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

139
140
141
142
143
144
              

          end

          invoke_sequence.call
        end
      end
    end

256
257
258
259
260
261
              

      # <tt>process_action</tt> callbacks around the normal behavior.
      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end

23
24
25
26
27
28
              

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

72
73
74
75
76
77
              

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

204
205
206
207
208
209
              

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

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

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

71
72
73
74
75
76
              

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

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

259
260
261
262
263
264
              

      def process_action(*)
        _perform_parameter_wrapping if _wrapper_enabled?
        super
      end

      # Returns the wrapper key which will be used to store wrapped parameters.

30
31
32
33
34
35
              

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

        def cleanup_view_runtime

158
159
160
161
162
163
              

      @_response_body = nil

      process_action(action_name, *args)
    end
    ruby2_keywords(:process)

38
39
40
41
42
43
              

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

225
226
227
228
229
230
              

      set_request!(request)
      set_response!(response)
      process(name)
      request.commit_flash
      to_a
    end

307
308
309
310
311
312
              

        middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
      else
        new.dispatch(name, req, res)
      end
    end
  end

47
48
49
50
51
52
              

          def dispatch(controller, action, req, res)
            controller.dispatch(action, req, res)
          end
      end

30
31
32
33
34
35
              

          controller = controller req
          res        = controller.make_response! req
          dispatch(controller, params[:action], req, res)
        rescue ActionController::RoutingError
          if @raise_on_name_error
            raise

49
50
51
52
53
54
              

          req.route_uri_pattern = route.path.spec.to_s

          _, headers, _ = response = route.app.serve(req)

          if "pass" == headers[Constants::X_CASCADE]
            req.script_name     = script_name

129
130
131
132
133
134
              

              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
            }
            yield [match_data, path_parameters, r]
          }
        end

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

30
31
32
33
34
35
              

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

880
881
882
883
884
885
              

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

      def recognize_path(path, environment = {})

18
19
20
21
22
23
              

      begin
        _, _, body = response = @app.call(env)
      rescue Exception
        env[RACK_TEMPFILES]&.each(&:close!)
        raise

27
28
29
30
31
32
              

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

      if etag_status?(status) && body.respond_to?(:to_ary) && !skip_caching?(headers)
        body = body.to_ary

29
30
31
32
33
34
              

      case env[REQUEST_METHOD]
      when "GET", "HEAD"
        status, headers, body = response = @app.call(env)

        if status == 200 && fresh?(env, headers)
          response[0] = 304

13
14
15
16
17
18
              

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

      if env[REQUEST_METHOD] == HEAD
        response[2] = Rack::BodyProxy.new([]) do

34
35
36
37
38
39
              

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

        return response unless html_response?(headers)
        return response if policy_present?(headers)

31
32
33
34
35
36
              

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

        # Returning CSP headers with a 304 Not Modified is harmful, since nonces in the new
        # CSP headers might not match nonces in the cached HTML.

270
271
272
273
274
275
              

          req = make_request env
          prepare_session(req)
          status, headers, body = app.call(req.env)
          res = Rack::Response::Raw.new status, headers
          commit_session(req, res)
          [status, headers, body]

264
265
266
267
268
269
              

        def call(env)
          context(env)
        end

        def context(env, app = @app)

687
688
689
690
691
692
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      response = @app.call(env)

      if request.have_cookie_jar?
        cookie_jar = request.cookie_jar

653
654
655
656
657
658
              

        end

        @app.call(env)
      end

      private

27
28
29
30
31
32
              

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

99
100
101
102
103
104
              

      if callbacks.empty?
        yield if block_given?
      else
        env = Filters::Environment.new(self, false, nil)

26
27
28
29
30
31
              

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

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)
        returned = response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
      rescue => error
        @executor.error_reporter.report(error, handled: false, source: "application.action_dispatch")

14
15
16
17
18
19
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      return @app.call(env) unless actionable_request?(request)

      ActiveSupport::ActionableError.dispatch(request.params[:error].to_s.safe_constantize, request.params[:action])

27
28
29
30
31
32
              

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

      if headers[Constants::X_CASCADE] == "pass"
        body.close if body.respond_to?(:close)

29
30
31
32
33
34
              

    def call(env)
      @app.call(env)
    rescue Exception => exception
      request = ActionDispatch::Request.new env
      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")

35
36
37
38
39
40
              

          logger.info { started_request_message(request) }
          status, headers, body = response = @app.call(env)
          body = ::Rack::BodyProxy.new(body, &handle.method(:finish))

          if response.frozen?

22
23
24
25
26
27
              

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

133
134
135
136
137
138
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

37
38
39
40
41
42
              

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

133
134
135
136
137
138
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

238
239
240
241
242
243
              

          super(name, *args, **kwargs, &block)
        elsif loggers.one?
          loggers.first.send(name, *args, **kwargs, &block)
        else
          loggers.map { |logger| logger.send(name, *args, **kwargs, &block) }
        end

22
23
24
25
26
27
              

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

90
91
92
93
94
95
              

      req = ActionDispatch::Request.new env
      req.remote_ip = GetIp.new(req, check_ip, proxies)
      @app.call(req.env)
    end

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

26
27
28
29
30
31
              

      req = ActionDispatch::Request.new env
      req.request_id = make_request_id(req.headers[@header])
      @app.call(env).tap { |_status, headers, _body| headers[@header] = req.request_id }
    end

    private

26
27
28
29
30
31
              

      end

      @app.call(env)
    end

    def method_override(env)

22
23
24
25
26
27
              

    def call(env)
      start_time = Utils.clock_time
      _, headers, _ = response = @app.call(env)

      request_time = Utils.clock_time - start_time

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)
        returned = response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
      rescue => error
        @executor.error_reporter.report(error, handled: false, source: "application.action_dispatch")

23
24
25
26
27
28
              

    def call(env)
      @file_handler.attempt(env) || @app.call(env)
    end
  end

112
113
114
115
116
117
              

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

      if body.respond_to?(:to_path)
        case type = variation(env)

139
140
141
142
143
144
              

      if hosts.empty? || excluded?(request)
        mark_as_authorized(request)
        @app.call(env)
      else
        env["action_dispatch.blocked_hosts"] = hosts
        @response_app.call(env)

534
535
536
537
538
539
              

    def call(env)
      req = build_request env
      app.call req.env
    end

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

358
359
360
361
362
363
              

        env['HTTP_COOKIE'] ||= cookie_jar.for(uri)
        @last_request = Rack::Request.new(env)
        status, headers, body = @app.call(env).to_a

        @last_response = MockResponse.new(status, headers, body, env['rack.errors'].flush)
        close_body(body)

151
152
153
154
155
156
              

        uri = parse_uri(uri, env)
        env = env_for(uri, env)
        process_request(uri, env, &block)
      end

      # Issue a request using the given HTTP verb for the given URI, with optional

286
287
288
289
290
291
              

        # NOTE: rack-test v0.5 doesn't build a default uri correctly
        # Make sure requested path is always a full URI.
        session.request(build_full_uri(path, request_env), request_env)

        @request_count += 1
        @request = ActionDispatch::Request.new(session.last_request.env)

14
15
16
17
18
19
              

      # for more details.
      def get(path, **args)
        process(:get, path, **args)
      end

      # Performs a POST request with the given parameters. See ActionDispatch::Integration::Session#process

43
44
45
46
47
48
              

  def store_static_page path
    app.get(path)

    file_name = "#{path.gsub(/\A\/|\/\z/, '')}.html"

35
36
37
38
39
40
              

  def store_static_pages paths
    paths.each { |path| store_static_page path }
  end

  def app

35
36
37
38
39
40
              

  def store_static_pages paths
    paths.each { |path| store_static_page path }
  end

  def app

35
36
37
38
39
40
              

  def store_static_pages paths
    paths.each { |path| store_static_page path }
  end

  def app

5
6
7
8
9
10
              

    paths = page_tree_paths Page.tree
    clean_static_pages
    store_static_pages paths
  end

  def page_tree_paths tree

6
7
8
9
10
11
              

    def self.call(*args)
      new(*args).call
    end
  end
end

2
3
4
5
6
              

  desc 'Generate all pages as static HTML files'
  task generate: :environment do
    Pages::Generate.call
  end
end

279
280
281
282
283
284
              

        @actions.each { |act| act.call(self, args, **opts) }
      else
        @actions.each { |act| act.call(self, args) }
      end
    end

279
280
281
282
283
284
              

        @actions.each { |act| act.call(self, args, **opts) }
      else
        @actions.each { |act| act.call(self, args) }
      end
    end

279
280
281
282
283
284
              

        @actions.each { |act| act.call(self, args, **opts) }
      else
        @actions.each { |act| act.call(self, args) }
      end
    end

217
218
219
220
221
222
              

          invoke_prerequisites(task_args, new_chain)
          execute(task_args) if needed?
        rescue Exception => ex
          add_chain_to(ex, new_chain)
          @invocation_exception = ex

197
198
199
200
201
202
              

    def invoke_with_call_chain(task_args, invocation_chain)
      new_chain = Rake::InvocationChain.append(self, invocation_chain)
      @lock.synchronize do
        begin
          if application.options.trace
            application.trace "** Invoke #{name} #{format_trace_flags}"

197
198
199
200
201
202
              

    def invoke_with_call_chain(task_args, invocation_chain)
      new_chain = Rake::InvocationChain.append(self, invocation_chain)
      @lock.synchronize do
        begin
          if application.options.trace
            application.trace "** Invoke #{name} #{format_trace_flags}"

186
187
188
189
190
191
              

    def invoke(*args)
      task_args = TaskArguments.new(arg_names, args)
      invoke_with_call_chain(task_args, InvocationChain::EMPTY)
    end

    # Same as invoke, but explicitly pass a call chain to detect

180
181
182
183
184
185
              

      name, args = parse_task_string(task_string)
      t = self[name]
      t.invoke(*args)
    end

    def parse_task_string(string) # :nodoc:

136
137
138
139
140
141
              

          display_prerequisites
        else
          top_level_tasks.each { |task_name| invoke_task(task_name) }
        end
      end
    end

136
137
138
139
140
141
              

          display_prerequisites
        else
          top_level_tasks.each { |task_name| invoke_task(task_name) }
        end
      end
    end

136
137
138
139
140
141
              

          display_prerequisites
        else
          top_level_tasks.each { |task_name| invoke_task(task_name) }
        end
      end
    end

145
146
147
148
149
150
              

      thread_pool.gather_history if options.job_stats == :history

      yield

      thread_pool.join if defined?(@thread_pool)
      if options.job_stats

130
131
132
133
134
135
              

    # Run the top level tasks of a Rake application.
    def top_level
      run_with_threads do
        if options.show_tasks
          display_tasks_and_comments
        elsif options.show_prereqs

81
82
83
84
85
86
              

        init "rake", argv
        load_rakefile
        top_level
      end
    end

206
207
208
209
210
211
              

    # Provide standard exception handling for the given block.
    def standard_exception_handling # :nodoc:
      yield
    rescue SystemExit
      # Exit silently with current status
      raise

78
79
80
81
82
83
              

    # call +top_level+ to run your top level tasks.
    def run(argv = ARGV)
      standard_exception_handling do
        init "rake", argv
        load_rakefile
        top_level

25
26
27
              

require "rake"

Rake.application.run

23
24
25
26
27
28
              

if Gem.respond_to?(:activate_bin_path)
load Gem.activate_bin_path('rake', 'rake', version)
else
gem "rake", version
load Gem.bin_path("rake", "rake", version)

23
24
25
26
27
28
              

if Gem.respond_to?(:activate_bin_path)
load Gem.activate_bin_path('rake', 'rake', version)
else
gem "rake", version
load Gem.bin_path("rake", "rake", version)