ibex 0.1.0 → 0.2.0

data/lib/ibex/table_simulation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "table_simulation/step"
+require_relative "table_simulation/result"
+require_relative "table_simulation/simulator"
+require_relative "table_simulation/text"
+
+module Ibex
+  # Safe LR table simulation over validated Automaton IR.
+  module TableSimulation
+  end
+end

data/lib/ibex/tables.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "ibex/tables/compact"
+require "ibex/tables/compact_actions"
+require "ibex/tables/compact_productions"
+
 module Ibex
   # Parser table construction and row-displacement compression.
   module Tables
@@ -9,75 +13,6 @@ module Ibex
 
     TableSet = Struct.new(:actions, :gotos, :default_actions, keyword_init: true)
 
-    # Sparse table represented by per-row offsets and ownership checks.
-    class Compact
-      attr_reader :offsets #: Array[Integer]
-      attr_reader :values #: Array[untyped]
-      attr_reader :checks #: Array[Integer?]
-      attr_reader :row_count #: Integer
-
-      class << self
-        # @rbs (Array[Hash[Integer, untyped]] rows) -> Compact
-        def build(rows)
-          offsets = Array.new(rows.length, 0)
-          values = [] #: Array[untyped]
-          checks = [] #: Array[Integer?]
-          rows.each_index.sort_by { |row| [-rows[row].length, row] }.each do |row|
-            offset = find_offset(rows[row].keys, checks)
-            offsets[row] = offset
-            rows[row].each do |column, value|
-              index = offset + column
-              values[index] = value
-              checks[index] = row
-            end
-          end
-          new(offsets: offsets, values: values, checks: checks, row_count: rows.length)
-        end
-
-        private
-
-        # @rbs (Array[Integer] columns, Array[Integer?] checks) -> Integer
-        def find_offset(columns, checks)
-          offset = 0
-          offset += 1 while columns.any? { |column| checks[offset + column] }
-          offset
-        end
-      end
-
-      # @rbs (offsets: Array[Integer], values: Array[untyped], checks: Array[Integer?], row_count: Integer) -> void
-      def initialize(offsets:, values:, checks:, row_count:)
-        @offsets = offsets.freeze
-        @values = values.freeze
-        @checks = checks.freeze
-        @row_count = row_count
-        freeze
-      end
-
-      # @rbs (Integer row, Integer column) -> untyped
-      def lookup(row, column)
-        return nil unless row.between?(0, @row_count - 1)
-        return nil if column.negative?
-
-        index = @offsets.fetch(row) + column
-        return nil unless index.between?(0, @checks.length - 1)
-
-        @checks[index] == row ? @values[index] : nil
-      end
-
-      # @rbs (Integer row) -> Hash[Integer, untyped]
-      def row(row)
-        return {} unless row.between?(0, @row_count - 1)
-
-        result = {} #: Hash[Integer, untyped]
-        @checks.each_index do |index|
-          next unless @checks[index] == row
-
-          result[index - @offsets[row]] = @values[index]
-        end
-        result
-      end
-    end
-
     # @rbs (IR::Automaton automaton, ?format: Symbol | String) -> TableSet
     def build(automaton, format: :compact)
       action_rows = automaton.states.map do |state|
@@ -95,7 +30,11 @@ module Ibex
       end
       raise ArgumentError, "unknown table format #{format.inspect}" unless format.to_sym == :compact
 
-      TableSet.new(actions: Compact.build(action_rows), gotos: Compact.build(goto_rows), default_actions: defaults)
+      TableSet.new(
+        actions: CompactActions.build(action_rows),
+        gotos: Compact.build(goto_rows),
+        default_actions: defaults
+      )
     end
     module_function :build
 

data/lib/ibex/version.rb

@@ -2,5 +2,5 @@
 
 # Ibex generates and runs Pure Ruby LR parsers.
 module Ibex
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ibex/watch/runner.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Watch
+    # 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: ^() -> untyped, publish: ^(untyped, SourceSnapshot, ^() -> bool) -> void, failure_paths: ^() -> Array[String], stderr: untyped, 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,93 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "digest"
+
+module Ibex
+  module Watch
+    # Stable metadata and content fingerprints for watched source paths.
+    class SourceSnapshot
+      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, Hash[Symbol, untyped]]
+        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, Hash[Symbol, untyped]]
+
+      # @rbs (String path) -> Hash[Symbol, untyped]?
+      def entry(path)
+        @entries[path]
+      end
+
+      private
+
+      # @rbs (String path) -> Hash[Symbol, untyped]
+      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) -> Hash[Symbol, untyped]
+      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 (Hash[Symbol, untyped] value, String path) -> void
+      def add_resolved_target(value, path)
+        target = File.realpath(path)
+        stat = File.stat(target)
+        value[:resolved_path] = target
+        value[:resolved] = stat_signature(stat)
+        value[:resolved][:sha256] = Digest::SHA256.file(target).hexdigest if stat.file?
+      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,45 @@
 
 require_relative "ibex/version"
 require_relative "ibex/error"
+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/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