@appthreat/atom-parsetools 1.0.0

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/lib/racc/statetransitiontable.rb

@@ -0,0 +1,311 @@
+#--
+#
+#
+#
+# Copyright (c) 1999-2006 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the same terms of ruby.
+# see the file "COPYING".
+#
+#++
+
+require_relative 'parser'
+
+module Racc
+
+  StateTransitionTable = Struct.new(:action_table,
+                                    :action_check,
+                                    :action_default,
+                                    :action_pointer,
+                                    :goto_table,
+                                    :goto_check,
+                                    :goto_default,
+                                    :goto_pointer,
+                                    :token_table,
+                                    :reduce_table,
+                                    :reduce_n,
+                                    :shift_n,
+                                    :nt_base,
+                                    :token_to_s_table,
+                                    :use_result_var,
+                                    :debug_parser)
+  class StateTransitionTable   # reopen
+    def StateTransitionTable.generate(states)
+      StateTransitionTableGenerator.new(states).generate
+    end
+
+    def initialize(states)
+      super()
+      @states = states
+      @grammar = states.grammar
+      self.use_result_var = true
+      self.debug_parser = true
+    end
+
+    attr_reader :states
+    attr_reader :grammar
+
+    def parser_class
+      ParserClassGenerator.new(@states).generate
+    end
+
+    def token_value_table
+      h = {}
+      token_table().each do |sym, i|
+        h[sym.value] = i
+      end
+      h
+    end
+  end
+
+
+  class StateTransitionTableGenerator
+
+    def initialize(states)
+      @states = states
+      @grammar = states.grammar
+    end
+
+    def generate
+      t = StateTransitionTable.new(@states)
+      gen_action_tables t, @states
+      gen_goto_tables t, @grammar
+      t.token_table = token_table(@grammar)
+      t.reduce_table = reduce_table(@grammar)
+      t.reduce_n = @states.reduce_n
+      t.shift_n = @states.shift_n
+      t.nt_base = @grammar.nonterminal_base
+      t.token_to_s_table = @grammar.symbols.map {|sym| sym.to_s }
+      t
+    end
+
+    def reduce_table(grammar)
+      t = [0, 0, :racc_error]
+      grammar.each_with_index do |rule, idx|
+        next if idx == 0
+        t.push rule.size
+        t.push rule.target.ident
+        t.push(if rule.action.empty?   # and @params.omit_action_call?
+               then :_reduce_none
+               else "_reduce_#{idx}".intern
+               end)
+      end
+      t
+    end
+
+    def token_table(grammar)
+      h = {}
+      grammar.symboltable.terminals.each do |t|
+        h[t] = t.ident
+      end
+      h
+    end
+
+    def gen_action_tables(t, states)
+      t.action_table = yytable  = []
+      t.action_check = yycheck  = []
+      t.action_default = yydefact = []
+      t.action_pointer = yypact   = []
+      e1 = []
+      e2 = []
+      states.each do |state|
+        yydefact.push act2actid(state.defact)
+        if state.action.empty?
+          yypact.push nil
+          next
+        end
+        vector = []
+        state.action.each do |tok, act|
+          vector[tok.ident] = act2actid(act)
+        end
+        addent e1, vector, state.ident, yypact
+      end
+      set_table e1, e2, yytable, yycheck, yypact
+    end
+
+    def gen_goto_tables(t, grammar)
+      t.goto_table   = yytable2  = []
+      t.goto_check   = yycheck2  = []
+      t.goto_pointer = yypgoto   = []
+      t.goto_default = yydefgoto = []
+      e1 = []
+      e2 = []
+      grammar.each_nonterminal do |tok|
+        tmp = []
+
+        # decide default
+        freq = Array.new(@states.size, 0)
+        @states.each do |state|
+          st = state.goto_table[tok]
+          if st
+            st = st.ident
+            freq[st] += 1
+          end
+          tmp[state.ident] = st
+        end
+        max = freq.max
+        if max > 1
+          default = freq.index(max)
+          tmp.map! {|i| default == i ? nil : i }
+        else
+          default = nil
+        end
+        yydefgoto.push default
+
+        # delete default value
+        tmp.pop until tmp.last or tmp.empty?
+        if tmp.compact.empty?
+          # only default
+          yypgoto.push nil
+          next
+        end
+
+        addent e1, tmp, (tok.ident - grammar.nonterminal_base), yypgoto
+      end
+      set_table e1, e2, yytable2, yycheck2, yypgoto
+    end
+
+    def addent(all, arr, chkval, ptr)
+      max = arr.size
+      min = nil
+      arr.each_with_index do |item, idx|
+        if item
+          min ||= idx
+        end
+      end
+      ptr.push(-7777)    # mark
+      arr = arr[min...max]
+      all.push [arr, chkval, mkmapexp(arr), min, ptr.size - 1]
+    end
+
+    n = 2 ** 16
+    begin
+      Regexp.compile("a{#{n}}")
+      RE_DUP_MAX = n
+    rescue RegexpError
+      n /= 2
+      retry
+    end
+
+    def mkmapexp(arr)
+      i = ii = 0
+      as = arr.size
+      map = String.new
+      maxdup = RE_DUP_MAX
+      curr = nil
+      while i < as
+        ii = i + 1
+        if arr[i]
+          ii += 1 while ii < as and arr[ii]
+          curr = '-'
+        else
+          ii += 1 while ii < as and not arr[ii]
+          curr = '.'
+        end
+
+        offset = ii - i
+        if offset == 1
+          map << curr
+        else
+          while offset > maxdup
+            map << "#{curr}{#{maxdup}}"
+            offset -= maxdup
+          end
+          map << "#{curr}{#{offset}}" if offset > 1
+        end
+        i = ii
+      end
+      Regexp.compile(map, Regexp::NOENCODING)
+    end
+
+    def set_table(entries, dummy, tbl, chk, ptr)
+      upper = 0
+      map = '-' * 10240
+
+      # sort long to short
+      entries.sort_by!.with_index {|a,i| [-a[0].size, i] }
+
+      entries.each do |arr, chkval, expr, min, ptri|
+        if upper + arr.size > map.size
+          map << '-' * (arr.size + 1024)
+        end
+        idx = map.index(expr)
+        ptr[ptri] = idx - min
+        arr.each_with_index do |item, i|
+          if item
+            i += idx
+            tbl[i] = item
+            chk[i] = chkval
+            map[i] = ?o
+          end
+        end
+        upper = idx + arr.size
+      end
+    end
+
+    def act2actid(act)
+      case act
+      when Shift  then act.goto_id
+      when Reduce then -act.ruleid
+      when Accept then @states.shift_n
+      when Error  then @states.reduce_n * -1
+      else
+        raise "racc: fatal: wrong act type #{act.class} in action table"
+      end
+    end
+
+  end
+
+
+  class ParserClassGenerator
+
+    def initialize(states)
+      @states = states
+      @grammar = states.grammar
+    end
+
+    def generate
+      table = @states.state_transition_table
+      c = Class.new(::Racc::Parser)
+      c.const_set :Racc_arg, [table.action_table,
+                              table.action_check,
+                              table.action_default,
+                              table.action_pointer,
+                              table.goto_table,
+                              table.goto_check,
+                              table.goto_default,
+                              table.goto_pointer,
+                              table.nt_base,
+                              table.reduce_table,
+                              table.token_value_table,
+                              table.shift_n,
+                              table.reduce_n,
+                              false]
+      c.const_set :Racc_token_to_s_table, table.token_to_s_table
+      c.const_set :Racc_debug_parser, true
+      define_actions c
+      c
+    end
+
+    private
+
+    def define_actions(c)
+      c.module_eval "def _reduce_none(vals, vstack) vals[0] end"
+      @grammar.each do |rule|
+        if rule.action.empty?
+          c.alias_method("_reduce_#{rule.ident}", :_reduce_none)
+        else
+          c.define_method("_racc_action_#{rule.ident}", &rule.action.proc)
+          c.module_eval(<<-End, __FILE__, __LINE__ + 1)
+            def _reduce_#{rule.ident}(vals, vstack)
+              _racc_action_#{rule.ident}(*vals)
+            end
+          End
+        end
+      end
+    end
+
+  end
+
+end   # module Racc

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/lib/racc/static.rb

@@ -0,0 +1,5 @@
+require_relative '../racc'
+require_relative 'parser'
+require_relative 'grammarfileparser'
+require_relative 'parserfilegenerator'
+require_relative 'logfilegenerator'

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/lib/racc.rb

@@ -0,0 +1,6 @@
+require_relative 'racc/compat'
+require_relative 'racc/debugflags'
+require_relative 'racc/grammar'
+require_relative 'racc/state'
+require_relative 'racc/exception'
+require_relative 'racc/info'

package/plugins/rubyastgen/bundle/ruby/3.4.0/specifications/ast-2.4.3.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+# stub: ast 2.4.3 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "ast".freeze
+  s.version = "2.4.3".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["whitequark".freeze]
+  s.date = "2025-03-19"
+  s.description = "A library for working with Abstract Syntax Trees.".freeze
+  s.email = ["whitequark@whitequark.org".freeze]
+  s.homepage = "https://whitequark.github.io/ast/".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "3.6.2".freeze
+  s.summary = "A library for working with Abstract Syntax Trees.".freeze
+
+  s.installed_by_version = "3.6.7".freeze
+
+  s.specification_version = 4
+
+  s.add_development_dependency(%q<rake>.freeze, ["~> 13.2".freeze])
+  s.add_development_dependency(%q<rspec>.freeze, ["~> 3.13".freeze])
+  s.add_development_dependency(%q<simplecov>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<coveralls>.freeze, ["~> 0.8.23".freeze])
+  s.add_development_dependency(%q<yard>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<kramdown>.freeze, [">= 0".freeze])
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/specifications/ostruct-0.6.1.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+# stub: ostruct 0.6.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "ostruct".freeze
+  s.version = "0.6.1".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Marc-Andre Lafortune".freeze]
+  s.date = "2024-11-08"
+  s.description = "Class to build custom data structures, similar to a Hash.".freeze
+  s.email = ["ruby-core@marc-andre.ca".freeze]
+  s.homepage = "https://github.com/ruby/ostruct".freeze
+  s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0".freeze)
+  s.rubygems_version = "3.5.11".freeze
+  s.summary = "Class to build custom data structures, similar to a Hash.".freeze
+
+  s.installed_by_version = "3.6.7".freeze
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/specifications/parser-3.3.8.0.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+# stub: parser 3.3.8.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "parser".freeze
+  s.version = "3.3.8.0".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "bug_tracker_uri" => "https://github.com/whitequark/parser/issues", "changelog_uri" => "https://github.com/whitequark/parser/blob/v3.3.8.0/CHANGELOG.md", "documentation_uri" => "https://www.rubydoc.info/gems/parser/3.3.8.0", "source_code_uri" => "https://github.com/whitequark/parser/tree/v3.3.8.0" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["whitequark".freeze]
+  s.date = "2025-04-14"
+  s.description = "A Ruby parser written in pure Ruby.".freeze
+  s.email = ["whitequark@whitequark.org".freeze]
+  s.executables = ["ruby-parse".freeze, "ruby-rewrite".freeze]
+  s.files = ["bin/ruby-parse".freeze, "bin/ruby-rewrite".freeze]
+  s.homepage = "https://github.com/whitequark/parser".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.0.0".freeze)
+  s.rubygems_version = "3.6.2".freeze
+  s.summary = "A Ruby parser written in pure Ruby.".freeze
+
+  s.installed_by_version = "3.6.7".freeze
+
+  s.specification_version = 4
+
+  s.add_runtime_dependency(%q<ast>.freeze, ["~> 2.4.1".freeze])
+  s.add_runtime_dependency(%q<racc>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<bundler>.freeze, [">= 1.15".freeze, "< 3.0.0".freeze])
+  s.add_development_dependency(%q<rake>.freeze, ["~> 13.0.1".freeze])
+  s.add_development_dependency(%q<cliver>.freeze, ["~> 0.3.2".freeze])
+  s.add_development_dependency(%q<yard>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<kramdown>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<minitest>.freeze, ["~> 5.10".freeze])
+  s.add_development_dependency(%q<simplecov>.freeze, ["~> 0.15.1".freeze])
+  s.add_development_dependency(%q<gauntlet>.freeze, [">= 0".freeze])
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/specifications/racc-1.8.1.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+# stub: racc 1.8.1 ruby lib
+# stub: ext/racc/cparse/extconf.rb
+
+Gem::Specification.new do |s|
+  s.name = "racc".freeze
+  s.version = "1.8.1".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "changelog_uri" => "https://github.com/ruby/racc/releases" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Minero Aoki".freeze, "Aaron Patterson".freeze]
+  s.date = "2024-07-30"
+  s.description = "Racc is an LALR(1) parser generator.\n  It is written in Ruby itself, and generates Ruby program.\n\n  NOTE: Ruby 1.8.x comes with Racc runtime module.  You\n  can run your parsers generated by racc 1.4.x out of the\n  box.\n".freeze
+  s.email = [nil, "aaron@tenderlovemaking.com".freeze]
+  s.executables = ["racc".freeze]
+  s.extensions = ["ext/racc/cparse/extconf.rb".freeze]
+  s.extra_rdoc_files = ["README.ja.rdoc".freeze, "README.rdoc".freeze]
+  s.files = ["README.ja.rdoc".freeze, "README.rdoc".freeze, "bin/racc".freeze, "ext/racc/cparse/extconf.rb".freeze]
+  s.homepage = "https://github.com/ruby/racc".freeze
+  s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
+  s.rdoc_options = ["--main".freeze, "README.rdoc".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5".freeze)
+  s.rubygems_version = "3.5.0.dev".freeze
+  s.summary = "Racc is an LALR(1) parser generator".freeze
+
+  s.installed_by_version = "3.6.7".freeze
+end

package/plugins/rubyastgen/setup.ps1

@@ -0,0 +1,4 @@
+$env:GEM_HOME="."
+bundle install --binstubs=../bin --no-cache --standalone=frontend
+Remove-Item -Recurse -Force bundle\ruby\3.4.0\bundler\gems\ruby_ast_gen-05140cf67b0c\.git*
+Remove-Item -Recurse -Force bundle\ruby\3.4.0\cache

package/plugins/rubyastgen/setup.sh

@@ -0,0 +1,6 @@
+#! /usr/bin/env bash
+set -e
+export GEM_HOME=.
+bundle install --binstubs=../bin --no-cache --standalone=frontend
+rm -rf bundle/ruby/*/bundler/gems/ruby_ast_gen-*/.git*
+rm -rf bundle/ruby/*/cache

package/rbastgen.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { dirname, join, delimiter } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { detectRuby } from "@appthreat/atom-common";
+
+let url = import.meta.url;
+if (!url.startsWith("file://")) {
+  url = new URL(`file://${import.meta.url}`).toString();
+}
+const dirName = import.meta ? dirname(fileURLToPath(url)) : __dirname;
+export const PLUGINS_HOME = join(dirName, "plugins");
+const RUBY_ASTGEN_BIN =
+  process.env.RUBY_ASTGEN_BIN || join(PLUGINS_HOME, "bin", "ruby_ast_gen");
+// Ruby version needed
+const RUBY_VERSION_NEEDED = "3.4.3";
+function main(argvs) {
+  const cwd = process.env.ATOM_CWD || process.cwd();
+  argvs.splice(0, 0, RUBY_ASTGEN_BIN);
+  const env = {
+    ...process.env
+  };
+  let rubyCmd = process.env.RUBY_CMD || "ruby";
+  if (
+    process.env.ATOM_RUBY_HOME &&
+    existsSync(join(process.env.ATOM_RUBY_HOME, "bin"))
+  ) {
+    const rubyBinDir = join(process.env.ATOM_RUBY_HOME, "bin");
+    if (rubyCmd === "ruby") {
+      rubyCmd = join(rubyBinDir, "ruby");
+    }
+    if (!env.PATH.includes(rubyBinDir)) {
+      env.PATH = `${rubyBinDir}${delimiter}${env.PATH}`;
+    }
+  }
+  if (rubyCmd === "ruby" && !detectRuby(RUBY_VERSION_NEEDED)) {
+    console.warn(
+      `Ruby ${RUBY_VERSION_NEEDED} is not installed! Set the environment variable "ATOM_RUBY_HOME" to the Ruby ${RUBY_VERSION_NEEDED} install directory.`
+    );
+    return false;
+  }
+  spawnSync(rubyCmd, argvs, {
+    encoding: "utf-8",
+    cwd,
+    stdio: "inherit",
+    stderr: "inherit",
+    env,
+    timeout: process.env.ATOM_TIMEOUT || process.env.ASTGEN_TIMEOUT
+  });
+}
+main(process.argv.slice(2));