@appthreat/atom 2.1.10 → 2.1.11

package/plugins/rubyastgen/bundle/jruby/3.1.0/cache/bundler/git/ruby_ast_gen-243d3717ca4e4cb1d20a3b48fd8f19c12a09423d/hooks/sendemail-validate.sample

@@ -1,77 +0,0 @@
-#!/bin/sh
-
-# An example hook script to validate a patch (and/or patch series) before
-# sending it via email.
-#
-# The hook should exit with non-zero status after issuing an appropriate
-# message if it wants to prevent the email(s) from being sent.
-#
-# To enable this hook, rename this file to "sendemail-validate".
-#
-# By default, it will only check that the patch(es) can be applied on top of
-# the default upstream branch without conflicts in a secondary worktree. After
-# validation (successful or not) of the last patch of a series, the worktree
-# will be deleted.
-#
-# The following config variables can be set to change the default remote and
-# remote ref that are used to apply the patches against:
-#
-#   sendemail.validateRemote (default: origin)
-#   sendemail.validateRemoteRef (default: HEAD)
-#
-# Replace the TODO placeholders with appropriate checks according to your
-# needs.
-
-validate_cover_letter () {
-	file="$1"
-	# TODO: Replace with appropriate checks (e.g. spell checking).
-	true
-}
-
-validate_patch () {
-	file="$1"
-	# Ensure that the patch applies without conflicts.
-	git am -3 "$file" || return
-	# TODO: Replace with appropriate checks for this patch
-	# (e.g. checkpatch.pl).
-	true
-}
-
-validate_series () {
-	# TODO: Replace with appropriate checks for the whole series
-	# (e.g. quick build, coding style checks, etc.).
-	true
-}
-
-# main -------------------------------------------------------------------------
-
-if test "$GIT_SENDEMAIL_FILE_COUNTER" = 1
-then
-	remote=$(git config --default origin --get sendemail.validateRemote) &&
-	ref=$(git config --default HEAD --get sendemail.validateRemoteRef) &&
-	worktree=$(mktemp --tmpdir -d sendemail-validate.XXXXXXX) &&
-	git worktree add -fd --checkout "$worktree" "refs/remotes/$remote/$ref" &&
-	git config --replace-all sendemail.validateWorktree "$worktree"
-else
-	worktree=$(git config --get sendemail.validateWorktree)
-fi || {
-	echo "sendemail-validate: error: failed to prepare worktree" >&2
-	exit 1
-}
-
-unset GIT_DIR GIT_WORK_TREE
-cd "$worktree" &&
-
-if grep -q "^diff --git " "$1"
-then
-	validate_patch "$1"
-else
-	validate_cover_letter "$1"
-fi &&
-
-if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL"
-then
-	git config --unset-all sendemail.validateWorktree &&
-	trap 'git worktree remove -ff "$worktree"' EXIT &&
-	validate_series
-fi

package/plugins/rubyastgen/bundle/jruby/3.1.0/cache/bundler/git/ruby_ast_gen-243d3717ca4e4cb1d20a3b48fd8f19c12a09423d/hooks/update.sample

@@ -1,128 +0,0 @@
-#!/bin/sh
-#
-# An example hook script to block unannotated tags from entering.
-# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
-#
-# To enable this hook, rename this file to "update".
-#
-# Config
-# ------
-# hooks.allowunannotated
-#   This boolean sets whether unannotated tags will be allowed into the
-#   repository.  By default they won't be.
-# hooks.allowdeletetag
-#   This boolean sets whether deleting tags will be allowed in the
-#   repository.  By default they won't be.
-# hooks.allowmodifytag
-#   This boolean sets whether a tag may be modified after creation. By default
-#   it won't be.
-# hooks.allowdeletebranch
-#   This boolean sets whether deleting branches will be allowed in the
-#   repository.  By default they won't be.
-# hooks.denycreatebranch
-#   This boolean sets whether remotely creating branches will be denied
-#   in the repository.  By default this is allowed.
-#
-
-# --- Command line
-refname="$1"
-oldrev="$2"
-newrev="$3"
-
-# --- Safety check
-if [ -z "$GIT_DIR" ]; then
-	echo "Don't run this script from the command line." >&2
-	echo " (if you want, you could supply GIT_DIR then run" >&2
-	echo "  $0 <ref> <oldrev> <newrev>)" >&2
-	exit 1
-fi
-
-if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
-	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
-	exit 1
-fi
-
-# --- Config
-allowunannotated=$(git config --type=bool hooks.allowunannotated)
-allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
-denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
-allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
-allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
-
-# check for no description
-projectdesc=$(sed -e '1q' "$GIT_DIR/description")
-case "$projectdesc" in
-"Unnamed repository"* | "")
-	echo "*** Project description file hasn't been set" >&2
-	exit 1
-	;;
-esac
-
-# --- Check types
-# if $newrev is 0000...0000, it's a commit to delete a ref.
-zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
-if [ "$newrev" = "$zero" ]; then
-	newrev_type=delete
-else
-	newrev_type=$(git cat-file -t $newrev)
-fi
-
-case "$refname","$newrev_type" in
-	refs/tags/*,commit)
-		# un-annotated tag
-		short_refname=${refname##refs/tags/}
-		if [ "$allowunannotated" != "true" ]; then
-			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
-			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
-			exit 1
-		fi
-		;;
-	refs/tags/*,delete)
-		# delete tag
-		if [ "$allowdeletetag" != "true" ]; then
-			echo "*** Deleting a tag is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	refs/tags/*,tag)
-		# annotated tag
-		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
-		then
-			echo "*** Tag '$refname' already exists." >&2
-			echo "*** Modifying a tag is not allowed in this repository." >&2
-			exit 1
-		fi
-		;;
-	refs/heads/*,commit)
-		# branch
-		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
-			echo "*** Creating a branch is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	refs/heads/*,delete)
-		# delete branch
-		if [ "$allowdeletebranch" != "true" ]; then
-			echo "*** Deleting a branch is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	refs/remotes/*,commit)
-		# tracking branch
-		;;
-	refs/remotes/*,delete)
-		# delete tracking branch
-		if [ "$allowdeletebranch" != "true" ]; then
-			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	*)
-		# Anything else (is there anything else?)
-		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
-		exit 1
-		;;
-esac
-
-# --- Finished
-exit 0

package/plugins/rubyastgen/bundle/jruby/3.1.0/cache/bundler/git/ruby_ast_gen-243d3717ca4e4cb1d20a3b48fd8f19c12a09423d/info/exclude

@@ -1,6 +0,0 @@
-# git ls-files --others --exclude-from=.git/info/exclude
-# Lines that start with '#' are comments.
-# For a project mostly in C, the following would be a good set of
-# exclude patterns (uncomment them if you want to use them):
-# *.[oa]
-# *~

package/plugins/rubyastgen/bundle/jruby/3.1.0/cache/bundler/git/ruby_ast_gen-243d3717ca4e4cb1d20a3b48fd8f19c12a09423d/packed-refs

@@ -1,7 +0,0 @@
-# pack-refs with: peeled fully-peeled sorted 
-bc1e5f01c2a108a2fd731f34f9127ffcb97d9e33 refs/heads/fix/char_limit
-05140cf67b0c70df3cf726c7cc4706d484c8d8cc refs/heads/main
-3ad09f7798b28e4e339947740e708d7c425eb58c refs/tags/v0.34.0
-df21eaeb39f962c41946ec4391ff20080e4d8218 refs/tags/v0.34.1
-ba9df703cca54d40c469ca83a99bd05e260c63a5 refs/tags/v0.34.2
-05140cf67b0c70df3cf726c7cc4706d484c8d8cc refs/tags/v1.0.0

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