jets_bb_fork 0.0.4

data/lib/jets/controller/layout.rb

@@ -0,0 +1,17 @@
+class Jets::Controller
+  module Layout
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :layout_name
+
+      def self.layout(name=nil)
+        if !name.nil?
+          name = name.to_s if name.is_a?(Symbol)
+          self.layout_name = name
+        else
+          self.layout_name
+        end
+      end
+    end # included
+  end # Layout
+end

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

@@ -0,0 +1,60 @@
+# The rack cors middleware handles all types of requests locally, this includes the OPTIONS request.
+# Remotely on lambda, the rack cors middleware handles all requests except the OPTIONS request.
+# The options request is handled by a OPTIONS API Gateway Method Mock. This is to allow it to bypass
+# API Gateway authorizers.
+module Jets::Controller::Middleware
+  class Cors
+    extend Memoist
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env['REQUEST_METHOD'] == 'OPTIONS'
+        return [200, cors_headers(true), StringIO.new]
+      end
+
+      status, headers, body = @app.call(env)
+      cors_headers.each do |k,v|
+        headers[k] ||= v
+      end
+      [status, headers, body]
+    end
+
+    def cors_headers(preflight=false)
+      headers = case Jets.config.cors
+      when true
+        {
+          "access-control-allow-origin" => "*", # Required for CORS support to work
+          "access-control-allow-credentials" => "true" # Required for cookies, authorization headers with HTTPS
+        }
+      when String
+        {
+          "access-control-allow-origin" => Jets.config.cors, # contains Hash with Access-Control-Allow-* values
+          "access-control-allow-credentials" => "true" # Required for cookies, authorization headers with HTTPS
+        }
+      when Hash
+        Jets.config.cors # contains Hash with Access-Control-Allow-* values
+      else
+        {}
+      end
+
+      headers.merge!(preflight_headers) if preflight
+      headers
+    end
+
+  private
+    # Preflight OPTIONS request has extra headers.
+    # This is only used locally. Remotely on AWS Lambda, OPTIONS requests are handled by an API Gateway Method.
+    def preflight_headers
+      # FYI: Jets as part of the rack processing normalizes the casing of these headers eventually.
+      # IE: Access-Control-Allow-Methods
+      default = {
+        "access-control-allow-methods" => "DELETE,GET,HEAD,OPTIONS,PATCH,POST,PUT",
+        "access-control-allow-headers" => "Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent",
+      }
+      Jets.config.cors_preflight || default
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'kramdown'
+
+# Handles mimicking of API Gateway to Lambda function call locally
+module Jets::Controller::Middleware
+  class Local
+    extend Memoist
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      route = RouteMatcher.new(env).find_route
+      unless route
+        return [404, {'Content-Type' => 'text/html'}, not_found(env)]
+      end
+
+      mimic = MimicAwsCall.new(route, env)
+      # Make @controller and @meth instance available so we dont not have to pass it around.
+      @controller, @meth, @event = mimic.controller, mimic.meth, mimic.event
+
+      if route.to == 'jets/rack#process' # megamode
+        # Bypass the Jets middlewares since it could interfere with the Rack
+        # application's middleware stack.
+        #
+        # Rails sends back a transfer-encoding=chunked. Curling Rails directly works,
+        # but passing the Rails 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 polymorphic_function?
+        # Will never hit when calling polymorphic function on AWS Lambda.
+        # This can only really get called with the local server.
+        run_polymophic_function
+      else # Normal Jets request
+        mimick_aws_lambda!(env, mimic.vars) unless on_aws?(env)
+        @app.call(env)
+      end
+    end
+
+    def polymorphic_function?
+      polymorphic_function.task.lang != :ruby
+    end
+
+    def polymorphic_function
+      # Abusing PolyFun to run polymorphic code, should call LambdaExecutor directly
+      # after reworking LambdaExecutor so it has a better interface.
+      Jets::PolyFun.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
+
+    # Modifies env the in the same way real call from AWS lambda would modify env
+    def mimick_aws_lambda!(env, vars)
+      env.merge!(vars)
+      env
+    end
+
+    def on_aws?(env)
+      return false if ENV['TEST'] # usually with test we're passing in full API Gateway fixtures with the HTTP_X_AMZN_TRACE_ID
+      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)
+      message = routes_error_message(env)
+      body = <<~HTML
+        <!DOCTYPE html>
+        <html>
+            <head>
+                <meta charset="utf-8">
+                <title>Route not found</title>
+            </head>
+            <body>
+              #{message}
+            </body>
+        </html>
+      HTML
+      StringIO.new(body)
+    end
+
+    # Show pretty route table for user to help with debugging in non-production mode
+    def routes_table
+      routes = Jets::Router.routes
+
+      return "Your routes table is empty." if routes.empty?
+
+      text = "Verb | Path | Controller#action\n"
+      text << "--- | --- | ---\n"
+      routes.each do |route|
+        text << "#{route.method} | #{route.path} | #{route.to}\n"
+      end
+      html = Kramdown::Document.new(text).to_html
+      puts html
+      html
+    end
+  end
+end

data/lib/jets/controller/middleware/local/api_gateway.rb

@@ -0,0 +1,93 @@
+# Takes a Rack env and converts to ApiGateway event
+class Jets::Controller::Middleware::Local
+  class ApiGateway
+    extend Memoist
+
+    def initialize(route, env)
+      @route, @env = route, env
+    end
+
+    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,
+        "pathParameters" => @route.extract_parameters(path),
+        "stageVariables" => nil,
+        "requestContext" => {},
+        "body" => get_body,
+        "isBase64Encoded" => false,
+      }
+    end
+    memoize :event
+
+    # 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'])
+    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/local/mimic_aws_call.rb

@@ -0,0 +1,38 @@
+class Jets::Controller::Middleware::Local
+  class MimicAwsCall
+    extend Memoist
+
+    def initialize(route, env)
+      @route, @env = route, env
+    end
+
+    def vars
+      {
+        'jets.controller' => controller,
+        'lambda.context' => context,
+        'lambda.event' => event,
+        'lambda.meth' => meth,
+      }
+    end
+
+    # Actual controller instance
+    def controller
+      controller_class = @route.controller_name.constantize
+      meth = @route.action_name
+      controller_class.new(event, context, meth)
+    end
+
+    def meth
+      @route.action_name
+    end
+
+    def event
+      @env['adapter.event'] || ApiGateway.new(@route, @env).event
+    end
+    memoize :event
+
+    def context
+      @env['adapter.context'] || {"fake" => "context in mimic_aws_call.rb"}
+    end
+  end
+end

data/lib/jets/controller/middleware/local/route_matcher.rb

@@ -0,0 +1,106 @@
+class Jets::Controller::Middleware::Local
+  class RouteMatcher
+    def initialize(env)
+      @env = env
+    end
+
+    def find_route
+      reset_routes!
+      # Precedence:
+      # 1. Routes with no captures get highest precedence: posts/new
+      # 2. Then we consider the routes with captures: post/:id
+      #
+      # Within these 2 groups we consider the routes with the longest path first
+      # since posts/:id and posts/:id/edit can both match.
+      routes = router.ordered_routes
+      route = routes.find do |r|
+        route_found?(r)
+      end
+      route
+    end
+
+    # "hot reload" for development
+    def reset_routes!
+      return unless Jets.env.development?
+
+      Jets::Router.clear!
+      Jets.application.load_routes(refresh: true)
+    end
+
+    def route_found?(route)
+      request_method = @env["REQUEST_METHOD"] || "GET"
+      actual_path = @env["PATH_INFO"].sub(/^\//,'') # remove beginning slash
+
+      # Immediately stop checking when the request method: GET, POST, ANY, etc
+      # doesnt match.
+      return false if request_method != route.method and route.method != "ANY"
+
+      path = route.path
+
+      if actual_path == path
+        # regular string match detection
+        return true # exact route matches are highest precedence
+      end
+
+      # Check path for route capture and wildcard matches:
+      # A colon (:) means the variable has a variable
+      if path.include?(':') # 2nd highest precedence
+        capture_detection(path, actual_path) # early return true or false
+      # A star (*) means the variable has a glob
+      elsif path.include?('*') # lowest precedence
+        proxy_detection(path, actual_path) # early return true or false
+      else
+        false # reach here, means no route matched
+      end
+    end
+
+    # catchall/globbing/wildcard/proxy routes. Examples:
+    #
+    #    get "files/*path", to: "files#show"
+    #    get "others/*rest", to: "others#show"
+    #    get "*catchall", to: "public_files#show" # last catchall route for Jets
+    #
+    def proxy_detection(route_path, actual_path)
+      # drop the proxy_segment
+      leading_path = route_path.split('/')[0..-2].join('/')
+
+      # get "*catchall", to: "public_files#show"
+      if leading_path.empty? # This is the last catchall route "*catchall"
+        return true # always return true here because the entire path
+        # will always match
+      end
+
+      # Other types of wildcard route:
+      #
+      #    get "files/*path", to: "files#show"
+      #    get "others/*rest", to: "others#show"
+      unless leading_path.ends_with?('/')
+        # Ensure trailing slash to make pattern matching stricter
+        leading_path = "#{leading_path}/"
+      end
+
+      pattern = "^#{leading_path}"
+      regexp = Regexp.new(pattern)
+      !!regexp.match(actual_path) # could be true or false
+    end
+
+    def capture_detection(route_path, actual_path)
+      # changes path to a string used for a regexp
+      # posts/:id/edit => posts\/(.*)\/edit
+
+      regexp_string = route_path.split('/').map do |s|
+                        s.include?(':') ? Jets::Route::CAPTURE_REGEX : s
+                      end.join('\/')
+      # make sure beginning and end of the string matches
+      regexp_string = "^#{regexp_string}$"
+
+      regexp = Regexp.new(regexp_string)
+      !!regexp.match(actual_path) # could be true or false
+    end
+
+    def router
+      return @router if @router
+      @router = Jets.application.routes
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# All roads lead here
+#
+# 1. AWS Lambda: PostsController - Rack::Adapter - 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
+    def initialize(env)
+      @env = env
+      @controller = env['jets.controller']
+      @event = env['lambda.event']
+      @context = env['lambda.context']
+      @meth = env['lambda.meth']
+    end
+
+    def call
+      dup.call!
+    end
+
+    def call!
+      setup
+      @controller.dispatch! # Returns triplet
+    end
+
+    # Common setup logical at this point of middleware processing right before
+    # calling any controller actions.
+    def setup
+      # We already recreated a mimicke 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 self.call(env)
+      instance = new(env)
+      instance.call
+    end
+  end
+end