giga-safe-hub 0.0.1

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

@@ -0,0 +1,145 @@
+module Spring
+  class ApplicationManager
+    attr_reader :pid, :child, :app_env, :spawn_env, :spring_env, :status
+
+    def initialize(app_env, spawn_env, spring_env)
+      @app_env    = app_env
+      @spawn_env  = spawn_env
+      @spring_env = spring_env
+      @mutex      = Mutex.new
+      @state      = :running
+      @pid        = nil
+    end
+
+    def log(message)
+      spring_env.log "[application_manager:#{app_env}] #{message}"
+    end
+
+    # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
+    # line which messes with backtraces in e.g. rspec
+    def synchronize
+      @mutex.lock
+      yield
+    ensure
+      @mutex.unlock
+    end
+
+    def start
+      start_child
+    end
+
+    def restart
+      return if @state == :stopping
+      start_child(true)
+    end
+
+    def alive?
+      @pid
+    end
+
+    def with_child
+      synchronize do
+        if alive?
+          begin
+            yield
+          rescue Errno::ECONNRESET, Errno::EPIPE, Errno::EINVAL
+            # The child has died but has not been collected by the wait thread yet,
+            # so start a new child and try again.
+            log "child dead; starting"
+            start
+            yield
+          end
+        else
+          log "child not running; starting"
+          start
+          yield
+        end
+      end
+    end
+
+    # Returns the pid of the process running the command, or nil if the application process died.
+    def run(client)
+      with_child do
+        child.send_io client
+        child.gets or raise Errno::EPIPE
+      end
+
+      pid = child.gets.to_i
+
+      unless pid.zero?
+        log "got worker pid #{pid}"
+        pid
+      end
+    rescue Errno::ECONNRESET, Errno::EPIPE => e
+      log "#{e} while reading from child; returning no pid"
+      nil
+    ensure
+      client.close
+    end
+
+    def stop
+      log "stopping"
+      @state = :stopping
+
+      if pid
+        Process.kill('TERM', pid)
+        Process.wait(pid)
+      end
+    rescue Errno::ESRCH, Errno::ECHILD
+      # Don't care
+    end
+
+    private
+
+    def start_child(preload = false)
+      @child, child_socket = UNIXSocket.pair
+
+      Bundler.with_original_env do
+        bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
+        @pid = Process.spawn(
+          {
+            "RAILS_ENV"           => app_env,
+            "RACK_ENV"            => app_env,
+            "SPRING_ORIGINAL_ENV" => JSON.dump(Spring::ORIGINAL_ENV),
+            "SPRING_PRELOAD"      => preload ? "1" : "0",
+            "SPRING_SPAWN_ENV"    => JSON.dump(spawn_env.compact),
+            **spawn_env,
+          },
+          "ruby",
+          *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
+          "-I", File.expand_path("../..", __FILE__),
+          "-e", "require 'spring/application/boot'",
+          3 => child_socket,
+          4 => spring_env.log_file,
+        )
+      end
+
+      start_wait_thread(pid, child) if child.gets
+      child_socket.close
+    end
+
+    def start_wait_thread(pid, child)
+      Process.detach(pid)
+
+      Spring.failsafe_thread {
+        # The recv can raise an ECONNRESET, killing the thread, but that's ok
+        # as if it does we're no longer interested in the child
+        loop do
+          IO.select([child])
+          peek = child.recv(1, Socket::MSG_PEEK)
+          break if peek.nil? || peek.empty?
+          sleep 0.01
+        end
+
+        log "child #{pid} shutdown"
+
+        synchronize {
+          if @pid == pid
+            @pid = nil
+            restart
+          end
+        }
+      }
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+command  = File.basename($0)
+bin_path = File.expand_path("../../../bin/spring", __FILE__)
+
+if command == "spring"
+  load bin_path
+else
+  disable = ENV["DISABLE_SPRING"]
+
+  if Process.respond_to?(:fork) && (disable.nil? || disable.empty? || disable == "0")
+    ARGV.unshift(command)
+    load bin_path
+  end
+end

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

@@ -0,0 +1,10 @@
+require "socket"
+require "thread"
+
+require "spring/configuration"
+require "spring/env"
+require "spring/process_title_updater"
+require "spring/json"
+require "spring/watcher"
+require "spring/failsafe_thread"
+

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