relaunch 0.0.1 → 0.15.0

data/lib/rerun/runner.rb

@@ -0,0 +1,376 @@
+require 'timeout'
+require 'io/wait'
+
+module Rerun
+  class Runner
+
+    # The watcher instance that wait for changes
+    attr_reader :watcher
+
+    def self.keep_running(cmd, options)
+      runner = new(cmd, options)
+      runner.start
+      runner.join
+      # apparently runner doesn't keep running anymore (as of Listen 2) so we have to sleep forever :-(
+      sleep 10000 while true # :-(
+    end
+
+    include System
+    include ::Timeout
+
+    def initialize(run_command, options = {})
+      @run_command, @options = run_command, options
+      @run_command = "ruby #{@run_command}" if @run_command.split(' ').first =~ /\.rb$/
+      @options[:directory] ||= options.delete(:dir) || '.'
+      @options[:ignore] ||= []
+    end
+
+    def start_keypress_thread
+      return if @options[:background]
+
+      @keypress_thread = Thread.new do
+        while true
+          if c = key_pressed
+            case c.downcase
+            when 'c'
+              say "Clearing screen"
+              clear_screen
+            when 'r'
+              say "Restarting"
+              restart
+            when 'f'
+              say "Stopping and starting"
+              restart(false)
+            when 'p'
+              toggle_pause
+            when 'x', 'q'
+              die
+              break # the break will stop this thread, in case the 'die' doesn't
+            else
+              puts "\n#{c.inspect} pressed inside rerun"
+              puts [["c", "clear screen"],
+                    ["r", "restart"],
+                    ["f", "forced restart (stop and start)"],
+                    ["p", "toggle pause"],
+                    ["x or q", "stop and exit"]
+                   ].map {|key, description| "  #{key} -- #{description}"}.join("\n")
+              puts
+            end
+          end
+          sleep 1 # todo: use select instead of polling somehow?
+        end
+      end
+      @keypress_thread.run
+    end
+
+    def stop_keypress_thread
+      @keypress_thread.kill if @keypress_thread
+      @keypress_thread = nil
+    end
+
+    def restart(with_signal = true)
+      @restarting = true
+      if @options[:restart] && with_signal
+        restart_with_signal(@options[:signal])
+      else
+        stop
+        start
+      end
+      @restarting = false
+    end
+
+    def toggle_pause
+      unless @pausing
+        say "Pausing.  Press 'p' again to resume."
+        @watcher.pause
+        @pausing = true
+      else
+        say "Resuming."
+        @watcher.unpause
+        @pausing = false
+      end
+    end
+
+    def unpause
+      @watcher.unpause
+    end
+
+    def dir
+      @options[:directory]
+    end
+
+    def pattern
+      @options[:pattern]
+    end
+
+    def clear?
+      @options[:clear]
+    end
+
+    def quiet?
+      @options[:quiet]
+    end
+
+    def verbose?
+      @options[:verbose]
+    end
+
+    def exit?
+      @options[:exit]
+    end
+
+    def app_name
+      @options[:name]
+    end
+
+    def restart_with_signal(restart_signal)
+      if @pid && (@pid != 0)
+        notify "restarting", "We will be with you shortly."
+        send_signal(restart_signal)
+      end
+    end
+
+    def force_polling
+      @options[:force_polling]
+    end
+
+    def start
+      if @already_running
+        taglines = [
+          "Here we go again!",
+          "Keep on trucking.",
+          "Once more unto the breach, dear friends, once more!",
+          "The road goes ever on and on, down from the door where it began.",
+        ]
+        notify "restarted", taglines[rand(taglines.size)]
+      else
+        taglines = [
+          "To infinity... and beyond!",
+          "Charge!",
+        ]
+        notify "launched", taglines[rand(taglines.size)]
+        @already_running = true
+      end
+
+      clear_screen if clear?
+      start_keypress_thread unless @keypress_thread
+
+      begin
+        @pid = run @run_command
+        say "Rerun (#{$PID}) running #{app_name} (#{@pid})"
+      rescue => e
+        puts "#{e.class}: #{e.message}"
+        raise ExitException
+      end
+
+      status_thread = Process.detach(@pid) # so if the child exits, it dies
+
+      Signal.trap("INT") do # INT = control-C -- allows user to stop the top-level rerun process
+        die
+      end
+
+      Signal.trap("TERM") do # TERM is the polite way of terminating a process
+        die
+      end
+
+      begin
+        sleep 2
+      rescue Interrupt => e
+        # in case someone hits control-C immediately ("oops!")
+        die
+      end
+
+      if exit?
+        status = status_thread.value
+        if status.success?
+          notify "succeeded", ""
+        else
+          notify "failed", "Exit status #{status.exitstatus}"
+        end
+      else
+        if !running?
+          notify "Launch Failed", "See console for error output"
+          @already_running = false
+        end
+      end
+
+      unless @watcher
+        watcher = Watcher.new(@options) do |changes|
+          message = change_message(changes)
+          say "Change detected: #{message}"
+          restart unless @restarting
+        end
+        watcher.start
+        @watcher = watcher
+        ignore = @options[:ignore]
+        say "Watching #{dir.join(', ')} for #{pattern}" +
+              (ignore.empty? ? "" : " (ignoring #{ignore.join(',')})") +
+              (watcher.adapter.nil? ? "" : " with #{watcher.adapter_name} adapter")
+      end
+    end
+
+    def run command
+      Kernel.spawn command
+    end
+
+    def change_message(changes)
+      message = [:modified, :added, :removed].map do |change|
+        count = changes[change] ? changes[change].size : 0
+        if count > 0
+          "#{count} #{change}"
+        end
+      end.compact.join(", ")
+
+      changed_files = changes.values.flatten
+      if changed_files.count > 0
+        message += ": "
+        message += changes.values.flatten[0..3].map {|path| path.split('/').last}.join(', ')
+        if changed_files.count > 3
+          message += ", ..."
+        end
+      end
+      message
+    end
+
+    def die
+      #stop_keypress_thread   # don't do this since we're probably *in* the keypress thread
+      stop # stop the child process if it exists
+      raise ExitException # todo: status code param
+    end
+
+    def join
+      @watcher.join
+    end
+
+    def running?
+      send_signal(0)
+    end
+
+    # Send the signal to process @pid and wait for it to die.
+    # @returns true if the process dies
+    # @returns false if either sending the signal fails or the process fails to die
+    def signal_and_wait(signal)
+
+      signal_sent = if windows?
+                      force_kill = (signal == 'KILL')
+                      system("taskkill /T #{'/F' if force_kill} /PID #{@pid}")
+                    else
+                      send_signal(signal)
+                    end
+
+      if signal_sent
+        # the signal was successfully sent, so wait for the process to die
+        begin
+          timeout(@options[:wait]) do
+            Process.wait(@pid)
+          end
+          process_status = $?
+          say "Process ended: #{process_status}" if verbose?
+          true
+        rescue Timeout::Error
+          false
+        end
+      else
+        false
+      end
+    end
+
+    # Send the signal to process @pid.
+    # @returns true if the signal is sent
+    # @returns false if sending the signal fails
+    # If sending the signal fails, the exception will be swallowed
+    # (and logged if verbose is true) and this method will return false.
+    #
+    def send_signal(signal)
+      say "Sending signal #{signal} to #{@pid}" unless signal == 0 if verbose?
+      Process.kill(signal, @pid)
+      true
+    rescue => e
+      say "Signal #{signal} failed: #{e.class}: #{e.message}" if verbose?
+      false
+    end
+
+    # todo: test escalation
+    def stop
+      if @pid && (@pid != 0)
+        notify "stopping", "All good things must come to an end." unless @restarting
+        @options[:signal].split(',').each do |signal|
+          success = signal_and_wait(signal)
+          return true if success
+        end
+      end
+    rescue
+      false
+    end
+
+    def git_head_changed?
+      old_git_head = @git_head
+      read_git_head
+      @git_head and old_git_head and @git_head != old_git_head
+    end
+
+    def read_git_head
+      git_head_file = File.join(dir, '.git', 'HEAD')
+      @git_head = File.exist?(git_head_file) && File.read(git_head_file)
+    end
+
+    def notify(title, body, background = true)
+      Notification.new(title, body, @options).send(background) if @options[:notify]
+      puts
+      say "#{app_name} #{title}"
+    end
+
+    def say msg
+      puts "#{Time.now.strftime("%T")} [rerun] #{msg}" unless quiet?
+    end
+
+    def stty(args)
+      system "stty #{args}"
+    end
+
+    # non-blocking stdin reader.
+    # returns a 1-char string if a key was pressed; otherwise nil
+    #
+    def key_pressed
+      return one_char if windows?
+      begin
+        # this "raw input" nonsense is because unix likes waiting for linefeeds before sending stdin
+
+        # 'raw' means turn raw input on
+
+        # restore proper output newline handling -- see "man stty" and /usr/include/sys/termios.h
+        # looks like "raw" flips off the OPOST bit 0x00000001 /* enable following output processing */
+        # which disables #define ONLCR		0x00000002	/* map NL to CR-NL (ala CRMOD) */
+        # so this sets it back on again since all we care about is raw input, not raw output
+        stty "raw opost"
+        one_char
+      ensure
+        stty "-raw" # turn raw input off
+      end
+
+      # note: according to 'man tty' the proper way restore the settings is
+      # tty_state=`stty -g`
+      # ensure
+      #   system 'stty "#{tty_state}'
+      # end
+      # but this way seems fine and less confusing
+    end
+
+    def clear_screen
+      # see http://ascii-table.com/ansi-escape-sequences-vt-100.php
+      $stdout.print "\033[H\033[2J"
+    end
+
+    private
+    def one_char
+      c = nil
+      msg = $stdin.respond_to?(:wait_readable) ? :wait_readable : :ready?
+
+      if $stdin.send(msg)
+        c = $stdin.getc
+      end
+      c.chr if c
+    end
+
+  end
+end

data/lib/rerun/system.rb

@@ -0,0 +1,22 @@
+module Rerun
+  module System
+
+    def mac?
+      RUBY_PLATFORM =~ /darwin/i
+    end
+
+    def windows?
+       RUBY_PLATFORM =~ /(mswin|mingw32)/i
+    end
+
+    def linux?
+       RUBY_PLATFORM =~ /linux/i
+    end
+
+    def rails?
+      rails_sig_file = File.expand_path(".")+"/config/boot.rb"
+      File.exist? rails_sig_file
+    end
+
+  end
+end

data/lib/rerun/watcher.rb

@@ -0,0 +1,134 @@
+require 'listen'
+
+Thread.abort_on_exception = true
+
+# This class will watch a directory and alert you of
+# new files, modified files, deleted files.
+#
+# Now uses the Listen gem, but spawns its own thread on top.
+# We should probably be accessing the Listen thread directly.
+#
+# Author: Alex Chaffee
+#
+module Rerun
+  class Watcher
+    InvalidDirectoryError = Class.new(RuntimeError)
+
+    #def self.default_ignore
+    #  Listen::Silencer.new(Listen::Listener.new).send :_default_ignore_patterns
+    #end
+
+    attr_reader :directory, :pattern, :priority, :ignore_dotfiles
+
+    # Create a file system watcher. Start it by calling #start.
+    #
+    # @param options[:directory] the directory to watch (default ".")
+    # @param options[:pattern] the glob pattern to search under the watched directory (default "**/*")
+    # @param options[:priority] the priority of the watcher thread (default 0)
+    #
+    def initialize(options = {}, &client_callback)
+      @client_callback = client_callback
+
+      options = {
+          :directory => ".",
+          :pattern => "**/*",
+          :priority => 0,
+          :ignore_dotfiles => true,
+      }.merge(options)
+
+      @pattern = options[:pattern]
+      @directories = options[:directory]
+      @directories = sanitize_dirs(@directories)
+      @priority = options[:priority]
+      @force_polling = options[:force_polling]
+      @ignore = [options[:ignore]].flatten.compact
+      @ignore_dotfiles = options[:ignore_dotfiles]
+      @thread = nil
+    end
+
+    def sanitize_dirs(dirs)
+      dirs = [*dirs]
+      dirs.map do |d|
+        d.chomp!("/")
+        unless FileTest.exist?(d) && FileTest.readable?(d) && FileTest.directory?(d)
+          raise InvalidDirectoryError, "Directory '#{d}' either doesnt exist or isn't readable"
+        end
+        File.expand_path(d)
+      end
+    end
+
+    def start
+      if @thread then
+        raise RuntimeError, "already started"
+      end
+
+      @thread = Thread.new do
+        @listener = Listen.to(*@directories, only: watching, ignore: ignoring, wait_for_delay: 1, force_polling: @force_polling) do |modified, added, removed|
+          count = modified.size + added.size + removed.size
+          if count > 0
+            @client_callback.call(:modified => modified, :added => added, :removed => removed)
+          end
+        end
+        @listener.start
+      end
+
+      @thread.priority = @priority
+
+      sleep 0.1 until @listener
+
+      at_exit { stop } # try really hard to clean up after ourselves
+    end
+
+    def watching
+      Rerun::Glob.new(@pattern).to_regexp
+    end
+
+    def ignoring
+      patterns = []
+      if ignore_dotfiles
+        patterns << /^\.[^.]/ # at beginning of string, a real dot followed by any other character
+      end
+      patterns + @ignore.map { |x| Rerun::Glob.new(x).to_regexp }
+    end
+
+    # kill the file watcher thread
+    def stop
+      @thread.wakeup rescue ThreadError
+      begin
+        @listener.stop
+      rescue Exception => e
+        puts "#{e.class}: #{e.message} stopping listener"
+      end
+      @thread.kill rescue ThreadError
+    end
+
+    # wait for the file watcher to finish
+    def join
+      @thread.join if @thread
+    rescue Interrupt
+      # don't care
+    end
+
+    def pause
+      @listener.pause if @listener
+    end
+
+    def unpause
+      @listener.start if @listener
+    end
+
+    def running?
+      @listener && @listener.processing?
+    end
+
+    def adapter
+      @listener &&
+          (backend = @listener.instance_variable_get(:@backend)) &&
+          backend.instance_variable_get(:@adapter)
+    end
+
+    def adapter_name
+      adapter && adapter.class.name.split('::').last
+    end
+  end
+end

data/lib/rerun.rb

@@ -0,0 +1,17 @@
+here = File.expand_path(File.dirname(__FILE__))
+$: << here unless $:.include?(here)
+
+require "listen"  # pull in the Listen gem
+require "rerun/options"
+require "rerun/system"
+require "rerun/notification"
+require "rerun/runner"
+require "rerun/watcher"
+require "rerun/glob"
+
+module Rerun
+  # Raised when the runner wants to exit cleanly.
+  # This allows tests to catch the exit instead of terminating the process.
+  class ExitException < StandardError; end
+end
+

data/relaunch.gemspec

@@ -0,0 +1,44 @@
+$spec = Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  s.name = 'relaunch'
+  s.version = '0.15.0'
+  s.required_ruby_version = '>= 3.3'
+
+  s.description = "Restarts your app when a file changes. A no-frills, command-line alternative to Guard, Shotgun, Autotest, etc."
+  s.summary     = "Launches an app, and restarts it whenever the filesystem changes. A no-frills, command-line alternative to Guard, Shotgun, Autotest, etc."
+
+  s.authors = ["Alex Chaffee", "Patrik Ragnarsson"]
+  s.email = ["alexch@gmail.com", "patrik@starkast.net"]
+
+  s.files = %w[
+    README.md
+    Changelog.md
+    Fork.md
+    LICENSE
+    Rakefile
+    relaunch.gemspec
+    bin/rerun
+    bin/rerun.bat
+    bin/relaunch
+    bin/relaunch.bat
+    icons/rails_grn_sml.png
+    icons/rails_red_sml.png] +
+      Dir['lib/**/*.rb']
+  s.executables = ['rerun', 'relaunch']
+  s.test_files = s.files.select {|path| path =~ /^spec\/.*_spec.rb/}
+
+  s.extra_rdoc_files = %w[README.md]
+
+  s.add_runtime_dependency 'listen', '~> 3.0'
+
+  s.homepage = "https://github.com/spinels/relaunch"
+  s.metadata["homepage_uri"] = s.homepage
+  s.metadata["changelog_uri"] = "#{s.homepage}/blob/main/Changelog.md"
+  s.metadata["source_code_uri"] = "#{s.homepage}/tree/main"
+  s.metadata["rubygems_mfa_required"] = "true"
+  s.require_paths = %w[lib]
+
+  s.license = 'MIT'
+end

metadata

@@ -1,24 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: relaunch
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.15.0
 platform: ruby
 authors:
-- Placeholder
+- Alex Chaffee
+- Patrik Ragnarsson
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
-executables: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Restarts your app when a file changes. A no-frills, command-line alternative
+  to Guard, Shotgun, Autotest, etc.
+email:
+- alexch@gmail.com
+- patrik@starkast.net
+executables:
+- relaunch
+- rerun
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
+- Changelog.md
+- Fork.md
+- LICENSE
+- README.md
+- Rakefile
+- bin/relaunch
+- bin/relaunch.bat
+- bin/rerun
+- bin/rerun.bat
+- icons/rails_grn_sml.png
+- icons/rails_red_sml.png
 - lib/relaunch.rb
-homepage: https://github.com/spinels/elsewhere
+- lib/rerun.rb
+- lib/rerun/glob.rb
+- lib/rerun/notification.rb
+- lib/rerun/options.rb
+- lib/rerun/runner.rb
+- lib/rerun/system.rb
+- lib/rerun/watcher.rb
+- relaunch.gemspec
+homepage: https://github.com/spinels/relaunch
 licenses:
 - MIT
-metadata: {}
-post_install_message: Coming soon.
+metadata:
+  homepage_uri: https://github.com/spinels/relaunch
+  changelog_uri: https://github.com/spinels/relaunch/blob/main/Changelog.md
+  source_code_uri: https://github.com/spinels/relaunch/tree/main
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -26,14 +71,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.19
-specification_version: 4
-summary: Placeholder gem
+rubygems_version: 4.0.16
+specification_version: 2
+summary: Launches an app, and restarts it whenever the filesystem changes. A no-frills,
+  command-line alternative to Guard, Shotgun, Autotest, etc.
 test_files: []