@appthreat/atom 2.0.24 → 2.1.0

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

@@ -0,0 +1,139 @@
+require 'parser/current'
+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::error "#{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::info "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.pretty_generate(ast))
+      RubyAstGen::Logger::info "Processed: #{relative_input_path} -> #{output_path}"
+    rescue StandardError => e
+      RubyAstGen::Logger::error "'#{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::error "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::error "Failed to parse #{file_path}: #{e.message}"
+    nil
+  end
+
+  def self.ruby_file?(file_path)
+    ext = File.extname(file_path)
+    ['.rb', '.gemspec', 'Rakefile'].include?(ext) || file_path.end_with?('.rb')
+  end
+
+end

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

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+# stub: ruby_ast_gen 0.34.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "ruby_ast_gen".freeze
+  s.version = "0.34.0".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "homepage_uri" => "https://github.com/whirlylabs/ruby_ast_gen" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["David Baker Effendi".freeze, "Andrei Dreyer".freeze]
+  s.bindir = "exe".freeze
+  s.date = "2025-01-10"
+  s.description = "A Ruby parser than dumps the AST as JSON output for Joern's `rubysrc2cpg` frontend".freeze
+  s.email = ["dave@whirlylabs.com".freeze, "andrei@whirlylabs.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, "sig/ruby_ast_gen.rbs".freeze]
+  s.homepage = "https://github.com/whirlylabs/ruby_ast_gen".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 3.0.7".freeze)
+  s.rubygems_version = "3.6.2".freeze
+  s.summary = "A Ruby parser than dumps the AST as JSON output".freeze
+
+  s.installed_by_version = "3.6.2".freeze
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-1c6e88faec50/sig/ruby_ast_gen.rbs

@@ -0,0 +1,3 @@
+module RubyAstGen
+  VERSION: String
+end

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

@@ -0,0 +1,93 @@
+# 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
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/bundler/gems/ruby_ast_gen-1c6e88faec50/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-1c6e88faec50/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/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+/opt/hostedtoolcache/Ruby/3.4.1/x64/bin/ruby extconf.rb
+creating Makefile
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250110-2738-8nl9so sitelibdir\=./.gem.20250110-2738-8nl9so clean
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250110-2738-8nl9so sitelibdir\=./.gem.20250110-2738-8nl9so
+compiling cparse.c
+linking shared-object racc/cparse.so
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250110-2738-8nl9so sitelibdir\=./.gem.20250110-2738-8nl9so install
+/usr/bin/install -c -m 0755 cparse.so ./.gem.20250110-2738-8nl9so/racc
+
+current directory: /home/runner/work/atom/atom/wrapper/nodejs/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
+make DESTDIR\= sitearchdir\=./.gem.20250110-2738-8nl9so sitelibdir\=./.gem.20250110-2738-8nl9so clean

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/ast-2.4.2/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.2/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.

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/ast-2.4.2/lib/ast/node.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module AST
+  # Node is an immutable class, instances of which represent abstract
+  # syntax tree nodes. It combines semantic information (i.e. anything
+  # that affects the algorithmic properties of a program) with
+  # meta-information (line numbers or compiler intermediates).
+  #
+  # Notes on inheritance
+  # ====================
+  #
+  # The distinction between semantics and metadata is important. Complete
+  # semantic information should be contained within just the {#type} and
+  # {#children} of a Node instance; in other words, if an AST was to be
+  # stripped of all meta-information, it should remain a valid AST which
+  # could be successfully processed to yield a result with the same
+  # algorithmic properties.
+  #
+  # Thus, Node should never be inherited in order to define methods which
+  # affect or return semantic information, such as getters for `class_name`,
+  # `superclass` and `body` in the case of a hypothetical `ClassNode`. The
+  # correct solution is to use a generic Node with a {#type} of `:class`
+  # and three children. See also {Processor} for tips on working with such
+  # ASTs.
+  #
+  # On the other hand, Node can and should be inherited to define
+  # application-specific metadata (see also {#initialize}) or customize the
+  # printing format. It is expected that an application would have one or two
+  # such classes and use them across the entire codebase.
+  #
+  # The rationale for this pattern is extensibility and maintainability.
+  # Unlike static ones, dynamic languages do not require the presence of a
+  # predefined, rigid structure, nor does it improve dispatch efficiency,
+  # and while such a structure can certainly be defined, it does not add
+  # any value but incurs a maintaining cost.
+  # For example, extending the AST even with a transformation-local
+  # temporary node type requires making globally visible changes to
+  # the codebase.
+  #
+  class Node
+    # Returns the type of this node.
+    # @return [Symbol]
+    attr_reader :type
+
+    # Returns the children of this node.
+    # The returned value is frozen.
+    # The to_a alias is useful for decomposing nodes concisely.
+    # For example:
+    #
+    #     node = s(:gasgn, :$foo, s(:integer, 1))
+    #     var_name, value = *node
+    #     p var_name # => :$foo
+    #     p value    # => (integer 1)
+    #
+    # @return [Array]
+    attr_reader :children
+    alias to_a children
+
+    # Returns the precomputed hash value for this node
+    # @return [Fixnum]
+    attr_reader :hash
+
+    # Constructs a new instance of Node.
+    #
+    # The arguments `type` and `children` are converted with `to_sym` and
+    # `to_a` respectively. Additionally, the result of converting `children`
+    # is frozen. While mutating the arguments is generally considered harmful,
+    # the most common case is to pass an array literal to the constructor. If
+    # your code does not expect the argument to be frozen, use `#dup`.
+    #
+    # The `properties` hash is passed to {#assign_properties}.
+    def initialize(type, children=[], properties={})
+      @type, @children = type.to_sym, children.to_a.freeze
+
+      assign_properties(properties)
+
+      @hash = [@type, @children, self.class].hash
+
+      freeze
+    end
+
+    # Test if other object is equal to
+    # @param [Object] other
+    # @return [Boolean]
+    def eql?(other)
+      self.class.eql?(other.class)   &&
+      @type.eql?(other.type)         &&
+      @children.eql?(other.children)
+    end
+
+    # By default, each entry in the `properties` hash is assigned to
+    # an instance variable in this instance of Node. A subclass should define
+    # attribute readers for such variables. The values passed in the hash
+    # are not frozen or whitelisted; such behavior can also be implemented
+    # by subclassing Node and overriding this method.
+    #
+    # @return [nil]
+    def assign_properties(properties)
+      properties.each do |name, value|
+        instance_variable_set :"@#{name}", value
+      end
+
+      nil
+    end
+    protected :assign_properties
+
+    alias   :original_dup :dup
+    private :original_dup
+
+    # Nodes are already frozen, so there is no harm in returning the
+    # current node as opposed to initializing from scratch and freezing
+    # another one.
+    #
+    # @return self
+    def dup
+      self
+    end
+    alias :clone :dup
+
+    # Returns a new instance of Node where non-nil arguments replace the
+    # corresponding fields of `self`.
+    #
+    # For example, `Node.new(:foo, [ 1, 2 ]).updated(:bar)` would yield
+    # `(bar 1 2)`, and `Node.new(:foo, [ 1, 2 ]).updated(nil, [])` would
+    # yield `(foo)`.
+    #
+    # If the resulting node would be identical to `self`, does nothing.
+    #
+    # @param  [Symbol, nil] type
+    # @param  [Array, nil]  children
+    # @param  [Hash, nil]   properties
+    # @return [AST::Node]
+    def updated(type=nil, children=nil, properties=nil)
+      new_type       = type       || @type
+      new_children   = children   || @children
+      new_properties = properties || {}
+
+      if @type == new_type &&
+          @children == new_children &&
+          properties.nil?
+        self
+      else
+        copy = original_dup
+        copy.send :initialize, new_type, new_children, new_properties
+        copy
+      end
+    end
+
+    # Compares `self` to `other`, possibly converting with `to_ast`. Only
+    # `type` and `children` are compared; metadata is deliberately ignored.
+    #
+    # @return [Boolean]
+    def ==(other)
+      if equal?(other)
+        true
+      elsif other.respond_to? :to_ast
+        other = other.to_ast
+        other.type == self.type &&
+          other.children == self.children
+      else
+        false
+      end
+    end
+
+    # Concatenates `array` with `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def concat(array)
+      updated(nil, @children + array.to_a)
+    end
+
+    alias + concat
+
+    # Appends `element` to `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def append(element)
+      updated(nil, @children + [element])
+    end
+
+    alias << append
+
+    # Converts `self` to a pretty-printed s-expression.
+    #
+    # @param  [Integer] indent Base indentation level.
+    # @return [String]
+    def to_sexp(indent=0)
+      indented = "  " * indent
+      sexp = "#{indented}(#{fancy_type}"
+
+      children.each do |child|
+        if child.is_a?(Node)
+          sexp += "\n#{child.to_sexp(indent + 1)}"
+        else
+          sexp += " #{child.inspect}"
+        end
+      end
+
+      sexp += ")"
+
+      sexp
+    end
+
+    alias to_s to_sexp
+
+    # Converts `self` to a s-expression ruby string.
+    # The code return will recreate the node, using the sexp module s()
+    #
+    # @param  [Integer] indent Base indentation level.
+    # @return [String]
+    def inspect(indent=0)
+      indented = "  " * indent
+      sexp = "#{indented}s(:#{@type}"
+
+      children.each do |child|
+        if child.is_a?(Node)
+          sexp += ",\n#{child.inspect(indent + 1)}"
+        else
+          sexp += ", #{child.inspect}"
+        end
+      end
+
+      sexp += ")"
+
+      sexp
+    end
+
+    # @return [AST::Node] self
+    def to_ast
+      self
+    end
+
+    # Converts `self` to an Array where the first element is the type as a Symbol,
+    # and subsequent elements are the same representation of its children.
+    #
+    # @return [Array<Symbol, [...Array]>]
+    def to_sexp_array
+      children_sexp_arrs = children.map do |child|
+        if child.is_a?(Node)
+          child.to_sexp_array
+        else
+          child
+        end
+      end
+
+      [type, *children_sexp_arrs]
+    end
+
+    # Enables matching for Node, where type is the first element
+    # and the children are remaining items.
+    #
+    # @return [Array]
+    def deconstruct
+      [type, *children]
+    end
+
+    protected
+
+    # Returns `@type` with all underscores replaced by dashes. This allows
+    # to write symbol literals without quotes in Ruby sources and yet have
+    # nicely looking s-expressions.
+    #
+    # @return [String]
+    def fancy_type
+      @type.to_s.gsub('_', '-')
+    end
+  end
+end