jets_bb_fork 0.0.4

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

@@ -0,0 +1,15 @@
+module Jets::Controller::Middleware
+  class Reloader
+    def initialize(app)
+      @app = app
+    end
+
+    @@reload_lock = Mutex.new
+    def call(env)
+      @@reload_lock.synchronize do
+        Jets::Autoloaders.main.reload
+        @app.call(env)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# 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/params.rb

@@ -0,0 +1,87 @@
+require "action_controller/metal/strong_parameters"
+require "action_dispatch"
+require "rack"
+
+class Jets::Controller
+  module Params
+    extend Memoist
+
+    # 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 params(raw: false, path_parameters: true, body_parameters: true)
+      path_params = event["pathParameters"] || {}
+
+      params = {}
+      params = params.deep_merge(body_params) if body_parameters
+      params = params.deep_merge(query_parameters) # always
+      params = params.deep_merge(path_params) if path_parameters
+
+      if raw
+        params
+      else
+        params = ActionDispatch::Request::Utils.normalize_encode_params(params) # for file uploads
+        ActionController::Parameters.new(params)
+      end
+    end
+
+    def query_parameters
+      event["queryStringParameters"] || {}
+    end
+
+    def body_params
+      body = event['isBase64Encoded'] ? base64_decode(event["body"]) : event["body"]
+      return {} if body.nil?
+
+      parsed_json = parse_json(body)
+      return parsed_json if parsed_json
+
+      headers = event["headers"] || {}
+      # API Gateway seems to use either: content-type or Content-Type
+      headers = headers.transform_keys { |key| key.downcase }
+      content_type = headers["content-type"]
+
+      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 :body_params
+
+  private
+
+    def parse_multipart(body)
+      boundary = ::Rack::Multipart::Parser.parse_boundary(headers["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
+  end
+end

data/lib/jets/controller/rack/adapter.rb

@@ -0,0 +1,88 @@
+require 'base64'
+
+module Jets::Controller::Rack
+  class Adapter
+    extend Memoist
+
+    # Returns back API Gateway response hash structure
+    def self.process(event, context, meth)
+      adapter = new(event, context, meth)
+      adapter.process
+    end
+
+    def initialize(event, context, meth)
+      @event, @context, @meth = event, context, meth
+    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
+    def process
+      status, headers, body = Jets.application.call(env)
+      convert_to_api_gateway(status, headers, body)
+    end
+
+    def env
+      Env.new(@event, @context, adapter: true).convert # convert to Rack env
+    end
+    memoize :env
+
+    # 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
+
+      resp = {
+        "statusCode" => status,
+        "headers" => headers,
+        "body" => body,
+        "isBase64Encoded" => base64,
+      }
+      adjust_for_elb(resp)
+      resp
+    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
+
+    # Called from Jets::Controller::Base.process. Example:
+    #
+    #   adapter.rack_vars(
+    #     'jets.controller' => self,
+    #     'lambda.context' => context,
+    #     'lambda.event' => event,
+    #     'lambda.meth' => meth,
+    #   )
+    #
+    # Passes a these special variables so we have access to them in the middleware.
+    # The controller instance is called in the Main middleware.
+    # The lambda.* info is used by the Rack::Local middleware to create a mimicked
+    # controller for the local server.
+    #
+    def rack_vars(vars)
+      env.merge!(vars)
+    end
+
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'rack'
+require 'base64'
+
+# Takes an ApiGateway event and converts it to an Rack env that can be used for
+# rack.call(env).
+module Jets::Controller::Rack
+  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 = @event['path'] || '/' # always set by API Gateway but might not be when testing shim, so setting it to make testing easier
+      env = Rack::MockRequest.env_for(path, options)
+      if @options[:adapter]
+        env['adapter.event'] = @event
+        env['adapter.context'] = @context
+      end
+      env
+    end
+
+  private
+    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'],
+        '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' => "WEBrick/1.3.1 (Ruby/2.2.2/2015-04-13)",
+      }
+
+      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
+
+    def content_type
+      headers['Content-Type'] || Jets::Controller::DEFAULT_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}"
+        options[key] = v
+      end
+      options
+    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
+      qs_params = @event["queryStringParameters"] || {} # always set with API Gateway but when testing node shim might not be
+      hash = Jets::Mega::HashConverter.encode(qs_params)
+      hash.to_query
+    end
+
+    def headers
+      @event['headers'] || {}
+    end
+  end
+end

data/lib/jets/controller/redirection.rb

@@ -0,0 +1,55 @@
+class Jets::Controller
+  module Redirection
+    # redirect_to "/posts", :status => 301
+    # redirect_to :action=>'atom', :status => 302
+    def redirect_to(url, options={})
+      unless url.is_a?(String)
+        raise "redirect_to url parameter must be a String. Please pass in a string"
+      end
+
+      uri = URI.parse(url)
+      # if no location.host, we been provided a relative host
+      if !uri.host && actual_host
+        url = "/#{url}" unless url.starts_with?('/')
+        url = add_stage_name(url)
+        redirect_url = actual_host + url
+      else
+        redirect_url = url
+      end
+
+      redirect_url = ensure_protocol(redirect_url)
+
+      aws_proxy = Rendering::RackRenderer.new(self,
+        status: options[:status] || 302,
+        headers: { "Location" => redirect_url },
+        body: "",
+        isBase64Encoded: false,
+      )
+      resp = aws_proxy.render
+      # redirect is a type of rendering
+      @rendered = true
+      @rendered_data = resp
+    end
+
+    def ensure_protocol(url)
+      return url if url.starts_with?('http')
+
+      # annoying but the request payload is different with localhost/rack vs
+      # api gateway
+      # check out:
+      #   spec/fixtures/dumps/api_gateway/posts/create.json
+      #   spec/fixtures/dumps/rack/posts/create.json
+      protocol = if headers["x-forwarded-proto"] # API Gateway
+          headers["x-forwarded-proto"]
+        elsif headers["origin"] # Rack / localhost
+          URI.parse(headers["origin"]).scheme
+        else
+          "http" # fallback. Capybara / Selenium tests
+        end
+
+      raise "Invalid protocol #{protocol}" unless protocol.starts_with?('http')
+
+      "#{protocol}://#{url}"
+    end
+  end
+end

data/lib/jets/controller/rendering.rb

@@ -0,0 +1,79 @@
+class Jets::Controller
+  module Rendering
+    include Redirection
+
+    def ensure_render
+      return @rendered_data if @rendered
+
+      # defaults to rendering templates
+      RackRenderer.new(self, managed_options).render
+    end
+
+    # Many different ways to render:
+    #
+    #  render "articles/index", layout: "application"
+    #  render :new
+    #  render template: "articles/index", layout: "application"
+    #  render json: {my: "data"}
+    #  render text: "plain text"
+    def render(options={}, rest={})
+      raise "DoubleRenderError" if @rendered
+
+      if options.is_a?(Symbol) or options.is_a?(String)
+        options = normalize_options(options, rest)
+      end
+
+      options.reverse_merge!(managed_options)
+      adjust_content_type!(options)
+
+      @rendered_data = RackRenderer.new(self, options).render
+
+      @rendered = true
+      @rendered_data
+    end
+
+    def adjust_content_type!(options)
+      if options.key?(:json)
+        options[:content_type] = "application/json"
+      elsif options.key?(:xml)
+        options[:content_type] = "application/xml"
+      end
+    end
+
+    def managed_options
+      layout = self.class.layout.nil? ? default_layout : self.class.layout
+      options = { layout: layout }
+      options[:headers] = response.headers unless response.headers.empty?
+      options
+    end
+
+    def default_layout
+      application_layout_exist = !Dir.glob("#{Jets.root}/app/views/layouts/application*").empty?
+      "application" if application_layout_exist
+    end
+
+    # Can normalize the options when it is a String or a Symbol
+    # Also set defaults here like the layout.
+    # Ensure options is a Hash, not a String or Symbol.
+    def normalize_options(options, rest)
+      template = options.to_s
+      rest.merge(template: template)
+    end
+
+    # Add API Gateway Stage Name
+    def add_stage_name(url)
+      return url unless actual_host
+
+      Jets::Controller::Stage.add(actual_host, url)
+    end
+
+    def url_for(url)
+      add_stage_name(url)
+    end
+
+    def actual_host
+      headers["host"]
+    end
+
+  end
+end

data/lib/jets/controller/rendering/rack_renderer.rb

@@ -0,0 +1,250 @@
+require "rack/utils"
+
+# Special renderer.  All the other renderers lead here
+module Jets::Controller::Rendering
+  class RackRenderer
+    delegate :request, :event, :headers, to: :controller
+    attr_reader :controller
+    def initialize(controller, options={})
+      @controller = controller
+      @options = options
+    end
+
+    # Example response:
+    #
+    #   [200, {"my-header" = > "value" }, "my body" ]
+    #
+    # Returns rack triplet
+    def render
+      # we do some normalization here
+      status = normalize_status_code(@options[:status])
+
+      base64 = normalized_base64_option(@options)
+
+      headers = @options[:headers] || {}
+      set_content_type!(status, headers)
+      # x-jets-base64 to convert this Rack triplet to a API Gateway hash structure later
+      headers["x-jets-base64"] = base64 ? 'yes' : 'no' # headers values must be Strings
+
+      # Rails rendering does heavy lifting
+      if drop_content_info?(status)
+        body = StringIO.new
+      else
+
+        renderer = ActionController::Base.renderer.new(renderer_options)
+        body = renderer.render(render_options)
+        body = StringIO.new(body)
+      end
+
+      [status, headers, body] # triplet
+    end
+
+    # Example: posts/index
+    def default_template_name
+      "#{template_namespace}/#{@controller.meth}"
+    end
+
+    # PostsController => "posts" is the namespace
+    def template_namespace
+      @controller.class.to_s.sub('Controller','').underscore.pluralize
+    end
+
+    # default options:
+    #   https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/renderer.rb#L41-L47
+    def renderer_options
+      options = {
+        # script_name: "", # unfortunately doesnt seem to effect relative_url_root like desired
+        # input: ""
+      }
+
+      origin = headers["origin"]
+      if origin
+        uri = URI.parse(origin)
+        options[:https] = uri.scheme == "https"
+      end
+
+      # Important to not use rack_headers as local variable instead of headers.
+      # headers is a method that gets deleted to controller.headers and using it
+      # seems to cause issues.
+      rack_headers = rackify_headers(headers)
+      options.merge!(rack_headers)
+
+      # Note @options[:method] uses @options vs options on purpose
+      @options[:method] = event["httpMethod"].downcase if event["httpMethod"]
+      options
+    end
+
+    # Takes headers and adds HTTP_ to front of the keys because that is what rack
+    # does to the headers passed from a request. This seems to be the standard
+    # when testing with curl and inspecting the headers in a Rack app.  Example:
+    # https://gist.github.com/tongueroo/94f22f6c261c8999e4f4f776547e2ee3
+    #
+    # This is useful for:
+    #
+    #   ActionController::Base.renderer.new(renderer_options)
+    #
+    # renderer_options are rack normalized headers.
+    #
+    # Example input (from api gateway)
+    #
+    #   {"host"=>"localhost:8888",
+    #   "user-agent"=>"curl/7.53.1",
+    #   "accept"=>"*/*",
+    #   "version"=>"HTTP/1.1",
+    #   "x-amzn-trace-id"=>"Root=1-5bde5b19-61d0d4ab4659144f8f69e38f"}
+    #
+    # Example output:
+    #
+    #   {"HTTP_HOST"=>"localhost:8888",
+    #   "HTTP_USER_AGENT"=>"curl/7.53.1",
+    #   "HTTP_ACCEPT"=>"*/*",
+    #   "HTTP_VERSION"=>"HTTP/1.1",
+    #   "HTTP_X_AMZN_TRACE_ID"=>"Root=1-5bde5b19-61d0d4ab4659144f8f69e38f"}
+    #
+    def rackify_headers(headers)
+      results = {}
+      headers.each do |k,v|
+        rack_key = 'HTTP_' + k.gsub('-','_').upcase
+        results[rack_key] = v
+      end
+      results
+    end
+
+    def render_options
+      # nomralize the template option
+      template = @options[:template]
+      if template and !template.include?('/')
+        template = "#{template_namespace}/#{template}"
+      end
+      template ||= default_template_name
+      # ready to override @options[:template]
+      @options[:template] = template if @options[:template]
+
+      render_options = {
+        template: template, # weird: template needs to be set no matter because it
+          # sets the name which is used in lookup_context.rb:209:in `normalize_name'
+        layout: @options[:layout],
+        assigns: controller_instance_variables,
+      }
+      types = %w[json inline plain file xml body action].map(&:to_sym)
+      types.each do |type|
+        render_options[type] = @options[type] if @options[type]
+      end
+
+      render_options
+    end
+
+    def controller_instance_variables
+      instance_vars = @controller.instance_variables.inject({}) do |vars, v|
+        k = v.to_s.sub(/^@/,'') # @var => var
+        vars[k] = @controller.instance_variable_get(v)
+        vars
+      end
+      instance_vars[:event] = event
+      instance_vars
+    end
+
+  private
+    # From jets/controller/response.rb
+    def drop_content_info?(status)
+      status.to_i / 100 == 1 or drop_body?(status)
+    end
+
+    DROP_BODY_RESPONSES = [204, 304]
+    def drop_body?(status)
+      DROP_BODY_RESPONSES.include?(status.to_i)
+    end
+
+    # maps:
+    #   :continue => 100
+    #   :success => 200
+    #   etc
+    def normalize_status_code(code)
+      status_code = if code.is_a?(Symbol)
+                      Rack::Utils::SYMBOL_TO_STATUS_CODE[code]
+                    else
+                      code
+                    end
+
+      # API Gateway requires status to be String but local rack is okay with either
+      # Note, ELB though requires status to be an Integer. We'll later in rack/adapter.rb
+      # adjust status to an Integer if request is coming from an ELB.
+      (status_code || 200).to_s
+    end
+
+    def set_content_type!(status, headers)
+      if drop_content_info?(status)
+        headers.delete "Content-Length"
+        headers.delete "Content-Type"
+      else
+        headers["Content-Type"] = @options[:content_type] ||
+                                  headers['content-type'] || # Mega Mode (Rails)
+                                  headers['Content-Type'] || # Just in case
+                                  Jets::Controller::DEFAULT_CONTENT_TYPE
+      end
+    end
+
+    def normalized_base64_option(options)
+      base64 = @options[:base64] if options.key?(:base64)
+      base64 = @options[:isBase64Encoded] if options.key?(:isBase64Encoded)
+      base64
+    end
+
+    class << self
+      def setup!
+        require "action_controller"
+        require "jets/overrides/rails"
+
+        # Load helpers
+        # Assign local variable because scope in the `:action_view do` block changes
+        app_helper_classes = find_app_helper_classes
+        ActiveSupport.on_load :action_view do
+          include ApplicationHelper # include first
+          app_helper_classes.each do |helper_class|
+            include helper_class
+          end
+        end
+
+        ActionController::Base.append_view_path("#{Jets.root}/app/views")
+        ActionView::Resolver.caching = !Jets.env.development?
+
+        setup_webpacker if Jets.webpacker?
+      end
+
+      # Does not include ApplicationHelper, will include ApplicationHelper explicitly first.
+      def find_app_helper_classes
+        internal_path = File.expand_path("../../internal", File.dirname(__FILE__))
+        internal_classes = find_app_helper_classes_from(internal_path)
+        app_classes = find_app_helper_classes_from(Jets.root)
+        (internal_classes + app_classes).uniq
+      end
+
+      def find_app_helper_classes_from(project_root)
+        klasses = []
+        expression = "#{project_root}/app/helpers/**/*"
+        Dir.glob(expression).each do |path|
+          next unless File.file?(path)
+          class_name = path.sub("#{project_root}/app/helpers/","").sub(/\.rb/,'')
+
+          unless class_name == "application_helper"
+            klasses << class_name.camelize.constantize # autoload
+          end
+        end
+        klasses
+      end
+
+      def setup_webpacker
+        require 'webpacker'
+        require 'webpacker/helper'
+
+        ActiveSupport.on_load :action_controller do
+          ActionController::Base.helper Webpacker::Helper
+        end
+
+        ActiveSupport.on_load :action_view do
+          include Webpacker::Helper
+        end
+      end
+    end
+  end
+end