jets 4.0.17 → 5.0.0.beta1

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