jets 4.0.8 → 5.0.0.beta1

data/lib/jets/tasks/tmp.rake

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+namespace :tmp do
+  desc "Clear cache, socket and screenshot files from tmp/ (narrow w/ tmp:cache:clear, tmp:sockets:clear, tmp:screenshots:clear)"
+  task clear: ["tmp:cache:clear", "tmp:sockets:clear", "tmp:screenshots:clear", "tmp:storage:clear"]
+
+  tmp_dirs = [ "tmp/cache",
+               "tmp/sockets",
+               "tmp/pids",
+               "tmp/cache/assets" ]
+
+  tmp_dirs.each { |d| directory d }
+
+  desc "Creates tmp directories for cache, sockets, and pids"
+  task create: tmp_dirs
+
+  namespace :cache do
+    # desc "Clears all files and directories in tmp/cache"
+    task :clear do
+      rm_rf Dir["tmp/cache/[^.]*"], verbose: false
+    end
+  end
+
+  namespace :sockets do
+    # desc "Clears all files in tmp/sockets"
+    task :clear do
+      rm Dir["tmp/sockets/[^.]*"], verbose: false
+    end
+  end
+
+  namespace :pids do
+    # desc "Clears all files in tmp/pids"
+    task :clear do
+      rm Dir["tmp/pids/[^.]*"], verbose: false
+    end
+  end
+
+  namespace :screenshots do
+    # desc "Clears all files in tmp/screenshots"
+    task :clear do
+      rm Dir["tmp/screenshots/[^.]*"], verbose: false
+    end
+  end
+
+  namespace :storage do
+    # desc "Clear all files and directories in tmp/storage"
+    task :clear do
+      rm_rf Dir["tmp/storage/[^.]*"], verbose: false
+    end
+  end
+end

data/lib/jets/tasks/yarn.rake

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+namespace :yarn do
+  desc "Install all JavaScript dependencies as specified via Yarn"
+  task :install do
+    # Install only production deps when for not usual envs.
+    valid_node_envs = %w[test development production]
+    node_env = ENV.fetch("NODE_ENV") do
+      valid_node_envs.include?(Rails.env) ? Rails.env : "production"
+    end
+
+    yarn_flags =
+      if `yarn --version`.start_with?("1")
+        "--no-progress --frozen-lockfile"
+      else
+        "--immutable"
+      end
+
+    system(
+      { "NODE_ENV" => node_env },
+      "yarn install #{yarn_flags}",
+      exception: true
+    )
+  rescue Errno::ENOENT
+    $stderr.puts "yarn install failed to execute."
+    $stderr.puts "Ensure yarn is installed and `yarn --version` runs without errors."
+    exit 1
+  end
+end

data/lib/jets/tasks/zeitwerk.rake

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+eager_load = ->() do
+  puts "Hold on, I am eager loading the application."
+  Zeitwerk::Loader.eager_load_all
+end
+
+report_not_checked = ->(not_checked) do
+  puts
+  puts <<~EOS
+    WARNING: The following directories will only be checked if you configure
+    them to be eager loaded:
+  EOS
+  puts
+
+  not_checked.each { |dir| puts "  #{dir}" }
+  puts
+
+  puts <<~EOS
+    You may verify them manually, or add them to config.eager_load_paths
+    in config/application.rb and run zeitwerk:check again.
+  EOS
+  puts
+end
+
+report = ->(not_checked) do
+  if not_checked.any?
+    report_not_checked[not_checked]
+    puts "Otherwise, all is good!"
+  else
+    puts "All is good!"
+  end
+end
+
+namespace :zeitwerk do
+  desc "Checks project structure for Zeitwerk compatibility"
+  task check: :environment do
+    begin
+      eager_load[]
+    rescue NameError => e
+      if e.message =~ /expected file .*? to define constant [\w:]+/
+        abort $&.sub(/expected file #{Regexp.escape(Jets.root.to_s)}./, "expected file ")
+      else
+        raise
+      end
+    end
+
+    require "active_support/core_ext/object/try"
+    eager_load_paths = Jets.configuration.eager_load_namespaces.filter_map do |eln|
+      # Quick regression fix for 6.0.3 to support namespaces that do not have
+      # eager load paths, like the recently added i18n. I'll rewrite this task.
+      eln.try(:config).try(:eager_load_paths)
+    end.flatten
+
+    not_checked = ActiveSupport::Dependencies.autoload_paths - eager_load_paths
+    not_checked.select! { |dir| Dir.exist?(dir) }
+    not_checked.reject! { |dir| Dir.empty?(dir) }
+
+    report[not_checked]
+  end
+end

data/lib/jets/tasks.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "rake"
+
+# Load Jets Rakefile extensions
+%w(
+  framework
+  log
+  middleware
+  misc
+  tmp
+  yarn
+  zeitwerk
+).tap { |arr|
+  arr << "statistics" if Rake.application.current_scope.empty?
+}.each do |task|
+  load "jets/tasks/#{task}.rake"
+end

data/lib/jets/turbine/configurable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Jets
+  class Turbine
+    module Configurable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        delegate :config, to: :instance
+
+        def inherited(base)
+          raise "You cannot inherit from a #{superclass.name} child"
+        end
+
+        def instance
+          @instance ||= new
+        end
+
+        def respond_to?(*args)
+          super || instance.respond_to?(*args)
+        end
+
+        def configure(&block)
+          class_eval(&block)
+        end
+
+        private
+          def method_missing(*args, &block)
+            instance.send(*args, &block)
+          end
+      end
+    end
+  end
+end

data/lib/jets/turbine/configuration.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "jets/configuration"
+
+module Jets
+  class Turbine
+    class Configuration
+      def initialize
+        @@options ||= {}
+      end
+
+      # Expose the eager_load_namespaces at "module" level for convenience.
+      def self.eager_load_namespaces # :nodoc:
+        @@eager_load_namespaces ||= []
+      end
+
+      # All namespaces that are eager loaded
+      def eager_load_namespaces
+        @@eager_load_namespaces ||= []
+      end
+
+      # Add files that should be watched for change.
+      def watchable_files
+        @@watchable_files ||= []
+      end
+
+      # Add directories that should be watched for change.
+      # The key of the hashes should be directories and the values should
+      # be an array of extensions to match in each directory.
+      def watchable_dirs
+        @@watchable_dirs ||= {}
+      end
+
+      # This allows you to modify the application's middlewares from Engines.
+      #
+      # All operations you run on the app_middleware will be replayed on the
+      # application once it is defined and the default_middlewares are
+      # created
+      def app_middleware
+        @@app_middleware ||= Jets::Configuration::MiddlewareStackProxy.new
+      end
+
+      # This allows you to modify application's generators from Turbines.
+      #
+      # Values set on app_generators will become defaults for application, unless
+      # application overwrites them.
+      def app_generators
+        @@app_generators ||= Jets::Configuration::Generators.new
+        yield(@@app_generators) if block_given?
+        @@app_generators
+      end
+
+      # First configurable block to run. Called before any initializers are run.
+      def before_configuration(&block)
+        ActiveSupport.on_load(:before_configuration, yield: true, &block)
+      end
+
+      # Third configurable block to run. Does not run if +config.eager_load+
+      # set to false.
+      def before_eager_load(&block)
+        ActiveSupport.on_load(:before_eager_load, yield: true, &block)
+      end
+
+      # Second configurable block to run. Called before frameworks initialize.
+      def before_initialize(&block)
+        ActiveSupport.on_load(:before_initialize, yield: true, &block)
+      end
+
+      # Last configurable block to run. Called after frameworks initialize.
+      def after_initialize(&block)
+        ActiveSupport.on_load(:after_initialize, yield: true, &block)
+      end
+
+      # Array of callbacks defined by #to_prepare.
+      def to_prepare_blocks
+        @@to_prepare_blocks ||= []
+      end
+
+      # Defines generic callbacks to run before #after_initialize. Useful for
+      # Jets::Turbine subclasses.
+      def to_prepare(&blk)
+        to_prepare_blocks << blk if blk
+      end
+
+      def respond_to?(name, include_private = false)
+        super || @@options.key?(name.to_sym)
+      end
+
+    private
+      def method_missing(name, *args, &blk)
+        if name.end_with?("=")
+          @@options[:"#{name[0..-2]}"] = args.first
+        elsif @@options.key?(name)
+          @@options[name]
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/jets/turbine.rb

@@ -1,41 +1,185 @@
+# frozen_string_literal: true
+
+require "active_support/descendants_tracker"
+require "active_support/inflector"
+require "active_support/core_ext/module/introspection"
+require "active_support/core_ext/module/delegation"
+
 module Jets
   class Turbine
-    class_attribute :after_initializers
-    class_attribute :initializers
-    class_attribute :on_exceptions
+    extend ActiveSupport::DescendantsTracker
+    include Initializable
+
+    ABSTRACT_TURBINES = %w(Jets::Turbine Jets::Engine Jets::Application)
 
     class << self
+      private :new
+      delegate :config, to: :instance
+
       def subclasses
-        @subclasses ||= []
+        super.reject(&:abstract_turbine?).sort
       end
 
-      def inherited(base)
-        subclasses << base
+      def rake_tasks(&blk)
+        register_block_for(:rake_tasks, &blk)
       end
 
-      def after_initializer(label, &block)
-        self.after_initializers ||= {}
-        self.after_initializers[label] = block
+      def console(&blk)
+        register_block_for(:load_console, &blk)
       end
 
-      def initializer(label, &block)
-        self.initializers ||= {}
-        self.initializers[label] = block
+      def runner(&blk)
+        register_block_for(:runner, &blk)
       end
 
-      def on_exception(label, &block)
-        self.on_exceptions ||= {}
-        self.on_exceptions[label] = block
+      def generators(&blk)
+        register_block_for(:generators, &blk)
       end
 
-      def exception_reporter(label, &block)
-        on_exception(label, &block)
+      def server(&blk)
+        register_block_for(:server, &blk)
       end
 
-      # Make config available in Turbine. Note only available outside of hooks like initializers.
-      def config
-        Jets.application.config
+      # Jets specific. The label is no longer used and kept for backwards compatibility.
+      # Note it uses the same register_block_for but works a bit differently.
+      # See on_exception_blocks method to see how it works.
+      def on_exception(label, &blk)
+        register_block_for(:on_exception, &blk)
       end
+
+      def abstract_turbine?
+        ABSTRACT_TURBINES.include?(name)
+      end
+
+      def turbine_name(name = nil)
+        @turbine_name = name.to_s if name
+        @turbine_name ||= generate_turbine_name(self.name)
+      end
+
+      # Since Jets::Turbine cannot be instantiated, any methods that call
+      # +instance+ are intended to be called only on subclasses of a Turbine.
+      def instance
+        @instance ||= new
+      end
+
+      # Allows you to configure the turbine. This is the same method seen in
+      # Turbine::Configurable, but this module is no longer required for all
+      # subclasses of Turbine so we provide the class method here.
+      def configure(&block)
+        instance.configure(&block)
+      end
+
+      def <=>(other) # :nodoc:
+        load_index <=> other.load_index
+      end
+
+      def inherited(subclass)
+        subclass.increment_load_index
+        super
+      end
+
+      protected
+        attr_reader :load_index
+
+        def increment_load_index
+          @@load_counter ||= 0
+          @load_index = (@@load_counter += 1)
+        end
+
+      private
+        def generate_turbine_name(string)
+          ActiveSupport::Inflector.underscore(string).tr("/", "_")
+        end
+
+        def respond_to_missing?(name, _)
+          return super if abstract_turbine?
+
+          instance.respond_to?(name) || super
+        end
+
+        # If the class method does not have a method, then send the method call
+        # to the Turbine instance.
+        def method_missing(name, *args, &block)
+          if !abstract_turbine? && instance.respond_to?(name)
+            instance.public_send(name, *args, &block)
+          else
+            super
+          end
+        end
+        ruby2_keywords(:method_missing)
+
+        # receives an instance variable identifier, set the variable value if is
+        # blank and append given block to value, which will be used later in
+        # `#each_registered_block(type, &block)`
+        def register_block_for(type, &blk)
+          var_name = "@#{type}"
+          blocks = instance_variable_defined?(var_name) ? instance_variable_get(var_name) : instance_variable_set(var_name, [])
+          blocks << blk if blk
+          blocks
+        end
     end
+
+    delegate :turbine_name, to: :class
+
+    def initialize # :nodoc:
+      if self.class.abstract_turbine?
+        raise "#{self.class.name} is abstract, you cannot instantiate it directly."
+      end
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}>"
+    end
+
+    def configure(&block) # :nodoc:
+      instance_eval(&block)
+    end
+
+    # This is used to create the <tt>config</tt> object on Turbines, an instance of
+    # Turbine::Configuration, that is used by Turbines and Application to store
+    # related configuration.
+    def config
+      @config ||= Turbine::Configuration.new
+    end
+
+    def turbine_namespace # :nodoc:
+      @turbine_namespace ||= self.class.module_parents.detect { |n| n.respond_to?(:turbine_namespace) }
+    end
+
+    def on_exception_blocks
+      self.class.instance_variable_get(:@on_exception) || []
+    end
+
+    protected
+      def run_console_blocks(app) # :nodoc:
+        each_registered_block(:console) { |block| block.call(app) }
+      end
+
+      def run_generators_blocks(app) # :nodoc:
+        each_registered_block(:generators) { |block| block.call(app) }
+      end
+
+      def run_runner_blocks(app) # :nodoc:
+        each_registered_block(:runner) { |block| block.call(app) }
+      end
+
+      def run_tasks_blocks(app) # :nodoc:
+        extend Rake::DSL
+        each_registered_block(:rake_tasks) { |block| instance_exec(app, &block) }
+      end
+
+      def run_server_blocks(app) # :nodoc:
+        each_registered_block(:server) { |block| block.call(app) }
+      end
+
+    private
+      # run `&block` in every registered block in `#register_block_for`
+      def each_registered_block(type, &block)
+        klass = self.class
+        while klass.respond_to?(type)
+          klass.public_send(type).each(&block)
+          klass = klass.superclass
+        end
+      end
   end
 end

data/lib/jets/util/camelize.rb

@@ -0,0 +1,24 @@
+class Jets::Util
+  module Camelize
+    # Not named camelize! because it conflicts with zeitwerk's camelize!
+    def camelize(object)
+      result = case object
+      when Array
+        object.map { |o| camelize(o) }
+      when Hash
+        Jets::Camelizer.transform(object).deep_symbolize_keys
+      else
+        object
+      end
+
+      case object
+      when Symbol
+        object
+      when NilClass
+        nil
+      else
+        object.replace(result)
+      end
+    end
+  end
+end

data/lib/jets/version.rb

@@ -1,3 +1,3 @@
 module Jets
-  VERSION = "4.0.8"
+  VERSION = "5.0.0.beta1"
 end

data/lib/jets.rb

@@ -1,14 +1,6 @@
 $stdout.sync = true unless ENV["JETS_STDOUT_SYNC"] == "0"
-
 $:.unshift(File.expand_path("../", __FILE__))
 
-require "jets/core_ext/bundler"
-require "jets/core_ext/file"
-require "jets/autoloaders"
-Jets::Autoloaders.log! if ENV["JETS_AUTOLOAD_LOG"]
-Jets::Autoloaders.once.setup # must be called before cli.setup
-Jets::Autoloaders.cli.setup
-
 require "active_support"
 require "active_support/concern"
 require "active_support/core_ext"
@@ -21,16 +13,16 @@ require "fileutils"
 require "json"
 require "memoist"
 require "rainbow/ext/string"
-require "serverlessgems"
+require "jets-api"
 
-module Jets
-  MAX_FUNCTION_NAME_SIZE = 64
+require "jets/core_ext"
+require "jets/autoloaders"
+loader = Jets::Autoloaders.for_gem
+loader.setup
 
+module Jets
   class Error < StandardError; end
   extend Core # root, logger, etc
 end
 
-# required for booter.rb: setup_db
-Jets::Autoloaders.once.on_setup do
-  Jets::Db
-end
+loader.eager_load if Jets.eager_load_gem?