jets 3.1.0 → 5.0.0

data/lib/jets/controller/cookies/jar.rb

@@ -1,269 +0,0 @@
-# Based on sinatra/cookies.rb
-# https://github.com/sinatra/sinatra/blob/master/sinatra-contrib/lib/sinatra/cookies.rb
-module Jets::Controller::Cookies
-  class Jar
-    include Enumerable
-    attr_reader :options
-
-    def initialize(controller)
-      @response_string = nil
-      @response_hash   = {}
-      @response        = controller.response
-      @request         = controller.request
-      @deleted         = []
-
-      @options = {
-        path: @request.script_name.to_s.empty? ? '/' : @request.script_name,
-        domain: @request.host == 'localhost' ? nil : @request.host,
-        secure: @request.ssl?,
-        httponly: true
-      }
-    end
-
-    def ==(other)
-      other.respond_to? :to_hash and to_hash == other.to_hash
-    end
-
-    def [](key)
-      response_cookies[key.to_s] || request_cookies[key.to_s]
-    end
-
-    def []=(key, value)
-      set(key, value: value)
-    end
-
-    def assoc(key)
-      to_hash.assoc(key.to_s)
-    end if Hash.method_defined? :assoc
-
-    def clear
-      each_key { |k| delete(k) }
-    end
-
-    def compare_by_identity?
-      false
-    end
-
-    def default
-      nil
-    end
-
-    alias default_proc default
-
-    def delete(key)
-      result = self[key]
-      @response.delete_cookie(key.to_s, @options)
-      result
-    end
-
-    def delete_if
-      return enum_for(__method__) unless block_given?
-      each { |k, v| delete(k) if yield(k, v) }
-      self
-    end
-
-    def each(&block)
-      return enum_for(__method__) unless block_given?
-      to_hash.each(&block)
-    end
-
-    def each_key(&block)
-      return enum_for(__method__) unless block_given?
-      to_hash.each_key(&block)
-    end
-
-    alias each_pair each
-
-    def each_value(&block)
-      return enum_for(__method__) unless block_given?
-      to_hash.each_value(&block)
-    end
-
-    def empty?
-      to_hash.empty?
-    end
-
-    def fetch(key, &block)
-      response_cookies.fetch(key.to_s) do
-        request_cookies.fetch(key.to_s, &block)
-      end
-    end
-
-    def flatten
-      to_hash.flatten
-    end if Hash.method_defined? :flatten
-
-    def has_key?(key)
-      response_cookies.has_key? key.to_s or request_cookies.has_key? key.to_s
-    end
-
-    def has_value?(value)
-      response_cookies.has_value? value or request_cookies.has_value? value
-    end
-
-    def hash
-      to_hash.hash
-    end
-
-    alias include? has_key?
-    alias member?  has_key?
-
-    def index(value)
-      warn "Hash#index is deprecated; use Hash#key"
-      key(value)
-    end
-
-    def inspect
-      "<##{self.class}: #{to_hash.inspect[1..-2]}>"
-    end
-
-    def invert
-      to_hash.invert
-    end if Hash.method_defined? :invert
-
-    def keep_if
-      return enum_for(__method__) unless block_given?
-      delete_if { |*a| not yield(*a) }
-    end
-
-    def key(value)
-      to_hash.key(value)
-    end
-
-    alias key? has_key?
-
-    def keys
-      to_hash.keys
-    end
-
-    def length
-      to_hash.length
-    end
-
-    def merge(other, &block)
-      to_hash.merge(other, &block)
-    end
-
-    def merge!(other)
-      other.each_pair do |key, value|
-        if block_given? and include? key
-          self[key] = yield(key.to_s, self[key], value)
-        else
-          self[key] = value
-        end
-      end
-    end
-
-    def rassoc(value)
-      to_hash.rassoc(value)
-    end
-
-    def rehash
-      response_cookies.rehash
-      request_cookies.rehash
-      self
-    end
-
-    def reject(&block)
-      return enum_for(__method__) unless block_given?
-      to_hash.reject(&block)
-    end
-
-    alias reject! delete_if
-
-    def replace(other)
-      select! { |k, v| other.include?(k) or other.include?(k.to_s)  }
-      merge! other
-    end
-
-    def select(&block)
-      return enum_for(__method__) unless block_given?
-      to_hash.select(&block)
-    end
-
-    alias select! keep_if if Hash.method_defined? :select!
-
-    def set(key, options = {})
-      @response.set_cookie key.to_s, @options.merge(options)
-    end
-
-    def shift
-      key, value = to_hash.shift
-      delete(key)
-      [key, value]
-    end
-
-    alias size length
-
-    def sort(&block)
-      to_hash.sort(&block)
-    end if Hash.method_defined? :sort
-
-    alias store []=
-
-    def to_hash
-      request_cookies.merge(response_cookies)
-    end
-
-    def to_a
-      to_hash.to_a
-    end
-
-    def to_s
-      to_hash.to_s
-    end
-
-    alias update merge!
-    alias value? has_value?
-
-    def values
-      to_hash.values
-    end
-
-    def values_at(*list)
-      list.map { |k| self[k] }
-    end
-
-    private
-
-    def warn(message)
-      super "#{caller.first[/^[^:]:\d+:/]} warning: #{message}"
-    end
-
-    def deleted
-      parse_response
-      @deleted
-    end
-
-    def response_cookies
-      parse_response
-      @response_hash
-    end
-
-    def parse_response
-      string = @response.headers['Set-Cookie']
-      return if @response_string == string
-
-      hash = {}
-
-      string.each_line do |line|
-        key, value = line.split(';', 2).first.to_s.split('=', 2)
-        next if key.nil?
-        key = Rack::Utils.unescape(key)
-        if line =~ /expires=Thu, 01[-\s]Jan[-\s]1970/
-          @deleted << key
-        else
-          @deleted.delete key
-          hash[key] = value
-        end
-      end
-
-      @response_hash.replace hash
-      @response_string = string
-    end
-
-    def request_cookies
-      @request.cookies.reject { |key, value| deleted.include? key }
-    end
-  end
-end

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