jets.benforeva 3.0.17.pre.mount.pre.fix

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

@@ -0,0 +1,267 @@
+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
+
+      if drop_content_info?(status)
+        body = StringIO.new
+      else
+        # Rails rendering does heavy lifting
+        # _prefixes provided by jets/overrides/rails/action_controller.rb
+        ActionController::Base._prefixes = @controller.controller_paths
+        renderer = ActionController::Base.renderer.new(renderer_options)
+        clear_view_cache
+        body = renderer.render(render_options)
+        body = StringIO.new(body)
+      end
+
+      [status, headers, body] # triplet
+    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"]
+
+      # This is how we pass parameters to actionpack. IE: params to the view.
+      # This is because renderer_options is actually the env that is passed to the rack request.
+      options.merge!("action_dispatch.request.path_parameters" => @controller.path_parameters)
+      options.merge!("action_dispatch.request.query_parameters" => @controller.query_parameters)
+      options.merge!("action_dispatch.request.request_parameters" => @controller.request_parameters)
+      options
+    end
+
+    def render_options
+      # normalize 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,
+        # prefixes: ["posts"],
+      }
+      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
+
+    # 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
+    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
+
+    # Pass controller instance variables from jets-based controller to ActionView scope
+    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
+      # jets internal variables
+      # So ActionView has access back to the jets controller
+      instance_vars[:_jets] = { controller: @controller }
+      instance_vars
+    end
+
+    def clear_view_cache
+      ActionView::LookupContext::DetailsKey.clear if Jets.env.development?
+    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 Jets::Router::Helpers # internal routes helpers
+          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")
+
+        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

data/lib/jets/controller/rendering.rb

@@ -0,0 +1,96 @@
+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)
+      return if options.key?(:content_type)
+
+      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
+
+    # Example usage:
+    #
+    #   render json: {success: true, location: add_stage(posts_path)}
+    #
+    def add_stage(url)
+      return url unless actual_host
+
+      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 = Jets::Controller::Stage.add(actual_host, url)
+        actual_host + url
+      else
+        url
+      end
+    end
+
+    def url_for(url)
+      add_stage(url)
+    end
+
+    # Actual host can be headers["origin"] when cloudfront is in front.
+    # Remember to set custom header "origin" header in cloudfront distribution.
+    # Can also override with Jets.config.app.domain.
+    # The actual_host value is used by redirect_to.
+    def actual_host
+      Jets.config.app.domain || headers["origin"] || headers["host"]
+    end
+
+  end
+end

data/lib/jets/controller/request.rb

@@ -0,0 +1,29 @@
+require 'rack/request'
+
+class Jets::Controller
+  class Request < ::Rack::Request
+    def initialize(event, context)
+      @event, @context = event, context
+      super(env)
+    end
+
+    def env
+      @env ||= Jets::Controller::Rack::Env.new(@event, @context).convert # convert to Rack env
+    end
+
+    # When request hits the middleware Controller::Rack::Middleware::Main endpoint
+    # We set the it with the updated env since it could had been mutated down the
+    # middleware stack.
+    def set_env!(env)
+      @env = env
+    end
+
+    # API Gateway is inconsistent about how it cases it keys.
+    # Sometimes it is "x-requested-with" vs "X-Requested-With"
+    # Normalize it with downcase.
+    def headers
+      headers = @event["headers"] || {}
+      headers.transform_keys { |key| key.downcase }
+    end
+  end
+end

data/lib/jets/controller/response.rb

@@ -0,0 +1,61 @@
+require 'rack/response'
+
+class Jets::Controller
+  # The response object. See Rack::Response and Rack::Response::Helpers for
+  # more info:
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
+  class Response < ::Rack::Response
+    DROP_BODY_RESPONSES = [204, 304]
+    def initialize(*)
+      super
+      # headers['Content-Type'] ||= 'text/html'
+    end
+
+    # TODO: unsure if we should even have these methods.  We dont really use them.
+    def body=(value)
+      value = value.body while Rack::Response === value
+      @body = String === value ? [value.to_str] : value
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      result = body
+
+      if drop_content_info?
+        headers.delete "Content-Length"
+        headers.delete "Content-Type"
+      end
+
+      if drop_body?
+        close
+        result = []
+      end
+
+      if calculate_content_length?
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers["Content-Length"] = body.inject(0) { |l, p| l + p.bytesize }.to_s
+      end
+
+      [status.to_i, headers, result]
+    end
+
+    private
+
+    def calculate_content_length?
+      headers["Content-Type"] and not headers["Content-Length"] and Array === body
+    end
+
+    def drop_content_info?
+      status.to_i / 100 == 1 or drop_body?
+    end
+
+    def drop_body?
+      DROP_BODY_RESPONSES.include?(status.to_i)
+    end
+  end
+end

data/lib/jets/controller/stage.rb

@@ -0,0 +1,34 @@
+class Jets::Controller
+  class Stage
+    def initialize(host, url)
+      @host, @url = host, url
+    end
+
+    def add
+      return @url unless add_stage?
+
+      stage_name = Jets::Resource::ApiGateway::Deployment.stage_name
+      stage_name_with_slashes = "/#{stage_name}/" # use to prevent stage name being added twice if url_for is called twice on the same string
+      @url.include?(stage_name_with_slashes) ? @url : "/#{stage_name}#{@url}"
+    end
+
+    def add_stage?
+      return false if on_cloud9?
+      @host.include?("amazonaws.com") && @url.starts_with?('/')
+    end
+
+    def on_cloud9?
+      self.class.on_cloud9?(@host)
+    end
+
+    class << self
+      def add(host, url)
+        new(host, url).add
+      end
+
+      def on_cloud9?(host)
+        !!(host =~ /cloud9\..*\.amazonaws\.com/)
+      end
+    end
+  end
+end

data/lib/jets/controller.rb

@@ -0,0 +1,3 @@
+class Jets::Controller
+  DEFAULT_CONTENT_TYPE = "text/html; charset=utf-8"
+end

data/lib/jets/core.rb

@@ -0,0 +1,157 @@
+module Jets::Core
+  extend Memoist
+
+  def application
+    Jets::Application.instance
+  end
+
+  def config
+    application.config
+  end
+
+  def aws
+    application.aws
+  end
+
+  # Load all application base classes and project classes
+  def boot
+    Jets::Booter.boot!
+  end
+
+  def root
+    # Do not memoize this method. Turbo mode can change it
+    root = ENV['JETS_ROOT'].to_s
+    root = Dir.pwd if root == ''
+    Pathname.new(root)
+  end
+
+  def env
+    env = ENV['JETS_ENV'] || 'development'
+    ENV['RAILS_ENV'] = ENV['RACK_ENV'] = env
+    ActiveSupport::StringInquirer.new(env)
+  end
+  memoize :env
+
+  def build_root
+    "/tmp/jets/#{config.project_name}".freeze
+  end
+  memoize :build_root
+
+  def logger
+    Jets.application.config.logger
+  end
+  memoize :logger
+
+  def webpacker?
+    Gem.loaded_specs.keys.any?{|k| k.start_with?("webpacker")}
+  end
+  memoize :webpacker?
+
+  def load_tasks
+    Jets::Commands::RakeTasks.load!
+  end
+
+  def version
+    Jets::VERSION
+  end
+
+  # NOTE: In development this will always be 1 because the app gets reloaded.
+  # On AWS Lambda, this will be ever increasing until the container gets replaced.
+  @@call_count = 0
+  def increase_call_count
+    @@call_count += 1
+  end
+
+  def call_count
+    @@call_count
+  end
+
+  @@prewarm_count = 0
+  def increase_prewarm_count
+    @@prewarm_count += 1
+  end
+
+  def prewarm_count
+    @@prewarm_count
+  end
+
+  def project_namespace
+    [config.project_name, config.short_env, config.env_extra].compact.join('-').gsub('_','-')
+  end
+
+  def rack?
+    path = "#{Jets.root}/rack"
+    File.exist?(path) || File.symlink?(path)
+  end
+
+  def poly_only?
+    return true if ENV['JETS_POLY_ONLY'] # bypass to allow rapid development of handlers
+    Jets::Commands::Build.poly_only?
+  end
+
+  def report_exception(exception)
+    puts "DEPRECATED: report_exception. Use on_exception instead.".color(:yellow)
+    on_exception(exception)
+  end
+
+  def on_exception(exception)
+    Jets::Turbine.subclasses.each do |subclass|
+      reporters = subclass.on_exceptions || []
+      reporters.each do |label, block|
+        block.call(exception)
+      end
+    end
+  end
+
+  def custom_domain?
+    Jets.config.domain.hosted_zone_name
+  end
+
+  def s3_event?
+    !Jets::Job::Base.s3_events.empty?
+  end
+
+  def process(event, context, handler)
+    if event['_prewarm']
+      Jets.increase_prewarm_count
+      Jets.logger.info("Prewarm request")
+      {prewarmed_at: Time.now.to_s}
+    else
+      Jets::Processors::MainProcessor.new(event, context, handler).run
+    end
+  end
+
+  def once
+    boot
+    override_lambda_ruby_runtime
+    tmp_load!
+    start_rack_server
+  end
+
+  def tmp_load!
+    Jets::TmpLoader.load!
+  end
+
+  # Megamode support
+  def start_rack_server(options={})
+    rack = Jets::RackServer.new(options)
+    rack.start
+    rack.wait_for_socket
+  end
+
+  def override_lambda_ruby_runtime
+    require "jets/overrides/lambda"
+  end
+
+  def ruby_folder
+    RUBY_VERSION.split('.')[0..1].join('.') + '.0'
+  end
+
+  # used to configure internal lambda functions
+  # current ruby runtime that user is running
+  # IE: ruby2.5 ruby2.7
+  def ruby_runtime
+    version = RUBY_VERSION.split('.')[0..1].join('.')
+    "ruby#{version}"
+  end
+end

data/lib/jets/core_ext/bundler.rb

@@ -0,0 +1,7 @@
+# Bundler 2.0 does yet not have with_unbundled_env
+# Bundler 2.1 deprecates with_unbundled_env for with_unbundled_env
+
+require "bundler"
+def Bundler.with_unbundled_env(&block)
+  with_clean_env(&block)
+end unless Bundler.respond_to?(:with_unbundled_env)

data/lib/jets/core_ext/kernel.rb

@@ -0,0 +1,13 @@
+module Kernel
+  module_function
+
+  alias_method :jets_original_require, :require
+  # @param path [String]
+  # @return [Boolean]
+  def require(path)
+    # Hack to prevent Rails const from being defined
+    # Actionview requires "rails-html-sanitizer" and that creates a Rails module
+    path = "jets-html-sanitizer" if path == "rails-html-sanitizer" && !ENV['JETS_RAILS_CONST']
+    jets_original_require(path)
+  end
+end

data/lib/jets/db.rb

@@ -0,0 +1,15 @@
+module Jets::Db ; end
+
+# Thanks: https://makandracards.com/makandra/42521-detecting-if-a-ruby-gem-is-loaded
+if File.exist?("#{Jets.root}/config/database.yml")
+  require "active_record"
+  specs = Gem.loaded_specs
+  require "mysql2" if specs.key?('mysql2')
+  require "pg" if specs.key?('pg')
+end
+
+if File.exist?("#{Jets.root}/config/dynamodb.yml")
+  specs = Gem.loaded_specs
+  specs.key?('dynomite')
+  require "dynomite" if specs.key?('dynomite')
+end

data/lib/jets/dotenv/show.rb

@@ -0,0 +1,11 @@
+class Jets::Dotenv
+  class Show
+    def self.list
+      puts "# Env from evaluated dotenv files"
+      vars = Jets::Dotenv.load!
+      vars.each do |k,v|
+        puts "#{k}=#{v}"
+      end
+    end
+  end
+end