astel 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19a38e5beaa849b77b5d60ea2d46b1913e589a1892dd36fc6797e34e5dbd2738
-  data.tar.gz: 7de828db0d6c9e6ea66179f2f931308b9609ccade0047dc99e0b5f77e61ead5f
+  metadata.gz: 85e86fbd64b1c816e86880477cc01cf530f8ce5aa83b712324e789bb831b81a4
+  data.tar.gz: 7d38a73bdb0382f836c8c145fc9bb998555cf808507a27579fc3ec26fc0674b5
 SHA512:
-  metadata.gz: 8364cddfb8fe41deb8770e0f3ca105467820030d77c3563184aa9d087cbd8de2649d05db67058b18f04476ef410f945ef948dc12f2226bd55d607fa4ba683dfb
-  data.tar.gz: 4feb4b4cd00035245cf4b992612f0d51c67e2d7fa74decaea77b59912a481e9cc6129938ded3882b3aecd33a186535783ecf00f755e7347b08ca820d14bbd550
+  metadata.gz: ae4f791ade056336ef1e7364197ba6a73dbec1daf9e8c5488ebd2936e45e61d05014a1bf7b7d439d81f74acca421b3211e7f70ce5f8a96b3d0d648e265cf61e3
+  data.tar.gz: 9cb66e271a5c5111bace0dbf59528fffd8341fc1b4db935329e1a2911c67b7e47e1810848ad34785706dad5ade7920700afe7070296badb79a5ceb6a7bf30327

data/CHANGELOG.md

@@ -5,6 +5,32 @@ 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
+- Accept same-offset insertions by default, with an opt-in strict policy
+- Add rewrite syntax validation, wrapping, and encoding compatibility checks
+- Add source formatting and location APIs
+- Add opt-in refactoring helpers with `require "astel/refactor"`
+- Add dependency-free unified diffs with `require "astel/diff"`
+- Add weekly rewrite-and-reparse fuzzing against real gem sources
+- Keep wrapping and comment attachment atomic and idempotent across edge cases
+
 ## [0.1.0] - 2026-07-15
 
 - Initial release

data/README.md

@@ -1,37 +1,92 @@
-# 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
 
-## Usage
+- Ruby 3.3+
+- Prism 0.30 or newer, but earlier than 2.0
 
-Require Astel before using its APIs:
+## Quick Start
+
+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:
@@ -45,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")
@@ -53,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)
@@ -71,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')
@@ -103,35 +157,91 @@ 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.replace(node.location, "new_name")
+rewriter.rewrite(validate: :parse)
+```
+
+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:
+
+```ruby
+rewriter.transaction do |rw|
+  rw.replace(first.location, "first")
+  rw.replace(second.location, "second")
+end
+```
+
+The transaction returns `false` without registering any edits when a conflict
+occurs. Pass `raise_on_conflict: true` to raise instead.
+
+### Inspect source formatting
+
+`SourceFile` exposes byte-based positions and detected formatting:
+
+```ruby
+source.line_at(node.location.start_offset)
+source.column_at(node.location.start_offset)
+source.indentation_at(node.location.start_offset)
+source.newline
+source.indent_unit
+```
+
+## Extensions
+
+Extensions are opt-in and add no dependencies beyond Astel's core requirements.
+
+### Structured edits
+
+```ruby
+require "astel/rewriter/structured"
 
 rewriter = Astel::Rewriter.new(source)
-rewriter.replace(node.location, "new_name")
+rewriter.remove_keyword_argument(call_node, :required)
+rewriter.insert_into_body(class_node, "def added\nend", position: :before_private)
+```
 
-rewriter.rewrite # => "new_name\n"
-source.source    # => "old_name\n"
+See [Refactoring recipes](docs/refactor.md) for the complete API and examples.
+
+### Unified diffs
+
+```ruby
+require "astel/unified_diff"
+
+puts rewriter.to_diff(context: 3)
 ```
 
-The rewriter supports `replace`, `remove`, `insert_before`, and `insert_after`.
-Overlapping edits raise `Astel::Rewriter::ConflictError`, and
-`Astel::Rewriter#edits` returns an immutable snapshot of registered edits.
+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
+dispatch, patterns, transactions, validation, and diffs.
 
-## Performance and concurrency
+## How It Works
 
-Compile node patterns once and reuse them for every candidate node. Astel also
-keeps a bounded cache of compiler output for repeated pattern strings.
+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.
 
-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.
+## Performance and Concurrency
 
-Benchmarks for dispatching, node patterns, and rewriting are available under
-`benchmark/`:
+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.
+
+Benchmarks are available under `benchmark/`:
 
 ```sh
 bundle exec ruby benchmark/dispatch_bench.rb
@@ -139,21 +249,37 @@ bundle exec ruby benchmark/node_pattern_bench.rb
 bundle exec ruby benchmark/rewriter_bench.rb
 ```
 
+## Scope
+
+Astel intentionally does not provide a nested action tree, file discovery,
+parallel execution, a CLI, a rule framework, or a parser compatibility layer.
+Those concerns stay in applications built on Astel. Source edits remain flat;
+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:
+
+```sh
+SEED=123 bundle exec ruby script/fuzz.rb path/to/gem/sources
+```
+
+CI runs the same check weekly against Rails, RuboCop, Sidekiq, Faraday, and
+Prism source releases.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on
@@ -164,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

@@ -0,0 +1,51 @@
+# Codemod guide
+
+A codemod can parse, traverse, match, edit, validate, and display a diff using
+Astel and Prism alone.
+
+```ruby
+require "astel"
+require "astel/rewriter/structured"
+require "astel/unified_diff"
+
+source = Astel::SourceFile.parse(path: "app/types/user_type.rb")
+raise "parse failed" unless source.valid?
+
+rewriter = Astel::Rewriter.new(source)
+pattern = Astel::NodePattern.compile(
+  "(call_node receiver: nil name: :field)"
+)
+
+dispatcher = Astel::Dispatcher.new
+dispatcher.on(:call_node) do |node|
+  next unless pattern.match?(node)
+  next unless rewriter.find_keyword_argument(node, :required)
+
+  rewriter.transaction do |rw|
+    rw.remove_keyword_argument(node, :required)
+    rw.insert_keyword_argument(node, "null: false")
+  end
+end
+dispatcher.run(source.ast)
+
+puts rewriter.to_diff
+File.write(source.path, rewriter.rewrite(validate: :parse)) unless rewriter.edits.empty?
+```
+
+Transactions keep rule-level changes atomic. If one staged edit conflicts, none
+of that transaction's edits are registered. Overlapping ranges remain errors;
+Astel does not build or reconcile a nested action tree.
+
+## TreeRewriter compatibility
+
+For non-overlapping ASCII edits, Astel's output is regression-tested against
+`Parser::Source::TreeRewriter` with 5,000 randomized operation sequences.
+
+There are two intentional semantic differences:
+
+- Astel uses byte offsets, while parser uses character offsets.
+- Same-offset insertions are emitted in registration order. TreeRewriter's
+  `insert_before` emits repeated insertions in reverse registration order.
+
+Use `duplicate_insertions: :raise` when duplicate insertions should be treated
+as conflicts.

data/docs/refactor.md

@@ -0,0 +1,87 @@
+# Refactoring recipes
+
+Load the helpers explicitly. Requiring `astel/rewriter/structured` adds them to every
+`Astel::Rewriter` instance.
+
+```ruby
+require "astel"
+require "astel/rewriter/structured"
+
+source = Astel::SourceFile.parse(path: "example.rb")
+rewriter = Astel::Rewriter.new(source)
+```
+
+## Keyword arguments and lists
+
+Find, remove, replace, or insert keyword arguments:
+
+```ruby
+argument = rewriter.find_keyword_argument(call_node, :required)
+rewriter.remove_keyword_argument(call_node, :required)
+rewriter.replace_keyword_key(argument, :method)
+rewriter.replace_keyword_value(argument, "false")
+rewriter.insert_keyword_argument(call_node, "null: false")
+```
+
+The list APIs accept `Prism::ArgumentsNode`, `Prism::ArrayNode`,
+`Prism::KeywordHashNode`, and `Prism::HashNode`:
+
+```ruby
+rewriter.remove_list_element(arguments, arguments.arguments.first)
+rewriter.remove_list_elements(arguments, arguments.arguments.values_at(0, 2))
+rewriter.insert_list_element(arguments, 1, "new_value")
+```
+
+Multiple removals are calculated together and registered as one edit, keeping
+comma handling atomic.
+
+## Add a method
+
+`insert_into_body` supports classes, modules, methods, singleton classes, and
+blocks. It detects the file's indentation and newline style.
+
+```ruby
+rewriter.insert_into_body(class_node, <<~RUBY, position: :before_private)
+  def active?
+    true
+  end
+RUBY
+```
+
+Positions are `:beginning`, `:end`, `:before_private`, `{ before: node }`, and
+`{ after: node }`.
+
+## Rewrite a constant path
+
+Use the core `replace` API when the AST location already identifies the exact
+source range:
+
+```ruby
+pattern = Astel::NodePattern.compile(
+  "(constant_path_node name: :OldClient)"
+)
+
+dispatcher = Astel::Dispatcher.new
+dispatcher.on(:constant_path_node) do |node|
+  rewriter.replace(node.location, "Services::NewClient") if pattern.match?(node)
+end
+dispatcher.run(source.ast)
+```
+
+## Formatting, lines, and comments
+
+```ruby
+rewriter.indentation_of(node)
+rewriter.indent(text, level: 1)
+rewriter.dedent(text)
+rewriter.reindent(text, to: node)
+
+rewriter.remove_line(node)
+rewriter.insert_line_before(node, "before")
+rewriter.insert_line_after(node, "after")
+rewriter.comment_out(node)
+
+rewriter.leading_comments(node)
+rewriter.trailing_comment(node)
+rewriter.remove_with_comments(node)
+```

data/lib/astel/diff.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'unified_diff'
+
+module Astel
+  Diff = UnifiedDiff
+  RewriterDiff = Diffable
+end

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

@@ -33,5 +33,74 @@ module Astel
     def range
       start_offset...end_offset
     end
+
+    def empty?
+      start_offset == end_offset
+    end
+
+    def contains?(other)
+      other = self.class.from(other)
+      start_offset <= other.start_offset && end_offset >= other.end_offset
+    end
+
+    def overlaps?(other)
+      other = self.class.from(other)
+      start_offset < other.end_offset && other.start_offset < end_offset
+    end
+
+    def join(other)
+      other = self.class.from(other)
+      first = start_offset <= other.start_offset ? self : other
+      last = end_offset >= other.end_offset ? self : other
+      self.class.new(
+        start_offset: first.start_offset,
+        end_offset: last.end_offset,
+        start_line: first.start_line,
+        start_column: first.start_column,
+        end_line: last.end_line,
+        end_column: last.end_column
+      )
+    end
+
+    def adjust(start: 0, **changes)
+      ending = changes.fetch(:end, 0)
+      raise ArgumentError, "unknown keyword: #{changes.keys.first}" unless (changes.keys - [:end]).empty?
+
+      adjusted_start = start_offset + start
+      adjusted_end = end_offset + ending
+      adjusted_start_column = start_column + start
+      adjusted_end_column = end_column + ending
+      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
+
+      self.class.new(
+        start_offset: adjusted_start,
+        end_offset: adjusted_end,
+        start_line: start_line,
+        start_column: adjusted_start_column,
+        end_line: end_line,
+        end_column: adjusted_end_column
+      )
+    end
+
+    def begin_point
+      self.class.point(offset: start_offset, line: start_line, column: start_column)
+    end
+
+    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