@appthreat/atom-parsetools 1.0.0

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-d8b5c5740b5a/lib/ruby_ast_gen/node_handling.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module NodeHandling
+
+  MAX_NESTING_DEPTH = 100
+
+  SINGLETONS = [:nil, :true, :false] #:__FILE__, :__LINE__, :__ENCODING__
+  LITERALS = [:int, :float, :rational, :complex, :str, :sym]
+  CALLS = [:send, :csend]
+  DYNAMIC_LITERALS = [:dsym, :dstr]
+  CONTROL_KW = [:break, :next]
+  ARGUMENTS = [:arg, :restarg, :blockarg, :kwrestarg, :shadowarg]
+  KW_ARGUMENTS = [:kwarg, :kwnilarg, :kwoptarg]
+  REFS = [:nth_ref, :back_ref]
+  FORWARD_ARGUMENTS = [:forward_args, :forwarded_args, :forward_arg]
+  ASSIGNMENTS = [:or_asgn, :and_asgn, :lvasgn, :ivasgn, :gvasgn, :cvasgn, :match_with_lvasgn]
+  BIN_OP = [:and, :or, :match_pattern, :match_pattern_p]
+  ACCESS = [:self, :ident, :lvar, :cvar, :gvar, :ivar, :splat, :kwsplat, :block_pass, :match_var]
+  QUAL_ACCESS = [:casgn]
+  COLLECTIONS = [:args, :array, :hash, :mlhs, :hash_pattern, :array_pattern, :array_pattern_with_tail, :find_pattern, :undef, :procarg0]
+  SPECIAL_CMD = [:yield, :super, :defined?, :xstr]
+  RANGE_OP = [:erange, :irange, :eflipflop, :iflipflop]
+
+  def self.fetch_member(loc, method)
+    loc.public_send(method) rescue -1
+  end
+
+  def self.ast_to_json(node, code, current_depth: 0, file_path: nil)
+    return unless node.is_a?(Parser::AST::Node)
+
+    loc = node.location
+    meta_data = {
+      start_line: fetch_member(loc, :line),
+      start_column: fetch_member(loc, :column),
+      end_line: fetch_member(loc, :last_line),
+      end_column: fetch_member(loc, :last_column),
+      offset_start: loc&.expression&.begin_pos,
+      offset_end: loc&.expression&.end_pos,
+      code: self.extract_code_snippet(loc, code)
+    }
+    if current_depth >= MAX_NESTING_DEPTH
+      RubyAstGen::Logger::warn "Reached max JSON depth on a #{node.type.to_s} node"
+      return { type: node.type.to_s, meta_data: meta_data, nested: true }
+    end
+
+    base_hash = {
+      type: node.type.to_s, # Node type (e.g., :send, :def, etc.)
+      meta_data: meta_data,
+      children: node.children.map do |child|
+        if child.is_a?(Parser::AST::Node)
+          ast_to_json(child, code, current_depth: current_depth + 1, file_path: file_path) # Recursively process child nodes
+        else
+          child # If it's not a node (e.g., literal), return as-is
+        end
+      end
+    }
+    add_node_properties(node.type, base_hash, file_path)
+    return base_hash
+  end
+
+  def self.trim_string(string)
+    string.gsub(/\n/, " ").gsub(/(\s)+/, " ")
+  end
+
+  def self.extract_code_snippet(location, source_code)
+    return nil unless location
+    range = location.expression || location
+    return nil unless range.is_a?(Parser::Source::Range)
+    snippet = source_code[range.begin_pos...range.end_pos]
+    self.trim_string(snippet.strip)
+  end
+
+  def self.add_node_properties(node_type, base_map, file_path)
+    children = base_map.delete(:children)
+
+    case node_type
+    when :def
+      base_map[:name] = children[0]
+      base_map[:arguments] = children[1]
+      base_map[:body] = children[2]
+    when :defs
+      base_map[:base] = children[0]
+      base_map[:name] = children[1]
+      base_map[:arguments] = children[2]
+      base_map[:body] = children[3]
+
+    when :class
+      base_map[:name] = children[0]
+      base_map[:superclass] = children[1] if children[1]
+      base_map[:body] = children[2]
+    when :sclass
+      base_map[:name] = children[0]
+      base_map[:def] = children[1]
+      base_map[:body] = children[2]
+    when :module
+      base_map[:name] = children[0]
+      base_map[:body] = children[1]
+
+    when :if
+      base_map[:condition] = children[0]
+      base_map[:then_branch] = children[1]
+      base_map[:else_branch] = children[2] if children[2]
+    when :while, :while_post
+      base_map[:condition] = children[0]
+      base_map[:body] = children[1]
+    when :for, :for_post
+      base_map[:variable] = children[0]
+      base_map[:collection] = children[1]
+      base_map[:body] = children[2]
+    when :block
+      base_map[:call_name] = children[0]
+      base_map[:arguments] = children[1]
+      base_map[:body] = children[2]
+    when :begin
+      base_map[:body] = children
+    when :kwbegin
+      base_map[:body] = children[0..-1]
+    when :case
+      base_map[:case_expression] = children[0]
+      base_map[:when_clauses] = children[1..-2]
+      base_map[:else_clause] = children[-1] if children[-1]
+    when :when
+      base_map[:conditions] = children[0..-2]
+      base_map[:then_branch] = children[-1]
+    when :unless
+      base_map[:condition] = children[0]
+      base_map[:then_branch] = children[1]
+    when :until, :until_post
+      base_map[:condition] = children[0]
+      base_map[:body] = children[1]
+    when :rescue, :case_match
+      base_map[:statement] = children[0]
+      base_map[:bodies] = children[1..-2]
+      base_map[:else_clause] = children[-1] if children[-1]
+    when :match_as
+      base_map[:value] = children[0]
+      base_map[:as] = children[1]
+    when :in_pattern
+      base_map[:pattern] = children[0]
+      base_map[:guard] = children[1]
+      base_map[:body] = children[2]
+    when :if_guard, :unless_guard
+      base_map[:condition] = children[0]
+    when :match_alt
+      base_map[:left] = children[0]
+      base_map[:right] = children[1]
+    when :resbody
+      base_map[:exec_list] = children[0]
+      base_map[:exec_var] = children[1]
+      base_map[:body] = children[2]
+    when :ensure
+      base_map[:statement] = children[0]
+      base_map[:body] = children[1]
+    when :regopt, *REFS, :redo
+      base_map[:value] = children[0] if children[0]
+    when :return
+      base_map[:values] = children[0..-1] if children[0]
+    when *CONTROL_KW
+      base_map[:arguments] = children[0] if children[0]
+    when *FORWARD_ARGUMENTS, :retry, :zsuper, :match_nil_pattern
+      # refer to :type
+    when *QUAL_ACCESS
+      base_map[:base] = children[0]
+      base_map[:lhs] = children[1]
+      base_map[:rhs] = children[2]
+    when :op_asgn
+      base_map[:lhs] = children[0]
+      base_map[:op] = children[1]
+      base_map[:rhs] = children[2]
+    when *ASSIGNMENTS
+      base_map[:lhs] = children[0]
+      base_map[:rhs] = children[1] if children[1]
+    when *BIN_OP
+      base_map[:lhs] = children[0]
+      base_map[:rhs] = children[1]
+    when *SINGLETONS
+      base_map[:value] = node_type
+    when *KW_ARGUMENTS
+      base_map[:key] = children[0]
+      base_map[:value] = children[1]
+    when *LITERALS, *ARGUMENTS, *ACCESS, :match_rest
+      base_map[:value] = children[0]
+    when :cbase
+      base_map[:base] = children[0]
+      base_map[:name] = children[1]
+
+    when *CALLS
+      base_map[:receiver] = children[0]
+      base_map[:name] = children[1]
+      base_map[:arguments] = children[2..-1] # Variable arguments
+    when *SPECIAL_CMD
+      base_map[:arguments] = children
+
+    when :pair, :optarg
+      base_map[:key] = children[0]
+      base_map[:value] = children[1]
+    when :const
+      base_map[:base] = children[0]
+      base_map[:name] = children[1]
+    when :alias
+      base_map[:alias] = children[0]
+      base_map[:name] = children[1]
+    when :regexp
+      base_map[:value] = children[0]
+      base_map[:opt] = children[1]
+    when *RANGE_OP
+      base_map[:start] = children[0]
+      base_map[:end] = children[1]
+
+    when :numblock
+      base_map[:call] = children[0]
+      base_map[:param_idx] = children[1]
+      base_map[:body] = children[2]
+    
+    when :masgn
+      base_map[:lhs] = children[0]
+      base_map[:rhs] = children[1]
+
+    when :preexe, :postexe
+      base_map[:body] = children[0]
+
+    when *COLLECTIONS, *DYNAMIC_LITERALS, *REFS
+      # put :children back
+      base_map[:children] = children
+
+    else
+      RubyAstGen::Logger::warn "Unhandled AST node type: #{node_type} - #{file_path}"
+      base_map[:children] = children
+    end
+  end
+
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-d8b5c5740b5a/lib/ruby_ast_gen/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubyAstGen
+  VERSION = "1.0.4"
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-d8b5c5740b5a/lib/ruby_ast_gen.rb

@@ -0,0 +1,140 @@
+$VERBOSE = nil
+require 'parser/current'
+$VERBOSE = true
+require 'fileutils'
+require 'json'
+require 'thread'
+
+require_relative 'ruby_ast_gen/version'
+require_relative 'ruby_ast_gen/node_handling'
+
+module RubyAstGen
+
+  module Logger
+
+    def self.debug(message)
+      puts "[DEBUG] #{message}"
+    end
+
+    def self.info(message)
+      puts "[INFO] #{message}"
+    end
+
+    def self.warn(message)
+      puts "[WARN] #{message}"
+    end
+
+    def self.error(message)
+      puts "[ERR] #{message}"
+    end
+  end
+
+  # Main method to parse the input and generate the AST output
+  def self.parse(opts)
+    if opts[:debug]
+      RubyAstGen::Logger::debug "CLI Arguments received: #{opts}" 
+    end
+
+    input_path = opts[:input]
+    output_dir = opts[:output]
+    exclude_regex = Regexp.new(opts[:exclude])
+
+    if opts[:debug]
+      RubyAstGen::Logger::debug "Exclude Regex Received: #{exclude_regex}"
+    end
+
+    FileUtils.mkdir_p(output_dir)
+
+    if File.file?(input_path)
+      process_file(input_path, output_dir, exclude_regex, input_path)
+    elsif File.directory?(input_path)
+      process_directory(input_path, output_dir, exclude_regex)
+    else
+      RubyAstGen::Logger::info "#{input_path} is neither a file nor a directory."
+      exit 1
+    end
+  end
+
+  private
+
+  # Process a single file and generate its AST
+  def self.process_file(file_path, output_dir, exclude_regex, base_dir)
+    # Get the relative path of the file to apply exclusion rules
+    relative_path = file_path.sub(%r{^.*\/}, '')
+    relative_input_path = file_path.sub("#{base_dir}/", '')
+    # Skip if the file matches the exclusion regex
+    if exclude_regex && exclude_regex.match?(relative_input_path)
+      RubyAstGen::Logger::debug "Excluding: #{relative_input_path}"
+      return
+    end
+
+    return unless ruby_file?(file_path) # Skip if it's not a Ruby-related file
+
+    begin
+      ast = parse_file(file_path, relative_input_path)
+      return unless ast
+
+      output_path = File.join(output_dir, "#{relative_path}.json")
+
+      File.write(output_path, JSON.generate(ast))
+    rescue StandardError => e
+      RubyAstGen::Logger::info "'#{relative_input_path}' - #{e.message}"
+    end
+  end
+
+  def self.process_directory(dir_path, output_dir, exclude_regex, max_threads = 10)
+    threads = []
+    queue = Queue.new
+
+    Dir.glob("#{dir_path}/**/*").each do |path|
+      next unless File.file?(path) && ruby_file?(path)
+      relative_dir = path.sub("#{dir_path}/", '')
+      next if exclude_regex.match?(relative_dir)
+
+      queue << path
+    end
+
+    max_threads.times do
+      threads << Thread.new do
+        until queue.empty?
+          begin
+            path = queue.pop(true) rescue nil # Non-blocking pop
+            next unless path
+
+            relative_path = path.sub(dir_path, '')
+            output_subdir = File.join(output_dir, File.dirname(relative_path))
+            FileUtils.mkdir_p(output_subdir)
+
+            process_file(path, output_subdir, exclude_regex, dir_path)
+          rescue => e
+            RubyAstGen::Logger::info "Error processing #{path}: #{e.message}"
+          end
+        end
+      end
+    end
+
+    threads.each(&:join)
+  end
+
+  def self.parse_file(file_path, relative_input_path)
+    code = File.read(file_path)
+    buffer = Parser::Source::Buffer.new(file_path)
+    buffer.source = code
+    parser = Parser::CurrentRuby.new
+    ast = parser.parse(buffer)
+    return unless ast
+    json_ast = NodeHandling::ast_to_json(ast, code, file_path: relative_input_path)
+    json_ast[:file_path] = file_path
+    json_ast[:rel_file_path] = relative_input_path
+    json_ast
+  rescue Parser::SyntaxError => e
+    RubyAstGen::Logger::info "Failed to parse #{file_path}: #{e.message}"
+    nil
+  end
+
+  def self.ruby_file?(file_path)
+    ext = File.extname(file_path)
+    %w[.rb .gemspec Rakefile .rake .ru].include?(ext) || file_path.end_with?('.rb')
+  end
+
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-d8b5c5740b5a/ruby_ast_gen.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+# stub: ruby_ast_gen 1.0.4 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "ruby_ast_gen".freeze
+  s.version = "1.0.4".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "homepage_uri" => "https://github.com/appthreat/ruby_ast_gen" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["David Baker Effendi".freeze, "Andrei Dreyer".freeze, "Team AppThreat".freeze]
+  s.bindir = "exe".freeze
+  s.date = "1980-01-02"
+  s.description = "A Ruby parser than dumps the AST as JSON output for atom `rubysrc2cpg` frontend".freeze
+  s.email = ["dave@whirlylabs.com".freeze, "andrei@whirlylabs.com".freeze, "hello@appthreat.com".freeze]
+  s.executables = ["ruby_ast_gen".freeze]
+  s.files = ["Gemfile".freeze, "exe/ruby_ast_gen".freeze, "lib/ruby_ast_gen".freeze, "lib/ruby_ast_gen.rb".freeze, "lib/ruby_ast_gen/node_handling.rb".freeze, "lib/ruby_ast_gen/version.rb".freeze, "ruby_ast_gen.gemspec".freeze]
+  s.homepage = "https://github.com/appthreat/ruby_ast_gen".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 3.1.4".freeze)
+  s.rubygems_version = "3.6.7".freeze
+  s.summary = "A Ruby parser than dumps the AST as JSON output".freeze
+
+  s.installed_by_version = "3.6.7".freeze
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-d8b5c5740b5a/spec/ruby_ast_gen_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+RSpec.describe RubyAstGen do
+  temp_name = ""
+  let(:temp_file) {
+    file = Tempfile.new('test_ruby_code')
+    temp_name = File.basename(file.path)
+    file
+  }
+
+  after(:each) do
+    temp_file.close
+    temp_file.unlink
+  end
+
+  def code(s)
+    temp_file.write(s)
+    temp_file.rewind
+  end
+
+  it "should parse a class successfully" do
+    code(<<-CODE)
+class Foo
+  CONST = 1
+end
+    CODE
+    ast = RubyAstGen::parse_file(temp_file.path, temp_name)
+    expect(ast).not_to be_nil
+  end
+
+  it "should parse assignment to HEREDOCs successfully" do
+    code(<<-CODE)
+multi_line_string = <<-TEXT
+This is a multi-line string.
+You can freely write across
+multiple lines using heredoc.
+TEXT
+    CODE
+    ast = RubyAstGen::parse_file(temp_file.path, temp_name)
+    expect(ast).not_to be_nil
+  end
+
+
+  it "should parse call with HEREDOC args successfully" do
+    code(<<-CODE)
+puts(<<-ARG1, <<-ARG2)
+This is the first HEREDOC.
+It spans multiple lines.
+ARG1
+This is the second HEREDOC.
+It also spans multiple lines.
+ARG2
+    CODE
+    ast = RubyAstGen::parse_file(temp_file.path, temp_name)
+    expect(ast).not_to be_nil
+  end
+
+  it "should create a singleton object body successfully" do
+    code(<<-CODE)
+class C
+ class << self
+  def f(x)
+   x + 1
+  end
+ end
+end
+    CODE
+    ast = RubyAstGen::parse_file(temp_file.path, temp_name)
+    expect(ast).not_to be_nil
+  end
+
+  it "should create an operator assignment successfully" do
+    code(<<-CODE)
+def foo(x)
+  x += 1
+end
+    CODE
+    ast = RubyAstGen::parse_file(temp_file.path, temp_name)
+    expect(ast).not_to be_nil
+  end
+
+  it "should create a function with a keyword option argument sucessfully" do
+    code(<<-CODE)
+def foo(a, bar: "default")
+  puts(bar)
+end
+    CODE
+    ast = RubyAstGen::parse_file(temp_file.path, temp_name)
+    expect(ast).not_to be_nil
+  end
+
+  it "should parse a large code snippet sucessfully" do
+    code(<<-CODE)
+# frozen_string_literal: true
+Railsgoat::Application.routes.draw do
+
+  get "login" => "sessions#new"
+  get "signup" => "users#new"
+  get "logout" => "sessions#destroy"
+
+  get "forgot_password" => "password_resets#forgot_password"
+  post "forgot_password" => "password_resets#send_forgot_password"
+  get "password_resets" => "password_resets#confirm_token"
+  post "password_resets" => "password_resets#reset_password"
+
+  get "dashboard/doc" => "dashboard#doc"
+
+  resources :sessions
+
+  resources :users do
+    get "account_settings"
+
+    resources :retirement
+    resources :paid_time_off
+    resources :work_info
+    resources :performance
+    resources :benefit_forms
+    resources :messages
+
+    resources :pay do
+      collection do
+        post "update_dd_info"
+        post "decrypted_bank_acct_num"
+      end
+    end
+
+  end
+
+  get "download" => "benefit_forms#download"
+  post "upload" => "benefit_forms#upload"
+
+  resources :tutorials do
+    collection do
+      get "credentials"
+    end
+  end
+
+  resources :schedule do
+    collection do
+      get "get_pto_schedule"
+    end
+  end
+
+  resources :admin do
+    get "dashboard"
+    get "get_user"
+    post "delete_user"
+    patch "update_user"
+    get "get_all_users"
+    get "analytics"
+  end
+
+  resources :dashboard do
+    collection do
+      get "home"
+      get "change_graph"
+    end
+  end
+
+  namespace :api, defaults: {format: "json"} do
+    namespace :v1 do
+      resources :users
+      resources :mobile
+    end
+  end
+
+  root to: "sessions#new"
+end
+    CODE
+    ast = RubyAstGen::parse_file(temp_file.path, temp_name)
+    expect(ast).not_to be_nil
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-d8b5c5740b5a/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "ruby_ast_gen"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-d8b5c5740b5a/update_version.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+# Script to update the version in `lib/ruby_ast_gen/version.rb`
+require 'fileutils'
+
+VERSION_FILE_PATH = 'lib/ruby_ast_gen/version.rb'
+
+
+if ARGV.empty?
+  puts "Usage: update_version.rb <new_version>"
+  exit 1
+end
+
+new_version = ARGV[0]
+unless new_version.match?(/^v\d+\.\d+\.\d+$/)
+  puts "Invalid version format. Please provide a version in the format 'vX.X.X' (e.g., v1.0.0)."
+  exit 1
+end
+stripped_version = new_version.gsub(/^v/, '')
+
+begin
+  contents = File.read(VERSION_FILE_PATH)
+rescue Errno::ENOENT
+  puts "Error: Couldn't find the version file at #{VERSION_FILE_PATH}"
+  exit 1
+end
+
+new_contents = contents.gsub(/VERSION\s*=\s*["']\d+\.\d+\.\d+["']/, "VERSION = \"#{stripped_version}\"")
+
+begin
+  File.write(VERSION_FILE_PATH, new_contents)
+  puts "Successfully updated version to #{stripped_version} in #{VERSION_FILE_PATH}"
+rescue Errno::EACCES
+  puts "Error: Insufficient permissions to update #{VERSION_FILE_PATH}"
+  exit 1
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/racc-1.8.1/gem_make.out

@@ -0,0 +1,18 @@
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+/opt/hostedtoolcache/Ruby/3.4.3/x64/bin/ruby extconf.rb
+creating Makefile
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250512-3001-2g9kdq sitelibdir\=./.gem.20250512-3001-2g9kdq clean
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250512-3001-2g9kdq sitelibdir\=./.gem.20250512-3001-2g9kdq
+compiling cparse.c
+linking shared-object racc/cparse.so
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250512-3001-2g9kdq sitelibdir\=./.gem.20250512-3001-2g9kdq install
+/usr/bin/install -c -m 0755 cparse.so ./.gem.20250512-3001-2g9kdq/racc
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250512-3001-2g9kdq sitelibdir\=./.gem.20250512-3001-2g9kdq clean

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/ast-2.4.3/LICENSE.MIT

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2013  Peter Zotov <whitequark@whitequark.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/ast-2.4.3/README.YARD.md

@@ -0,0 +1,12 @@
+{AST} is a library for manipulating abstract syntax trees.
+
+It embraces immutability; each AST node is inherently frozen at
+creation, and updating a child node requires recreating that node
+and its every parent, recursively.
+
+This is a design choice. It does create some pressure on
+garbage collector, but completely eliminates all concurrency
+and aliasing problems.
+
+See also {AST::Node}, {AST::Processor::Mixin} and {AST::Sexp} for
+additional recommendations and design patterns.