mini-clean-kit 0.0.1

data/spring-4.7.0/lib/spring/client/binstub.rb

@@ -0,0 +1,190 @@
+module Spring
+  module Client
+    class Binstub < Command
+      SHEBANG = /\#\!.*\n(\#.*\n)*/
+
+      # If loading the bin/spring file works, it'll run Spring which will
+      # eventually call Kernel.exit. This means that in the client process
+      # we will never execute the lines after this block. But if the Spring
+      # client is not invoked for whatever reason, then the Kernel.exit won't
+      # happen, and so we'll fall back to the lines after this block, which
+      # should cause the "unsprung" version of the command to run.
+      LOADER = <<~CODE
+        load File.expand_path("spring", __dir__)
+      CODE
+
+      # The defined? check ensures these lines don't execute when we load the
+      # binstub from the application process. Which means that in the application
+      # process we'll execute the lines which come after the LOADER block, which
+      # is what we want.
+      SPRING = <<~CODE
+        #!/usr/bin/env ruby
+
+        # This file loads Spring without loading other gems in the Gemfile in order to be fast.
+        # It gets overwritten when you run the `spring binstub` command.
+
+        if !defined?(Spring) && [nil, "development", "test"].include?(ENV["RAILS_ENV"])
+          require "bundler"
+
+          Bundler.definition.requested_specs.find { |spec| spec.name == "spring" }&.tap do |spring|
+            Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
+            gem "spring", spring.version
+            require "spring/binstub"
+          end
+        end
+      CODE
+
+      OLD_BINSTUB = %{if !Process.respond_to?(:fork) || Gem::Specification.find_all_by_name("spring").empty?}
+
+      BINSTUB_VARIATIONS = Regexp.union [
+        %{load File.expand_path("spring", __dir__)\n},
+        %{begin\n  load File.expand_path('../spring', __FILE__)\nrescue LoadError => e\n  raise unless e.message.include?('spring')\nend\n},
+        %{begin\n  load File.expand_path('../spring', __FILE__)\nrescue LoadError\nend\n},
+        %{begin\n  spring_bin_path = File.expand_path('../spring', __FILE__)\n  load spring_bin_path\nrescue LoadError => e\n  raise unless e.message.end_with? spring_bin_path, 'spring/binstub'\nend\n},
+        LOADER
+      ].map { |binstub| /#{Regexp.escape(binstub).gsub("'", "['\"]")}/ }
+
+      class Item
+        attr_reader :command, :existing
+
+        def initialize(command)
+          @command = command
+
+          if command.binstub.exist?
+            @existing = command.binstub.read
+          elsif command.name == "rails"
+            scriptfile = Spring.application_root_path.join("script/rails")
+            @existing = scriptfile.read if scriptfile.exist?
+          end
+        end
+
+        def status(text, stream = $stdout)
+          stream.puts "* #{command.binstub_name}: #{text}"
+        end
+
+        def add
+          if existing
+            if existing.include?(OLD_BINSTUB)
+              fallback = existing.match(/#{Regexp.escape OLD_BINSTUB}\n(.*)else/m)[1]
+              fallback.gsub!(/^  /, "")
+              fallback = nil if fallback.include?("exec")
+              generate(fallback)
+              status "upgraded"
+            elsif existing.include?(LOADER)
+              status "Spring already present"
+            elsif existing =~ BINSTUB_VARIATIONS
+              upgraded = existing.sub(BINSTUB_VARIATIONS, LOADER)
+              File.write(command.binstub, upgraded)
+              status "upgraded"
+            else
+              head, shebang, tail = existing.partition(SHEBANG)
+
+              if shebang.include?("ruby")
+                unless command.binstub.exist?
+                  FileUtils.touch command.binstub
+                  command.binstub.chmod 0755
+                end
+
+                File.write(command.binstub, "#{head}#{shebang}#{LOADER}#{tail}")
+                status "Spring inserted"
+              else
+                status "doesn't appear to be ruby, so cannot use Spring", $stderr
+                exit 1
+              end
+            end
+          else
+            generate
+            status "generated with Spring"
+          end
+        end
+
+        def generate(fallback = nil)
+          unless fallback
+            fallback = "require 'bundler/setup'\n" \
+                       "load Gem.bin_path('#{command.gem_name}', '#{command.exec_name}')\n"
+          end
+
+          File.write(command.binstub, "#!/usr/bin/env ruby\n#{LOADER}#{fallback}")
+          command.binstub.chmod 0755
+        end
+
+        def remove
+          if existing
+            File.write(command.binstub, existing.sub(BINSTUB_VARIATIONS, ""))
+            status "Spring removed"
+          end
+        end
+      end
+
+      attr_reader :bindir, :items
+
+      def self.description
+        "Generate Spring based binstubs. Use --all to generate a binstub for all known commands. Use --remove to revert."
+      end
+
+      def self.rails_command
+        @rails_command ||= CommandWrapper.new("rails")
+      end
+
+      def self.call(args)
+        require "spring/commands"
+        super
+      end
+
+      def initialize(args)
+        super
+
+        @bindir = env.root.join("bin")
+        @all    = false
+        @mode   = :add
+        @items  = args.drop(1)
+                      .map { |name| find_commands name }
+                      .flatten.uniq
+                      .map { |command| Item.new(command) }
+      end
+
+      def find_commands(name)
+        case name
+        when "--all"
+          @all = true
+          commands = Spring.commands.dup
+          commands.delete_if { |command_name, _| command_name.start_with?("rails_") }
+          commands.values + [self.class.rails_command]
+        when "--remove"
+          @mode = :remove
+          []
+        when "rails"
+          [self.class.rails_command]
+        else
+          if command = Spring.commands[name]
+            [command]
+          else
+            $stderr.puts "The '#{name}' command is not known to spring."
+            exit 1
+          end
+        end
+      end
+
+      def call
+        case @mode
+        when :add
+          bindir.mkdir unless bindir.exist?
+
+          File.write(spring_binstub, SPRING)
+          spring_binstub.chmod 0755
+
+          items.each(&:add)
+        when :remove
+          spring_binstub.delete if @all
+          items.each(&:remove)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def spring_binstub
+        bindir.join("spring")
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/command.rb

@@ -0,0 +1,18 @@
+require "spring/env"
+
+module Spring
+  module Client
+    class Command
+      def self.call(args)
+        new(args).call
+      end
+
+      attr_reader :args, :env
+
+      def initialize(args)
+        @args = args
+        @env  = Env.new
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/help.rb

@@ -0,0 +1,62 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Help < Command
+      attr_reader :spring_commands, :application_commands
+
+      def self.description
+        "Print available commands."
+      end
+
+      def self.call(args)
+        require "spring/commands"
+        super
+      end
+
+      def initialize(args, spring_commands = nil, application_commands = nil)
+        super args
+
+        @spring_commands      = spring_commands      || Spring::Client::COMMANDS.dup
+        @application_commands = application_commands || Spring.commands.dup
+
+        @spring_commands.delete_if { |k, v| k.start_with?("-") }
+
+        @application_commands["rails"] = @spring_commands.delete("rails")
+      end
+
+      def call
+        puts formatted_help
+      end
+
+      def formatted_help
+        ["Version: #{env.version}\n",
+         "Usage: spring COMMAND [ARGS]\n",
+         *command_help("Spring itself", spring_commands),
+         '',
+         *command_help("your application", application_commands)].join("\n")
+      end
+
+      def command_help(subject, commands)
+        ["Commands for #{subject}:\n",
+        *commands.sort_by(&:first).map { |name, command| display(name, command) }.compact]
+      end
+
+      private
+
+      def all_commands
+        spring_commands.merge application_commands
+      end
+
+      def display(name, command)
+        if command.description
+          "  #{name.ljust(max_name_width)}  #{command.description}"
+        end
+      end
+
+      def max_name_width
+        @max_name_width ||= all_commands.keys.map(&:length).max
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/rails.rb

@@ -0,0 +1,34 @@
+module Spring
+  module Client
+    class Rails < Command
+      COMMANDS = %w(console runner generate destroy test)
+
+      ALIASES = {
+        "c" => "console",
+        "r" => "runner",
+        "g" => "generate",
+        "d" => "destroy",
+        "t" => "test"
+      }
+
+      def self.description
+        "Run a rails command. The following sub commands will use Spring: #{COMMANDS.to_a.join ', '}."
+      end
+
+      def call
+        command_name = ALIASES[args[1]] || args[1]
+
+        if COMMANDS.include?(command_name)
+          Run.call(["rails_#{command_name}", *args.drop(2)])
+        elsif command_name&.start_with?("db:") && !command_name.start_with?("db:system")
+          Run.call(["rake", *args.drop(1)])
+        else
+          require "spring/configuration"
+          ARGV.shift
+          load Dir.glob(Spring.application_root_path.join("{bin,script}/rails")).first
+          exit
+        end
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/run.rb

@@ -0,0 +1,297 @@
+require "rbconfig"
+require "socket"
+require "bundler"
+
+module Spring
+  module Client
+    class Run < Command
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
+      ServerReadTimeout = Class.new(StandardError)
+
+      attr_reader :server
+
+      def initialize(args)
+        super
+
+        @signal_queue  = []
+        @server_booted = false
+      end
+
+      def log(message)
+        env.log "[client] #{message}"
+      end
+
+      def connect
+        @server = UNIXSocket.open(env.socket_name)
+      end
+
+      def call
+        begin
+          connect
+        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
+          cold_run
+        else
+          warm_run
+        end
+      ensure
+        server.close if server
+      end
+
+      def warm_run
+        run
+      rescue CommandNotFound
+        require "spring/commands"
+
+        if Spring.command?(args.first)
+          # Command installed since Spring started
+          stop_server
+          cold_run
+        else
+          raise
+        end
+      end
+
+      def cold_run
+        boot_server
+        connect
+        run
+      end
+
+      def run
+        verify_server_version
+
+        application, client = UNIXSocket.pair
+
+        queue_signals
+        connect_to_application(client)
+        run_command(client, application)
+      rescue Errno::ECONNRESET
+        exit 1
+      end
+
+      def boot_server
+        env.socket_path.unlink if env.socket_path.exist?
+
+        pid     = Process.spawn(server_process_env, env.server_command, out: File::NULL)
+        timeout = Time.now + Spring.boot_timeout
+
+        @server_booted = true
+
+        until env.socket_path.exist?
+          _, status = Process.waitpid2(pid, Process::WNOHANG)
+
+          if status
+            exit status.exitstatus
+          elsif Time.now > timeout
+            $stderr.puts "Starting Spring server with `#{env.server_command}` " \
+                         "timed out after #{Spring.boot_timeout} seconds"
+            exit 1
+          end
+
+          sleep 0.1
+        end
+      end
+
+      def server_booted?
+        @server_booted
+      end
+
+      def gem_env
+        bundle = Bundler.bundle_path.to_s
+        paths  = Gem.path + ENV["GEM_PATH"].to_s.split(File::PATH_SEPARATOR)
+
+        {
+          "GEM_PATH" => [bundle, *paths].uniq.join(File::PATH_SEPARATOR),
+          "GEM_HOME" => bundle
+        }
+      end
+
+      def reset_env
+        ENV.slice(*Spring.reset_on_env)
+      end
+
+      def server_process_env
+        reset_env.merge(gem_env)
+      end
+
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
+      def verify_server_version
+        begin
+          line = read_server_line
+        rescue ServerReadTimeout
+          if waiting_for_server_boot?
+            begin
+              # Try again, but with same timeout as booting, as server might still be booting
+              #   from another client starting it.
+              line = read_server_line(Spring.boot_timeout)
+            rescue ServerReadTimeout
+              reboot_or_raise_connection_error
+              return
+            end
+          else
+            reboot_or_raise_connection_error
+            return
+          end
+        end
+
+        if line.nil?
+          reboot_or_raise_connection_error
+          return
+        end
+
+        server_version = line.chomp
+        if server_version != env.version
+          $stderr.puts "There is a version mismatch between the Spring client " \
+                         "(#{env.version}) and the server (#{server_version})."
+
+          if server_booted?
+            $stderr.puts "We already tried to reboot the server, but the mismatch is still present."
+            exit 1
+          else
+            $stderr.puts "Restarting to resolve."
+            stop_server
+            cold_run
+          end
+        end
+      end
+
+      def read_server_line(timeout = Spring.connect_timeout)
+        raise ServerReadTimeout if IO.select([server], [], [], timeout).nil?
+
+        server.gets
+      end
+
+      def waiting_for_server_boot?
+        !server_booted? && env.server_running?
+      end
+
+      def reboot_or_raise_connection_error
+        if server_booted?
+          raise "Error connecting to Spring server"
+        else
+          stop_server
+          cold_run
+        end
+      end
+
+      def connect_to_application(client)
+        server.send_io client
+        send_json server, "args" => args, "default_rails_env" => default_rails_env, "spawn_env" => spawn_env, "reset_env" => reset_env
+
+        if IO.select([server], [], [], Spring.connect_timeout)
+          server.gets or raise CommandNotFound
+        else
+          raise "Error connecting to Spring server"
+        end
+      end
+
+      def run_command(client, application)
+        application.send_io STDOUT
+        application.send_io STDERR
+        application.send_io STDIN
+
+        log "waiting for the application to be preloaded"
+        preload_status = application.gets
+        preload_status = preload_status.chomp if preload_status
+        log "app preload status: #{preload_status}"
+        exit 1 if preload_status == "1"
+
+        log "sending command"
+        send_json application, "args" => args, "env" => ENV.to_hash
+
+        pid = server.gets
+        pid = pid.chomp if pid
+
+        # We must not close the client socket until we are sure that the application has
+        # received the FD. Otherwise the FD can end up getting closed while it's in the server
+        # socket buffer on OS X. This doesn't happen on Linux.
+        client.close
+
+        if pid && !pid.empty?
+          log "got pid: #{pid}"
+
+          suspend_resume_on_tstp_cont(pid)
+
+          forward_signals(application)
+          status = application.read
+          log "got exit status #{status.inspect}"
+
+          # Status should always be an integer. If it is empty, something unexpected must have happened to the server.
+          if status.to_s.strip.empty?
+            log "unexpected empty exit status, app crashed?"
+            exit 1
+          end
+
+          exit status.to_i
+        else
+          log "got no pid"
+          exit 1
+        end
+      ensure
+        application.close
+      end
+
+      def queue_signals
+        FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { @signal_queue << sig }
+        end
+      end
+
+      def suspend_resume_on_tstp_cont(pid)
+        trap("TSTP") {
+          log "suspended"
+          Process.kill("STOP", pid.to_i)
+          Process.kill("STOP", Process.pid)
+        }
+        trap("CONT") {
+          log "resumed"
+          Process.kill("CONT", pid.to_i)
+        }
+      end
+
+      def forward_signals(application)
+        @signal_queue.each { |sig| kill sig, application }
+
+        FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { forward_signal sig, application }
+        end
+      end
+
+      def forward_signal(sig, application)
+        if kill(sig, application) != 0
+          # If the application process is gone, then don't block the
+          # signal on this process.
+          trap(sig, 'DEFAULT')
+          Process.kill(sig, Process.pid)
+        end
+      end
+
+      def kill(sig, application)
+        application.puts(sig)
+        application.gets.to_i
+      end
+
+      def send_json(socket, data)
+        data = JSON.dump(data)
+
+        socket.puts  data.bytesize
+        socket.write data
+      end
+
+      def default_rails_env
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
+
+      def spawn_env
+        Spring.spawn_on_env.to_h do |key|
+          [key, ENV[key]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Spring
+  module Client
+    class Server < Command
+      def self.description
+        "Explicitly start a Spring server in the foreground"
+      end
+
+      def call
+        require "spring/server"
+        Spring::Server.boot(foreground: foreground?)
+      end
+
+      def foreground?
+        !args.include?("--background")
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/status.rb

@@ -0,0 +1,30 @@
+module Spring
+  module Client
+    class Status < Command
+      def self.description
+        "Show current status."
+      end
+
+      def call
+        if env.server_running?
+          puts "Spring is running:"
+          puts
+          print_process env.pid
+          application_pids.each { |pid| print_process pid }
+        else
+          puts "Spring is not running."
+        end
+      end
+
+      def print_process(pid)
+        puts `ps -p #{pid} -o pid= -o command=`
+      end
+
+      def application_pids
+        candidates = `ps -ax -o ppid= -o pid=`.lines
+        candidates.select { |l| l =~ /^(\s+)?#{env.pid} / }
+                  .map    { |l| l.split(" ").last   }
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/client/stop.rb

@@ -0,0 +1,22 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Stop < Command
+      def self.description
+        "Stop all Spring processes for this project."
+      end
+
+      def call
+        case env.stop
+        when :stopped
+          puts "Spring stopped."
+        when :killed
+          $stderr.puts "Spring did not stop; killing forcibly."
+        when :not_running
+          puts "Spring is not running"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Version < Command
+      def call
+        puts "Spring version #{Spring::VERSION}"
+      end
+    end
+  end
+end