jets 3.1.0 → 5.0.0

data/lib/jets/commands.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "jets/command"
+
+aliases = {
+  "g"  => "generate",
+  "c"  => "console",
+  "s"  => "server",
+  "db" => "dbconsole",
+  "r"  => "runner",
+  "t"  => "test"
+}
+
+command = ARGV.shift
+command = aliases[command] || command
+
+Jets::Command.invoke command, ARGV

data/lib/jets/configuration.rb

@@ -0,0 +1,166 @@
+# 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,195 +1,117 @@
+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.
-class Jets::Controller
-  class Base < Jets::Lambda::Functions
-    include ActiveSupport::Rescuable
-    include Authorization
-    include Callbacks
-    include Cookies
-    include ForgeryProtection
-    include Jets::Router::Helpers
-    include Layout
-    include Params
-    include Rendering
-
-    delegate :headers, to: :request
-    delegate :set_header, to: :response
-    attr_reader :request, :response
-    attr_accessor :session
-    def initialize(event, context={}, meth)
-      super
-      @request = Request.new(event, context)
-      @response = Response.new
-    end
-
-    # Overrides Base.process
-    def self.process(event, context={}, meth)
-      controller = new(event, context, meth)
-      # Using send because process! is private method in Jets::RackController so
-      # it doesnt create a lambda function.  It's doesnt matter what scope process!
-      # is in Controller::Base because Jets lambda functions inheritance doesnt
-      # include methods in Controller::Base.
-      # TODO: Can process! be a protected method to avoid this?
-      controller.send(:process!)
-    end
-
-    # One key difference between process! vs dispatch!
-    #
-    #    process! - takes the request through the middleware stack
-    #    dispatch! - does not
-    #
-    # Most of the time, you want process! instead of dispatch!
-    #
-    def process!
-      adapter = Jets::Controller::Rack::Adapter.new(event, context)
-      adapter.rack_vars(
-        'jets.controller' => self,
-        'lambda.context' => context,
-        'lambda.event' => event,
-        'lambda.meth' => meth,
-      )
-
-      # adapter.process calls
-      #
-      #     Jets.application.call(env)
-      #
-      # and that goes through the middleware stacks. The last middleware stack is Jets::Controller::Middleware::Main
-      #
-      #     class Jets::Controller::Middleware::Main
-      #       def call!
-      #         setup
-      #         @controller.dispatch! # Returns triplet
-      #       end
-      #     end
-      #
-      adapter.process # Returns API Gateway hash structure
-    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!
-      method_override!
-
-      t1 = Time.now
-      log_start
-
-      begin
-        if run_before_actions(break_if: -> { @rendered })
-          send(@meth)
-          action_completed = true
-        else
-          Jets.logger.info "Filter chain halted as #{@last_callback_name} rendered or redirected"
-        end
-
-        triplet = ensure_render
-        run_after_actions if action_completed
-      rescue Exception => exception
-        rescue_with_handler(exception) || raise
-        triplet = ensure_render
-      end
-
-      took = Time.now - t1
-      status = triplet[0]
-      log_finish(status: status, took: took)
-      triplet # status, headers, body
-    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 = "delete"
-      end
-    end
-
-    def processing_log
-      processing = "Processing #{self.class.name}##{@meth}"
-      processing << " (original method #{@original_meth})" if @original_meth
-      processing
-    end
-
-    # Documented interface method, careful not to rename
-    def log_start
-      # JSON.dump makes logging look pretty in CloudWatch logs because it keeps it on 1 line
-      ip = request.ip
-      Jets.logger.info "Started #{@event['httpMethod']} \"#{@event['path']}\" for #{ip} at #{Time.now}"
-      Jets.logger.info processing_log
-      Jets.logger.info "  Event: #{event_log}"
-      Jets.logger.info "  Parameters: #{JSON.dump(filtered_parameters.to_h)}"
-    end
-
-    # Documented interface method, careful not to rename
-    def log_finish(options={})
-      status, took = options[:status], options[:took]
-      Jets.logger.info "Completed Status Code #{status} in #{took}s"
-    end
-
-    def event_log
-      display_event = @event.dup
+module Jets::Controller
+  DEFAULT_CONTENT_TYPE = "text/html; charset=utf-8"
 
-      if @event['isBase64Encoded']
-        display_event['body'] = '[BASE64_ENCODED]'
-      else
-        display_event['body'] = parameter_filter.filter_json(display_event['body'])
-      end
+  class RoutingError < StandardError; end
 
-      display_event["queryStringParameters"] = parameter_filter.filter(display_event['queryStringParameters'])
-      display_event["pathParameters"] = parameter_filter.filter(display_event['pathParameters'])
-      json_dump(display_event)
+  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
 
-    # Handles binary data safely
-    def json_dump(data)
-      JSON.dump(data)
-    rescue Encoding::UndefinedConversionError
-      data['body'] = '[BINARY]'
-      JSON.dump(data)
-    end
+    abstract!
 
-    def controller_paths
-      paths = []
-      klass = self.class
-      while klass != Jets::Controller::Base
-        paths << klass.controller_path
-        klass = klass.superclass
-      end
-      paths
-    end
-
-    def controller_name
-      self.class.to_s.underscore
-    end
+    use_renderers :json, :js, :xml
+  end
 
-    def action_name
-      @meth
-    end
+  # See Jets::Controller::Compat::ActionController::Metal dispatch! method
 
-    class_attribute :internal_controller
-    class << self
-      def internal(value=nil)
-        if !value.nil?
-          self.internal_controller = value
-        else
-          self.internal_controller
-        end
-      end
-
-      def helper_method(*meths)
-        meths.each do |meth|
-          Jets::Router::Helpers.define_helper_method(meth)
-        end
-      end
-    end
-  end
+  ActiveSupport.run_load_hooks(:jets_controller, Base)
 end

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

@@ -0,0 +1,126 @@
+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