jets_bb_fork 0.0.4

data/lib/jets/commands/webpacker_template.rb

@@ -0,0 +1,18 @@
+require 'thor'
+
+# These commands are ran after rake webpacker:install to enhance the generated
+# javascript assets to support Jets.
+# Done this way so it works for both jets new and jets webpacker:install
+class Jets::Commands::WebpackerTemplate < Thor::Group
+  include Thor::Actions
+
+  class_option :force, desc: "Bypass confirmation and overwrite existing files."
+  class_option :bootstrap, type: :boolean, default: true, desc: "Install bootstrap"
+  def self.source_root
+    File.expand_path("templates/webpacker", File.dirname(__FILE__))
+  end
+
+  def reapply_templates
+    directory "app/javascript", "app/javascript", force: options[:force]#, bootstrap: options[:bootstrap]
+  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/controller/base.rb

@@ -0,0 +1,108 @@
+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 Callbacks
+    include Cookies
+    include Layout
+    include Params
+    include Rendering
+    include ActiveSupport::Rescuable
+
+    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
+
+    def process!
+      adapter = Jets::Controller::Rack::Adapter.new(event, context, meth)
+      adapter.rack_vars(
+        'jets.controller' => self,
+        'lambda.context' => context,
+        'lambda.event' => event,
+        'lambda.meth' => meth,
+      )
+      # adapter.process ultimately calls app controller action at the very last
+      # middleware stack.
+      adapter.process # Returns API Gateway hash structure
+    end
+
+    def dispatch!
+      t1 = Time.now
+      log_info_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]
+      Jets.logger.info "Completed Status Code #{status} in #{took}s"
+      triplet # status, headers, body
+    end
+
+    def log_info_start
+      display_event = @event.dup
+      display_event['body'] = '[BASE64_ENCODED]' if @event['isBase64Encoded']
+      # 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 #{self.class.name}##{@meth}"
+      Jets.logger.info "  Event: #{json_dump(display_event)}"
+      Jets.logger.info "  Parameters: #{JSON.dump(params(raw: true).to_h)}"
+    end
+
+    # Handles binary data safely
+    def json_dump(data)
+      JSON.dump(data)
+    rescue Encoding::UndefinedConversionError
+      data['body'] = '[BINARY]'
+      JSON.dump(data)
+    end
+
+    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.
+      controller.send(:process!)
+    end
+
+    class_attribute :internal_controller
+    def self.internal(value=nil)
+      if !value.nil?
+        self.internal_controller = value
+      else
+        self.internal_controller
+      end
+    end
+
+    class_attribute :auth_type
+    def self.authorization_type(value=nil)
+      if !value.nil?
+        self.auth_type = value
+      else
+        self.auth_type
+      end
+    end
+  end
+end

data/lib/jets/controller/callbacks.rb

@@ -0,0 +1,68 @@
+# Simpified version of callbacks
+# Does not support if
+class Jets::Controller
+  module Callbacks
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :before_actions, default: []
+      class_attribute :after_actions, default: []
+
+      class << self
+        def before_action(meth, options={})
+          self.before_actions += [[meth, options]]
+        end
+
+        def prepend_before_action(meth, options={})
+          self.before_actions = [[meth, options]] + self.before_actions
+        end
+
+        def skip_before_action(meth)
+          self.before_actions = self.before_actions.reject { |el| el.first.to_s == meth.to_s }
+        end
+
+        alias_method :append_before_action, :before_action
+
+        def after_action(meth, options={})
+          self.after_actions += [[meth, options]]
+        end
+
+        def prepend_after_action(meth, options={})
+          self.after_actions = [[meth, options]] + self.after_actions
+        end
+
+        def skip_after_action(meth)
+          self.after_actions = self.after_actions.reject { |el| el.first.to_s == meth.to_s }
+        end
+
+        alias_method :append_after_action, :after_action
+      end
+    end # included
+
+    # Instance Methods
+    # define run_before_actions and run_after_actions
+    # returns true if all actions were run, false if break_if condition yielded `true`
+    [:before, :after].each do |type|
+      define_method "run_#{type}_actions" do |break_if: nil|
+        called_method = @meth.to_sym
+        callbacks = self.class.send("#{type}_actions")
+        callbacks.each do |array|
+          callback, options = array
+
+          except = options[:except]
+          next if except && except.include?(called_method)
+
+          only = options[:only]
+          if only
+            send(callback) if only.include?(called_method)
+          else
+            send(callback)
+          end
+          @last_callback_name = callback
+
+          return false if !break_if.nil? && break_if.call
+        end
+        true
+      end
+    end
+  end # ClassOptions
+end

data/lib/jets/controller/cookies.rb

@@ -0,0 +1,38 @@
+# 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/cookies/jar.rb

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