interscript 2.4.5 → 3.0.0

data/lib/interscript/isc/grammar/concerns/items.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Interscript
+  module Isc
+    module Grammar
+      module Concerns
+        # Item expressions: the building blocks of rule matches and targets.
+        module Items
+          include Parsanol
+
+          rule(:item_atom) do
+            quoted_string |
+              str("none").as(:none) |
+              zero_width_primitive |
+              any_character |
+              any_constructor |
+              capture_constructor |
+              maybe_constructor |
+              some_constructor |
+              function_call |
+              capture_reference |
+              alias_reference
+          end
+
+          # some(...) — one or more matches (greedy).
+          rule(:some_constructor) do
+            str("some") >> str("(") >> whitespace? >>
+              item.as(:some_inner) >>
+              whitespace? >> str(")")
+          end
+
+          # Function call: upcase, downcase, title_case, reverse, etc.
+          # These appear as the `to` value in sub rules: `sub "X" upcase`.
+          rule(:function_call) do
+            (str("upcase") | str("downcase") | str("title_case") |
+              str("reverse") | str("strip") | str("swapcase")).as(:function)
+          end
+
+          rule(:zero_width_primitive) do
+            (
+              str("boundary") |
+              str("line_start") |
+              str("line_end") |
+              str("word_boundary") |
+              str("space") |
+              str("non_boundary")
+            ).as(:primitive)
+          end
+
+          # any_character — matches any single character.
+          rule(:any_character) do
+            str("any_character").as(:any_char)
+          end
+
+          rule(:any_constructor) do
+            str("any") >> str("(") >> whitespace? >>
+              (range_arg | set_arg | alias_arg | item.as(:any_item)).as(:any) >>
+              whitespace? >> str(")")
+          end
+
+          # `any(identifier)` — accept a bare alias reference inside any().
+          # Exclude zero-width primitives (space, boundary, etc.) which are
+          # handled by `item` via `zero_width_primitive` in `item_atom`.
+          rule(:alias_arg) do
+            (zero_width_primitive.absent? >> keyword.absent? >> identifier).as(:alias_ref)
+          end
+
+          # capture(...) — wraps a sub-expression with a capture group.
+          # The captured value can be referenced in the target via `ref(N)`.
+          rule(:capture_constructor) do
+            str("capture") >> str("(") >> whitespace? >>
+              item.as(:capture_inner) >>
+              whitespace? >> str(")")
+          end
+
+          # maybe(...) — optional match (zero or one occurrence).
+          rule(:maybe_constructor) do
+            str("maybe") >> str("(") >> whitespace? >>
+              item.as(:maybe_inner) >>
+              whitespace? >> str(")")
+          end
+
+          rule(:range_arg) do
+            quoted_string.as(:lo) >>
+              whitespace? >> str("..") >> whitespace? >>
+              quoted_string.as(:hi)
+          end
+
+          rule(:set_arg) do
+            quoted_string.as(:single) |
+              (str("[") >> whitespace? >>
+                (list_item >> ((comma | whitespace) >> list_item).repeat).as(:list) >>
+                whitespace? >> str("]"))
+          end
+
+          # A list item is an item expression (which includes quoted strings).
+          rule(:list_item) do
+            item
+          end
+
+          rule(:alias_reference) do
+            (keyword.absent? >> identifier >>
+              (str(".") >> identifier.as(:qualified_name)).maybe >>
+              str("{").absent?).as(:alias)
+          end
+
+          # ref(N) — reference to Nth capture group. Only valid in `to` position.
+          rule(:capture_reference) do
+            (str("ref") >> str("(") >> whitespace? >>
+              match(/[0-9]/).as(:digit) >> whitespace? >>
+              str(")")).as(:ref)
+          end
+
+          rule(:keyword) do
+            str("parallel") | str("sequence") | str("stage") |
+              str("compose") | str("separate") | str("system") |
+              str("metadata") | str("aliases") | str("tests") |
+              str("notes") | str("description") | str("name") |
+              str("authority") | str("dependency") | str("run") |
+              str("sub") | str("before") | str("after") |
+              str("not_before") | str("not_after") | str("any") |
+              str("none") | str("boundary") | str("line_start") |
+              str("line_end") | str("word_boundary") |
+              str("downcase") | str("upcase") | str("title_case") |
+              str("capture") | str("maybe") | str("some") | str("ref") |
+              str("any_character")
+          end
+
+          # Concatenation: one or more atoms. The continuation pattern
+          # requires that whitespace or `+` be IMMEDIATELY followed by
+          # something that's clearly an item_atom start (a quote, `(`,
+          # letter, etc.) AND not a block-rule keyword like `to`, `before`.
+          rule(:item) do
+            (item_atom >>
+              ((concat_sep >> item_continuation.present?) >> item_atom).repeat
+            ).as(:concatenation)
+          end
+
+          rule(:concat_sep) do
+            (whitespace? >> str("+") >> whitespace?) | whitespace
+          end
+
+          # Positive lookahead: the next thing is a valid item_atom continuation.
+          # Excludes keywords that end the item (to, before, after, not_before,
+          # not_after, the closing brace, AND `identifier =` which signals a
+          # new alias declaration).
+          rule(:item_continuation) do
+            (str("to") | str("before") | str("after") |
+              str("not_before") | str("not_after") |
+              str("}")).absent? >>
+              (identifier >> whitespace? >> str("=")).absent? >>
+              item_atom_start
+          end
+
+          rule(:item_atom_start) do
+            str('"') | str("'") |
+              match(/[A-Za-z_]/)
+          end
+
+          rule(:constraint) do
+            (str("before") >> whitespace >> item.as(:before)) |
+              (str("after") >> whitespace >> item.as(:after)) |
+              (str("not_before") >> whitespace >> item.as(:not_before)) |
+              (str("not_after") >> whitespace >> item.as(:not_after))
+          end
+
+          rule(:constraints) do
+            (whitespace >> constraint).repeat.as(:constraints)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interscript/isc/grammar/concerns/metadata.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Interscript
+  module Isc
+    module Grammar
+      module Concerns
+        # Metadata block: identity + provenance + lifecycle of a system.
+        module Metadata
+          include Parsanol
+
+          rule(:metadata_block) do
+            str("metadata") >> whitespace? >>
+              braced(metadata_field.repeat(0)).as(:metadata)
+          end
+
+          rule(:metadata_field) do
+            whitespace? >>
+              (
+                description_field |
+                relations_field |
+                system_status_field |
+                code_status_field |
+                specification_field |
+                notes_field |
+                provenance_field |
+                generic_field
+              ) >> whitespace?
+          end
+
+          rule(:authority_field) do
+            str("authority") >> whitespace >> quoted_string.as(:authority)
+          end
+
+          rule(:source_spelling_field) do
+            str("source_spelling") >> whitespace >> quoted_string.as(:source_spelling)
+          end
+
+          rule(:target_spelling_field) do
+            str("target_spelling") >> whitespace >> quoted_string.as(:target_spelling)
+          end
+
+          rule(:identifying_field) do
+            str("identifying") >> whitespace >> quoted_string.as(:identifying)
+          end
+
+          rule(:name_field) do
+            str("name") >> whitespace >> quoted_string.as(:name)
+          end
+
+          rule(:specification_field) do
+            str("specification") >> whitespace >>
+              quoted_string.as(:specification) >>
+              (comma >> quoted_string.as(:specification)).repeat
+          end
+
+          rule(:description_field) do
+            str("description") >> whitespace? >>
+              braced(raw_text.as(:description))
+          end
+
+          rule(:system_status_field) do
+            str("system_status") >> whitespace >>
+              (str("current") | str("former") | str("inactive")).as(:system_status)
+          end
+
+          rule(:code_status_field) do
+            str("code_status") >> whitespace >>
+              (str("preferred") | str("proposed") | str("deprecated")).as(:code_status)
+          end
+
+          rule(:relations_field) do
+            str("relations") >> whitespace? >>
+              braced(relation_block.repeat(0)).as(:relations)
+          end
+
+          rule(:relation_block) do
+            whitespace? >>
+              relation_type.as(:type) >> whitespace >>
+              quoted_string.as(:system) >>
+              (whitespace >> str("note") >> whitespace >>
+                quoted_string.as(:note)).maybe >>
+              whitespace?
+          end
+
+          rule(:relation_type) do
+            str("supersedes") | str("superseded_by") | str("based_on") |
+              str("basis_for") | str("alias_of") | str("adopted_from") |
+              str("related_to")
+          end
+
+          rule(:notes_field) do
+            str("notes") >> whitespace? >>
+              braced(note_line.repeat(0).as(:notes))
+          end
+
+          rule(:note_line) do
+            whitespace? >>
+              str("note") >> whitespace? >>
+              quoted_string.as(:note) >> whitespace?
+          end
+
+          rule(:provenance_field) do
+            str("provenance") >> whitespace? >>
+              quoted_string.as(:provenance) >>
+              (comma >> quoted_string.as(:provenance)).repeat
+          end
+
+          # Generic field: any identifier followed by a bare value (string,
+          # number, or whitespace-delimited tokens up to the next field or
+          # close brace). This makes the parser permissive about future
+          # field additions; semantic validation happens in DocumentBuilder.
+          rule(:generic_field) do
+            identifier.as(:field_name) >> inline_whitespace? >>
+              (empty_field |
+               field_value.as(:field_value) |
+               braced(raw_text.as(:field_block)))
+          end
+
+          rule(:field_value) do
+            quoted_string |
+              (newline.absent? >> (str("}").absent? >> str("{").absent? >> any)).repeat(1).as(:raw)
+          end
+
+          rule(:empty_field) do
+            # An identifier with no value (just newline or `}` after). Use
+            # lookahead without consuming.
+            newline.present? | str("}").present?
+          end
+
+          # Raw text inside `{ ... }` — for description blocks. Consumes any
+          # character that isn't an unescaped closing brace. Literal braces
+          # inside the body are escaped as `\{` and `\}` by the codemod.
+          rule(:raw_text) do
+            (str("\\{") | str("\\}") | (str("}").absent? >> any)).repeat
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interscript/isc/grammar/concerns/primitives.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Interscript
+  module Isc
+    module Grammar
+      module Concerns
+        # Lexical primitives shared by every other concern.
+        # Mirrors the structure of LutaML LML's Concerns::Primitives.
+        module Primitives
+          include Parsanol
+
+          # -- Whitespace and comments
+
+          rule(:space) { match(/\s/).repeat(1) }
+          rule(:space?) { space.maybe }
+
+          rule(:newline) { str("\n") | str("\r\n") | str("\r") }
+          rule(:newlines) { newline.repeat(1) }
+          rule(:newlines?) { newlines.maybe }
+
+          rule(:line_comment) do
+            str("#") >> (newline.absent? >> any).repeat
+          end
+
+          rule(:whitespace) do
+            (space | line_comment).repeat(1)
+          end
+          rule(:whitespace?) { whitespace.maybe }
+
+          # Inline whitespace: spaces and tabs only, NO newlines. Used between
+          # a field name and its value to prevent eating the newline that
+          # signals an empty value.
+          rule(:inline_space) { match(/[ \t]/).repeat(1) }
+          rule(:inline_whitespace) do
+            (inline_space | line_comment).repeat(1)
+          end
+          rule(:inline_whitespace?) { inline_whitespace.maybe }
+
+          # Comma, used in lists. Trailing whitespace allowed.
+          rule(:comma) { str(",") >> whitespace? }
+
+          # Arrow, used in tests.
+          rule(:arrow) { whitespace? >> str("->") >> whitespace? }
+
+          # -- Identifiers
+
+          rule(:identifier_first) { match(/[a-zA-Z_]/) }
+          rule(:identifier_rest) { match(/[a-zA-Z0-9_]/) }
+          rule(:identifier) do
+            (identifier_first >> identifier_rest.repeat).as(:identifier)
+          end
+
+          # -- String literals
+
+          rule(:escape_sequence) do
+            str("\\") >> (
+              str("n").as(:newline) |
+              str("r").as(:carriage_return) |
+              str("t").as(:tab) |
+              str('"').as(:dquote) |
+              str("\\").as(:backslash) |
+              (str("u") >> match(/[0-9a-fA-F]/).repeat(4, 4).as(:unicode)) |
+              # The corpus converter emits \U with 4 hex digits too
+              # (gki-bel "\U040E") — accept 4..8, don't be stricter than
+              # the corpus.
+              (str("U") >> match(/[0-9a-fA-F]/).repeat(4, 8).as(:unicode)) |
+              # Converter-corrupted files (un-mar) contain a bare \\U with no
+              # hex digits at all — parse it as a literal U so the map loads.
+              str("U").as(:u_lone)
+            )
+          end
+
+          # Single-quoted strings: no escape interpretation.
+          rule(:single_quoted_string) do
+            str("'") >>
+              (str("'").absent? >> any).repeat.as(:string) >>
+              str("'")
+          end
+
+          # Double-quoted strings: \\uXXXX, \\n, etc. are interpreted.
+          # Escape-free stretches are captured as ONE run slice — a
+          # per-char capture allocates a hash + slice per character
+          # (~700k nodes for a large map) and the Transform pattern
+          # match grinds on them even under the native parse engine.
+          rule(:plain_run) do
+            (str("\\") | str('"')).absent? >> any
+          end
+          rule(:double_quoted_string) do
+            str('"') >>
+              (escape_sequence | plain_run.repeat(1).as(:run)).repeat.as(:string) >>
+              str('"')
+          end
+
+          rule(:quoted_string) do
+            double_quoted_string | single_quoted_string
+          end
+
+          # -- Brace-delimited block scaffold
+
+          # Wrap an inner rule in `{ ... }` with optional surrounding whitespace.
+          def braced(inner)
+            str("{") >> whitespace? >>
+              inner >>
+              whitespace? >> str("}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interscript/isc/grammar/concerns/stages.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Interscript
+  module Isc
+    module Grammar
+      module Concerns
+        # Stages: ordered transformation pipelines.
+        module Stages
+          include Parsanol
+
+          rule(:stage_block) do
+            str("stage") >>
+              (str("(") >> identifier.as(:stage_name) >> str(")") |
+               whitespace >> identifier.as(:stage_name)) >> whitespace? >>
+              braced(stage_item.repeat(0)).as(:stage)
+          end
+
+          rule(:stage_item) do
+            whitespace? >>
+              (sequence_block | parallel_block | run_rule | separate_directive |
+                string_case_directive | compose_directive | rababa_directive |
+                bare_rule | comment_item) >>
+              whitespace?
+          end
+
+          # Comments and stray identifiers are silently consumed.
+          rule(:comment_item) do
+            (str("#") >> (str("\n").absent? >> any).repeat).as(:comment) |
+              identifier.as(:noop)
+          end
+
+          # Bare rule directly in a stage body (not wrapped in sequence/parallel).
+          # The original .imp allows this; treat it as a one-rule sequence.
+          rule(:bare_rule) do
+            rule.as(:bare_rule)
+          end
+
+          rule(:sequence_block) do
+            str("sequence") >> whitespace? >>
+              braced(rule_line.repeat(0)).as(:sequence)
+          end
+
+          rule(:parallel_block) do
+            str("parallel") >> whitespace? >>
+              braced(rule_line.repeat(0)).as(:parallel)
+          end
+
+          rule(:separate_directive) do
+            str("separate").as(:separate) >>
+              (whitespace >> str("separator") >> whitespace >>
+                item_atom.as(:separator)).maybe
+          end
+
+          # `downcase`, `upcase`, `title_case` — string-case directives.
+          # title_case takes an optional word_separator kwarg.
+          rule(:string_case_directive) do
+            (str("downcase") | str("upcase")).as(:case) |
+              (str("title_case").as(:case) >>
+                (whitespace >> kwarg_list.as(:case_kwargs)).maybe)
+          end
+
+          # `compose` / `decompose` — Unicode normalization directives.
+          rule(:compose_directive) do
+            str("compose").as(:compose) | str("decompose").as(:compose)
+          end
+
+          # `rababa config: "key"` — invoke the rababa diacritization service.
+          # The keyword arguments are passed through to the runtime funcall.
+          rule(:rababa_directive) do
+            str("rababa").as(:funcall_name) >>
+              (whitespace >> kwarg_list.as(:funcall_kwargs)).maybe
+          end
+
+          # `name: "value"` (`,`-separated). Used by rababa and other
+          # function-call directives. Each kwarg is captured as a
+          # subtree so multiple kwargs collect into a list.
+          rule(:kwarg_list) do
+            kwarg.as(:kwarg) >> (str(",") >> whitespace? >> kwarg.as(:kwarg)).repeat
+          end
+
+          rule(:kwarg) do
+            identifier.as(:kwarg_name) >> whitespace? >>
+              str(":") >> whitespace? >>
+              quoted_string.as(:kwarg_value)
+          end
+
+          rule(:rule_line) do
+            whitespace? >> (rule | comment_item) >> whitespace?
+          end
+
+          # A rule is either compact form (single line) or block form
+          # (multi-line). Both produce the same semantic node.
+          #
+          # In compact form, `from` and `to` are single atoms (no concatenation).
+          # This covers the 95% case (`sub "щ" "shch"`). Multi-atom matches
+          # require the block form.
+          rule(:rule) do
+            block_rule | compact_rule
+          end
+
+          rule(:compact_rule) do
+            str("sub") >> whitespace >>
+              item_atom.as(:from) >> whitespace >>
+              item_atom.as(:to) >>
+              constraints
+          end
+
+          rule(:block_rule) do
+            str("sub") >> whitespace? >>
+              str("{") >> whitespace? >>
+              str("from") >> whitespace >> item.as(:from) >> whitespace? >>
+              str("to") >> whitespace >> item.as(:to) >>
+              (whitespace >> constraint).repeat.as(:constraints) >>
+              whitespace? >> str("}")
+          end
+
+          rule(:run_rule) do
+            str("run") >> whitespace >>
+              ((str("map.") >> identifier.as(:dep) >>
+                str(".stage.") >> identifier.as(:stage)) |
+               (str("stage.") >> identifier.as(:stage)).as(:run_stage_only))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interscript/isc/grammar/concerns/system.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Interscript
+  module Isc
+    module Grammar
+      module Concerns
+        # Top-level system block.
+        module System
+          include Parsanol
+
+          # A block-item is any of the top-level constructs that may appear
+          # inside `system "<code>" { ... }`.
+          rule(:block_item) do
+            whitespace? >>
+              (metadata_block | aliases_block | tests_block |
+                stage_block | dependency_decl) >>
+              whitespace?
+          end
+
+          rule(:system_block) do
+            str("system") >> whitespace >>
+              quoted_string.as(:system_code) >> whitespace? >>
+              braced(block_item.repeat(0)).as(:body) >>
+              whitespace?
+          end
+
+          # Root rule.
+          rule(:isc_source) do
+            whitespace? >> system_block.as(:system) >> whitespace?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interscript/isc/grammar/concerns/tests.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Interscript
+  module Isc
+    module Grammar
+      module Concerns
+        # Tests block: normative input/output pairs.
+        module Tests
+          include Parsanol
+
+          rule(:tests_block) do
+            str("tests") >> whitespace? >>
+              braced(test_line.repeat(0)).as(:tests)
+          end
+
+          rule(:test_line) do
+            whitespace? >>
+              quoted_string.as(:input) >>
+              arrow >>
+              quoted_string.as(:expected) >>
+              (whitespace >> str("note") >> whitespace >>
+                quoted_string.as(:note)).maybe >>
+              whitespace?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interscript/isc/grammar/concerns.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Interscript
+  module Isc
+    module Grammar
+      module Concerns
+        autoload :Primitives, "interscript/isc/grammar/concerns/primitives"
+        autoload :Items, "interscript/isc/grammar/concerns/items"
+        autoload :Metadata, "interscript/isc/grammar/concerns/metadata"
+        autoload :Aliases, "interscript/isc/grammar/concerns/aliases"
+        autoload :Tests, "interscript/isc/grammar/concerns/tests"
+        autoload :Stages, "interscript/isc/grammar/concerns/stages"
+        autoload :Dependencies, "interscript/isc/grammar/concerns/dependencies"
+        autoload :System, "interscript/isc/grammar/concerns/system"
+      end
+    end
+  end
+end

data/lib/interscript/isc/grammar/core.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Interscript
+  module Isc
+    module Grammar
+      # Core grammar: composes every concern into a single Parser ancestor.
+      # Mirrors the structure of LutaML LML's Grammar::Core.
+      module Core
+        include Parsanol
+        include Concerns::Primitives
+        include Concerns::Items
+        include Concerns::Metadata
+        include Concerns::Aliases
+        include Concerns::Tests
+        include Concerns::Stages
+        include Concerns::Dependencies
+        include Concerns::System
+      end
+    end
+  end
+end