@appthreat/atom 2.1.10 → 2.1.12

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/ast-2.4.2/LICENSE.MIT

@@ -1,20 +0,0 @@
-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/jruby/3.1.0/gems/ast-2.4.2/README.YARD.md

@@ -1,12 +0,0 @@
-{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/jruby/3.1.0/gems/ast-2.4.2/lib/ast/node.rb

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

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/ast-2.4.2/lib/ast/processor/mixin.rb

@@ -1,288 +0,0 @@
-module AST
-  class Processor
-    # The processor module is a module which helps transforming one
-    # AST into another.  In a nutshell, the {#process} method accepts
-    # a {Node} and dispatches it to a handler corresponding to its
-    # type, and returns a (possibly) updated variant of the node.
-    #
-    # The processor module has a set of associated design patterns.
-    # They are best explained with a concrete example. Let's define a
-    # simple arithmetic language and an AST format for it:
-    #
-    # Terminals (AST nodes which do not have other AST nodes inside):
-    #
-    #   * `(integer <int-literal>)`,
-    #
-    # Nonterminals (AST nodes with other nodes as children):
-    #
-    #   * `(add <node> <node>)`,
-    #   * `(multiply <node> <node>)`,
-    #   * `(divide <node> <node>)`,
-    #   * `(negate <node>)`,
-    #   * `(store <node> <string-literal>)`: stores value of `<node>`
-    #     into a variable named `<string-literal>`,
-    #   * `(load <string-literal>)`: loads value of a variable named
-    #     `<string-literal>`,
-    #   * `(each <node> ...)`: computes each of the `<node>`s and
-    #     prints the result.
-    #
-    # All AST nodes have the same Ruby class, and therefore they don't
-    # know how to traverse themselves. (A solution which dynamically
-    # checks the type of children is possible, but is slow and
-    # error-prone.) So, a class including the module which knows how
-    # to traverse the entire tree should be defined.  Such classes
-    # have a handler for each nonterminal node which recursively
-    # processes children nodes:
-    #
-    #     require 'ast'
-    #
-    #     class ArithmeticsProcessor
-    #       include AST::Processor::Mixin
-    #       # This method traverses any binary operators such as (add)
-    #       # or (multiply).
-    #       def process_binary_op(node)
-    #         # Children aren't decomposed automatically; it is
-    #         # suggested to use Ruby multiple assignment expansion,
-    #         # as it is very convenient here.
-    #         left_expr, right_expr = *node
-    #
-    #         # AST::Node#updated won't change node type if nil is
-    #         # passed as a first argument, which allows to reuse the
-    #         # same handler for multiple node types using `alias'
-    #         # (below).
-    #         node.updated(nil, [
-    #           process(left_expr),
-    #           process(right_expr)
-    #         ])
-    #       end
-    #       alias_method :on_add,      :process_binary_op
-    #       alias_method :on_multiply, :process_binary_op
-    #       alias_method :on_divide,   :process_binary_op
-    #
-    #       def on_negate(node)
-    #         # It is also possible to use #process_all for more
-    #         # compact code if every child is a Node.
-    #         node.updated(nil, process_all(node))
-    #       end
-    #
-    #       def on_store(node)
-    #         expr, variable_name = *node
-    #
-    #         # Note that variable_name is not a Node and thus isn't
-    #         # passed to #process.
-    #         node.updated(nil, [
-    #           process(expr),
-    #           variable_name
-    #         ])
-    #       end
-    #
-    #       # (load) is effectively a terminal node, and so it does
-    #       # not need an explicit handler, as the following is the
-    #       # default behavior.  Essentially, for any nodes that don't
-    #       # have a defined handler, the node remains unchanged.
-    #       def on_load(node)
-    #         nil
-    #       end
-    #
-    #       def on_each(node)
-    #         node.updated(nil, process_all(node))
-    #       end
-    #     end
-    #
-    # Let's test our ArithmeticsProcessor:
-    #
-    #     include AST::Sexp
-    #     expr = s(:add, s(:integer, 2), s(:integer, 2))
-    #
-    #     p ArithmeticsProcessor.new.process(expr) == expr # => true
-    #
-    # As expected, it does not change anything at all. This isn't
-    # actually very useful, so let's now define a Calculator, which
-    # will compute the expression values:
-    #
-    #     # This Processor folds nonterminal nodes and returns an
-    #     # (integer) terminal node.
-    #     class ArithmeticsCalculator < ArithmeticsProcessor
-    #       def compute_op(node)
-    #         # First, node children are processed and then unpacked
-    #         # to local variables.
-    #         nodes = process_all(node)
-    #
-    #         if nodes.all? { |node| node.type == :integer }
-    #           # If each of those nodes represents a literal, we can
-    #           # fold this node!
-    #           values = nodes.map { |node| node.children.first }
-    #           AST::Node.new(:integer, [
-    #             yield(values)
-    #           ])
-    #         else
-    #           # Otherwise, we can just leave the current node in the
-    #           # tree and only update it with processed children
-    #           # nodes, which can be partially folded.
-    #           node.updated(nil, nodes)
-    #         end
-    #       end
-    #
-    #       def on_add(node)
-    #         compute_op(node) { |left, right| left + right }
-    #       end
-    #
-    #       def on_multiply(node)
-    #         compute_op(node) { |left, right| left * right }
-    #       end
-    #     end
-    #
-    # Let's check:
-    #
-    #     p ArithmeticsCalculator.new.process(expr) # => (integer 4)
-    #
-    # Excellent, the calculator works! Now, a careful reader could
-    # notice that the ArithmeticsCalculator does not know how to
-    # divide numbers. What if we pass an expression with division to
-    # it?
-    #
-    #     expr_with_division = \
-    #       s(:add,
-    #         s(:integer, 1),
-    #         s(:divide,
-    #           s(:add, s(:integer, 8), s(:integer, 4)),
-    #           s(:integer, 3))) # 1 + (8 + 4) / 3
-    #
-    #     folded_expr_with_division = ArithmeticsCalculator.new.process(expr_with_division)
-    #     p folded_expr_with_division
-    #     # => (add
-    #     #      (integer 1)
-    #     #      (divide
-    #     #        (integer 12)
-    #     #        (integer 3)))
-    #
-    # As you can see, the expression was folded _partially_: the inner
-    # `(add)` node which could be computed was folded to
-    # `(integer 12)`, the `(divide)` node is left as-is because there
-    # is no computing handler for it, and the root `(add)` node was
-    # also left as it is because some of its children were not
-    # literals.
-    #
-    # Note that this partial folding is only possible because the
-    # _data_ format, i.e. the format in which the computed values of
-    # the nodes are represented, is the same as the AST itself.
-    #
-    # Let's extend our ArithmeticsCalculator class further.
-    #
-    #     class ArithmeticsCalculator
-    #       def on_divide(node)
-    #         compute_op(node) { |left, right| left / right }
-    #       end
-    #
-    #       def on_negate(node)
-    #         # Note how #compute_op works regardless of the operator
-    #         # arity.
-    #         compute_op(node) { |value| -value }
-    #       end
-    #     end
-    #
-    # Now, let's apply our renewed ArithmeticsCalculator to a partial
-    # result of previous evaluation:
-    #
-    #     p ArithmeticsCalculator.new.process(expr_with_division) # => (integer 5)
-    #
-    # Five! Excellent. This is also pretty much how CRuby 1.8 executed
-    # its programs.
-    #
-    # Now, let's do some automated bug searching. Division by zero is
-    # an error, right? So if we could detect that someone has divided
-    # by zero before the program is even run, that could save some
-    # debugging time.
-    #
-    #     class DivisionByZeroVerifier < ArithmeticsProcessor
-    #       class VerificationFailure < Exception; end
-    #
-    #       def on_divide(node)
-    #         # You need to process the children to handle nested divisions
-    #         # such as:
-    #         # (divide
-    #         #   (integer 1)
-    #         #   (divide (integer 1) (integer 0))
-    #         left, right = process_all(node)
-    #
-    #         if right.type == :integer &&
-    #            right.children.first == 0
-    #           raise VerificationFailure, "Ouch! This code divides by zero."
-    #         end
-    #       end
-    #
-    #       def divides_by_zero?(ast)
-    #         process(ast)
-    #         false
-    #       rescue VerificationFailure
-    #         true
-    #       end
-    #     end
-    #
-    #     nice_expr = \
-    #       s(:divide,
-    #         s(:add, s(:integer, 10), s(:integer, 2)),
-    #         s(:integer, 4))
-    #
-    #     p DivisionByZeroVerifier.new.divides_by_zero?(nice_expr)
-    #     # => false. Good.
-    #
-    #     bad_expr = \
-    #       s(:add, s(:integer, 10),
-    #         s(:divide, s(:integer, 1), s(:integer, 0)))
-    #
-    #     p DivisionByZeroVerifier.new.divides_by_zero?(bad_expr)
-    #     # => true. WHOOPS. DO NOT RUN THIS.
-    #
-    # Of course, this won't detect more complex cases... unless you
-    # use some partial evaluation before! The possibilites are
-    # endless. Have fun.
-    module Mixin
-      # Dispatches `node`. If a node has type `:foo`, then a handler
-      # named `on_foo` is invoked with one argument, the `node`; if
-      # there isn't such a handler, {#handler_missing} is invoked
-      # with the same argument.
-      #
-      # If the handler returns `nil`, `node` is returned; otherwise,
-      # the return value of the handler is passed along.
-      #
-      # @param  [AST::Node, nil] node
-      # @return [AST::Node, nil]
-      def process(node)
-        return if node.nil?
-
-        node = node.to_ast
-
-        # Invoke a specific handler
-        on_handler = :"on_#{node.type}"
-        if respond_to? on_handler
-          new_node = send on_handler, node
-        else
-          new_node = handler_missing(node)
-        end
-
-        node = new_node if new_node
-
-        node
-      end
-
-      # {#process}es each node from `nodes` and returns an array of
-      # results.
-      #
-      # @param  [Array<AST::Node>] nodes
-      # @return [Array<AST::Node>]
-      def process_all(nodes)
-        nodes.to_a.map do |node|
-          process node
-        end
-      end
-
-      # Default handler. Does nothing.
-      #
-      # @param  [AST::Node] node
-      # @return [AST::Node, nil]
-      def handler_missing(node)
-      end
-    end
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/ast-2.4.2/lib/ast/processor.rb

@@ -1,12 +0,0 @@
-module AST
-  # This class includes {AST::Processor::Mixin}; however, it is
-  # deprecated, since the module defines all of the behaviors that
-  # the processor includes.  Any new libraries should use
-  # {AST::Processor::Mixin} instead of subclassing this.
-  #
-  # @deprecated Use {AST::Processor::Mixin} instead.
-  class Processor
-    require 'ast/processor/mixin'
-    include Mixin
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/ast-2.4.2/lib/ast/sexp.rb

@@ -1,30 +0,0 @@
-module AST
-  # This simple module is very useful in the cases where one needs
-  # to define deeply nested ASTs from Ruby code, for example, in
-  # tests. It should be used like this:
-  #
-  #     describe YourLanguage::AST do
-  #       include Sexp
-  #
-  #       it "should correctly parse expressions" do
-  #         YourLanguage.parse("1 + 2 * 3").should ==
-  #             s(:add,
-  #               s(:integer, 1),
-  #               s(:multiply,
-  #                 s(:integer, 2),
-  #                 s(:integer, 3)))
-  #       end
-  #     end
-  #
-  # This way the amount of boilerplate code is greatly reduced.
-  module Sexp
-    # Creates a {Node} with type `type` and children `children`.
-    # Note that the resulting node is of the type AST::Node and not a
-    # subclass.
-    # This would not pose a problem with comparisons, as {Node#==}
-    # ignores metadata.
-    def s(type, *children)
-      Node.new(type, children)
-    end
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/ast-2.4.2/lib/ast.rb

@@ -1,17 +0,0 @@
-# {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.
-#
-module AST
-  require 'ast/node'
-  require 'ast/processor'
-  require 'ast/sexp'
-end