jets 4.0.8 → 5.0.0.beta1

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

@@ -0,0 +1,67 @@
+module Jets::Controller::Response::Compat
+  module Response
+    extend ActiveSupport::Concern
+
+    included do
+      # Must come before include ActionDispatch::Http::Cache::Response
+      # Aliasing these off because AD::Http::Cache::Response defines them.
+      alias :_cache_control :cache_control
+      alias :_cache_control= :cache_control=
+    end
+
+    class_methods do
+      cattr_accessor :default_charset, default: "utf-8"
+    end
+
+    ContentTypeHeader = Struct.new :mime_type, :charset
+    NullContentTypeHeader = ContentTypeHeader.new nil, nil
+
+    CONTENT_TYPE = "Content-Type"
+    CONTENT_TYPE_PARSER = /
+      \A
+      (?<mime_type>[^;\s]+\s*(?:;\s*(?:(?!charset)[^;\s])+)*)?
+      (?:;\s*charset=(?<quote>"?)(?<charset>[^;\s]+)\k<quote>)?
+    /x # :nodoc:
+
+    def parse_content_type(content_type)
+      if content_type && match = CONTENT_TYPE_PARSER.match(content_type)
+        ContentTypeHeader.new(match[:mime_type], match[:charset])
+      else
+        NullContentTypeHeader
+      end
+    end
+
+    # Small internal convenience method to get the parsed version of the current
+    # content type header.
+    def parsed_content_type_header
+      parse_content_type(get_header("Content-Type"))
+    end
+
+    def set_content_type(content_type, charset)
+      type = content_type || ""
+      type = "#{type}; charset=#{charset.to_s.downcase}" if charset
+      set_header CONTENT_TYPE, type
+    end
+
+    # Sets the HTTP character set. In case of +nil+ parameter
+    # it sets the charset to +default_charset+.
+    #
+    #   response.charset = 'utf-16' # => 'utf-16'
+    #   response.charset = nil      # => 'utf-8'
+    def charset=(charset)
+      content_type = parsed_content_type_header.mime_type
+      if false == charset
+        set_content_type content_type, nil
+      else
+        set_content_type content_type, charset || self.class.default_charset
+      end
+    end
+
+    # The charset of the response. HTML wants to know the encoding of the
+    # content you're giving them, so we need to send that along.
+    def charset
+      header_info = parsed_content_type_header
+      header_info.charset || self.class.default_charset
+    end
+  end
+end

data/lib/jets/controller/response.rb

@@ -1,21 +1,96 @@
+require 'action_dispatch/http/cache'
+require 'action_dispatch/http/filter_redirect'
+require 'monitor'
 require 'rack/response'
+require 'rack/utils'
 
-class Jets::Controller
+module Jets::Controller
   # The response object. See Rack::Response and Rack::Response::Helpers for
   # more info:
   # http://rubydoc.info/github/rack/rack/master/Rack/Response
   # http://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
   class Response < ::Rack::Response
-    DROP_BODY_RESPONSES = [204, 304]
+    include Compat::Response
+
+    include ActionDispatch::Http::FilterRedirect
+    include ActionDispatch::Http::Cache::Response
+    include MonitorMixin
+
+    attr_accessor :request
+
     def initialize(*)
       super
-      # headers['Content-Type'] ||= 'text/html'
+      prepare_cache_control!
+    end
+
+    # What Rack::Response#initialize does.
+    def body=(body)
+      if body.nil?
+        @body = []
+        @buffered = true
+        @length = 0
+      elsif body.respond_to?(:to_str)
+        @body = [body]
+        @buffered = true
+        @length = body.to_str.bytesize
+      else
+        @body = body
+        @buffered = false
+        @length = 0
+      end
+      @body
+    end
+
+    # Sets the HTTP status code.
+    def status=(status)
+      @status = Rack::Utils.status_code(status)
+    end
+
+    def to_a
+      commit!
+      rack_response status, headers.to_hash
+    end
+
+    def committed?; synchronize { @committed }; end
+    # sending? and send? are for compatibility but not used for Jets
+    def sending?;   synchronize { @sending };   end
+    def sent?;      synchronize { @sent };      end
+
+    def commit!
+      synchronize do
+        before_committed
+        @committed = true
+      end
     end
 
-    # TODO: unsure if we should even have these methods.  We dont really use them.
-    def body=(value)
-      value = value.body while Rack::Response === value
-      @body = String === value ? [value.to_str] : value
+    def before_committed
+      assign_default_content_type_and_charset!
+      merge_and_normalize_cache_control!(@cache_control)
+      handle_conditional_get!
+      handle_no_content!
+    end
+
+    def assign_default_content_type_and_charset!
+      return if media_type
+
+      ct = parsed_content_type_header
+      set_content_type(ct.mime_type || Mime[:html].to_s,
+                       ct.charset || self.class.default_charset)
+    end
+
+    def handle_no_content!
+      if NO_CONTENT_CODES.include?(@status)
+        headers.delete "Content-Length"
+      end
+    end
+
+    NO_CONTENT_CODES = [100, 101, 102, 103, 204, 205, 304]
+    def rack_response(status, header)
+      if NO_CONTENT_CODES.include?(status)
+        [status, header, []]
+      else
+        [status, header, body]
+      end
     end
 
     def each
@@ -44,7 +119,14 @@ class Jets::Controller
       [status.to_i, headers, result]
     end
 
-    private
+    # The response code of the request.
+    alias response_code status
+
+    def media_type
+      headers["Content-Type"]
+    end
+
+  private
 
     def calculate_content_length?
       headers["Content-Type"] and not headers["Content-Length"] and Array === body
@@ -54,6 +136,7 @@ class Jets::Controller
       status.to_i / 100 == 1 or drop_body?
     end
 
+    DROP_BODY_RESPONSES = [204, 304]
     def drop_body?
       DROP_BODY_RESPONSES.include?(status.to_i)
     end

data/lib/jets/core.rb

@@ -1,25 +1,28 @@
 module Jets::Core
   extend Memoist
 
-  def application
-    Jets::Application.instance
-  end
+  mattr_accessor :cache
 
-  def config
-    application.config
+  delegate :aws, :autoloaders, :config, to: :application
+
+  @application = @app_class = nil
+
+  attr_writer :application
+  attr_accessor :app_class
+  def application
+    @application ||= (app_class.instance if app_class)
   end
 
-  def aws
-    application.aws
+  def backtrace_cleaner
+    @backtrace_cleaner ||= Jets::BacktraceCleaner.new
   end
 
-  # Load all application base classes and project classes
-  def boot
-    Jets::Booter.boot!
+  # The Configuration instance used to configure the Rails environment
+  def configuration
+    application.config
   end
 
   def root
-    # Do not memoize this method. Turbo mode can change it
     root = ENV['JETS_ROOT'].to_s
     root = Dir.pwd if root == ''
     Pathname.new(root)
@@ -44,25 +47,78 @@ module Jets::Core
     extra
   end
 
-def build_root
-    "/tmp/jets/#{config.project_name}".freeze
+  def project_name
+    path = "config/project_name"
+    if ENV['JETS_PROJECT_NAME'] && !ENV['JETS_PROJECT_NAME'].blank?
+      ENV['JETS_PROJECT_NAME']
+    elsif File.exist?(path)
+      IO.read(path).strip
+    elsif parsed_project_name
+      parsed_project_name
+    else
+      Dir.pwd.split("/").last # conventionally infer app name from current directory
+    end
+  end
+
+  def project_namespace
+    [project_name, short_env, extra].compact.join('-').gsub('_','-')
+  end
+
+  def table_namespace
+    [project_name, short_env].compact.join('-')
+  end
+
+  ENV_MAP = {
+    development: 'dev',
+    production: 'prod',
+    staging: 'stag',
+  }
+  def short_env
+    ENV_MAP[Jets.env.to_sym] || Jets.env
+  end
+
+  # Double evaling config/application.rb causes subtle issues:
+  #   * double loading of shared resources: Jets::Stack.subclasses will have the same
+  #   class twice when config is called when declaring a function
+  #   * forces us to rescue all exceptions, which is a big hammer
+  #
+  # Lets parse for the project name instead for now.
+  #
+  # Keep for backwards compatibility
+  def parsed_project_name
+    lines = IO.readlines("#{Jets.root}/config/application.rb")
+    project_name_line = lines.find { |l| l =~ /config\.project_name.*=/ && l !~ /^\s+#/ }
+    project_name_line.gsub(/.*=/,'').strip.gsub(/["']/,'') if project_name_line
+  end
+  memoize :parsed_project_name
+
+  # Load all application base classes and project classes
+  def boot
+    Jets::Booter.boot!
+  end
+
+  def build_root
+    "/tmp/jets/#{Jets.project_name}".freeze
   end
   memoize :build_root
 
   def logger
-    Jets.application.config.logger
+    @logger
+  end
+
+  def logger=(logger)
+    @logger = logger
+  end
+
+  def deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
   end
-  memoize :logger
 
   def webpacker?
     Gem.loaded_specs.keys.any?{|k| k.start_with?("webpacker")}
   end
   memoize :webpacker?
 
-  def load_tasks
-    Jets::Commands::RakeTasks.load!
-  end
-
   def version
     Jets::VERSION
   end
@@ -87,32 +143,9 @@ def build_root
     @@prewarm_count
   end
 
-  def project_namespace
-    [config.project_name, config.short_env, config.extra].compact.join('-').gsub('_','-')
-  end
-
-  def rack?
-    path = "#{Jets.root}/rack"
-    File.exist?(path) || File.symlink?(path)
-  end
-
   def poly_only?
     return true if ENV['JETS_POLY_ONLY'] # bypass to allow rapid development of handlers
-    Jets::Commands::Build.poly_only?
-  end
-
-  def report_exception(exception)
-    puts "DEPRECATED: report_exception. Use on_exception instead.".color(:yellow)
-    on_exception(exception)
-  end
-
-  def on_exception(exception)
-    Jets::Turbine.subclasses.each do |subclass|
-      reporters = subclass.on_exceptions || []
-      reporters.each do |label, block|
-        block.call(exception)
-      end
-    end
+    Jets::Cfn::Builder.poly_only?
   end
 
   def custom_domain?
@@ -136,21 +169,14 @@ def build_root
   def once
     boot
     override_lambda_ruby_runtime
+    # require "jets/overrides/puma" # leaving around as a comment in case needed in the future
     tmp_load!
-    start_rack_server
   end
 
   def tmp_load!
     Jets::TmpLoader.load!
   end
 
-  # Megamode support
-  def start_rack_server(options={})
-    rack = Jets::RackServer.new(options)
-    rack.start
-    rack.wait_for_socket
-  end
-
   def override_lambda_ruby_runtime
     require "jets/overrides/lambda"
   end
@@ -166,4 +192,63 @@ def build_root
     version = RUBY_VERSION.split('.')[0..1].join('.')
     "ruby#{version}"
   end
+
+  def one_lambda_per_controller?
+    Jets.config.cfn.build.controllers == "one_lambda_per_controller"
+  end
+
+  def one_lambda_for_all_controllers?
+    Jets.config.cfn.build.controllers == "one_lambda_for_all_controllers"
+  end
+
+  # Do not memoize here. The JetsBucket.name does it's own special memoization.
+  def s3_bucket
+    Jets::Cfn::Resource::S3::JetsBucket.name
+  end
+
+  def report_exception(exception)
+    # See Jets::ExceptionReporting decorate_exception_with_exception_reported!
+    if exception.respond_to?(:with_exception_reported?) && exception.with_exception_reported?
+      return
+    end
+
+    Jets.application.turbines.each do |turbine|
+      turbine.on_exception_blocks.each do |block|
+        block.call(exception)
+      end
+    end
+  end
+
+  # Returns the ActiveSupport::ErrorReporter of the current \Jets project,
+  # otherwise it returns +nil+ if there is no project.
+  #
+  #   Jets.error.handle(IOError) do
+  #     # ...
+  #   end
+  #   Jets.error.report(error)
+  def error
+    application && application.executor.error_reporter
+    # ActiveSupport.error_reporter
+  end
+
+  # Returns a Pathname object of the public folder of the current
+  # \Jets project, otherwise it returns +nil+ if there is no project:
+  #
+  #   Jets.public_path
+  #     # => #<Pathname:/Users/someuser/some/path/project/public>
+  def public_path
+    application && Pathname.new(application.paths["public"].first)
+  end
+
+  def autoloaders
+    application.autoloaders
+  end
+
+  # It's useful to eager load and find out any error within the jets code immediately.
+  # Leaving in place because think the layer of protection is good.
+  # Eager load outside of a jets project can error. IE: `jets -h`
+  # Eager load inside a jets project is fine.
+  def eager_load_gem?
+    File.exist?("config/application.rb") || ENV['JETS_TEST'] || defined?(ENGINE_ROOT) # jets project
+  end
 end

data/lib/jets/core_ext/kernel.rb

@@ -5,8 +5,8 @@ module Kernel
   # @param path [String]
   # @return [Boolean]
   def require(path)
-    # Hack to prevent Rails const from being defined
-    # Actionview requires "rails-html-sanitizer" and that creates a Rails module
+    # Hack to prevent Jets const from being defined
+    # Actionview requires "jets-html-sanitizer" and that creates a Jets module
     path = "jets-html-sanitizer" if path == "rails-html-sanitizer" && !ENV['JETS_RAILS_CONST']
     jets_original_require(path)
   end

data/lib/jets/core_ext/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def camelize
+    to_s.camelize.to_sym
+  end
+end

data/lib/jets/core_ext.rb

@@ -0,0 +1,4 @@
+require "jets/core_ext/bundler"
+require "jets/core_ext/file"
+require "jets/core_ext/symbol"
+# Do not require jets/core_ext/kernel because it is a special case

data/lib/jets/dev_caching.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Jets
+  module DevCaching # :nodoc:
+    class << self
+      FILE = "tmp/caching-dev.txt"
+
+      def enable_by_file
+        FileUtils.mkdir_p("tmp")
+
+        if File.exist?(FILE)
+          delete_cache_file
+          puts "Development mode is no longer being cached."
+        else
+          create_cache_file
+          puts "Development mode is now being cached."
+        end
+
+        FileUtils.touch "tmp/restart.txt"
+      end
+
+      def enable_by_argument(caching)
+        FileUtils.mkdir_p("tmp")
+
+        if caching
+          create_cache_file
+        elsif caching == false && File.exist?(FILE)
+          delete_cache_file
+        end
+      end
+
+      private
+        def create_cache_file
+          FileUtils.touch FILE
+        end
+
+        def delete_cache_file
+          File.delete FILE
+        end
+    end
+  end
+end

data/lib/jets/dotenv/ssm.rb

@@ -49,11 +49,11 @@ class Jets::Dotenv
 
     def ssm_name(key, value)
       if value == "SSM"
-        "/#{Jets.config.project_name}/#{Jets.env}/#{key}"
+        "/#{Jets.project_name}/#{Jets.env}/#{key}"
       else
         value.start_with?("/") ?
           value :
-          "/#{Jets.config.project_name}/#{Jets.env}/#{value}"
+          "/#{Jets.project_name}/#{Jets.env}/#{value}"
       end
     end
 

data/lib/jets/dotenv.rb

@@ -16,12 +16,13 @@ class Jets::Dotenv
   end
 
   def on_aws?
+    return true if ENV['ON_AWS']
     !!ENV['_HANDLER'] # https://docs.aws.amazon.com/lambda/latest/dg/lambda-environment-variables.html
   end
 
   # dotenv files with the following precedence:
   #
-  # - .env.development.jets_env_extra (highest)
+  # - .env.development.jets_extra (highest)
   # - .env.development.remote (2nd highest, only if JETS_ENV_REMOTE=1)
   # - .env.development.local (unless JETS_ENV_REMOTE=1)
   # - .env.development

data/lib/jets/engine/configuration.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Jets
+  class Engine
+    class Configuration < ::Jets::Turbine::Configuration
+      attr_reader :root
+      attr_accessor :middleware, :javascript_path
+      attr_writer :eager_load_paths, :autoload_once_paths, :autoload_paths
+
+      def initialize(root = nil)
+        super()
+        @root = root
+        @generators = app_generators.dup
+        @middleware = Jets::Configuration::MiddlewareStackProxy.new
+        @javascript_path = "javascript"
+      end
+
+      # Holds generators configuration:
+      #
+      #   config.generators do |g|
+      #     g.orm             :data_mapper, migration: true
+      #     g.template_engine :haml
+      #     g.test_framework  :rspec
+      #   end
+      #
+      # If you want to disable color in console, do:
+      #
+      #   config.generators.colorize_logging = false
+      #
+      def generators
+        @generators ||= Jets::Configuration::Generators.new
+        yield(@generators) if block_given?
+        @generators
+      end
+
+      def paths
+        @paths ||= begin
+          paths = Jets::Paths::Root.new(@root)
+
+          paths.add "app",                 eager_load: true,
+                                            glob: "{*,*/concerns}",
+                                            exclude: ["assets", javascript_path]
+          paths.add "app/assets",          glob: "*"
+          paths.add "app/controllers",     eager_load: true
+          paths.add "app/channels",        eager_load: true
+          paths.add "app/helpers",         eager_load: true
+          paths.add "app/models",          eager_load: true
+          paths.add "app/mailers",         eager_load: true
+          paths.add "app/views"
+          # Jets
+          paths.add "app/functions",         ignore: true
+          paths.add "app/shared",            eager_load: false
+          paths.add "app/shared/extensions", collapse: true
+          paths.add "app/shared/functions",  ignore: true
+          paths.add "app/shared/resources",  collapse: true
+
+          paths.add "lib",                 load_path: true
+          paths.add "lib/assets",          glob: "*"
+          paths.add "lib/tasks",           glob: "**/*.rake"
+
+          paths.add "config"
+          paths.add "config/environments", glob: -"#{Jets.env}.rb"
+          paths.add "config/initializers", glob: "**/*.rb"
+          paths.add "config/locales",      glob: "**/*.{rb,yml}"
+          paths.add "config/routes.rb"
+          paths.add "config/routes",       glob: "**/*.rb"
+
+          paths.add "db"
+          paths.add "db/migrate"
+          paths.add "db/seeds.rb"
+
+          paths.add "vendor",              load_path: true
+          paths.add "vendor/assets",       glob: "*"
+
+          paths
+        end
+      end
+
+      def root=(value)
+        @root = paths.path = Pathname.new(value).expand_path
+      end
+
+      def eager_load_paths
+        @eager_load_paths ||= paths.eager_load
+      end
+
+      def autoload_once_paths
+        @autoload_once_paths ||= paths.autoload_once
+      end
+
+      def autoload_paths
+        @autoload_paths ||= paths.autoload_paths
+      end
+    end
+  end
+end

data/lib/jets/engine/turbines.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Jets
+  class Engine < Turbine
+    class Turbines
+      include Enumerable
+      attr_reader :_all
+
+      def initialize
+        @_all ||= ::Jets::Turbine.subclasses.map(&:instance) +
+          ::Jets::Engine.subclasses.map(&:instance)
+      end
+
+      def each(*args, &block)
+        _all.each(*args, &block)
+      end
+
+      def -(others)
+        _all - others
+      end
+    end
+  end
+end