raindown 0.7.0 → 0.8.0

data/lib/raindown/supervisor.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'project_worker'
-require_relative 'projects'
-
-module Raindown
-  # Watches every Raindown project in a directory, like ~/dev, and writes back to each Markdown file as it's saved.
-  #
-  # Each project's nodes load in a process of its own, forked once the shared code has loaded, so starting a project
-  # costs almost nothing and two projects can have nodes of the same name. One listener watches the directory and sends
-  # each changed file to its project's process. Without fork, as on Windows, the projects share this process.
-  class Supervisor
-    # Watching skips these folders as they hold dependencies and builds, which Projects ignores too.
-    IGNORE = %r{(?:\A|/)(?:#{Projects::IGNORED.join('|')})/}
-
-    attr_reader :directory, :workers
-
-    def initialize(directory:, bare: false, execute: false)
-      @directory = File.expand_path(directory)
-      @bare = bare
-      @execute = execute
-      @workers = {}
-    end
-
-    def start
-      require 'listen'
-      $stdout.sync = true
-      preload
-
-      Projects.roots(directory).each { worker(it) }
-      puts "Watching #{workers.size} #{workers.size == 1 ? 'project' : 'projects'} in #{directory} for changes..."
-
-      trap_interrupt
-      listener.start
-      sleep
-    ensure
-      stop
-    end
-
-    # Sends each changed file to its project, starting a worker for a new project, or restarting one when its nodes change.
-    def handle(paths)
-      paths.each do |path|
-        root = Projects.root(path) || next
-
-        if Projects.node?(path, root:)
-          restart(root)
-        elsif Projects.markdown?(path, root:)
-          worker(root).update(path)
-        end
-      end
-    end
-
-    def stop
-      workers.each_value(&:stop)
-      workers.clear
-    end
-
-    private
-
-    def listener
-      Listen.to(directory, ignore: IGNORE) { |modified, added, _removed| handle(modified + added) }
-    end
-
-    def worker(root)
-      workers[root] ||= begin
-        worker = ProjectWorker.new(root:, name: name(root), bare: @bare, execute: @execute)
-        fork? ? ForkedWorker.new(worker).tap(&:start) : worker.tap(&:start)
-      end
-    end
-
-    # Without fork the projects share this process, where nodes can't be unloaded.
-    def restart(root)
-      return warn("[#{name(root)}] Restart raindown to load the node changes") unless fork?
-
-      worker = workers.delete(root) || return
-      worker.stop
-      puts "[#{worker.name}] Reloading nodes"
-      worker(root)
-    end
-
-    # A project in the directory is named by its path from there, and the project the directory is in by its folder.
-    def name(root)
-      return File.basename(root) unless root.start_with?(File.join(directory, ''))
-
-      root.delete_prefix(File.join(directory, ''))
-    end
-
-    # Loaded before forking, so every project's process shares them instead of loading its own.
-    def preload
-      return unless fork?
-
-      require 'lownode'
-      require 'dirload'
-    end
-
-    def fork?
-      Process.respond_to?(:fork)
-    end
-
-    # Ctrl+C reaches every process in the terminal, so the workers stop with the watcher.
-    def trap_interrupt
-      trap('INT') { exit }
-    end
-  end
-
-  # A project's worker in a forked process, which reads the files to update from a pipe until the pipe closes.
-  # The process ends with exit! as it's forked mid-call, so exit would run the watcher's ensure and stop its siblings.
-  class ForkedWorker
-    def initialize(worker)
-      @worker = worker
-    end
-
-    def name
-      @worker.name
-    end
-
-    def start
-      @writer&.close
-      reader, @writer = IO.pipe
-      @pid = fork do
-        @writer.close
-        trap('INT') { exit!(0) }
-        @worker.start
-        while (path = reader.gets)
-          @worker.update(path.chomp)
-        end
-        exit!(0)
-      end
-      reader.close
-    end
-
-    # A worker that stopped, such as from a crash, starts again for the next file.
-    def update(path, restarted: false)
-      start unless alive?
-      @writer.puts(path)
-      @writer.flush
-    rescue Errno::EPIPE
-      raise if restarted
-
-      start
-      update(path, restarted: true)
-    end
-
-    def stop
-      @writer&.close
-      Process.kill('TERM', @pid) if alive?
-      Process.wait(@pid)
-    rescue Errno::ECHILD, Errno::ESRCH
-      nil
-    end
-
-    private
-
-    def alive?
-      @pid && Process.waitpid(@pid, Process::WNOHANG).nil?
-    rescue Errno::ECHILD
-      false
-    end
-  end
-end

data/lib/raindown/tui/feelings/waffle.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Raindown
-  module TUI
-    # The waffle after the rain with a pat of butter, when a batch of code is refined, and the week's work is done:
-    #    ╔═══╦═══╦═══╦═══╦═══╗
-    #    ║   ║   ║   ║   ║   ║
-    #    ╠═══╬═══╬═══╬═══╬═══╣
-    #    ║   ║   ║███║   ║   ║
-    #    ╠═══╬═══╬═══╬═══╬═══╣
-    #    ║   ║   ║   ║   ║   ║
-    #    ╚═══╩═══╩═══╩═══╩═══╝
-    module Waffle
-      EDGE = :code_number
-      BUTTER = :button
-      WAFFLE = [
-        [['╔═══╦═══╦═══╦═══╦═══╗', EDGE]],
-        [['║   ║   ║   ║   ║   ║', EDGE]],
-        [['╠═══╬═══╬═══╬═══╬═══╣', EDGE]],
-        [['║   ║   ║', EDGE], ['███', BUTTER], ['║   ║   ║', EDGE]],
-        [['╠═══╬═══╬═══╬═══╬═══╣', EDGE]],
-        [['║   ║   ║   ║   ║   ║', EDGE]],
-        [['╚═══╩═══╩═══╩═══╩═══╝', EDGE]],
-        [['100% refined', :feelings]],
-        [['The work is mysterious and important.', :feelings]]
-      ].freeze
-
-      private
-
-      def waffle
-        top = [(height - WAFFLE.length) / 2, 0].max
-        lines = [*Array.new(top, []), *WAFFLE, *Array.new(height, [])].first(height)
-        lines.map { centred(it) }
-      end
-
-      # The parts in the middle of the width.
-      def centred(parts)
-        left = [(width - parts.sum { display_width(it[0]) }) / 2, 0].max
-        padded([segment('', :blank, width: left), *parts.map { |text, style| segment(text, style, width: display_width(text)) }])
-      end
-    end
-  end
-end

data/lib/raindown/tui/workers/workers.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../projects'
-require_relative 'worker'
-
-module Raindown
-  module TUI
-    # A Worker for each project in the terminal UI's folder: the folder's own, and every project inside it.
-    # A file's requests go to the worker of the project it's in, the nearest one above it, even when it's new.
-    # Workers start when they're first asked something.
-    class Workers
-      attr_reader :root, :roots
-
-      def initialize(root:, fork: Worker.fork?)
-        @root = root
-        @fork = fork
-        @workers = {}
-        find_roots
-      end
-
-      def for(path)
-        worker(Projects.root(path) || root)
-      end
-
-      # A worker for each project, as they were found when the workers last started.
-      def each(&)
-        roots.map { worker(it) }.each(&)
-      end
-
-      # Stops the workers, so the next requests start them again, loading their projects' nodes again,
-      # and finds the projects again, like ones added since.
-      def restart
-        stop
-        @workers.clear
-        find_roots
-      end
-
-      def stop
-        @workers.each_value(&:stop)
-      end
-
-      private
-
-      def worker(project)
-        @workers[project] ||= Worker.new(root: project, fork: @fork)
-      end
-
-      def find_roots
-        @roots = [root, *Projects.roots(root)].uniq.sort
-      end
-    end
-  end
-end

data/lib/raindown/watcher.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../raindown'
-require_relative 'rewriter'
-
-module Raindown
-  # Watches one file and writes back to it as it's saved, like its TOC, tables and endpoint responses.
-  class Watcher
-    attr_reader :path, :bare, :execute
-
-    def initialize(path:, bare: false, execute: false)
-      @path = path
-      @bare = bare
-      @execute = execute
-    end
-
-    def start
-      require 'listen'
-
-      $stdout.sync = true
-
-      safely { rewrite }
-      puts "Watching #{path} for changes..."
-
-      listener.start
-      sleep
-    end
-
-    private
-
-    def listener
-      directory = File.dirname(File.expand_path(path))
-      filename = File.basename(path)
-
-      Listen.to(directory) do |modified, added, _removed|
-        next unless (modified + added).any? { |f| File.basename(f) == filename }
-
-        # Writing back saves the file again, and that save changes nothing, so it ends there.
-        safely { puts "Updated #{path}" if rewrite }
-      end
-    end
-
-    # An error in the file is shown rather than stopping the watcher, so it can be fixed and saved again.
-    def safely
-      yield
-    rescue StandardError => e
-      raise if ENV['RAINDOWN_DEBUG']
-
-      warn "raindown: #{path}: #{e.message}"
-    end
-
-    # The files' metadata is loaded again each time, so new and renamed files are listed.
-    def rewrite
-      Rewriter.update(path:, bare:, execute:, metadata: Pages.for(path))
-    end
-  end
-end