jets 4.0.8 → 5.0.0.beta1

data/lib/jets/controller/cookies.rb

@@ -1,38 +0,0 @@
-# Based on sinatra/cookies.rb
-# https://github.com/sinatra/sinatra/blob/master/sinatra-contrib/lib/sinatra/cookies.rb
-class Jets::Controller
-  # = Jets::Controller::Cookies
-  #
-  # Easy way to deal with cookies
-  #
-  # == Usage
-  #
-  # Allows you to read cookies:
-  #
-  #   def index
-  #     "value: #{cookies[:something]}"
-  #   end
-  #
-  # And of course to write cookies:
-  #
-  #   def show
-  #     cookies[:something] = 'foobar'
-  #     render json: cookies
-  #   end
-  #
-  # And generally behaves like a hash:
-  #
-  #   def index
-  #     cookies.merge! 'foo' => 'bar', 'bar' => 'baz'
-  #     cookies.keep_if { |key, value| key.start_with? 'b' }
-  #     foo, bar = cookies.values_at 'foo', 'bar'
-  #     puts "size: #{cookies.length}"
-  #     render json: cookies
-  #   end
-  #
-  module Cookies
-    def cookies
-      @cookies ||= Jar.new(self)
-    end
-  end
-end

data/lib/jets/controller/error/invalid_authenticity_token.rb

@@ -1,6 +0,0 @@
-class Jets::Controller
-  class Error
-    class InvalidAuthenticityToken < Error #:nodoc:
-    end
-  end
-end

data/lib/jets/controller/error.rb

@@ -1,4 +0,0 @@
-class Jets::Controller
-  class Error < RuntimeError #:nodoc:
-  end
-end

data/lib/jets/controller/forgery_protection.rb

@@ -1,43 +0,0 @@
-class Jets::Controller
-  module ForgeryProtection
-    extend ActiveSupport::Concern
-
-    included do
-      config = Jets.config
-      default_protect_from_forgery = config.dig(:controllers, :default_protect_from_forgery)
-      if default_protect_from_forgery.nil? && config.mode == "html" || default_protect_from_forgery # true
-        protect_from_forgery
-      end
-    end
-
-    class_methods do
-      def protect_from_forgery(options = {})
-        before_action :verify_authenticity_token, options
-      end
-
-      def skip_forgery_protection
-        skip_before_action :verify_authenticity_token
-      end
-
-      def forgery_protection_enabled?
-        # Example:
-        #
-        #    before_actions [[:verify_authenticity_token, {}], [:set_post, {:only=>[:show, :edit, :update, :delete]}
-        #
-        before_actions.map { |a| a[0] }.include?(:verify_authenticity_token)
-      end
-    end
-
-    # Instance methods
-    def verify_authenticity_token
-      return true if Jets.env.test? || request.get? || request.head?
-
-      token = session[:authenticity_token]
-      verified = !token.nil? && (token == params[:authenticity_token] || token == request.headers["x-csrf-token"])
-
-      unless verified
-        raise Error::InvalidAuthenticityToken
-      end
-    end
-  end
-end

data/lib/jets/controller/layout.rb

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

@@ -1,60 +0,0 @@
-# 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,Auth,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/mimic_aws_call.rb

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

@@ -1,22 +0,0 @@
-class Jets::Controller::Middleware::Local
-  class RouteMatcher
-    def initialize(env)
-      @env = env
-    end
-
-    def find_route
-      Jets::Router::Finder.new(path, method).run
-    end
-
-  private
-    attr_reader :env
-
-    def method
-      env["REQUEST_METHOD"] || "GET"
-    end
-
-    def path
-      env["PATH_INFO"].sub(/^\//,'')
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-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/parameters_filter.rb

@@ -1,29 +0,0 @@
-require "active_support/parameter_filter"
-
-class Jets::Controller
-  class ParametersFilter
-    attr_reader :filters, :params_filter
-
-    def initialize(filters)
-      @filters = filters
-      @params_filter = ActiveSupport::ParameterFilter.new(filters)
-    end
-
-    def filter(params)
-      params && params_filter.filter(params)
-    end
-
-    def filter_json(json_text)
-      return json_text if filters.blank? || json_text.blank?
-
-      begin
-        hash_params = JSON.parse(json_text)
-        filtered_params = filter(hash_params)
-        JSON.dump(filtered_params)
-      rescue JSON::ParserError
-        String.new
-      end
-    end
-
-  end
-end

data/lib/jets/controller/params.rb

@@ -1,117 +0,0 @@
-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)
-      params = {}
-      params = params.deep_merge(body_params) if body_parameters
-      params = params.deep_merge(unescape_recursively(query_params)) # 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 unescape_recursively(obj)
-      case obj
-      when Hash then obj.map { |k, v| [k, unescape_recursively(v)] }.to_h
-      when Array then obj.map { |v| unescape_recursively(v) }
-      else CGI.unescape(obj.to_s)
-      end
-    end
-
-    def filtered_parameters(**kwargs)
-      parameter_filter.filter params(**kwargs, raw: true) # Always filter raw hash
-    end
-
-    def path_params
-      path_params = event["pathParameters"] || {}
-      path_params = path_params.map { |k, path| [k, CGI.unescape(path)] }.to_h
-    end
-    alias_method :path_parameters, :path_params
-
-    def query_params
-      event["queryStringParameters"] || {}
-    end
-    alias_method :query_parameters, :query_params
-
-    def request_params
-      {
-        controller: controller_name,
-        action: action_name,
-      }
-    end
-    alias_method :request_parameters, :request_params
-
-    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
-    alias_method :body_parameters, :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
-
-    def parameter_filter
-      @parameter_filter ||= ParametersFilter.new Jets.config.controllers.filtered_parameters
-    end
-  end
-end

data/lib/jets/controller/redirection.rb

@@ -1,61 +0,0 @@
-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
-
-      redirect_url = add_stage(url)
-      redirect_url = ensure_protocol(redirect_url)
-
-      default = {
-        headers: { "Location" => redirect_url },
-        isBase64Encoded: false,
-      }
-      if request.xhr?
-        options[:content_type] ||= "application/json"
-        options[:status] ||= 200
-        options[:body] ||= JSON.dump(success: true, location: redirect_url)
-      else
-        options[:status] ||= 302
-        options[:body] ||= ""
-      end
-      Jets.logger.info("redirect_to options #{options}")
-      options = default.merge(options)
-
-      aws_proxy = Rendering::RackRenderer.new(self, options)
-      resp = aws_proxy.render
-      # redirect is a type of rendering
-      @rendered = true
-      @rendered_data = resp
-    end
-
-    def redirect_back(fallback_location: '/')
-      location = request.headers["referer"] || fallback_location
-      redirect_to(location)
-    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