varar-core 0.5.0

data/lib/varar/core/sentences.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Varar
+  module Core
+    # Split a block of plain text into sentences on . ! ? and \n, skipping
+    # terminators inside backtick spans and double-quoted strings and treating
+    # common abbreviations as non-breaking. All offsets are UTF-16 code units
+    # into the block text. Port of sentences.ts.
+    Sentence = Data.define(:text, :start_offset, :end_offset)
+
+    module Sentences
+      ABBREVIATIONS = Set.new(['e.g.', 'i.e.', 'etc.', 'cf.', 'vs.']).freeze
+
+      module_function
+
+      def split_sentences(text)
+        cp_to_u16 = build_cp_to_u16(text)
+        n = text.length
+        out = []
+
+        # Mark no-split zones (backtick spans, double-quoted strings).
+        skip = Array.new(n, false)
+        j = 0
+        while j < n
+          c = text[j]
+          if ['`', '"'].include?(c)
+            close = text.index(c, j + 1)
+            break if close.nil?
+
+            (j..close).each { |k| skip[k] = true }
+            j = close + 1
+            next
+          end
+          j += 1
+        end
+
+        i = 0
+        segment_start = 0
+        while i < n
+          if skip[i]
+            i += 1
+            next
+          end
+          ch = text[i]
+          if ["\n", '.', '!', '?'].include?(ch)
+            if ch == '.' && inside_number_or_abbrev?(text, i)
+              i += 1
+              next
+            end
+            stop = i + 1
+            push_segment(out, text, segment_start, stop, cp_to_u16)
+            i = stop
+            i += 1 while i < n && [' ', "\n"].include?(text[i])
+            segment_start = i
+            next
+          end
+          i += 1
+        end
+
+        push_segment(out, text, segment_start, n, cp_to_u16)
+        out
+      end
+
+      # cp_to_u16[cp_i] is the UTF-16 offset of text[cp_i].
+      def build_cp_to_u16(text)
+        result = Array.new(text.length + 1, 0)
+        u16 = 0
+        text.each_char.with_index do |ch, i|
+          result[i] = u16
+          u16 += ch.ord > 0xFFFF ? 2 : 1
+        end
+        result[text.length] = u16
+        result
+      end
+
+      def inside_number_or_abbrev?(text, dot_pos)
+        prev = dot_pos.positive? ? text[dot_pos - 1] : ''
+        nxt = dot_pos + 1 < text.length ? text[dot_pos + 1] : ''
+        return true if digit?(prev) && digit?(nxt)
+
+        ABBREVIATIONS.each do |abbrev|
+          start = [0, dot_pos + 1 - abbrev.length].max
+          return true if text[start...(dot_pos + 1)] == abbrev
+        end
+        lower?(nxt)
+      end
+
+      def push_segment(out, text, start_cp, end_cp, cp_to_u16)
+        return if end_cp <= start_cp
+
+        raw = text[start_cp...end_cp]
+        stripped = raw.strip
+        return if stripped.empty?
+
+        lead = raw.length - raw.lstrip.length
+        trail = raw.length - raw.rstrip.length
+        out << Sentence.new(
+          text: stripped,
+          start_offset: cp_to_u16[start_cp + lead],
+          end_offset: cp_to_u16[end_cp - trail]
+        )
+      end
+
+      def digit?(ch)
+        !ch.empty? && ch.match?(/[0-9]/)
+      end
+
+      # Unicode-aware "is a lowercase letter": has case and is already lower.
+      def lower?(ch)
+        !ch.empty? && ch != ch.upcase && ch == ch.downcase
+      end
+    end
+  end
+end

data/lib/varar/core/span.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Varar
+  module Core
+    # A source span. Offsets and columns are **UTF-16 code units** (an astral
+    # character like 😀 counts as 2), matching the goldens and LSP's default
+    # position encoding. Lines/cols are 1-based.
+    Span = Data.define(
+      :start_offset, :end_offset,
+      :start_line, :start_col,
+      :end_line, :end_col
+    )
+
+    # UTF-16 offset conversion. Ruby strings are code-point indexed, so the
+    # whole core converts to/from UTF-16 code units here (the single riskiest
+    # part of the port — mirrors Python's span.py). Reused by the matcher and
+    # by hash.rb.
+    module Offsets
+      module_function
+
+      # UTF-16 code-unit length of a string (astral chars count as 2).
+      def utf16_len(str)
+        n = 0
+        str.each_char { |ch| n += ch.ord > 0xFFFF ? 2 : 1 }
+        n
+      end
+
+      # UTF-16 offset of the code-point index `cp_index` in `source`.
+      def to_utf16_offset(source, cp_index)
+        utf16_len(source[0...cp_index])
+      end
+
+      # Inverse of to_utf16_offset: the code-point index at a UTF-16 offset.
+      def cp_index_for_utf16(source, u16)
+        count = 0
+        source.each_char.with_index do |ch, i|
+          return i if count >= u16
+
+          count += ch.ord > 0xFFFF ? 2 : 1
+        end
+        source.length
+      end
+
+      # Slice `source` by UTF-16 offsets, returning the covered substring.
+      def utf16_slice(source, start_u16, end_u16)
+        a = cp_index_for_utf16(source, start_u16)
+        b = cp_index_for_utf16(source, end_u16)
+        source[a...b]
+      end
+
+      # 1-based [line, col] at a UTF-16 offset; col counts UTF-16 units and
+      # resets to 1 after each newline (mirrors span.ts's lineCol).
+      def line_col(source, offset_u16)
+        line = 1
+        col = 1
+        count = 0
+        source.each_char do |ch|
+          break if count >= offset_u16
+
+          width = ch.ord > 0xFFFF ? 2 : 1
+          if ch == "\n"
+            line += 1
+            col = 1
+          else
+            col += width
+          end
+          count += width
+        end
+        [line, col]
+      end
+
+      # Build a Span from UTF-16 start/end offsets.
+      def span_from_offsets(source, start_u16, end_u16)
+        start_line, start_col = line_col(source, start_u16)
+        end_line, end_col = line_col(source, end_u16)
+        Span.new(
+          start_offset: start_u16, end_offset: end_u16,
+          start_line: start_line, start_col: start_col,
+          end_line: end_line, end_col: end_col
+        )
+      end
+    end
+  end
+end

data/lib/varar/core/step_role.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Varar
+  module Core
+    # The role a step definition plays:
+    #   "stimulus" — drives the software (arranges and acts on state)
+    #   "sensor"   — the read-only assertion (the only role that returns for
+    #                comparison)
+    # Purely structural — never inspects sentence words (no Given/When/Then
+    # heuristics). Port of step-role.ts.
+    module StepRole
+      module_function
+
+      # Guess a step's role from its document-order neighbours. A step with
+      # nothing after it is most likely the observation; anything followed by
+      # other steps is most likely driving the software.
+      def infer_step_role(neighbours)
+        after = neighbours[:after] || neighbours['after'] || []
+        after.empty? ? 'sensor' : 'stimulus'
+      end
+    end
+  end
+end

data/lib/varar/core/structurer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'varar/core/span'
+require 'varar/core/ast'
+
+module Varar
+  module Core
+    # Group scanned blocks into Examples, tracking heading scope and orphan
+    # attachments. Port of structurer.ts.
+    module Structurer
+      module_function
+
+      def structure(path, source, blocks)
+        examples = []
+        orphan_attachments = []
+        scope_stack = [] # [[level, text], ...]
+        last_example_idx = -1
+        attachment_open = false
+
+        blocks.each do |block|
+          case block.kind
+          when 'heading'
+            # Pop deeper-or-equal-level entries before pushing the new heading.
+            scope_stack.pop while !scope_stack.empty? && scope_stack.last[0] >= block.level
+            scope_stack << [block.level, block.text]
+            attachment_open = false
+
+          when 'paragraph', 'list_item', 'blockquote'
+            # Merge a block into the previous example when that example's last
+            # block is an attachment (table/fence) with no blank line between.
+            if attachment_open && last_example_idx >= 0
+              prev = examples[last_example_idx]
+              prev_last = prev.body.last
+              last_is_attachment = !prev_last.nil? && %w[table fence].include?(prev_last.kind)
+              if last_is_attachment
+                between = Offsets.utf16_slice(source, prev.span.end_offset, block.span.start_offset)
+                unless between.match?(/\n\s*\n/)
+                  new_span = Offsets.span_from_offsets(source, prev.span.start_offset, block.span.end_offset)
+                  examples[last_example_idx] = Example.new(
+                    scope_stack: prev.scope_stack,
+                    span: new_span,
+                    body: prev.body + [block]
+                  )
+                  next
+                end
+              end
+            end
+
+            examples << Example.new(
+              scope_stack: scope_stack.map { |(_, text)| text },
+              span: block.span,
+              body: [block]
+            )
+            last_example_idx = examples.length - 1
+            attachment_open = true
+
+          when 'table', 'fence'
+            if attachment_open && last_example_idx >= 0
+              prev = examples[last_example_idx]
+              new_span = Offsets.span_from_offsets(source, prev.span.start_offset, block.span.end_offset)
+              examples[last_example_idx] = Example.new(
+                scope_stack: prev.scope_stack,
+                span: new_span,
+                body: prev.body + [block]
+              )
+            else
+              orphan_attachments << block
+            end
+
+          when 'thematic_break'
+            attachment_open = false
+          end
+        end
+
+        VarDoc.new(
+          path: path,
+          source: source,
+          examples: examples,
+          orphan_attachments: orphan_attachments
+        )
+      end
+    end
+  end
+end

data/lib/varar/core/table_cells.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'varar/core/span'
+
+module Varar
+  module Core
+    # Parse a Markdown/Gherkin table row into trimmed cells and per-cell source
+    # spans. Port of table-cells.ts. All offsets count UTF-16 code units.
+    module TableCells
+      module_function
+
+      # Split a `| a | b |` row into [cells, cell_spans]. +line_start_offset+
+      # is the UTF-16 offset of the row's first character within +source+.
+      def parse_row_cells(line_text, line_start_offset, source)
+        first_cp = line_text.index('|')
+        last_cp = line_text.rindex('|')
+        return [[], []] if first_cp.nil? || last_cp.nil? || last_cp <= first_cp
+
+        # Pipe positions: convert code-point index to UTF-16 (matters when
+        # astral chars precede the pipe). '|' is ASCII → 1 UTF-16 unit.
+        first_u16 = Offsets.to_utf16_offset(line_text, first_cp)
+        inner_start_u16 = first_u16 + 1
+
+        inner = line_text[(first_cp + 1)...last_cp]
+
+        cells = []
+        cell_spans = []
+        cursor = 0 # running UTF-16 position within inner
+
+        # split(-1) keeps trailing empty segments, matching JS/Python split.
+        inner.split('|', -1).each do |seg|
+          trimmed = seg.strip
+          leading = Offsets.utf16_len(seg) - Offsets.utf16_len(seg.lstrip)
+          abs_start = line_start_offset + inner_start_u16 + cursor + leading
+          cells << trimmed
+          cell_spans << Offsets.span_from_offsets(source, abs_start, abs_start + Offsets.utf16_len(trimmed))
+          cursor += Offsets.utf16_len(seg) + 1 # +1 for the '|' delimiter
+        end
+
+        [cells, cell_spans]
+      end
+    end
+  end
+end

data/lib/varar/core.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Varar
+  # The pure functional core: parse, match, plan, execute, diffs, drift, and
+  # the conformance projections. No filesystem, network, globals, or time.
+  module Core
+    VERSION = '0.5.0'
+  end
+end
+
+require 'varar/core/span'
+require 'varar/core/ast'
+require 'varar/core/table_cells'
+require 'varar/core/scanner'
+require 'varar/core/structurer'
+require 'varar/core/parse'
+require 'varar/core/step_role'
+require 'varar/core/registry'
+require 'varar/core/sentences'
+require 'varar/core/diagnostics'
+require 'varar/core/cell_diff'
+require 'varar/core/matcher'
+require 'varar/core/plan'
+require 'varar/core/deep_freeze'
+require 'varar/core/doc_string_diff'
+require 'varar/core/param_diff'
+require 'varar/core/failure_anchor'
+require 'varar/core/execute'
+require 'varar/core/hash'
+require 'varar/core/drift'
+require 'varar/core/canonical_json'
+require 'varar/core/conformance'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: varar-core
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Aslak Hellesøy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber-cucumber-expressions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 20.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 20.0.0
+description: The pure functional pipeline (parse, match, plan, execute, drift) behind
+  Vár.
+email:
+- aslak@oselvar.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/varar/core.rb
+- lib/varar/core/ast.rb
+- lib/varar/core/canonical_json.rb
+- lib/varar/core/cell_diff.rb
+- lib/varar/core/conformance.rb
+- lib/varar/core/deep_freeze.rb
+- lib/varar/core/diagnostics.rb
+- lib/varar/core/doc_string_diff.rb
+- lib/varar/core/drift.rb
+- lib/varar/core/execute.rb
+- lib/varar/core/failure_anchor.rb
+- lib/varar/core/hash.rb
+- lib/varar/core/matcher.rb
+- lib/varar/core/param_diff.rb
+- lib/varar/core/parse.rb
+- lib/varar/core/plan.rb
+- lib/varar/core/registry.rb
+- lib/varar/core/scanner.rb
+- lib/varar/core/sentences.rb
+- lib/varar/core/span.rb
+- lib/varar/core/step_role.rb
+- lib/varar/core/structurer.rb
+- lib/varar/core/table_cells.rb
+homepage: https://varar.dev
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Markdown-native BDD — pure functional core engine
+test_files: []