astel 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3aa35253044b63edd2bcce05297d78c15740ac93627b8d32ec909eba8dd2ce1
-  data.tar.gz: 495161fcfbd3b410f7e220002f177afa8a5c9892f97ab6a3a7360b8005e414c6
+  metadata.gz: 85e86fbd64b1c816e86880477cc01cf530f8ce5aa83b712324e789bb831b81a4
+  data.tar.gz: 7d38a73bdb0382f836c8c145fc9bb998555cf808507a27579fc3ec26fc0674b5
 SHA512:
-  metadata.gz: aee6be8604da7c4b6bfa7ff2d4c010ba987501d4c1238852095201144a1f8068807eeeaf52b59b32d6b3e2adcbe4a52703f97c2b09f082bab76ce979986c11df
-  data.tar.gz: 9365ceb989c157954fbb88fd473c6c73a6c8e8548ddd0642da65ae890a5af51ae9dcba9e8512433cb3dcac08ce19672325be307b4df319ff83de4dc44c7b8ce6
+  metadata.gz: ae4f791ade056336ef1e7364197ba6a73dbec1daf9e8c5488ebd2936e45e61d05014a1bf7b7d439d81f74acca421b3211e7f70ce5f8a96b3d0d648e265cf61e3
+  data.tar.gz: 9cb66e271a5c5111bace0dbf59528fffd8341fc1b4db935329e1a2911c67b7e47e1810848ad34785706dad5ade7920700afe7070296badb79a5ceb6a7bf30327

data/CHANGELOG.md

@@ -5,6 +5,21 @@ project follows Semantic Versioning.
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-09-07
+
+- Add the primary opt-in extension APIs `Astel::NodeSourceText`, `Astel::UnifiedDiff`, and `Astel::Diffable`, plus structured source-editing methods for `Astel::Rewriter` loaded through `astel/rewriter/structured`
+- Support operator, setter, Unicode, underscore, and quoted symbol names in `NodePattern` expressions
+- Keep `Astel::NodeExt`, `Astel::Refactor`, `Astel::Diff`, and `Astel::RewriterDiff`, together with their previous require paths, as compatibility entry points
+- Restrict `NodePattern` attributes to Prism node fields and side-effect-free node predicates; invalid node types and attributes now report their actual pattern position
+- Return unified diff output as a binary string so UTF-8 paths can be combined safely with source in other encodings
+- Preserve the source encoding when rewriting: representable replacements are transcoded, while invalid or unrepresentable byte sequences are rejected before an edit is registered
+- Preserve positional and keyword argument semantics when adding, removing, or renaming keywords, including omitted values, keyword splats, forwarded and literal blocks, surrounding comments, and multibyte source
+- Keep heredoc bodies and terminators attached to their expressions during argument removal, keyword-value replacement, line insertion, commenting, and comment-aware removal, including interpolated and multiple heredocs
+- Keep body insertions inside inline and nested definitions, place normal-body insertions before `rescue`, and preserve multiline literal contents, indentation, line endings, and non-UTF-8 source text
+- Use whitespace separators for `%w`, `%W`, `%i`, and `%I` collections and keep comments when inserting into otherwise empty collections
+- Recognize only effective frozen-string magic comments, including Emacs-style directives, and return valid empty line ranges at EOF after LF or CRLF
+- Generate sparse unified diffs with Myers' algorithm and use a bounded-memory full-replacement fallback for large edit distances instead of allocating a quadratic LCS matrix
+
 ## [0.2.0] - 2026-08-30
 
 - Add atomic `Rewriter#transaction` and `#merge!` operations

data/README.md

@@ -1,38 +1,92 @@
-# Astel
-
-[![Gem Version](https://badge.fury.io/rb/astel.svg)](https://badge.fury.io/rb/astel)
-[![Ruby](https://github.com/ydah/astel/actions/workflows/main.yml/badge.svg)](https://github.com/ydah/astel/actions/workflows/main.yml)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
-
-Astel provides fast, reusable building blocks for Ruby source analysis and
-transformation on top of [Prism](https://github.com/ruby/prism). It parses each
-source once and provides APIs for AST traversal, declarative node matching, and
-non-destructive source rewriting.
+<h1 align="center">Astel</h1>
+
+<p align="center">
+  <strong>Fast, Prism-native building blocks for Ruby source analysis and transformation</strong>
+</p>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/astel"><img src="https://img.shields.io/gem/v/astel.svg?colorB=319e8c" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/astel"><img src="https://img.shields.io/gem/dt/astel.svg" alt="Downloads"></a>
+  <img src="https://img.shields.io/badge/ruby-%3E%3D%203.3-ruby.svg" alt="Ruby Version">
+  <a href="https://github.com/ydah/astel/actions/workflows/main.yml"><img src="https://github.com/ydah/astel/actions/workflows/main.yml/badge.svg" alt="Ruby"></a>
+  <a href="LICENSE.txt"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
+</p>
+
+<p align="center">
+  <a href="#features">Features</a> ·
+  <a href="#installation">Installation</a> ·
+  <a href="#quick-start">Quick Start</a> ·
+  <a href="#core-apis">Core APIs</a> ·
+  <a href="#extensions">Extensions</a> ·
+  <a href="#development">Development</a>
+</p>
+
+---
+
+Astel parses Ruby source once with [Prism](https://github.com/ruby/prism), then
+provides focused APIs for AST traversal, declarative node matching, and
+non-destructive source rewriting. It is designed as a library for codemods,
+linters, and other Ruby tooling rather than as a rule framework or CLI.
+
+## Features
+
+- Parse source once and retain its AST, comments, errors, and formatting
+- Visit the AST once while dispatching multiple node callbacks
+- Compile reusable node patterns with captures and alternatives
+- Record byte-safe edits with deterministic conflict detection
+- Group related edits in atomic transactions and validate rewritten syntax
+- Opt into semantic refactoring helpers and unified diffs
+- Preserve source encodings, indentation, and CRLF line endings
 
 ## Installation
 
-Install Astel with Bundler:
+Add Astel to your bundle:
 
 ```sh
 bundle add astel
 ```
 
-Or install it directly with RubyGems:
+Or install it directly:
 
 ```sh
 gem install astel
 ```
 
-Astel requires Ruby 3.3 or newer and Prism 0.30 or newer, but earlier than 2.0.
+### Requirements
+
+- Ruby 3.3+
+- Prism 0.30 or newer, but earlier than 2.0
 
-## Usage
+## Quick Start
 
-Require Astel before using its APIs:
+Parse, find, and rewrite a method call:
 
 ```ruby
 require "astel"
+
+source = Astel::SourceFile.from_string("old_name\n", path: "example.rb")
+rewriter = Astel::Rewriter.new(source)
+pattern = Astel::NodePattern.compile("(call_node name: :old_name)")
+
+dispatcher = Astel::Dispatcher.new
+dispatcher.on(:call_node) do |node|
+  rewriter.replace(node.location, "new_name") if pattern.match?(node)
+end
+dispatcher.run(source.ast)
+
+rewriter.rewrite # => "new_name\n"
+source.source    # => "old_name\n"
 ```
 
+## Core APIs
+
+| API | Purpose |
+|-----|---------|
+| `Astel::SourceFile` | Parse source and expose its AST, errors, comments, and formatting |
+| `Astel::Dispatcher` | Visit the tree once and invoke callbacks by Prism node type |
+| `Astel::NodePattern` | Compile and reuse declarative AST matchers |
+| `Astel::Rewriter` | Record, validate, and apply non-destructive source edits |
+
 ### Parse source
 
 Parse a file from disk:
@@ -46,7 +100,7 @@ source.errors    # => Prism parse errors
 source.valid?    # => true when there are no parse errors
 ```
 
-Use `Astel::SourceFile.from_string` when the source is already in memory:
+Use `from_string` when the source is already in memory:
 
 ```ruby
 source = Astel::SourceFile.from_string("value = 1\n", path: "example.rb")
@@ -54,8 +108,8 @@ source = Astel::SourceFile.from_string("value = 1\n", path: "example.rb")
 
 ### Traverse the AST
 
-`Astel::Dispatcher` walks the tree once and invokes callbacks registered for
-specific Prism node types:
+`Astel::Dispatcher` invokes every callback registered for a visited Prism node
+type:
 
 ```ruby
 source = Astel::SourceFile.from_string(<<~RUBY)
@@ -72,8 +126,7 @@ Multiple callbacks can be registered for the same node type.
 
 ### Match nodes
 
-`Astel::NodePattern` compiles a declarative pattern that can be reused across
-nodes:
+`Astel::NodePattern` compiles a pattern that can be reused across nodes:
 
 ```ruby
 source = Astel::SourceFile.from_string('"value".freeze')
@@ -104,26 +157,19 @@ captures.
 
 ### Rewrite source
 
-`Astel::Rewriter` records edits without modifying the original `SourceFile`:
+`Astel::Rewriter` supports `replace`, `remove`, `insert_before`, `insert_after`,
+and `wrap`. It records edits without modifying the original `SourceFile`:
 
 ```ruby
-source = Astel::SourceFile.from_string("old_name\n")
-node = source.ast.statements.body.first
-
-rewriter = Astel::Rewriter.new(source)
 rewriter.replace(node.location, "new_name")
-
-rewriter.rewrite # => "new_name\n"
-source.source    # => "old_name\n"
+rewriter.rewrite(validate: :parse)
 ```
 
-The rewriter supports `replace`, `remove`, `insert_before`, `insert_after`, and
-`wrap`. Overlapping edits raise `Astel::Rewriter::ConflictError`, and
-`Astel::Rewriter#edits` returns an immutable snapshot of registered edits.
-Same-offset insertions are concatenated in registration order. Pass
-`duplicate_insertions: :raise` to retain the strict behavior from Astel 0.1.
+Overlapping edits raise `Astel::Rewriter::ConflictError`. Same-offset
+insertions are emitted in registration order; pass
+`duplicate_insertions: :raise` for strict duplicate handling.
 
-Group related edits atomically with a transaction:
+Group related edits atomically:
 
 ```ruby
 rewriter.transaction do |rw|
@@ -133,13 +179,11 @@ end
 ```
 
 The transaction returns `false` without registering any edits when a conflict
-occurs. Pass `raise_on_conflict: true` to raise instead. Use
-`rewrite(validate: :parse)` to reject rewritten source containing syntax errors.
+occurs. Pass `raise_on_conflict: true` to raise instead.
 
-### Source formatting
+### Inspect source formatting
 
-`SourceFile` exposes byte-based line and column lookup, line locations, source
-slicing, dominant newline detection, and indentation detection:
+`SourceFile` exposes byte-based positions and detected formatting:
 
 ```ruby
 source.line_at(node.location.start_offset)
@@ -149,12 +193,14 @@ source.newline
 source.indent_unit
 ```
 
-### Refactoring helpers
+## Extensions
+
+Extensions are opt-in and add no dependencies beyond Astel's core requirements.
 
-Load semantic source-editing helpers explicitly:
+### Structured edits
 
 ```ruby
-require "astel/refactor"
+require "astel/rewriter/structured"
 
 rewriter = Astel::Rewriter.new(source)
 rewriter.remove_keyword_argument(call_node, :required)
@@ -165,10 +211,8 @@ See [Refactoring recipes](docs/refactor.md) for the complete API and examples.
 
 ### Unified diffs
 
-Diff support is also opt-in and has no additional runtime dependency:
-
 ```ruby
-require "astel/diff"
+require "astel/unified_diff"
 
 puts rewriter.to_diff(context: 3)
 ```
@@ -177,20 +221,27 @@ As with Git-generated zero-context patches, `context: 0` requires
 `git apply --unidiff-zero`.
 
 See the [codemod guide](docs/codemod-guide.md) for an end-to-end example using
-the dispatcher, node patterns, transactions, validation, and diffs.
+dispatch, patterns, transactions, validation, and diffs.
+
+## How It Works
+
+1. `SourceFile` parses source once with Prism and retains the parse result.
+2. `Dispatcher` and `NodePattern` locate relevant nodes without reparsing.
+3. `Rewriter` records flat edits and rejects overlaps when they are registered.
+4. `rewrite` applies the edits in one pass and can validate the result with Prism.
+5. The optional diff extension renders the final change as a unified patch.
 
-## Performance and concurrency
+## Performance and Concurrency
 
-Compile node patterns once and reuse them for every candidate node. Astel also
-keeps a bounded cache of compiler output for repeated pattern strings.
+Compile node patterns once and reuse them for every candidate node. Astel keeps
+a bounded cache of compiler output for repeated pattern strings.
 
-For repository-wide tools, process independent files in worker processes at
-the application layer. Keep each `SourceFile` and its Prism AST inside the
-worker that parsed it; Astel intentionally does not own a process pool or move
-ASTs between workers.
+For repository-wide tools, process independent files in worker processes at the
+application layer. Keep each `SourceFile` and its Prism AST inside the worker
+that parsed it; Astel intentionally does not own a process pool or move ASTs
+between workers.
 
-Benchmarks for dispatching, node patterns, and rewriting are available under
-`benchmark/`:
+Benchmarks are available under `benchmark/`:
 
 ```sh
 bundle exec ruby benchmark/dispatch_bench.rb
@@ -207,20 +258,20 @@ overlapping ranges raise instead of being silently reordered or discarded.
 
 ## Development
 
-After checking out the repository, install dependencies and run the test suite:
+Install dependencies and run the test suite:
 
 ```sh
 bundle install
 bundle exec rake
 ```
 
-Verify the packaged gem with:
+Verify the packaged gem:
 
 ```sh
 bundle exec ruby script/package_smoke.rb
 ```
 
-Run the deterministic source-rewrite fuzz check against Ruby source trees with:
+Run the deterministic source-rewrite fuzz check against Ruby source trees:
 
 ```sh
 SEED=123 bundle exec ruby script/fuzz.rb path/to/gem/sources
@@ -239,5 +290,4 @@ See [CHANGELOG.md](CHANGELOG.md) for notable changes.
 
 ## License
 
-The gem is available as open source under the terms of the
-[MIT License](LICENSE.txt).
+Released under the [MIT License](LICENSE.txt).

data/docs/codemod-guide.md

@@ -5,8 +5,8 @@ Astel and Prism alone.
 
 ```ruby
 require "astel"
-require "astel/refactor"
-require "astel/diff"
+require "astel/rewriter/structured"
+require "astel/unified_diff"
 
 source = Astel::SourceFile.parse(path: "app/types/user_type.rb")
 raise "parse failed" unless source.valid?

data/docs/refactor.md

@@ -1,11 +1,11 @@
 # Refactoring recipes
 
-Load the helpers explicitly. Requiring `astel/refactor` adds them to every
+Load the helpers explicitly. Requiring `astel/rewriter/structured` adds them to every
 `Astel::Rewriter` instance.
 
 ```ruby
 require "astel"
-require "astel/refactor"
+require "astel/rewriter/structured"
 
 source = Astel::SourceFile.parse(path: "example.rb")
 rewriter = Astel::Rewriter.new(source)

data/lib/astel/diff.rb

@@ -1,135 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../astel'
+require_relative 'unified_diff'
 
 module Astel
-  module Diff
-    module_function
-
-    def unified(before, after, path:, context: 3)
-      validate_options(path, context)
-      return '' if before == after
-
-      operations = operations(before.lines(chomp: false), after.lines(chomp: false))
-      annotated = annotate(operations)
-      hunks = hunk_ranges(annotated, context)
-      output = +"--- a/#{path}\n+++ b/#{path}\n"
-      hunks.each { |range| append_hunk(output, annotated[range]) }
-      output
-    end
-
-    def operations(before, after)
-      prefix = 0
-      prefix += 1 while prefix < before.length && prefix < after.length && before[prefix] == after[prefix]
-      suffix = 0
-      while suffix < before.length - prefix && suffix < after.length - prefix &&
-            before[-suffix - 1] == after[-suffix - 1]
-        suffix += 1
-      end
-
-      old_middle = before[prefix...(before.length - suffix)]
-      new_middle = after[prefix...(after.length - suffix)]
-      before.first(prefix).map { |line| [:equal, line] } +
-        lcs_operations(old_middle, new_middle) +
-        (suffix.zero? ? [] : before.last(suffix).map { |line| [:equal, line] })
-    end
-    private_class_method :operations
-
-    def lcs_operations(before, after)
-      # ponytail: LCS is O(n*m) on the changed middle; switch to Myers if large rewrites become common.
-      lengths = Array.new(before.length + 1) { Array.new(after.length + 1, 0) }
-      (before.length - 1).downto(0) do |old_index|
-        (after.length - 1).downto(0) do |new_index|
-          lengths[old_index][new_index] = if before[old_index] == after[new_index]
-                                            lengths[old_index + 1][new_index + 1] + 1
-                                          else
-                                            [lengths[old_index + 1][new_index],
-                                             lengths[old_index][new_index + 1]].max
-                                          end
-        end
-      end
-
-      result = []
-      old_index = 0
-      new_index = 0
-      while old_index < before.length || new_index < after.length
-        if old_index < before.length && new_index < after.length && before[old_index] == after[new_index]
-          result << [:equal, before[old_index]]
-          old_index += 1
-          new_index += 1
-        elsif new_index == after.length ||
-              (old_index < before.length && lengths[old_index + 1][new_index] >= lengths[old_index][new_index + 1])
-          result << [:delete, before[old_index]]
-          old_index += 1
-        else
-          result << [:insert, after[new_index]]
-          new_index += 1
-        end
-      end
-      result
-    end
-    private_class_method :lcs_operations
-
-    def annotate(operations)
-      old_line = 1
-      new_line = 1
-      operations.map do |type, line|
-        entry = { type: type, line: line, old_line: old_line, new_line: new_line }
-        old_line += 1 unless type == :insert
-        new_line += 1 unless type == :delete
-        entry
-      end
-    end
-    private_class_method :annotate
-
-    def hunk_ranges(operations, context)
-      changed = operations.each_index.reject { |index| operations[index][:type] == :equal }
-      changed.map { |index| [[index - context, 0].max, [index + context, operations.length - 1].min] }
-             .each_with_object([]) do |(start_index, end_index), ranges|
-        if ranges.last && start_index <= ranges.last.end + 1
-          ranges[-1] = ranges.last.begin..[ranges.last.end, end_index].max
-        else
-          ranges << (start_index..end_index)
-        end
-      end
-    end
-    private_class_method :hunk_ranges
-
-    def append_hunk(output, entries)
-      old_count = entries.count { |entry| entry[:type] != :insert }
-      new_count = entries.count { |entry| entry[:type] != :delete }
-      old_start = entries.first[:old_line] - (old_count.zero? ? 1 : 0)
-      new_start = entries.first[:new_line] - (new_count.zero? ? 1 : 0)
-      output << "@@ -#{range(old_start, old_count)} +#{range(new_start, new_count)} @@\n"
-      entries.each do |entry|
-        marker = { equal: ' ', delete: '-', insert: '+' }.fetch(entry[:type])
-        output << marker << entry[:line]
-        next if entry[:line].end_with?("\n")
-
-        output << "\n\\n"
-      end
-    end
-    private_class_method :append_hunk
-
-    def range(start_line, count)
-      count == 1 ? start_line.to_s : "#{start_line},#{count}"
-    end
-    private_class_method :range
-
-    def validate_options(path, context)
-      if path.to_s.empty? || path.to_s.match?(/[\t\r\n]/)
-        raise ArgumentError, 'path must not be empty or contain control separators'
-      end
-      raise ArgumentError, 'context must be a non-negative integer' unless context.is_a?(Integer) && context >= 0
-    end
-    private_class_method :validate_options
-  end
-
-  module RewriterDiff
-    def to_diff(context: 3, path: @source_file.path)
-      Diff.unified(@source_file.source, rewrite, path: path, context: context)
-    end
-  end
+  Diff = UnifiedDiff
+  RewriterDiff = Diffable
 end
-
-Astel::Rewriter.include(Astel::RewriterDiff)

data/lib/astel/dispatcher.rb

@@ -32,7 +32,18 @@ module Astel
     end
 
     def self.install_traversal_method(type, node_class)
-      lines = [
+      source = traversal_method_source(type, node_class)
+      Traversal.class_eval(source, __FILE__, __LINE__)
+    end
+    private_class_method :install_traversal_method
+
+    def self.traversal_method_source(type, node_class)
+      [*callback_dispatch_source(type), *child_traversal_source(node_class), 'end'].join("\n")
+    end
+    private_class_method :traversal_method_source
+
+    def self.callback_dispatch_source(type)
+      [
         "def visit_#{type}(node)",
         "  callbacks = @callbacks[:#{type}]",
         '  if Astel::Dispatcher::CallbackList === callbacks',
@@ -41,34 +52,33 @@ module Astel
         '    callbacks.call(node)',
         '  end'
       ]
+    end
+    private_class_method :callback_dispatch_source
 
-      if defined?(Prism::Reflection)
-        append_reflected_children(lines, node_class)
-      else
-        lines << '  node.child_nodes.reverse_each { |child| @stack << child if child }'
+    def self.child_traversal_source(node_class)
+      unless defined?(Prism::Reflection)
+        return ['  node.child_nodes.reverse_each { |child| @stack << child if child }']
       end
 
-      lines << 'end'
-      Traversal.class_eval(lines.join("\n"), __FILE__, __LINE__)
+      Prism::Reflection.fields_for(node_class).reverse_each.flat_map do |field|
+        reflected_child_source(field)
+      end
     end
-    private_class_method :install_traversal_method
-
-    def self.append_reflected_children(lines, node_class)
-      Prism::Reflection.fields_for(node_class).reverse_each do |field|
-        name = field.name
-        case field
-        when Prism::Reflection::NodeField
-          lines << "  @stack << node.#{name}"
-        when Prism::Reflection::OptionalNodeField
-          lines << "  if (child = node.#{name})"
-          lines << '    @stack << child'
-          lines << '  end'
-        when Prism::Reflection::NodeListField
-          lines << "  node.#{name}.reverse_each { |child| @stack << child }"
-        end
+    private_class_method :child_traversal_source
+
+    def self.reflected_child_source(field)
+      case field
+      when Prism::Reflection::NodeField
+        ["  @stack << node.#{field.name}"]
+      when Prism::Reflection::OptionalNodeField
+        ["  if (child = node.#{field.name})", '    @stack << child', '  end']
+      when Prism::Reflection::NodeListField
+        ["  node.#{field.name}.reverse_each { |child| @stack << child }"]
+      else
+        []
       end
     end
-    private_class_method :append_reflected_children
+    private_class_method :reflected_child_source
 
     NODE_CLASSES.each { |type, node_class| install_traversal_method(type, node_class) }
 
@@ -84,14 +94,7 @@ module Astel
       raise ArgumentError, "unknown Prism node type: #{node_type}" unless NODE_TYPES.include?(type)
       raise ArgumentError, 'callback must respond to call' unless callback.respond_to?(:call)
 
-      registered = @callbacks[type]
-      if registered.is_a?(CallbackList)
-        registered << callback
-      elsif registered
-        @callbacks[type] = CallbackList.new([registered, callback])
-      else
-        @callbacks[type] = callback
-      end
+      register_callback(type, callback)
       self
     end
 
@@ -101,5 +104,18 @@ module Astel
       Traversal.new(@callbacks).run(ast)
       self
     end
+
+    private
+
+    def register_callback(type, callback)
+      registered = @callbacks[type]
+      if registered.is_a?(CallbackList)
+        registered << callback
+      elsif registered
+        @callbacks[type] = CallbackList.new([registered, callback])
+      else
+        @callbacks[type] = callback
+      end
+    end
   end
 end

data/lib/astel/location.rb

@@ -70,8 +70,12 @@ module Astel
       adjusted_end = end_offset + ending
       adjusted_start_column = start_column + start
       adjusted_end_column = end_column + ending
-      if adjusted_start.negative? || adjusted_start > adjusted_end ||
-         adjusted_start_column.negative? || adjusted_end_column.negative?
+      unless valid_adjustment?(
+        start_offset: adjusted_start,
+        end_offset: adjusted_end,
+        start_column: adjusted_start_column,
+        end_column: adjusted_end_column
+      )
         raise RangeError, 'adjusted location is invalid'
       end
 
@@ -92,5 +96,11 @@ module Astel
     def end_point
       self.class.point(offset: end_offset, line: end_line, column: end_column)
     end
+
+    private
+
+    def valid_adjustment?(start_offset:, end_offset:, start_column:, end_column:)
+      start_offset >= 0 && start_offset <= end_offset && start_column >= 0 && end_column >= 0
+    end
   end
 end

data/lib/astel/node_ext.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-require 'prism'
+require_relative 'node_source_text'
 
 module Astel
-  module NodeExt
-    refine Prism::Node do
-      def source_text
-        location.slice
-      end
-    end
-  end
+  NodeExt = NodeSourceText
 end