jets 5.0.14 → 6.0.0.beta1

data/lib/jets/tasks/zeitwerk.rake

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

@@ -1,18 +0,0 @@
-# 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/tmp_loader.rb

@@ -1,53 +0,0 @@
-module Jets
-  class TmpLoader
-    include AwsServices
-
-    def self.load!
-      new.load
-    end
-
-    def initialize(yaml_path=nil)
-      yaml_path ||= "#{Jets.root}/handlers/data.yml"
-      return unless File.exist?(yaml_path)
-      @data = Jets::Util::Yamler.load_file(yaml_path)
-      @s3_bucket = @data['s3_bucket']
-      @rack_zip = @data['rack_zip']
-    end
-
-    def load
-      rack
-    end
-
-    def rack
-      return unless @rack_zip
-      download_and_extract(@rack_zip, '/tmp/rack')
-    end
-
-    def download_and_extract(zip_file, folder_dest)
-      s3_key = "jets/code/#{zip_file}" # jets/code/rack-checksum.zip
-      download_path = "/tmp/#{zip_file}" # /tmp/rack-checksum.zip
-
-      download(s3_key, download_path)
-      unzip(download_path, folder_dest)
-    end
-
-    def download(key, dest)
-      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#get_object-instance_method
-      # stream object directly to disk
-      s3.get_object(response_target: dest,
-                    bucket: @s3_bucket,
-                    key: key)
-    end
-
-    def unzip(zipfile, folder_dest)
-      sh "unzip -qo #{zipfile} -d #{folder_dest}"
-    end
-
-    def sh(command)
-      puts "=> #{command}"
-      success = system(command)
-      raise "Command #{command} failed" unless success
-      success
-    end
-  end
-end

data/lib/jets/turbine/configurable.rb

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

@@ -1,101 +0,0 @@
-# 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,185 +0,0 @@
-# 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
-    extend ActiveSupport::DescendantsTracker
-    include Initializable
-
-    ABSTRACT_TURBINES = %w(Jets::Turbine Jets::Engine Jets::Application)
-
-    class << self
-      private :new
-      delegate :config, to: :instance
-
-      def subclasses
-        super.reject(&:abstract_turbine?).sort
-      end
-
-      def rake_tasks(&blk)
-        register_block_for(:rake_tasks, &blk)
-      end
-
-      def console(&blk)
-        register_block_for(:load_console, &blk)
-      end
-
-      def runner(&blk)
-        register_block_for(:runner, &blk)
-      end
-
-      def generators(&blk)
-        register_block_for(:generators, &blk)
-      end
-
-      def server(&blk)
-        register_block_for(:server, &blk)
-      end
-
-      # 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.rb

@@ -1,40 +0,0 @@
-require 'shellwords'
-
-class Jets::Util
-  class << self
-    # Make sure that the result is a text.
-    def normalize_result(result)
-      JSON.dump(result)
-    end
-
-    def cp_r(src, dest)
-      # Fix for https://github.com/tongueroo/jets/issues/122
-      #
-      # Using FileUtils.cp_r doesnt work if there are special files like socket files in the src dir.
-      # Instead of using this hack https://bugs.ruby-lang.org/issues/10104
-      # Using rsync to perform the copy.
-      src.chop! if src.ends_with?('/')
-      dest.chop! if dest.ends_with?('/')
-      check_rsync_installed!
-      sh "rsync -a --links --no-specials --no-devices #{Shellwords.escape(src)}/ #{Shellwords.escape(dest)}/", quiet: true
-    end
-
-    @@rsync_installed = false
-    def check_rsync_installed!
-      return if @@rsync_installed # only check once
-      if system "type rsync > /dev/null 2>&1"
-        @@rsync_installed = true
-      else
-        raise Jets::Error.new("Rsync is required. Rsync does not seem to be installed.")
-      end
-    end
-
-    def sh(command, quiet: false)
-      puts "=> #{command}" unless quiet
-      system(command)
-      success = $?.success?
-      raise Jets::Error.new("Command failed: #{command}") unless success
-      success
-    end
-  end
-end