mini-clean-kit 0.0.1

data/spring-4.7.0/lib/spring/server.rb

@@ -0,0 +1,162 @@
+module Spring
+  ORIGINAL_ENV = ENV.to_hash
+end
+
+require "spring/boot"
+require "spring/application_manager"
+
+# Must be last, as it requires bundler/setup, which alters the load path
+require "spring/commands"
+
+module Spring
+  class Server
+    def self.boot(options = {})
+      new(options).boot
+    end
+
+    attr_reader :env
+
+    def initialize(options = {})
+      @foreground   = options.fetch(:foreground, false)
+      @env          = options[:env] || default_env
+      @applications = Hash.new do |hash, key|
+        hash[key] = ApplicationManager.new(*key, env)
+      end
+      @pidfile      = env.pidfile_path.open('a')
+      @mutex        = Mutex.new
+    end
+
+    def foreground?
+      @foreground
+    end
+
+    def log(message)
+      env.log "[server] #{message}"
+    end
+
+    def boot
+      Spring.verify_environment
+
+      write_pidfile
+      set_pgid unless foreground?
+      ignore_signals unless foreground?
+      set_exit_hook
+      set_process_title
+      start_server
+    end
+
+    def start_server
+      server = UNIXServer.open(env.socket_name)
+      log "started on #{env.socket_name}"
+      loop { serve server.accept }
+    rescue Interrupt
+    end
+
+    def serve(client)
+      log "accepted client"
+      client.puts env.version
+
+      app_client = client.recv_io
+      command    = JSON.load(client.read(client.gets.to_i))
+
+      args, default_rails_env, spawn_env, reset_env = command.values_at('args', 'default_rails_env', 'spawn_env', 'reset_env')
+
+      if Spring.command?(args.first)
+        application = @applications[rails_env_for(args, default_rails_env, spawn_env)]
+        reset_if_env_changed(application, reset_env)
+
+        log "running command #{args.first}"
+        client.puts
+        client.puts application.run(app_client)
+      else
+        log "command not found #{args.first}"
+        client.close
+      end
+    rescue SocketError => e
+      raise e unless client.eof?
+    rescue Errno::EPIPE => e
+      log "client disconnected with error #{e.message}, ignoring command"
+    ensure
+      redirect_output
+    end
+
+    def rails_env_for(args, default_rails_env, spawn_env)
+      [Spring.command(args.first).env(args.drop(1)) || default_rails_env, spawn_env]
+    end
+
+    # Boot the server into the process group of the current session.
+    # This will cause it to be automatically killed once the session
+    # ends (i.e. when the user closes their terminal).
+    def set_pgid
+      pgid = Process.getpgid(Process.getsid)
+      Process.setpgid(0, pgid)
+    end
+
+    # Ignore SIGINT and SIGQUIT otherwise the user typing ^C or ^\ on the command line
+    # will kill the server/application.
+    def ignore_signals
+      IGNORE_SIGNALS.each { |sig| trap(sig, "IGNORE") }
+    end
+
+    def set_exit_hook
+      server_pid = Process.pid
+
+      # We don't want this hook to run in any forks of the current process
+      at_exit { shutdown if Process.pid == server_pid }
+    end
+
+    def shutdown
+      log "shutting down"
+
+      [env.socket_path, env.pidfile_path].each do |path|
+        if path.exist?
+          path.unlink rescue nil
+        end
+      end
+
+      @applications.values.map { |a| Spring.failsafe_thread { a.stop } }.map(&:join)
+    end
+
+    def write_pidfile
+      if @pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+        @pidfile.truncate(0)
+        @pidfile.write("#{Process.pid}\n")
+        @pidfile.fsync
+      else
+        exit 1
+      end
+    end
+
+    # We need to redirect STDOUT and STDERR, otherwise the server will
+    # keep the original FDs open which would break piping. (e.g.
+    # `spring rake -T | grep db` would hang forever because the server
+    # would keep the stdout FD open.)
+    def redirect_output
+      [STDOUT, STDERR].each { |stream| stream.reopen(env.log_file) }
+    end
+
+    def set_process_title
+      ProcessTitleUpdater.run { |distance|
+        "spring server | #{env.app_name} | started #{distance} ago"
+      }
+    end
+
+    private
+
+    def reset_if_env_changed(application, reset_env)
+      application.stop if ENV.slice(*reset_env.keys) != reset_env
+    end
+
+    def default_env
+      Env.new(log_file: default_log_file)
+    end
+
+    def default_log_file
+      if foreground? && !ENV["SPRING_LOG"]
+        $stdout
+      else
+        nil
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/version.rb

@@ -0,0 +1,3 @@
+module Spring
+  VERSION = "4.7.0"
+end

data/spring-4.7.0/lib/spring/watcher/abstract.rb

@@ -0,0 +1,117 @@
+require "pathname"
+
+module Spring
+  module Watcher
+    # A user of a watcher can use IO.select to wait for changes:
+    #
+    #   watcher = MyWatcher.new(root, latency)
+    #   IO.select([watcher]) # watcher is running in background
+    #   watcher.stale? # => true
+    class Abstract
+      attr_reader :files, :directories, :root, :latency
+
+      def initialize(root, latency)
+        @mutex       = Mutex.new
+        @root        = File.realpath(root)
+        @latency     = latency
+        @files       = {}
+        @directories = {}
+        @stale       = false
+        @listeners   = []
+
+        @on_debug    = nil
+      end
+
+      def synchronize(&block)
+        # Used by some gems.
+        @mutex.synchronize(&block)
+      end
+
+      def on_debug(&block)
+        @on_debug = block
+      end
+
+      def debug
+        @on_debug.call(yield) if @on_debug
+      end
+
+      def add(*items)
+        debug { "watcher: add: #{items.inspect}" }
+
+        items = items.flatten.map do |item|
+          item = Pathname.new(item)
+
+          if item.relative?
+            Pathname.new("#{root}/#{item}")
+          else
+            item
+          end
+        end
+
+        items = items.select do |item|
+          if item.symlink?
+            item.readlink.exist?.tap do |exists|
+              if !exists
+                debug { "add: ignoring dangling symlink: #{item.inspect} -> #{item.readlink.inspect}" }
+              end
+            end
+          else
+            item.exist?
+          end
+        end
+
+        @mutex.synchronize do
+          items.each do |item|
+            if item.directory?
+              directories[item.realpath.to_s] = true
+            else
+              begin
+                files[item.realpath.to_s] = true
+              rescue Errno::ENOENT
+                # Race condition. Ignore symlinks whose target was removed
+                # since the check above, or are deeply chained.
+                debug { "add: ignoring now-dangling symlink: #{item.inspect} -> #{item.readlink.inspect}" }
+              end
+            end
+          end
+
+          subjects_changed
+        end
+      end
+
+      def stale?
+        @stale
+      end
+
+      def on_stale(&block)
+        debug { "added listener: #{block.inspect}" }
+        @listeners << block
+      end
+
+      def mark_stale
+        return if stale?
+        @stale = true
+        debug { "marked stale, calling listeners: listeners=#{@listeners.inspect}" }
+        @listeners.each(&:call)
+      end
+
+      def restart
+        debug { "restarting" }
+        stop
+        start
+      end
+
+      def start
+        raise NotImplementedError
+      end
+
+      def stop
+        raise NotImplementedError
+      end
+
+      def subjects_changed
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/watcher/polling.rb

@@ -0,0 +1,98 @@
+require "spring/watcher/abstract"
+
+module Spring
+  module Watcher
+    class Polling < Abstract
+      attr_reader :mtime
+
+      def initialize(root, latency)
+        super
+        @mtime  = 0
+        @poller = nil
+      end
+
+      def check_stale
+        @mutex.synchronize do
+          computed = compute_mtime
+          if mtime < computed
+            debug { "check_stale: mtime=#{mtime.inspect} < computed=#{computed.inspect}" }
+            mark_stale
+          end
+        end
+      end
+
+      def add(*)
+        check_stale if @poller
+        super
+      end
+
+      def start
+        debug { "start: poller=#{@poller.inspect}" }
+        unless @poller
+          @poller = Thread.new {
+            Thread.current.abort_on_exception = true
+
+            begin
+              until stale?
+                Kernel.sleep latency
+                check_stale
+              end
+            rescue Exception => e
+              debug do
+                "poller: aborted: #{e.class}: #{e}\n  #{e.backtrace.join("\n  ")}"
+              end
+              raise
+            ensure
+              @poller = nil
+            end
+          }
+        end
+      end
+
+      def stop
+        debug { "stopping poller: #{@poller.inspect}" }
+        if @poller
+          @poller.kill
+          @poller = nil
+        end
+      end
+
+      def running?
+        @poller && @poller.alive?
+      end
+
+      def subjects_changed
+        computed = compute_mtime
+        debug { "subjects_changed: mtime #{@mtime} -> #{computed}" }
+        @mtime = computed
+      end
+
+      private
+
+      def compute_mtime
+        expanded_files.map do |f|
+          # Get the mtime of symlink targets. Ignore dangling symlinks.
+          if File.symlink?(f)
+            begin
+              File.mtime(f)
+            rescue Errno::ENOENT
+              0
+            end
+          # If a file no longer exists, treat it as changed.
+          else
+            begin
+              File.mtime(f)
+            rescue Errno::ENOENT
+              debug { "compute_mtime: no longer exists: #{f}" }
+              Float::MAX
+            end
+          end.to_f
+        end.max || 0
+      end
+
+      def expanded_files
+        (files.keys + Dir["{#{directories.keys.map { |d| "#{d}/**/*" }.join(",")}}"]).uniq
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/watcher.rb

@@ -0,0 +1,30 @@
+require "spring/watcher/abstract"
+require "spring/configuration"
+
+module Spring
+  class << self
+    attr_accessor :watch_interval
+    attr_writer :watcher
+    attr_reader :watch_method
+  end
+
+  def self.watch_method=(method)
+    if method.is_a?(Class)
+      @watch_method = method
+    else
+      require "spring/watcher/#{method}"
+      @watch_method = Watcher.const_get(method.to_s.gsub(/(^.|_.)/) { $1[-1].upcase })
+    end
+  end
+
+  self.watch_interval = 0.2
+  self.watch_method = :polling
+
+  def self.watcher
+    @watcher ||= watch_method.new(Spring.application_root_path, watch_interval)
+  end
+
+  def self.watch(*items)
+    watcher.add(*items)
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: mini-clean-kit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on spring
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- mini-clean-kit.gemspec
+- spring-4.7.0/LICENSE.txt
+- spring-4.7.0/README.md
+- spring-4.7.0/bin/spring
+- spring-4.7.0/lib/spring/application.rb
+- spring-4.7.0/lib/spring/application/boot.rb
+- spring-4.7.0/lib/spring/application_manager.rb
+- spring-4.7.0/lib/spring/binstub.rb
+- spring-4.7.0/lib/spring/boot.rb
+- spring-4.7.0/lib/spring/client.rb
+- spring-4.7.0/lib/spring/client/binstub.rb
+- spring-4.7.0/lib/spring/client/command.rb
+- spring-4.7.0/lib/spring/client/help.rb
+- spring-4.7.0/lib/spring/client/rails.rb
+- spring-4.7.0/lib/spring/client/run.rb
+- spring-4.7.0/lib/spring/client/server.rb
+- spring-4.7.0/lib/spring/client/status.rb
+- spring-4.7.0/lib/spring/client/stop.rb
+- spring-4.7.0/lib/spring/client/version.rb
+- spring-4.7.0/lib/spring/command_wrapper.rb
+- spring-4.7.0/lib/spring/commands.rb
+- spring-4.7.0/lib/spring/commands/rails.rb
+- spring-4.7.0/lib/spring/commands/rake.rb
+- spring-4.7.0/lib/spring/configuration.rb
+- spring-4.7.0/lib/spring/env.rb
+- spring-4.7.0/lib/spring/errors.rb
+- spring-4.7.0/lib/spring/failsafe_thread.rb
+- spring-4.7.0/lib/spring/json.rb
+- spring-4.7.0/lib/spring/process_title_updater.rb
+- spring-4.7.0/lib/spring/server.rb
+- spring-4.7.0/lib/spring/version.rb
+- spring-4.7.0/lib/spring/watcher.rb
+- spring-4.7.0/lib/spring/watcher/abstract.rb
+- spring-4.7.0/lib/spring/watcher/polling.rb
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Andrey78/mini-clean-kit
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []