ibex 0.1.0 → 0.3.0

data/lib/ibex/watch/runner.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Watch
+    # @rbs!
+    #   interface _BuildResult
+    #     def source_paths: () -> Array[String]
+    #     def attempted_paths: () -> Array[String]
+    #   end
+    #   interface _Output
+    #     def puts: (*Object?) -> Object?
+    #   end
+
+    # Polls source fingerprints, debounces changes, and publishes stable builds.
+    class Runner
+      DEFAULT_INTERVAL = 0.25 #: Float
+      DEFAULT_DEBOUNCE = 0.05 #: Float
+
+      # rubocop:disable Layout/LineLength
+      # @rbs (paths: Array[String], build: ^() -> _BuildResult, publish: ^(_BuildResult, SourceSnapshot, ^() -> bool) -> void, failure_paths: ^() -> Array[String], stderr: _Output, clock: ^() -> Float, sleeper: ^(Float) -> void, iteration_hook: ^(Symbol, Integer, Array[String]) -> (Integer | Symbol | nil), ?interval: Float, ?debounce: Float) -> void
+      def initialize(paths:, build:, publish:, failure_paths:, stderr:, clock:, sleeper:, iteration_hook:,
+                     interval: DEFAULT_INTERVAL, debounce: DEFAULT_DEBOUNCE)
+        @fixed_paths = normalize_paths(paths)
+        @successful_paths = [] #: Array[String]
+        @paths = @fixed_paths
+        @build = build
+        @publish = publish
+        @failure_paths = failure_paths
+        @stderr = stderr
+        @clock = clock
+        @sleeper = sleeper
+        @iteration_hook = iteration_hook
+        @interval = interval
+        @debounce = debounce
+        @signal_status = nil #: Integer?
+        @requested_status = nil #: Integer?
+        @last_failure_message = nil #: String?
+        @last_failure_snapshot = nil #: SourceSnapshot?
+        @iteration = 0
+      end
+      # rubocop:enable Layout/LineLength
+
+      # @rbs () -> Integer
+      def run
+        with_signal_handlers do
+          snapshot = SourceSnapshot.new(@paths)
+          loop do
+            status = stop_status(:before_build)
+            return status if status
+
+            snapshot, retry_build = build_once(snapshot)
+            status = stop_status(:after_build)
+            return status if status
+
+            if retry_build
+              snapshot = debounce(snapshot)
+              status = @signal_status || @requested_status
+              return status if status
+
+              next
+            end
+
+            snapshot = wait_for_change(snapshot)
+            status = @signal_status || @requested_status
+            return status if status
+          end
+        end
+      end
+
+      private
+
+      # @rbs (SourceSnapshot before) -> [SourceSnapshot, bool]
+      def build_once(before)
+        @iteration += 1
+        result = @build.call
+        @paths = normalize_paths(@fixed_paths + result.source_paths + result.attempted_paths)
+        rendered = SourceSnapshot.new(@paths)
+        return [rendered, true] unless rendered.unchanged_since?(before)
+        return [rendered, false] if @signal_status
+
+        @publish.call(result, rendered, -> { @signal_status.nil? })
+        @last_failure_message = nil
+        @last_failure_snapshot = nil
+        @successful_paths = @paths - @fixed_paths
+        published = SourceSnapshot.new(@paths)
+        [published, published != rendered]
+      rescue GenerationTransaction::SourceChanged
+        [SourceSnapshot.new(@paths), true]
+      rescue GenerationTransaction::Error => e
+        raise if e.rollback_failed
+
+        failed_build(before, e)
+      rescue Ibex::Error, SystemCallError, SystemStackError => e
+        failed_build(before, e)
+      end
+
+      # @rbs (SourceSnapshot snapshot) -> SourceSnapshot
+      def wait_for_change(snapshot)
+        loop do
+          @sleeper.call(@interval)
+          return snapshot if @signal_status
+
+          status = stop_status(:poll)
+          return snapshot if status
+
+          changed = SourceSnapshot.new(@paths)
+          next if changed == snapshot
+
+          return debounce(changed)
+        end
+      end
+
+      # @rbs (SourceSnapshot changed) -> SourceSnapshot
+      def debounce(changed)
+        loop do
+          @clock.call
+          @sleeper.call(@debounce)
+          return changed if @signal_status
+
+          settled = SourceSnapshot.new(@paths)
+          return settled if settled == changed
+
+          changed = settled
+        end
+      end
+
+      # @rbs (Exception error) -> void
+      def report_failure(error)
+        @stderr.puts(error.message)
+      end
+
+      # @rbs (SourceSnapshot before, Exception error) -> [SourceSnapshot, bool]
+      def failed_build(before, error)
+        previous_paths = @paths
+        @paths = normalize_paths(@fixed_paths + @successful_paths + @failure_paths.call)
+        current = SourceSnapshot.new(@paths)
+        retry_build = @paths != previous_paths || !current.unchanged_since?(before)
+        report_failure_once(error, current)
+        [current, retry_build]
+      end
+
+      # @rbs (Exception error, SourceSnapshot snapshot) -> void
+      def report_failure_once(error, snapshot)
+        duplicate = @last_failure_message == error.message && @last_failure_snapshot == snapshot
+        report_failure(error) unless duplicate
+        @last_failure_message = error.message
+        @last_failure_snapshot = snapshot
+      end
+
+      # @rbs (Symbol event) -> Integer?
+      def stop_status(event)
+        return @signal_status if @signal_status
+
+        result = @iteration_hook.call(event, @iteration, @paths.dup)
+        @requested_status = result if result.is_a?(Integer)
+        @requested_status = 0 if result == :stop
+        return @requested_status if @requested_status
+
+        nil
+      end
+
+      # @rbs (Array[String] paths) -> Array[String]
+      def normalize_paths(paths)
+        paths.map { |path| File.expand_path(path) }.uniq.sort
+      end
+
+      # @rbs () { () -> Integer } -> Integer
+      def with_signal_handlers
+        previous = {} #: Hash[String, untyped]
+        if Thread.current == Thread.main
+          previous["INT"] = Signal.trap("INT") { @signal_status = 130 }
+          previous["TERM"] = Signal.trap("TERM") { @signal_status = 143 }
+        end
+        yield
+      ensure
+        previous&.each { |signal, handler| Signal.trap(signal, handler) }
+      end
+    end
+  end
+end

data/lib/ibex/watch/source_snapshot.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "digest"
+
+module Ibex
+  module Watch
+    # Stable metadata and content fingerprints for watched source paths.
+    class SourceSnapshot
+      # @rbs!
+      #   type fingerprint_value = Symbol | String | Integer | nil | Hash[Symbol, fingerprint_value]
+      #   type fingerprint = Hash[Symbol, fingerprint_value]
+
+      attr_reader :paths #: Array[String]
+
+      # @rbs (Array[String] paths) -> void
+      def initialize(paths)
+        @paths = paths.map { |path| File.expand_path(path) }.uniq.sort.freeze
+        @entries = @paths.to_h { |path| [path, fingerprint(path)] }.freeze #: Hash[String, fingerprint]
+        freeze
+      end
+
+      # @rbs (SourceSnapshot other) -> bool
+      def ==(other)
+        @entries == other.__send__(:entries)
+      end
+
+      # Every path in this snapshot must have had the same value in the older snapshot.
+      # @rbs (SourceSnapshot older) -> bool
+      def unchanged_since?(older)
+        @paths.all? do |path|
+          older.__send__(:entry, path) == @entries.fetch(path)
+        end
+      end
+
+      protected
+
+      attr_reader :entries #: Hash[String, fingerprint]
+
+      # @rbs (String path) -> fingerprint?
+      def entry(path)
+        @entries[path]
+      end
+
+      private
+
+      # @rbs (String path) -> fingerprint
+      def fingerprint(path)
+        stat = File.lstat(path)
+        value = stat_signature(stat)
+        if stat.symlink?
+          value[:readlink] = File.readlink(path)
+          add_resolved_target(value, path)
+        else
+          value[:resolved_path] = File.realpath(path)
+          value[:sha256] = Digest::SHA256.file(path).hexdigest if stat.file?
+        end
+        value
+      rescue SystemCallError => e
+        { kind: :error, error: e.class.name, errno: e.respond_to?(:errno) ? e.errno : nil }
+      end
+
+      # @rbs (File::Stat stat) -> fingerprint
+      def stat_signature(stat)
+        {
+          kind: file_kind(stat), dev: stat.dev, ino: stat.ino, size: stat.size,
+          mtime_ns: nanoseconds(stat.mtime), ctime_ns: nanoseconds(stat.ctime)
+        }
+      end
+
+      # @rbs (File::Stat stat) -> Symbol
+      def file_kind(stat)
+        return :file if stat.file?
+        return :directory if stat.directory?
+        return :symlink if stat.symlink?
+
+        :other
+      end
+
+      # @rbs (Time time) -> Integer
+      def nanoseconds(time)
+        (time.to_i * 1_000_000_000) + time.nsec
+      end
+
+      # @rbs (fingerprint value, String path) -> void
+      def add_resolved_target(value, path)
+        target = File.realpath(path)
+        stat = File.stat(target)
+        value[:resolved_path] = target
+        resolved = stat_signature(stat)
+        resolved[:sha256] = Digest::SHA256.file(target).hexdigest if stat.file?
+        value[:resolved] = resolved
+      rescue SystemCallError => e
+        value[:resolved] = { kind: :error, error: e.class.name, errno: e.respond_to?(:errno) ? e.errno : nil }
+      end
+    end
+  end
+end

data/lib/ibex/watch.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "watch/source_snapshot"
+require_relative "watch/runner"
+
+module Ibex
+  # Portable polling support for repeatable parser generation.
+  module Watch
+  end
+end

data/lib/ibex.rb

@@ -3,21 +3,55 @@
 
 require_relative "ibex/version"
 require_relative "ibex/error"
+require_relative "ibex/configuration"
+require_relative "ibex/messages"
+require_relative "ibex/location"
+require_relative "ibex/error_messages"
+require_relative "ibex/artifact_set"
+require_relative "ibex/generation_input"
+require_relative "ibex/generation_manifest"
+require_relative "ibex/generation_transaction"
+require_relative "ibex/watch"
 require_relative "ibex/tables"
-require_relative "ibex/runtime"
+require "ibex/runtime"
+require_relative "ibex/coverage"
+require_relative "ibex/table_simulation"
 require_relative "ibex/frontend"
 require_relative "ibex/ir"
 require_relative "ibex/normalize"
 require_relative "ibex/analysis"
+require_relative "ibex/samples"
+require_relative "ibex/fuzz"
+require_relative "ibex/delta_reducer"
+require_relative "ibex/verify"
+require_relative "ibex/equiv"
+require_relative "ibex/diff"
+require_relative "ibex/metrics"
+require_relative "ibex/fix"
+require_relative "ibex/bison_import"
+require_relative "ibex/grammar_tests"
+require_relative "ibex/racc_migration"
 require_relative "ibex/lalr"
 require_relative "ibex/codegen/symbol_labels"
 require_relative "ibex/codegen/report"
+require_relative "ibex/codegen/explain"
+require_relative "ibex/codegen/ambiguity"
+require_relative "ibex/codegen/action_locations"
+require_relative "ibex/codegen/generated_action_abi"
+require_relative "ibex/codegen/action_method_source"
+require_relative "ibex/codegen/cst_metadata"
+require_relative "ibex/codegen/ruby_actions"
 require_relative "ibex/codegen/ruby"
 require_relative "ibex/codegen/rbs"
+require_relative "ibex/codegen/action_source"
 require_relative "ibex/codegen/dot"
+require_relative "ibex/codegen/mermaid"
 require_relative "ibex/codegen/html"
+require_relative "ibex/codegen/railroad"
+require_relative "ibex/codegen/documentation"
 
 # Ibex generates and runs Pure Ruby LR parsers.
 module Ibex
   ParseError = Runtime::ParseError #: singleton(Runtime::ParseError)
+  ResourceLimitError = Runtime::ResourceLimitError #: singleton(Runtime::ResourceLimitError)
 end