jets 5.0.17 → 6.0.0.beta1

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

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

@@ -1,6 +0,0 @@
-# Breaking all the rules to get the beautiful webpacker middleware working
-
-require "webpacker"
-require "webpacker/dev_server_proxy"
-
-Webpacker.bootstrap # whenever jets server is runs should Webpacker.bootstrap

data/lib/jets/controller/rack_adapter/action.rb

@@ -1,35 +0,0 @@
-module Jets::Controller::RackAdapter
-  module Action
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def action(name)
-        lambda do |env|
-          route = find_first_route_for_action(name)
-          env['PATH_INFO'] = route_path(route)
-          controller = new({}, {}, name, env)
-          controller.dispatch! # does not go through middleware stack
-        end
-      end
-
-      # Find first route to be used for PATH_INFO.
-      # This allows engine_delegate to work properly.
-      def find_first_route_for_action(name)
-        Jets::Router.routes.find do |r|
-          route_controller_path, route_action_name = r.to.split('#')
-          route_controller_path == controller_path && route_action_name == name.to_s
-        end
-      end
-
-      def route_path(route)
-        if route
-          path = route.path
-          path = "/#{path}" unless path.starts_with?('/')
-        else
-          path = "/#{controller_path}##{name} (action proc)"
-        end
-        path
-      end
-    end
-  end
-end

data/lib/jets/controller/rack_adapter/env.rb

@@ -1,145 +0,0 @@
-require 'rack'
-require 'base64'
-
-# Only called by AWS Lambda
-# Takes an ApiGateway event and converts it to an Rack env that can be used for rack middleware
-module Jets::Controller::RackAdapter
-  class Env
-    def initialize(event, context, options={})
-      @event, @context, @options = event, context, options
-    end
-
-    def convert
-      options = {}
-      options = add_top_level(options)
-      options = add_http_headers(options)
-      path = path_with_base_path || @event['path'] || '/' # always set by API Gateway but might not be when testing shim, so setting it to make testing easier
-
-      # In case of non-ascii characters, CGI.escape will escape them
-      # IE: get '/ほげ'
-      # This just because MockRequest.env_for uses URI.parse which does not
-      # escape non-ascii characters and throws an error
-      unescaped_path = path
-      path = path.chars.map { |char| char.ascii_only? ? char : CGI.escape(char) }.join
-      env = Rack::MockRequest.env_for(path, options)
-      env['PATH_INFO'] = unescaped_path
-      # env['QUERY_STRING'] = query_string
-      env
-    end
-
-  private
-    def path_with_base_path
-      resource = @event['resource']
-      pathParameters = @event['pathParameters']
-
-      if(!pathParameters.nil? and !resource.nil?)
-        resource = pathParameters.reduce(resource) {|resource, parameter|
-          key, value = parameter
-          resource = resource.gsub("{#{key}+}", value)
-          resource = resource.gsub("{#{key}}", value)
-          resource
-        }
-      end
-
-      resource
-    end
-
-    def add_top_level(options)
-      map = {
-        'CONTENT_TYPE' => content_type,
-        'QUERY_STRING' => query_string,
-        'REMOTE_ADDR' => headers['X-Forwarded-For'],
-        'REMOTE_HOST' => headers_host,
-        'REQUEST_METHOD' => @event['httpMethod'] || 'GET', # useful to default to GET when testing with Lambda console
-        'REQUEST_PATH' => @event['path'],
-        'REQUEST_URI' => request_uri,
-        'SCRIPT_NAME' => "",
-        'SERVER_NAME' => headers_host,
-        'SERVER_PORT' => headers['X-Forwarded-Port'],
-        'SERVER_PROTOCOL' => "HTTP/1.1",  # unsure if this should be set
-        'SERVER_SOFTWARE' => headers['User-Agent'],
-      }
-
-      map['CONTENT_LENGTH'] = content_length if content_length
-      # Even if not set, Rack always assigns an StringIO to "rack.input"
-      map['rack.input'] = StringIO.new(body) if body
-
-      options.merge(map)
-    end
-
-    # Generally should use content_type method instead of headers['Content-Type'] because
-    # headers['Content-Type'] is not normally available for Rails.
-    #
-    # Jets makes it available and normalizes the casing by grabbing it from APIGW event['headers']
-    # APIGW is inconsistent about the casing.
-    # In POST request it's content-type and in GET request it's Content-Type
-    #
-    #   Rack (local) uses Content-Type and APIGW (remote) uses content-type
-    #   Rack::MethodOverride relys on content-type to detect content type properly.
-    #
-    def content_type
-      headers['Content-Type'] || headers['content-type']
-    end
-
-    def content_length
-      bytesize = body.bytesize.to_s if body
-      headers['Content-Length'] || bytesize
-    end
-
-    # Decoding base64 from API Gateaway if necessary
-    # Rack will be none the wiser
-    def body
-      if @event['isBase64Encoded']
-        Base64.decode64(@event['body'])
-      else
-        @event['body']
-      end
-    end
-
-    def add_http_headers(options)
-      headers.each do |k,v|
-        # content-type => HTTP_CONTENT_TYPE
-        key = k.gsub('-','_').upcase
-        key = "HTTP_#{key}"
-        if k == "Host"
-          options[key] = headers_host
-        else
-          options[key] = v
-        end
-      end
-      options
-    end
-
-    def headers_host
-      Jets.config.app.domain || headers['Host']
-    end
-
-    def request_uri
-      # IE: "http://localhost:8888/posts/tung/edit?foo=bar"
-      proto = headers['X-Forwarded-Proto']
-      host = headers_host
-      port = headers['X-Forwarded-Port']
-
-      # Add port if needed
-      if proto == 'https' && port != '443' or
-         proto == 'http'  && port != '80'
-        host = "#{host}:#{port}"
-      end
-
-      path = @event['path']
-      qs = "?#{query_string}" unless query_string.empty?
-      "#{proto}://#{host}#{path}#{qs}"
-    end
-
-    def query_string
-      query = @event["queryStringParameters"] || @event["multiValueQueryStringParameters"] || {} # always set with API Gateway but when testing node shim might not be
-      Rack::Utils.build_nested_query(query)
-      # query.map { |k,v| "#{k}=#{v}" }.join('&')
-    end
-
-    # request headers
-    def headers
-      @event['headers'] || {}
-    end
-  end
-end

data/lib/jets/controller/request/compat/params.rb

@@ -1,144 +0,0 @@
-require "action_dispatch/request/utils"
-require "rack"
-
-module Jets::Controller::Request::Compat
-  # Provides these 3 methods to make it Rails compatible:
-  #
-  #   request_parameters
-  #   query_parameters
-  #   path_parameters
-  #
-  module Params
-    extend Memoist
-
-    delegate :normalize_encode_params, to: ActionDispatch::Request::Utils
-    def set_binary_encoding(params)
-      controller = path_parameters[:controller]
-      action = path_parameters[:action]
-      ActionDispatch::Request::Utils.set_binary_encoding(self, params, controller, action)
-    end
-
-    # Merge all the parameters together for convenience.
-    # Users still have access via events.
-    #
-    # Precedence:
-    #   1. path parameters have highest precdence
-    #   2. query string parameters
-    #   3. body parameters
-    def parameters(include_path_params: true, include_body_params: true)
-      params = {}
-      params = params.deep_merge(request_parameters) if include_body_params
-      params = params.deep_merge(unescape_recursively(query_parameters)) # always
-      params = params.deep_merge(path_parameters) if include_path_params
-      params = set_binary_encoding(params)
-      params = normalize_encode_params(params)
-      params
-    end
-    memoize :parameters
-    alias params parameters
-
-    def path_parameters
-      path_params = event["pathParameters"] || {}
-      path_params.merge!(path_parameters_defaults)
-      path_params = path_params.map { |k, path| [k, CGI.unescape(path.to_s)] }.to_h
-    end
-
-    def path_parameters_defaults
-      route = Jets::Router::Matcher.new.find_by_request(self)
-      if route
-        controller = route.controller_name.delete_suffix("Controller").underscore
-        {
-          controller: controller,
-          action: route.action_name,
-        }.merge(route.resolved_defaults)
-      else
-        {}
-      end
-    end
-
-    # Based on ActionDispatch::Request#GET https://bit.ly/48hvDwe
-    # Override Rack's GET method to support indifferent access.
-    def GET
-      fetch_header("action_dispatch.request.query_parameters") do |k|
-        params = event["queryStringParameters"] || {}
-        set_binary_encoding(params)
-        set_header k, normalize_encode_params(params)
-      end
-    end
-    alias query_parameters GET
-
-    # Based on ActionDispatch::Request#POST https://bit.ly/48fxh1A
-    # Override Rack's POST method to support indifferent access.
-    def POST
-      fetch_header("action_dispatch.request.request_parameters") do
-        params = get_request_parameters
-        self.request_parameters = normalize_encode_params(params)
-      end
-    end
-    alias request_parameters POST
-
-    def request_parameters=(params)
-      raise if params.nil?
-      set_header("action_dispatch.request.request_parameters", params)
-    end
-
-    def get_request_parameters
-      body = event['isBase64Encoded'] ? base64_decode(event["body"]) : event["body"]
-      return {} if body.nil?
-
-      parsed_json = parse_json(body)
-      return parsed_json if parsed_json
-
-      if content_type.to_s.include?("application/x-www-form-urlencoded")
-        return ::Rack::Utils.parse_nested_query(body)
-      elsif content_type.to_s.include?("multipart/form-data")
-        return parse_multipart(body)
-      end
-
-      {} # fallback to empty Hash
-    end
-    memoize :get_request_parameters
-
-    # jets specific
-    def request_method_from_hidden_method_field
-      get_request_parameters["_method"].to_s.upcase if get_request_parameters["_method"]
-    end
-
-  private
-
-    def parse_multipart(body)
-      boundary = ::Rack::Multipart::Parser.parse_boundary(content_type)
-      options = multipart_options(body, boundary)
-      env = ::Rack::MockRequest.env_for("/", options)
-      ::Rack::Multipart.parse_multipart(env) # params Hash
-    end
-
-    def multipart_options(data, boundary = "AaB03x")
-      type = %(multipart/form-data; boundary=#{boundary})
-      length = data.bytesize
-
-      { "CONTENT_TYPE" => type,
-        "CONTENT_LENGTH" => length.to_s,
-        :input => StringIO.new(data) }
-    end
-
-    def parse_json(text)
-      JSON.parse(text)
-    rescue JSON::ParserError
-      nil
-    end
-
-    def base64_decode(body)
-      return nil if body.nil?
-      Base64.decode64(body)
-    end
-
-    def unescape_recursively(obj)
-      case obj
-      when Hash then obj.map { |k, v| [k, unescape_recursively(v)] }.to_h
-      when Array then obj.map { |v| unescape_recursively(v) }
-      else CGI.unescape(obj.to_s)
-      end
-    end
-  end
-end

data/lib/jets/controller/request/compat/request.rb

@@ -1,125 +0,0 @@
-module Jets::Controller::Request::Compat
-  # Based on ActionDispatch::Request class
-  module Request
-    extend Memoist
-
-    ENV_METHODS = %w[ AUTH_TYPE GATEWAY_INTERFACE
-      PATH_TRANSLATED REMOTE_HOST
-      REMOTE_IDENT REMOTE_USER REMOTE_ADDR
-      SERVER_NAME SERVER_PROTOCOL
-      ORIGINAL_SCRIPT_NAME
-
-      HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
-      HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_FROM
-      HTTP_NEGOTIATE HTTP_PRAGMA HTTP_CLIENT_IP
-      HTTP_X_FORWARDED_FOR HTTP_ORIGIN HTTP_VERSION
-      HTTP_X_CSRF_TOKEN HTTP_X_REQUEST_ID HTTP_X_FORWARDED_HOST
-      ].freeze
-
-    ENV_METHODS.each do |env|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        # frozen_string_literal: true
-        def #{env.delete_prefix("HTTP_").downcase}  # def accept_charset
-          get_header "#{env}"                       #   get_header "HTTP_ACCEPT_CHARSET"
-        end                                         # end
-      METHOD
-    end
-
-    LOCALHOST   = Regexp.union [/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, /^::1$/, /^0:0:0:0:0:0:0:1(%.*)?$/]
-
-    def session
-      key = ActionDispatch::Request::Session::ENV_SESSION_KEY
-      session = env[key]
-      if session.nil? # controller dispatch! does not go through middleware
-        # mock session that is disabled
-        session = ActionDispatch::Request::Session.new(nil, self, enabled: false)
-      end
-      session
-    end
-
-    def session=(session) # :nodoc:
-      ActionDispatch::Request::Session.set self, session
-    end
-
-    def session_options=(options)
-      ActionDispatch::Request::Session::Options.set self, options
-    end
-
-    def reset_session
-      session.destroy
-    end
-
-    def headers
-      top_level_headers.merge(http_headers)
-    end
-
-    def http_headers
-      Hash[*env.select {|k,v| k.start_with? 'HTTP_'}
-        .collect {|k,v| [k.sub(/^HTTP_/, ''), v]}
-        .collect {|k,v| [k.split('_').collect(&:capitalize).join('-'), v]}
-        .sort
-        .flatten]
-    end
-
-    # These are not part of a Rails headers but believe
-    # they make sense to add as it feel like expected behavior.
-    def top_level_headers
-      hash = {
-        "Host" => env["HTTP_HOST"],
-        "Content-Type" => env["CONTENT_TYPE"],
-        "Content-Length" => env["CONTENT_LENGTH"],
-      }
-      hash.delete_if { |k, v| v.nil? }
-      hash
-    end
-
-    # Returns the lowercase name of the HTTP server software.
-    def server_software
-      (get_header("SERVER_SOFTWARE") && /^([a-zA-Z]+)/ =~ get_header("SERVER_SOFTWARE")) ? $1.downcase : nil
-    end
-
-    # Returns the authorization header regardless of whether it was specified directly or through one of the
-    # proxy alternatives.
-    def authorization
-      get_header("HTTP_AUTHORIZATION")   ||
-      get_header("X-HTTP_AUTHORIZATION") ||
-      get_header("X_HTTP_AUTHORIZATION") ||
-      get_header("REDIRECT_X_HTTP_AUTHORIZATION")
-    end
-
-    # True if the request came from localhost, 127.0.0.1, or ::1.
-    def local?
-      LOCALHOST.match?(remote_addr) && LOCALHOST.match?(remote_ip)
-    end
-
-    def controller_class_for(name)
-      controller_param = name.underscore
-      const_name = controller_param.camelize << "Controller"
-      const_name.constantize
-    end
-
-    def request_method_symbol
-      request_method.downcase.to_sym
-    end
-    alias method_symbol request_method_symbol
-
-    # Returns the IP address of client as a +String+,
-    # usually set by the RemoteIp middleware.
-    def remote_ip
-      @remote_ip ||= (get_header("action_dispatch.remote_ip") || ip).to_s
-    end
-
-    def remote_ip=(remote_ip)
-      @remote_ip = nil
-      set_header "action_dispatch.remote_ip", remote_ip
-    end
-
-    # Needed when action_view.preload_links_header = true
-    # Rails 6.1 defaults
-    def send_early_hints(links)
-      return unless env["rack.early_hints"]
-
-      env["rack.early_hints"].call(links)
-    end
-  end
-end

data/lib/jets/controller/request.rb

@@ -1,46 +0,0 @@
-require 'rack/request'
-
-module Jets::Controller
-  class Request
-    include Rack::Request::Helpers
-    include Compat::Request
-    include Compat::Params
-
-    include ActionDispatch::Flash::RequestMethods
-    include ActionDispatch::Http::Cache::Request
-    include ActionDispatch::Http::MimeNegotiation
-    include ActionDispatch::Http::FilterParameters # parameter_filter and filtered_parameters
-    include ActionDispatch::Http::URL
-    include ActionDispatch::RequestCookieMethods
-    include ActionDispatch::ContentSecurityPolicy::Request
-    include ActionDispatch::PermissionsPolicy::Request
-    include Rack::Request::Env
-
-    # since jets delegates parameter_filter from controller to request
-    public :parameter_filter
-
-    attr_reader :event, :env
-    attr_accessor :routes
-    def initialize(rack_env: nil, event: nil)
-      @rack_env = rack_env
-      @event = event
-      @env = normalize_env
-      super(@env) # Rack::Env module => super()
-    end
-
-    def normalize_env
-      if @rack_env # already rack env
-        @rack_env # rack_env is from Controller.action => lambda { |env| .. }
-      else
-        Jets::Controller::RackAdapter::Env.new(@event, {}).convert # convert to Rack env
-      end
-    end
-
-    # When request hits the middleware Controller::RackAdapter::Middleware::Main endpoint
-    # We updated env since it could had been mutated down the middleware stack
-    # from Mimic to Main.
-    def set_env!(env)
-      @env = env
-    end
-  end
-end

data/lib/jets/controller/response/compat/response.rb

@@ -1,67 +0,0 @@
-module Jets::Controller::Response::Compat
-  module Response
-    extend ActiveSupport::Concern
-
-    included do
-      # Must come before include ActionDispatch::Http::Cache::Response
-      # Aliasing these off because AD::Http::Cache::Response defines them.
-      alias :_cache_control :cache_control
-      alias :_cache_control= :cache_control=
-    end
-
-    class_methods do
-      cattr_accessor :default_charset, default: "utf-8"
-    end
-
-    ContentTypeHeader = Struct.new :mime_type, :charset
-    NullContentTypeHeader = ContentTypeHeader.new nil, nil
-
-    CONTENT_TYPE = "Content-Type"
-    CONTENT_TYPE_PARSER = /
-      \A
-      (?<mime_type>[^;\s]+\s*(?:;\s*(?:(?!charset)[^;\s])+)*)?
-      (?:;\s*charset=(?<quote>"?)(?<charset>[^;\s]+)\k<quote>)?
-    /x # :nodoc:
-
-    def parse_content_type(content_type)
-      if content_type && match = CONTENT_TYPE_PARSER.match(content_type)
-        ContentTypeHeader.new(match[:mime_type], match[:charset])
-      else
-        NullContentTypeHeader
-      end
-    end
-
-    # Small internal convenience method to get the parsed version of the current
-    # content type header.
-    def parsed_content_type_header
-      parse_content_type(get_header("Content-Type"))
-    end
-
-    def set_content_type(content_type, charset)
-      type = content_type || ""
-      type = "#{type}; charset=#{charset.to_s.downcase}" if charset
-      set_header CONTENT_TYPE, type
-    end
-
-    # Sets the HTTP character set. In case of +nil+ parameter
-    # it sets the charset to +default_charset+.
-    #
-    #   response.charset = 'utf-16' # => 'utf-16'
-    #   response.charset = nil      # => 'utf-8'
-    def charset=(charset)
-      content_type = parsed_content_type_header.mime_type
-      if false == charset
-        set_content_type content_type, nil
-      else
-        set_content_type content_type, charset || self.class.default_charset
-      end
-    end
-
-    # The charset of the response. HTML wants to know the encoding of the
-    # content you're giving them, so we need to send that along.
-    def charset
-      header_info = parsed_content_type_header
-      header_info.charset || self.class.default_charset
-    end
-  end
-end