jets 5.0.14 → 6.0.0.beta1

data/lib/jets/configuration.rb

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/ordered_options"
-require "active_support/core_ext/object"
-
-module Jets
-  module Configuration
-    # MiddlewareStackProxy is a proxy for the Jets middleware stack that allows
-    # you to configure middlewares in your application. It works basically as a
-    # command recorder, saving each command to be applied after initialization
-    # over the default middleware stack, so you can add, swap, or remove any
-    # middleware in Jets.
-    #
-    # You can add your own middlewares by using the +config.middleware.use+ method:
-    #
-    #     config.middleware.use Magical::Unicorns
-    #
-    # This will put the <tt>Magical::Unicorns</tt> middleware on the end of the stack.
-    # You can use +insert_before+ if you wish to add a middleware before another:
-    #
-    #     config.middleware.insert_before Rack::Head, Magical::Unicorns
-    #
-    # There's also +insert_after+ which will insert a middleware after another:
-    #
-    #     config.middleware.insert_after Rack::Head, Magical::Unicorns
-    #
-    # Middlewares can also be completely swapped out and replaced with others:
-    #
-    #     config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
-    #
-    # Middlewares can be moved from one place to another:
-    #
-    #     config.middleware.move_before ActionDispatch::Flash, Magical::Unicorns
-    #
-    # This will move the <tt>Magical::Unicorns</tt> middleware before the
-    # <tt>ActionDispatch::Flash</tt>. You can also move it after:
-    #
-    #     config.middleware.move_after ActionDispatch::Flash, Magical::Unicorns
-    #
-    # And finally they can also be removed from the stack completely:
-    #
-    #     config.middleware.delete ActionDispatch::Flash
-    #
-    class MiddlewareStackProxy
-      def initialize(operations = [], delete_operations = [])
-        @operations = operations
-        @delete_operations = delete_operations
-      end
-
-      def insert_before(...)
-        @operations << -> middleware { middleware.insert_before(...) }
-      end
-
-      alias :insert :insert_before
-
-      def insert_after(...)
-        @operations << -> middleware { middleware.insert_after(...) }
-      end
-
-      def swap(...)
-        @operations << -> middleware { middleware.swap(...) }
-      end
-
-      def use(...)
-        @operations << -> middleware { middleware.use(...) }
-      end
-
-      def delete(...)
-        @delete_operations << -> middleware { middleware.delete(...) }
-      end
-
-      def move_before(...)
-        @delete_operations << -> middleware { middleware.move_before(...) }
-      end
-
-      alias :move :move_before
-
-      def move_after(...)
-        @delete_operations << -> middleware { middleware.move_after(...) }
-      end
-
-      def unshift(...)
-        @operations << -> middleware { middleware.unshift(...) }
-      end
-
-      def merge_into(other) # :nodoc:
-        (@operations + @delete_operations).each do |operation|
-          operation.call(other)
-        end
-
-        other
-      end
-
-      def +(other) # :nodoc:
-        MiddlewareStackProxy.new(@operations + other.operations, @delete_operations + other.delete_operations)
-      end
-
-      protected
-        attr_reader :operations, :delete_operations
-    end
-
-    class Generators # :nodoc:
-      attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging, :api_only
-      attr_reader :hidden_namespaces, :after_generate_callbacks
-
-      def initialize
-        @aliases = Hash.new { |h, k| h[k] = {} }
-        @options = Hash.new { |h, k| h[k] = {} }
-        @fallbacks = {}
-        @templates = []
-        @colorize_logging = true
-        @api_only = false
-        @hidden_namespaces = []
-        @after_generate_callbacks = []
-      end
-
-      def initialize_copy(source)
-        @aliases = @aliases.deep_dup
-        @options = @options.deep_dup
-        @fallbacks = @fallbacks.deep_dup
-        @templates = @templates.dup
-      end
-
-      def hide_namespace(namespace)
-        @hidden_namespaces << namespace
-      end
-
-      def after_generate(&block)
-        @after_generate_callbacks << block
-      end
-
-      def method_missing(method, *args)
-        method = method.to_s.delete_suffix("=").to_sym
-
-        # Note: Using :rails because piggybacking off of rails generators
-        if args.empty?
-          if method == :rails
-            return @options[method]
-          else
-            return @options[:rails][method]
-          end
-        end
-
-        if method == :rails || args.first.is_a?(Hash)
-          namespace, configuration = method, args.shift
-        else
-          # Examples:
-          #   method :orm args [:active_record, {:migration=>true, :timestamps=>true}] @options {}
-          #   namespace :active_record
-          #   configuration {:migration=>true, :timestamps=>true}
-          namespace, configuration = args.shift, args.shift
-          namespace = namespace.to_sym if namespace.respond_to?(:to_sym)
-          @options[:rails][method] = namespace
-        end
-
-        if configuration
-          aliases = configuration.delete(:aliases)
-          @aliases[namespace].merge!(aliases) if aliases
-          @options[namespace].merge!(configuration)
-        end
-
-        # Example @options: {:rails=>{:orm=>:active_record}, :active_record=>{:migration=>true, :timestamps=>true}}
-      end
-    end
-  end
-end

data/lib/jets/controller/base.rb

@@ -1,117 +0,0 @@
-require "action_controller"
-require "action_controller/log_subscriber"
-require "active_support/concern"
-require "active_support/callbacks"
-require "abstract_controller/callbacks"
-require "json"
-require "rack/utils" # Rack::Utils.parse_nested_query
-
-# Controller public methods get turned into Lambda functions.
-module Jets::Controller
-  DEFAULT_CONTENT_TYPE = "text/html; charset=utf-8"
-
-  class RoutingError < StandardError; end
-
-  class Base < Jets::Lambda::Functions
-    # Make Jets controller "compatible" with Rails
-    # Note: Rolling include into a single Compat module causes naming conflicts with ActionController and AbstractController.
-    # So we include each module individually. It's clearer this way anyway.
-    include Compat::AbstractController::Base
-    include Compat::ActionController::Metal
-    include Compat::RouteSet
-    include Compat::Caching
-    include Compat::Future
-
-    # Order matters due to use of super and the module included chain.
-    include AbstractController::Rendering    # at top to normalize render options asap
-    include AbstractController::Translation
-    include AbstractController::AssetPaths
-
-    include ActionController::Helpers
-    include Jets::Router::Helpers::NamedRoutes
-
-    include ActionController::UrlFor      # includes ActionDispatch::Routing::UrlFor
-    include ActionController::Redirecting
-    include ActionView::Layouts           # includes ActionView::Rendering
-    include ActionController::Rendering
-    include ActionController::Renderers::All # for use_renderers :json, :js, :xml
-    include ActionController::ConditionalGet
-    include ActionController::EtagWithTemplateDigest
-    include ActionController::EtagWithFlash
-    include ActionController::Caching
-    include ActionController::MimeResponds
-    include ActionController::ImplicitRender # includes BasicImplicitRender action_controller/metal/basic_implicit_render.rb
-    include ActionController::StrongParameters
-    include ActionController::ParameterEncoding
-    include ActionController::Cookies
-    include ActionController::Flash
-    include ActionController::FormBuilder
-    include ActionController::RequestForgeryProtection
-    include ActionController::ContentSecurityPolicy
-    include ActionController::PermissionsPolicy
-    # include ActionController::Streaming       # not supported
-    # include ActionController::DataStreaming   # not supported
-    include ActionController::HttpAuthentication::Basic::ControllerMethods
-    include ActionController::HttpAuthentication::Digest::ControllerMethods
-    include ActionController::HttpAuthentication::Token::ControllerMethods
-    # include ActionController::DefaultHeaders  # not needed
-    include ActionController::Logging           # log_at: ability to change log level
-
-    # More Jets overrides and customizations
-    include Handler               # Lambda Handler process! method. Runs on AWS only.
-    include RackAdapter::Action   # action rack method
-
-    # Before callbacks should also be executed as early as possible, so
-    # also include them at the bottom.
-    include AbstractController::Callbacks
-
-    # Must near bottom because decorating Rails behavior
-    include Decorate::Authorization         # APIGW Authorizers
-    include Decorate::UrlFor                # add_apigw_stage
-    include Decorate::Redirecting           # add_apigw_stage
-    include Decorate::Logging
-
-    # Append rescue at the bottom to wrap as much as possible.
-    include ActionController::Rescue
-
-    # Add instrumentations hooks at the bottom, to ensure they instrument
-    # all the methods properly.
-    include ActionController::Instrumentation # TODO: figure why notifications dont work
-
-    # Params wrapper should come before instrumentation so they are
-    # properly showed in logs
-    include ActionController::ParamsWrapper
-
-    def initialize(event, context, meth, rack_env)
-      # Passing in rack env so the same rack env (same object id) is used.
-      # This is important for:
-      #  1. Constraints lambda procs
-      #  2. Controller.action rack methods
-      @event = event
-      @context = context
-      @meth = meth
-      @rack_env = rack_env
-      @_request = Jets::Controller::Request.new(event: event, rack_env: @rack_env)
-      # Note: Rails sets request.route in the Rails::Engine#build_request instead.
-      # The Jets request class is built slightly differently, so set it here.
-      # The request.routes method is need to that url_helpers work in generally.
-      # It's just how Rails ActionView implements url_helpers.
-      @_request.routes = self.class._routes
-      @_response = Jets::Controller::Response.new
-      @_response.request = @request
-      # Jets::Controller::Base#initialize interface is different than ActionController::Controller::Base.
-      # The super call goes to ActionController modules that can decorate and call super again.
-      # At the end of the module chain is Jets::Controller::Compat::ActionController::Metal#initialize
-      # which goes back to the original Jets::Lambda::Functions#initialize(event, context, meth) interface.
-      super() # ActionController::Base#initialize() interface
-    end
-
-    abstract!
-
-    use_renderers :json, :js, :xml
-  end
-
-  # See Jets::Controller::Compat::ActionController::Metal dispatch! method
-
-  ActiveSupport.run_load_hooks(:jets_controller, Base)
-end

data/lib/jets/controller/compat/abstract_controller/base.rb

@@ -1,126 +0,0 @@
-require "abstract_controller/error"
-require "active_support/configurable"
-require "active_support/descendants_tracker"
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/module/attr_internal"
-
-module Jets::Controller::Compat::AbstractController
-  module Base
-    extend ActiveSupport::Concern
-    include ActiveSupport::Configurable
-
-    delegate :action_methods,
-             :controller_name,
-             :controller_path,
-             to: :class
-    class_methods do
-      # A list of method names that should be considered actions. This
-      # includes all public instance methods on a controller, less
-      # any internal methods (see internal_methods), adding back in
-      # any methods that are internal, but still exist on the class
-      # itself.
-      #
-      # ==== Returns
-      # * <tt>Set</tt> - A set of all methods that should be considered actions.
-      def action_methods
-        @action_methods ||= begin
-          # All public instance methods of this class, including ancestors
-          methods = (public_instance_methods(true) -
-            # Except for public instance methods of Base and its ancestors
-            internal_methods +
-            # Be sure to include shadowed public instance methods of this class
-            public_instance_methods(false))
-
-          methods.map!(&:to_s)
-
-          methods.to_set
-        end
-      end
-
-        # A list of all internal methods for a controller. This finds the first
-      # abstract superclass of a controller, and gets a list of all public
-      # instance methods on that abstract class. Public instance methods of
-      # a controller would normally be considered action methods, so methods
-      # declared on abstract classes are being removed.
-      # (ActionController::Metal and ActionController::Base are defined as abstract)
-      def internal_methods
-        controller = self
-
-        controller = controller.superclass until controller.abstract?
-        controller.public_instance_methods(true)
-      end
-
-      def controller_name
-        @controller_name ||= name.demodulize.delete_suffix("Controller").underscore
-      end
-
-      def controller_path
-        @controller_path ||= name.delete_suffix("Controller").underscore
-      end
-
-      # Returns true if the given controller is capable of rendering
-      # a path. A subclass of +AbstractController::Base+
-      # may return false. An Email controller for example does not
-      # support paths, only full URLs.
-      def supports_path?
-        true
-      end
-    end
-
-    ##
-    # Returns the body of the HTTP response sent by the controller.
-    attr_internal :response_body
-
-    ##
-    # Returns the name of the action this controller is processing.
-    def action_name
-      @meth
-    end
-
-    def available_action?(action_name)
-      self.class.action_methods.include?(action_name.to_s)
-    end
-
-    # Tests if a response body is set. Used to determine if the
-    # +process_action+ callback needs to be terminated in
-    # AbstractController::Callbacks.
-    def performed?
-      if response_body.respond_to?(:each)
-        !response_body.compact.empty? # [""] is considered true
-      else # nil
-        !response_body.nil?
-      end
-    end
-
-    def inspect # :nodoc:
-      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
-    end
-
-  private
-    # Returns true if the name can be considered an action because
-    # it has a method defined in the controller.
-    #
-    # ==== Parameters
-    # * <tt>name</tt> - The name of an action to be tested
-    def action_method?(name)
-      self.class.action_methods.include?(name)
-    end
-
-    # Call the action. Override this in a subclass to modify the
-    # behavior around processing an action. This, and not #process,
-    # is the intended way to override action dispatching.
-    #
-    # Notice that the first argument is the method to be dispatched
-    # which is *not* necessarily the same as the action name.
-    def process_action
-      send_action(action_name) # to BasicImplicitRender#send_action => super (posts#index) or default_render
-    end
-
-    # Actually call the method associated with the action. Override
-    # this method if you wish to change how action methods are called,
-    # not to add additional behavior around it. For example, you would
-    # override #send_action if you want to inject arguments into the
-    # method.
-    alias send_action send
-  end
-end

data/lib/jets/controller/compat/action_controller/metal.rb

@@ -1,99 +0,0 @@
-module Jets::Controller::Compat::ActionController
-  module Metal
-    extend ActiveSupport::Concern
-
-    delegate :commit_flash,
-             :filtered_parameters,
-             :parameter_filter,
-             :params,
-             :reset_session,
-             :session,
-             :session=,
-             :_routes,
-             to: :request
-    delegate :content_type,
-             :content_type=,
-             :get_header,
-             :headers,
-             :location,
-             :location=,
-             :media_type,
-             :response_code,
-             :set_header,
-             :status,
-             :status=,
-             :to_a,
-             to: :response
-    attr_internal :request, :response
-
-    alias :response_code :status # :nodoc:
-
-    # End of the module include chain.
-    # Go back from the ActionController::Base#initialize() interface
-    # to the original Jets::Lambda::Functions#initialize(event, context, meth) interface
-    def initialize
-      super(@event, @context, @meth)
-    end
-
-    # One key difference between process! vs dispatch!
-    #
-    #    process! - takes the request through the middleware stack
-    #    dispatch! - does not
-    #
-    # dispatch! is useful for megamode or mounted applications
-    #
-    def dispatch!
-      # extend Jets.application.routes.url_helpers
-      # extend Blorgh::Engine.routes.url_helpers
-
-      # ActionView::Base.send :include, Jets.application.routes.url_helpers
-      # ActionView::Base.send :include, Blorgh::Engine.routes.url_helpers
-      # extend Jets.application.routes.mounted_helpers
-
-      method_override!
-      process_action
-      commit_flash
-      response.to_a
-    end
-
-    # Override @meth when POST with _method=delete
-    # By the time processing reaches dispatch which calls method_override!
-    # The Rack::MethodOverride middleware has overriden env['REQUEST_METHOD'] with DELETE
-    # and set env['rack.methodoverride.original_method']
-    def method_override!
-      env = request.env
-      if env['rack.methodoverride.original_method'] && env['REQUEST_METHOD'] == 'DELETE'
-        @original_meth = @meth
-        @meth = "destroy"
-      end
-    end
-
-    # Not using rack.response.body directly because its value is wrapped in an Array, IE: [body]
-    # and ActionController components check response_body assuming it can be nil or a String.
-    # So we assign the String at the controller.response_body level and [body] at the
-    # the Response#body= level.
-    def response_body=(body)
-      body = [body] unless body.nil? || body.respond_to?(:each)
-      return unless body
-      response.body = body
-      super
-    end
-
-    # Unsure how Rails defines this but this is the Rails behavior according to the Kingsman/Devise port
-    def response=(triplet)
-      if triplet.is_a?(Array)
-        status, headers, body = triplet
-        self.status = status
-        self.headers.merge!(headers)
-        self.response_body = body
-      else
-        self.response_body = triplet # string
-      end
-    end
-
-    # Tests if render or redirect has already happened.
-    def performed?
-      response_body || response.committed?
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Jets::Controller::Compat
-  # Got most from AbstractController::Caching and ActionController::Caching
-  module Caching
-    extend ActiveSupport::Concern
-
-    delegate :perform_caching, to: :class
-    class_methods do
-      def perform_caching
-        Jets.config.controller.perform_caching
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Jets::Controller::Compat
-  module Future
-    # raise_on_missing_callback_actions will be called in Rails 7.1
-    def raise_on_missing_callback_actions
-      puts <<~EOL
-        raise_on_missing_callback_actions called, Jets defaults to true so
-        when we upgrade to Rails 7.1 components it'll trigger and will
-        fix any issues. Also will need to make it configurable.
-      EOL
-      true
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module Jets::Controller::Compat
-  module RouteSet
-    # Override behavior from ActionDispatch::Routing::UrlFor
-    #
-    # When Jets include ActionDispatch::Routing::UrlFor is in the Jets::Controller::Base class
-    # It sets @_routes = nil
-    #
-    # We need to set @_routes to the Jets::Controller::Request routes object
-    # to provide a Jets custom routes object that's compatiable the Rails routes object.
-    #
-    # Why does @_routes have to be set?
-    #
-    # How this works is a bit hard to follow. Here's the current trace with actionpack 7.0.8
-    #
-    # Here's where controller render goes from controller-land to view-land.
-    #
-    #     action_controller/metal/rendering.rb:158:in `render_to_body'
-    #     action_view/rendering.rb:114:in `render_to_body'
-    #
-    # In action_view/rendering.rb render_to_body => _render_template is called and
-    # a view_context is created.
-    #
-    #     def view_context
-    #       view_context_class.new(lookup_context, view_assigns, self)
-    #     end
-    #
-    # self is the <PostsController>. The controller instance is the _routes is used.
-    # The view_context_class is somehow a wrapped anonymous class that has the
-    # ActionView::Base#initialize method.
-    #
-    # Usage:
-    #
-    #     module Jets::Controller
-    #       class Base < Jets::Lambda::Functions
-    #         ...
-    #         include Compat::RouteSet::ControllerPrepend
-    #         ...
-    #         include ActionController::UrlFor # includes ActionDispatch::Routing::UrlFor
-    #         ...
-    #         include Compat::RouteSet::ControllerAppend
-    #
-    def initialize(*)
-      @_routes = self.class._routes # set by inherited hook in JetsTurbines::RoutesHelpers.with
-      super
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-module Jets::Controller::Decorate
-  module ApigwStage
-    def add_apigw_stage(url)
-      return url unless add_apigw_stage?
-      stage_name = ENV['JETS_APIGW_STAGE'] || Jets::Cfn::Resource::ApiGateway::Deployment.stage_name
-      uri = URI.parse(url)
-      path = uri.path
-      original_ends_with_slash = path.ends_with?('/')
-      path = "/#{path}" unless path.starts_with?('/')
-      segments = path.split('/')
-      # unless to prevent stage name being added twice if url_for is called twice on the same string
-      segments.insert(1, stage_name) unless segments[1] == stage_name
-      new_path = segments.join('/') # modified path
-      new_path = "#{new_path}/" if !new_path.ends_with?('/') && original_ends_with_slash
-      uri.path = new_path
-      uri.to_s
-    end
-
-    def add_apigw_stage?
-      return true if ENV['JETS_APIGW_STAGE']
-      return false if ENV['JETS_TEST']
-      return false unless request # nil for `importmap json` cli and actionmailer
-
-      # Using request.host which might be different than event['headers']['Host'] when config.app.domain is set.
-      # This means that visiting the APIGW domain name directly will not prepend the stage name
-      # to the helper method urls.  This is ok since the APIGW domain name is not used in production.
-      # It's a compromise since we cannot pass the CloudFront host to APIGW.
-      # Rather have the CloudFront user-friendly domain name work than APIGW domain name.
-      # Examples:
-      #   https://djvojd3em5.execute-api.us-west-2.amazonaws.com/dev/
-      #   https://friendly.domain.com/
-      host = request.host
-      on_cloud9 = !!(host =~ /cloud9\..*\.amazonaws\.com/)
-      return false if on_cloud9
-
-      host.include?('amazonaws.com')
-    end
-  end
-end