jets 5.0.14 → 6.0.0.beta1

data/lib/jets/controller/decorate/authorization.rb

@@ -1,91 +0,0 @@
-module Jets::Controller::Decorate
-  module Authorization
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :auth_type,
-                      :auth_to,
-                      :auth_options, # for only and except filters
-                      :api_key_needed,
-                      :authorization_scopes_value
-    end
-
-    class_methods do
-      def controller_path
-        name.sub(/Controller$/, "".freeze).underscore
-      end
-
-      def authorization_type(value=nil)
-        if !value.nil?
-          self.auth_type = value
-        else
-          self.auth_type
-        end
-      end
-
-      def authorizer(value=nil, options={})
-        if !value.nil?
-          self.auth_to = value # IE: main#protect
-          self.auth_options = options # IE: only: %w[index] or expect: [:show]
-        else
-          self.auth_to
-        end
-      end
-
-      def authorization_scopes(value=nil)
-        if !value.nil?
-          self.authorization_scopes_value = value
-        else
-          self.authorization_scopes_value
-        end
-      end
-
-      def authorizer_metadata
-        Jets::Router::Route::Authorizer.metadata(auth_to)
-      end
-
-      # Used to add to parameter to controller templates
-      def authorizer_id
-        Jets::Router::Route::Authorizer.logical_id(auth_to)
-      end
-
-      # Used to add to the API::Gateway Method selectively
-      def authorizer_logical_id_for(action_name)
-        return unless auth_to
-
-        only = auth_options[:only].map(&:to_s) if auth_options && auth_options[:only]
-        except = auth_options[:except].map(&:to_s) if auth_options && auth_options[:except]
-
-        if except and !except.include?(action_name)
-          logical_id = Jets::Router::Route::Authorizer.logical_id(auth_to)
-        end
-
-        # only overrides except
-        if only and only.include?(action_name)
-          logical_id = Jets::Router::Route::Authorizer.logical_id(auth_to)
-        end
-
-        # if both only and except are not set then always set the logical_id
-        if !only && !except
-          logical_id = Jets::Router::Route::Authorizer.logical_id(auth_to)
-        end
-
-        logical_id
-      end
-
-      # Autoamtically sets authorization_type for the specific route based on the controller authorizer
-      def infer_authorization_type_for(action_name)
-        return unless authorizer_logical_id_for(action_name)
-        Jets::Authorizer::Base.authorization_type(auth_to)
-      end
-
-      def api_key_required(value=nil)
-        if !value.nil?
-          self.api_key_needed = value
-        else
-          self.api_key_needed
-        end
-      end
-    end
-  end
-end

data/lib/jets/controller/decorate/logging.rb

@@ -1,90 +0,0 @@
-module Jets::Controller::Decorate
-  module Logging
-    extend ActiveSupport::Concern
-
-    included do
-      # A little bit tricky. Jets::Controller::Base includes AbstractController::Logger
-      # via ActionController::Redirecting.
-      # AbstractController::Logger defines a config_accessor :logger
-      # This results in logger being nil.  We set it to logger here to correct it.
-      # Unsure why this does not happen with ActionController::Base though.
-      delegate :logger, to: Jets # fixes logger but Rails doesnt need this
-    end
-
-    def dispatch!
-      t1 = Time.now
-      log_start
-      triplet = super # Abstract#dispatch!
-      took = Time.now - t1
-      log_finish status: status, took: took
-      triplet
-    end
-
-    def processing_log
-      processing = "Processing #{self.class.name}##{@meth}"
-      processing << " (original method #{@original_meth})" if @original_meth
-      processing
-    end
-
-    # Documented interface method, careful not to rename
-    def log_start
-      # Commented out Started because Jets::Rack::Logger middleware handles now
-      # ip = request.ip
-      # logger.info "Started (Jets) #{request.request_method} \"#{request.path}\" for #{ip} at #{Time.now}"
-
-      logger.info processing_log
-      logger.info "  Raw Event: #{@event}" if ENV['JETS_LOG_RAW_EVENT']
-      logger.info "  Event: #{event_log}" if log_event?
-      params = filtered_parameters.to_h.except('controller', 'action')
-      # JSON.dump makes logging look pretty in CloudWatch logs because it keeps it on 1 line
-      logger.info "  Parameters: #{JSON.dump(params)}" unless params.empty?
-    end
-
-    def log_event?
-      return false if ENV['JETS_LOG_EVENT'] == '0'
-      Jets.config.logging.event
-    end
-
-    # Documented interface method, careful not to rename
-    def log_finish(options={})
-      status, took = options[:status], options[:took]
-      logger.info "Completed Status Code #{status} in #{"%.3f" % took}s"
-    end
-
-    def event_log
-      event = @event.dup # clone to display event
-
-      if event['isBase64Encoded']
-        event['body'] = '[BASE64_ENCODED]'
-      else
-        event['body'] = filter_json_log(event['body'])
-      end
-
-      event["multiValueQueryStringParameters"] = parameter_filter.filter(event['multiValueQueryStringParameters']) if event['multiValueQueryStringParameters']
-      event["pathParameters"] = parameter_filter.filter(event['pathParameters']) if event['pathParameters']
-      event["queryStringParameters"] = parameter_filter.filter(event['queryStringParameters']) if event['queryStringParameters']
-      json_dump_log(event)
-    end
-
-    # Append _log to reduce chance of name collision with user defined methods
-    def filter_json_log(json_text)
-      return json_text if json_text.blank?
-
-      begin
-        hash_params = JSON.parse(json_text)
-        filtered_params = parameter_filter.filter(hash_params)
-        JSON.dump(filtered_params)
-      rescue JSON::ParserError
-        '[FILTERED]'
-      end
-    end
-
-    # Handles binary data safely
-    def json_dump_log(data)
-      JSON.dump(data)
-    rescue Encoding::UndefinedConversionError
-      data['body'] = '[BINARY]'
-      JSON.dump(data)
-    end
-  end
-end

data/lib/jets/controller/decorate/redirecting.rb

@@ -1,16 +0,0 @@
-module Jets::Controller::Decorate
-  module Redirecting
-    include ApigwStage
-
-    def _compute_redirect_to_location(request, options) # :nodoc:
-      adjust = options.respond_to?(:to_str) || options.is_a?(String)
-      options = add_apigw_stage(options) if adjust
-      super
-    end
-
-    def redirect_back(fallback_location: '/')
-      location = request.headers["Referer"] || fallback_location
-      redirect_to location
-    end
-  end
-end

data/lib/jets/controller/decorate/url_for.rb

@@ -1,10 +0,0 @@
-module Jets::Controller::Decorate
-  module UrlFor
-    include ApigwStage
-
-    def url_for(options = nil)
-      url = super
-      add_apigw_stage(url)
-    end
-  end
-end

data/lib/jets/controller/handler/apigw.rb

@@ -1,93 +0,0 @@
-require 'base64'
-
-# Also, logic in the opposite direction: Jets::Controller::Middleware::Mimic::Apigw
-# Only called by AWS Lambda before it runs through the middlewares.
-module Jets::Controller::Handler
-  class Apigw
-    extend Memoist
-
-    attr_reader :event, :context, :controller, :meth, :rack_env
-    def initialize(event, context, controller, meth, rack_env)
-      @event = event
-      @context = context
-      @controller = controller
-      @meth = meth
-      @rack_env = rack_env
-    end
-
-    # 1. Convert API Gateway event event to Rack env
-    # 2. Process using full Rack middleware stack
-    # 3. Convert back to API gateway response structure payload
-    #
-    # Returns back API Gateway response hash structure
-    # Only called when running in AWS Lambda.
-    #
-    # Set the jets.* env variables so we have access to them in the middleware.
-    # The controller instance is called in the Main middleware.
-    # On AWS, will use original event and context.
-    # On local server, will use Middleware::Mimic event and context.
-    def process_through_middlewares
-      env = rack_env.merge(
-        'jets.controller' => @controller, # original controller instance from handler
-        'jets.context'    => @context,    # original AWS Lambda context
-        'jets.event'      => @event,      # original AWS Lambda event
-        'jets.meth'       => @meth,
-      )
-      status, headers, body = Jets.application.call(env) # goes through full middleware stack
-      # middleware can handle Array or BodyProxy, APIGW require Strings
-      case body
-      when Rack::Files::Iterator
-        str = File.read(body.path)
-      else
-        # join for Rack::BodyProxy or Array
-        str = body.join
-      end
-      convert_to_api_gateway(status, headers, str)
-    end
-
-    # Transform the structure to AWS_PROXY compatible structure
-    # http://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
-    def convert_to_api_gateway(status, headers, body)
-      base64 = headers["x-jets-base64"] == 'yes'
-      body = body.respond_to?(:read) ? body.read : body
-      body = Base64.encode64(body) if base64
-
-      {}.tap do |resp|
-        resp['statusCode'] = status
-        resp['body'] = body
-        resp['isBase64Encoded'] = base64
-        add_response_headers(resp, headers)
-        adjust_for_elb(resp)
-      end
-    end
-
-    def add_response_headers(resp, headers)
-      resp['headers'] = headers.reject { |_, val| val.is_a?(Array) }
-      multi_value_headers = headers.select { |_, val| val.is_a?(Array) }
-
-      resp['multiValueHeaders'] = multi_value_headers unless multi_value_headers.blank?
-    end
-
-    # Note: ELB is not officially support. This is just in case users wish to manually
-    # connect ELBs to the functions created by Jets.
-    def adjust_for_elb(resp)
-      return resp unless from_elb?
-
-      # ELB requires statusCode to be an Integer whereas API Gateway requires statusCode to be a String
-      status = resp["statusCode"] = resp["statusCode"].to_i
-
-      # ELB also requires statusDescription attribute
-      status_desc = Rack::Utils::HTTP_STATUS_CODES[status]
-      status_desc = status_desc.nil? ? status.to_s : "#{status} #{status_desc}"
-      resp["statusDescription"] = status_desc
-
-      resp
-    end
-
-    def from_elb?
-      # NOTE: @event["requestContext"]["elb"] is set when the request is coming from an elb
-      # Can set JETS_ELB=1 for local testing
-      @event["requestContext"] && @event["requestContext"]["elb"] || ENV['JETS_ELB']
-    end
-  end
-end

data/lib/jets/controller/handler.rb

@@ -1,41 +0,0 @@
-module Jets::Controller
-  # Only called by AWS Lambda before it runs through the middlewares.
-  module Handler
-    extend ActiveSupport::Concern
-
-    # One key difference between process! vs dispatch!
-    #
-    #    process! - takes the request through the middleware stack
-    #    dispatch! - does not
-    #
-    # Generally, we want to use process! so it goes through the middleware stacks.
-    #
-    # The last middleware stack is Jets::Controller::Middleware::Main
-    # Which comes back to dispatch! in this same Controller Base class.
-    #
-    #     class Jets::Controller::Middleware::Main
-    #       def call!
-    #         setup
-    #         @controller.dispatch! # Returns triplet
-    #       end
-    #     end
-    #
-    def process!
-      apigw = Jets::Controller::Handler::Apigw.new(event, context, self, @meth, @rack_env)
-      apigw.process_through_middlewares # Returns API Gateway hash structure
-    end
-
-    class_methods do
-      def process(event, context={}, meth)
-        rack_env = Jets::Controller::RackAdapter::Env.new(event, context).convert # convert to Rack env
-        controller = new(event, context, meth, rack_env)
-        # Using send because process! was a private method in Jets::RackController (old) so
-        # it doesnt create a lambda function.  It's doesnt matter what scope process!
-        # is in Controller::Base because Jets lambda functions inheritance doesnt
-        # include methods in Controller::Base.
-        controller.send(:process!)
-      end
-    end
-  end
-end
-

data/lib/jets/controller/middleware/main.rb

@@ -1,61 +0,0 @@
-# All roads lead here
-#
-# 1. AWS Lambda: PostsController - Handler::Apigw - Jets.application.call
-# 2. Local server:  config.ru - run Jet.application - Jets.application.call
-#
-# Then eventually:
-#
-#   Jets.application.call - Middleware stack - Jets::Controller::Middleware::Main
-#
-module Jets::Controller::Middleware
-  class Main
-    include Jets::ExceptionReporting
-
-    def initialize(env)
-      @env = env
-      @controller = env['jets.controller'] # original controller instance from handler or mimic
-      @context = env['jets.context']  # original AWS Lambda event or mimic context
-      @event = env['jets.event']      # original AWS Lambda event or mimic event
-      @meth = env['jets.meth']
-    end
-
-    def call
-      dup.call!
-    end
-
-    # With exception reporting here instead of Controller::Base#process so any
-    # exception in the middleware stack is caught.
-    # Also using with_exception_reporting instead of
-    # prepend Jets::ExceptionReporting::Process because the method is call!
-    # not process. The interface is different.
-    def call!
-      with_exception_reporting do
-        setup
-        @controller.dispatch! # Returns triplet
-      end
-    end
-
-    # Common setup logical at this point of middleware processing right before
-    # calling any controller actions.
-    def setup
-      # We already recreated a mimic rack env earlier as part of the very first
-      # middleware layer. However, by the time the rack env reaches the main middleware
-      # it could had been updated by other middlewares. We update the env here again.
-      @controller.request.set_env!(@env)
-      # This allows sesison helpers to work. Sessions are managed by
-      # the Rack::Session::Cookie middleware by default.
-      @controller.session = @env['rack.session'] || {}
-    end
-
-    def jets_host
-      protocol = @event.dig('headers', 'X-Forwarded-Proto') || @env['rack.url_scheme']
-      default = "#{protocol}://#{@env['HTTP_HOST']}"
-      Jets.config.helpers.host || default
-    end
-
-    def self.call(env)
-      instance = new(env)
-      instance.call
-    end
-  end
-end

data/lib/jets/controller/middleware/mimic/apigw.rb

@@ -1,130 +0,0 @@
-# Takes a Rack env and converts to ApiGateway event
-# This runs only locally, when not on AWS Lambda
-# Note: Logic in the opposite direction: Jets::Controller::Handler::Apigw#rack_vars
-class Jets::Controller::Middleware::Mimic
-  class Apigw
-    extend Memoist
-
-    def initialize(route, env)
-      @route, @env = route, env
-    end
-
-    # Actual controller instance
-    def controller
-      controller_class = @route.controller_name.constantize
-      meth = @route.action_name
-      # must keep the same env as @env, rack env, else constraint lambda proc request will be different
-      controller_class.new(event, context, meth, @env)
-    end
-    memoize :controller # for same object_id in case apigw.controller is called twice
-
-    def meth
-      @route.action_name
-    end
-    memoize :meth
-
-    def context
-      LambdaContext.new
-    end
-    memoize :context
-
-    def event
-      resource = @route.path(:api_gateway) # /posts/{id}/edit
-      path = @env['PATH_INFO'].sub('/','') # remove beginning slash
-      {
-        "resource" => resource, # "/posts/{id}/edit"
-        "path" => @env['PATH_INFO'],  # /posts/tung/edit
-        "httpMethod" => @env['REQUEST_METHOD'], # GET
-        "headers" => request_headers,
-        "queryStringParameters" => query_string_parameters,
-        "multiValueQueryStringParameters" => multi_value_query_string_parameters,
-        "pathParameters" => @route.extract_parameters(path),
-        "stageVariables" => nil,
-        "requestContext" => {},
-        "body" => get_body,
-        "isBase64Encoded" => false,
-      }
-    end
-    memoize :event
-    alias convert event
-
-    protected
-    # Annoying. The headers part of the AWS Lambda proxy structure
-    # does not consisently use the same casing scheme for the header keys.
-    # Sometimes it looks like this:
-    #   Accept-Encoding
-    # and sometimes it looks like this:
-    #   cache-control
-    # Map for special cases when the casing doesn't match.
-    CASING_MAP = {
-      "Cache-Control" => "cache-control",
-      "Content-Type" => "content-type",
-      "Origin" => "origin",
-      "Upgrade-Insecure-Requests" => "upgrade-insecure-requests",
-    }
-
-    # Map rack env headers to Api Gateway event headers. Most rack env headers are
-    # prepended by HTTP_.
-    #
-    # Some API Gateway Lambda Proxy are also in the rack env headers. Example:
-    #
-    #   "X-Amz-Cf-Id": "W8DF6J-lx1bkV00eCiBwIq5dldTSGGiG4BinJlxvN_4o8fCZtbsVjw==",
-    #   "X-Amzn-Trace-Id": "Root=1-5a0dc1ac-58a7db712a57d6aa4186c2ac",
-    #   "X-Forwarded-For": "88.88.88.88, 54.239.203.117",
-    #   "X-Forwarded-Port": "443",
-    #   "X-Forwarded-Proto": "https",
-    #
-    # For sample dump of the event headers, check out:
-    #   spec/fixtures/samples/event-headers-form-post.json
-    #
-    # We generally do add those API Gateway Lambda specific headers because
-    # they would be fake anyway and by not adding them we can distinguish a
-    # local request from a remote request on API Gateway.
-    def request_headers
-      headers = @env.select { |k,v| k =~ /^HTTP_/ }.inject({}) do |h,(k,v)|
-          # map things like HTTP_USER_AGENT to "User-Agent"
-          key = k.sub('HTTP_','').split('_').map(&:capitalize).join('-')
-          h[key] = v
-          h
-        end
-      # Content type is not prepended with HTTP_
-      headers["Content-Type"] = @env["CONTENT_TYPE"] if @env["CONTENT_TYPE"]
-
-      # Adjust the casing so it matches the Lambda AWS Proxy structure
-      CASING_MAP.each do |nice_casing, bad_casing|
-        if headers.key?(nice_casing)
-          headers[bad_casing] = headers.delete(nice_casing)
-        end
-      end
-
-      headers
-    end
-
-    def query_string_parameters
-      Rack::Utils.parse_nested_query(@env['QUERY_STRING'])
-      # @env['QUERY_STRING']&.split('&')&.each_with_object({}) do |parameter, hash|
-      #   key, value = parameter.split('=')
-      #   hash[key] = value
-      # end || {}
-    end
-    alias multi_value_query_string_parameters query_string_parameters
-
-    # def multi_value_query_string_parameters
-    #   @env['QUERY_STRING']&.split('&')&.each_with_object({}) do |parameter, hash|
-    #     key, value = parameter.split('=')
-    #     hash[key] = [] if hash[key].nil?
-    #     hash[key] << value
-    #   end || {}
-    # end
-
-    # To get the post body:
-    #   rack.input: #<StringIO:0x007f8ccf8db9a0>
-    def get_body
-      input = @env["rack.input"] || StringIO.new
-      body = input.read
-      input.rewind # IMPORTANT or else it screws up other middlewares that use the body
-      # return nil for blank string, because Lambda AWS_PROXY does this
-      body unless body.empty?
-    end
-  end
-end

data/lib/jets/controller/middleware/mimic/lambda_context.rb

@@ -1,44 +0,0 @@
-class Jets::Controller::Middleware::Mimic
-  # This class uses method_missing to mimic for all possible future methods
-  # that AWS Lambda might add to the context object.
-  #
-  # The current methods available on the Lambda Context object:
-  #   aws_request_id, invoked_function_arn, log_group_name,
-  #   log_stream_name, function_name, memory_limit_in_mb, function_version,
-  #   identity, client_context, deadline_ms
-  #
-  # Locally, example mimic values:
-  #
-  #   context.aws_request_id "mimic lambda context: aws_request_id"
-  #   context.invoked_function_arn "mimic lambda context: invoked_function_arn"
-  #   context.log_group_name "mimic lambda context: log_group_name"
-  #   context.log_stream_name "mimic lambda context: log_stream_name"
-  #   context.function_name "mimic lambda context: function_name"
-  #   context.memory_limit_in_mb "mimic lambda context: memory_limit_in_mb"
-  #   context.function_version "mimic lambda context: function_version"
-  #   context.identity "mimic lambda context: identity"
-  #   context.client_context "mimic lambda context: client_context"
-  #   context.deadline_ms "mimic lambda context: deadline_ms"
-  #
-  # On AWS, example real values:
-  #
-  #   context.aws_request_id "b8357b1d-15f2-4197-9c6b-d6873be5eaba"
-  #   context.invoked_function_arn "arn:aws:lambda:us-west-2:112233445566:function:demo-dev-controller"
-  #   context.log_group_name "/aws/lambda/demo-dev-controller"
-  #   context.log_stream_name "2023/09/10/[$LATEST]18323c481c674665b25496c329daa382"
-  #   context.function_name "demo-dev-controller"
-  #   context.memory_limit_in_mb "1536"
-  #   context.function_version "$LATEST"
-  #   context.identity nil
-  #   context.client_context nil
-  #   context.deadline_ms 1694353587386
-  #
-  class LambdaContext
-    def initialize(*)
-    end
-
-    def method_missing(method_name, *args)
-      "mimic lambda context: #{method_name}"
-    end
-  end
-end

data/lib/jets/controller/middleware/mimic.rb

@@ -1,105 +0,0 @@
-require 'kramdown'
-
-# Handles mimicing of API Gateway to Lambda function call locally
-# Logic in the opposite direction: Jets::Controller::Handler::Apigw#rack_vars
-module Jets::Controller::Middleware
-  class Mimic
-    extend Memoist
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      matcher = Jets::Router::Matcher.new
-      route = matcher.find_by_env(env) # simpler version does not check constraints
-      return not_found(env) unless route
-
-      # Make instance available so we dont not have to pass it around.
-      # Also important to assign to instance variables so values are memoized in variables
-      # So the mimic logic work because @env.merge! does not happened
-      # until end. We do not want apigw.controller to create a new controller instance
-      # with a different object_id
-      apigw = Apigw.new(route, env) # takes rack env and converts to API Gateway event structure
-      @controller = apigw.controller
-      @meth = apigw.meth
-      @event = apigw.event
-      @context = apigw.context
-
-      route = matcher.find_by_request(@controller.request) # need request object to check constraints
-      return not_found(env) unless route
-
-      if route.to == 'jets/rack#process' # megamode
-        # Bypass the Jets middlewares since it could interfere with the Rack
-        # application's middleware stack.
-        #
-        # Jets sends back a transfer-encoding=chunked. Curling Jets directly works,
-        # but passing the Jets response back through this middleware results in errors.
-        # Disable chunking responses by deleting the transfer-encoding response header.
-        # Would like to understand why this happens this better, if someone can explain please let me know.
-        status, headers, body = @controller.dispatch! # jets/rack_controller
-        headers.delete "transfer-encoding"
-        [status, headers, body]
-      elsif route.to == 'jets/mount#call' # mount route
-        status, headers, body = @controller.dispatch! # jets/mount_controller
-        [status, headers, body]
-      elsif polymorphic_function?
-        run_polymophic_function
-      else # Normal Jets request
-        unless on_aws?(env)
-          # Only set these variables when running locally and not on AWS.
-          # On AWS, these are set by the Jets::Controller::Handler::Apigw#rack_vars
-          env.merge!(
-            'jets.controller' => @controller, # mimic controller instance
-            'jets.context'    => @context,    # mimic context
-            'jets.event'      => @event,      # mimic event
-            'jets.meth'       => @meth,
-          )
-        end
-        @app.call(env) # goes to all middleware all the way to Jets::Controller::Middleware::Main
-      end
-    end
-
-    # Never hit when calling polymorphic function on AWS Lambda. Can only get called with the local server.
-    def polymorphic_function?
-      return false if ENV['_HANDLER'] # slight speed improvement on Lambda
-      polymorphic_function.definition.lang != :ruby
-    end
-
-    def polymorphic_function
-      # Abusing Poly to run polymorphic code, should call LambdaExecutor directly
-      # after reworking LambdaExecutor so it has a better interface.
-      Jets::Poly.new(@controller.class, @meth)
-    end
-    memoize :polymorphic_function
-
-    def run_polymophic_function
-      resp = polymorphic_function.run(@event, @meth) # polymorphic code
-      status = resp['statusCode']
-      headers = resp['headers']
-      body = StringIO.new(resp['body'])
-      [status, headers, body] # triplet
-    end
-
-    def on_aws?(env)
-      return true if ENV['ON_AWS']
-      return false if Jets.env.test? # usually with test we're passing in full API Gateway fixtures with the HTTP_X_AMZN_TRACE_ID
-      return false if ENV['JETS_ELB'] # If we're using an ELB and Jets is inside a container running jets server, we don't want to pretend we're on AWS.
-      on_cloud9 = !!(env['HTTP_HOST'] =~ /cloud9\..*\.amazonaws\.com/)
-      !!env['HTTP_X_AMZN_TRACE_ID'] && !on_cloud9
-    end
-
-    def routes_error_message(env)
-      message = "<h2>404 Error: Route #{env['PATH_INFO'].sub('/','')} not found</h2>"
-      if Jets.env != "production"
-        message << "<p>Here are the routes defined in your application:</p>"
-        message << "#{routes_table}"
-      end
-      message
-    end
-
-    def not_found(env)
-      raise Jets::Controller::RoutingError, "No route matches #{env['PATH_INFO'].inspect}"
-    end
-  end
-end