brakeman 4.10.0 → 4.10.1

data/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/instruction.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: false
+
+require_relative "child"
+require_relative "source"
+
+module REXML
+  # Represents an XML Instruction; IE, <? ... ?>
+  # TODO: Add parent arg (3rd arg) to constructor
+  class Instruction < Child
+    START = "<?"
+    STOP = "?>"
+
+    # target is the "name" of the Instruction; IE, the "tag" in <?tag ...?>
+    # content is everything else.
+    attr_accessor :target, :content
+
+    # Constructs a new Instruction
+    # @param target can be one of a number of things.  If String, then
+    # the target of this instruction is set to this.  If an Instruction,
+    # then the Instruction is shallowly cloned (target and content are
+    # copied).
+    # @param content Must be either a String, or a Parent.  Can only
+    # be a Parent if the target argument is a Source.  Otherwise, this
+    # String is set as the content of this instruction.
+    def initialize(target, content=nil)
+      case target
+      when String
+        super()
+        @target = target
+        @content = content
+      when Instruction
+        super(content)
+        @target = target.target
+        @content = target.content
+      else
+        message =
+          "processing instruction target must be String or REXML::Instruction: "
+        message << "<#{target.inspect}>"
+        raise ArgumentError, message
+      end
+      @content.strip! if @content
+    end
+
+    def clone
+      Instruction.new self
+    end
+
+    # == DEPRECATED
+    # See the rexml/formatters package
+    #
+    def write writer, indent=-1, transitive=false, ie_hack=false
+      Kernel.warn( "#{self.class.name}.write is deprecated", uplevel: 1)
+      indent(writer, indent)
+      writer << START
+      writer << @target
+      if @content
+        writer << ' '
+        writer << @content
+      end
+      writer << STOP
+    end
+
+    # @return true if other is an Instruction, and the content and target
+    # of the other matches the target and content of this object.
+    def ==( other )
+      other.kind_of? Instruction and
+      other.target == @target and
+      other.content == @content
+    end
+
+    def node_type
+      :processing_instruction
+    end
+
+    def inspect
+      "<?p-i #{target} ...?>"
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/light/node.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: false
+require_relative '../xmltokens'
+
+# [ :element, parent, name, attributes, children* ]
+  # a = Node.new
+  # a << "B"            # => <a>B</a>
+  # a.b                 # => <a>B<b/></a>
+  # a.b[1]                      # => <a>B<b/><b/><a>
+  # a.b[1]["x"] = "y"   # => <a>B<b/><b x="y"/></a>
+  # a.b[0].c            # => <a>B<b><c/></b><b x="y"/></a>
+  # a.b.c << "D"                # => <a>B<b><c>D</c></b><b x="y"/></a>
+module REXML
+  module Light
+    # Represents a tagged XML element.  Elements are characterized by
+    # having children, attributes, and names, and can themselves be
+    # children.
+    class Node
+      NAMESPLIT = /^(?:(#{XMLTokens::NCNAME_STR}):)?(#{XMLTokens::NCNAME_STR})/u
+      PARENTS = [ :element, :document, :doctype ]
+      # Create a new element.
+      def initialize node=nil
+        @node = node
+        if node.kind_of? String
+          node = [ :text, node ]
+        elsif node.nil?
+          node = [ :document, nil, nil ]
+        elsif node[0] == :start_element
+          node[0] = :element
+        elsif node[0] == :start_doctype
+          node[0] = :doctype
+        elsif node[0] == :start_document
+          node[0] = :document
+        end
+      end
+
+      def size
+        if PARENTS.include? @node[0]
+          @node[-1].size
+        else
+          0
+        end
+      end
+
+      def each
+        size.times { |x| yield( at(x+4) ) }
+      end
+
+      def name
+        at(2)
+      end
+
+      def name=( name_str, ns=nil )
+        pfx = ''
+        pfx = "#{prefix(ns)}:" if ns
+        _old_put(2, "#{pfx}#{name_str}")
+      end
+
+      def parent=( node )
+        _old_put(1,node)
+      end
+
+      def local_name
+        namesplit
+        @name
+      end
+
+      def local_name=( name_str )
+        _old_put( 1, "#@prefix:#{name_str}" )
+      end
+
+      def prefix( namespace=nil )
+        prefix_of( self, namespace )
+      end
+
+      def namespace( prefix=prefix() )
+        namespace_of( self, prefix )
+      end
+
+      def namespace=( namespace )
+        @prefix = prefix( namespace )
+        pfx = ''
+        pfx = "#@prefix:" if @prefix.size > 0
+        _old_put(1, "#{pfx}#@name")
+      end
+
+      def []( reference, ns=nil )
+        if reference.kind_of? String
+          pfx = ''
+          pfx = "#{prefix(ns)}:" if ns
+          at(3)["#{pfx}#{reference}"]
+        elsif reference.kind_of? Range
+          _old_get( Range.new(4+reference.begin, reference.end, reference.exclude_end?) )
+        else
+          _old_get( 4+reference )
+        end
+      end
+
+      def =~( path )
+        XPath.match( self, path )
+      end
+
+      # Doesn't handle namespaces yet
+      def []=( reference, ns, value=nil )
+        if reference.kind_of? String
+          value = ns unless value
+          at( 3 )[reference] = value
+        elsif reference.kind_of? Range
+          _old_put( Range.new(3+reference.begin, reference.end, reference.exclude_end?), ns )
+        else
+          if value
+            _old_put( 4+reference, ns, value )
+          else
+            _old_put( 4+reference, ns )
+          end
+        end
+      end
+
+      # Append a child to this element, optionally under a provided namespace.
+      # The namespace argument is ignored if the element argument is an Element
+      # object.  Otherwise, the element argument is a string, the namespace (if
+      # provided) is the namespace the element is created in.
+      def << element
+        if node_type() == :text
+          at(-1) << element
+        else
+          newnode = Node.new( element )
+          newnode.parent = self
+          self.push( newnode )
+        end
+        at(-1)
+      end
+
+      def node_type
+        _old_get(0)
+      end
+
+      def text=( foo )
+        replace = at(4).kind_of?(String)? 1 : 0
+        self._old_put(4,replace, normalizefoo)
+      end
+
+      def root
+        context = self
+        context = context.at(1) while context.at(1)
+      end
+
+      def has_name?( name, namespace = '' )
+        at(3) == name and namespace() == namespace
+      end
+
+      def children
+        self
+      end
+
+      def parent
+        at(1)
+      end
+
+      def to_s
+
+      end
+
+      private
+
+      def namesplit
+        return if @name.defined?
+        at(2) =~ NAMESPLIT
+        @prefix = '' || $1
+        @name = $2
+      end
+
+      def namespace_of( node, prefix=nil )
+        if not prefix
+          name = at(2)
+          name =~ NAMESPLIT
+          prefix = $1
+        end
+        to_find = 'xmlns'
+        to_find = "xmlns:#{prefix}" if not prefix.nil?
+        ns = at(3)[ to_find ]
+        ns ? ns : namespace_of( @node[0], prefix )
+      end
+
+      def prefix_of( node, namespace=nil )
+        if not namespace
+          name = node.name
+          name =~ NAMESPLIT
+          $1
+        else
+          ns = at(3).find { |k,v| v == namespace }
+          ns ? ns : prefix_of( node.parent, namespace )
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/namespace.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: false
+
+require_relative 'xmltokens'
+
+module REXML
+  # Adds named attributes to an object.
+  module Namespace
+    # The name of the object, valid if set
+    attr_reader :name, :expanded_name
+    # The expanded name of the object, valid if name is set
+    attr_accessor :prefix
+    include XMLTokens
+    NAMESPLIT = /^(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})/u
+
+    # Sets the name and the expanded name
+    def name=( name )
+      @expanded_name = name
+      case name
+      when NAMESPLIT
+        if $1
+          @prefix = $1
+        else
+          @prefix = ""
+          @namespace = ""
+        end
+        @name = $2
+      when ""
+        @prefix = nil
+        @namespace = nil
+        @name = nil
+      else
+        message = "name must be \#{PREFIX}:\#{LOCAL_NAME} or \#{LOCAL_NAME}: "
+        message += "<#{name.inspect}>"
+        raise ArgumentError, message
+      end
+    end
+
+    # Compares names optionally WITH namespaces
+    def has_name?( other, ns=nil )
+      if ns
+        return (namespace() == ns and name() == other)
+      elsif other.include? ":"
+        return fully_expanded_name == other
+      else
+        return name == other
+      end
+    end
+
+    alias :local_name :name
+
+    # Fully expand the name, even if the prefix wasn't specified in the
+    # source file.
+    def fully_expanded_name
+      ns = prefix
+      return "#{ns}:#@name" if ns.size > 0
+      return @name
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/node.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: false
+require_relative "parseexception"
+require_relative "formatters/pretty"
+require_relative "formatters/default"
+
+module REXML
+  # Represents a node in the tree.  Nodes are never encountered except as
+  # superclasses of other objects.  Nodes have siblings.
+  module Node
+    # @return the next sibling (nil if unset)
+    def next_sibling_node
+      return nil if @parent.nil?
+      @parent[ @parent.index(self) + 1 ]
+    end
+
+    # @return the previous sibling (nil if unset)
+    def previous_sibling_node
+      return nil if @parent.nil?
+      ind = @parent.index(self)
+      return nil if ind == 0
+      @parent[ ind - 1 ]
+    end
+
+    # indent::
+    #   *DEPRECATED* This parameter is now ignored.  See the formatters in the
+    #   REXML::Formatters package for changing the output style.
+    def to_s indent=nil
+      unless indent.nil?
+        Kernel.warn( "#{self.class.name}.to_s(indent) parameter is deprecated", uplevel: 1)
+        f = REXML::Formatters::Pretty.new( indent )
+        f.write( self, rv = "" )
+      else
+        f = REXML::Formatters::Default.new
+        f.write( self, rv = "" )
+      end
+      return rv
+    end
+
+    def indent to, ind
+                        if @parent and @parent.context and not @parent.context[:indentstyle].nil? then
+                                indentstyle = @parent.context[:indentstyle]
+                        else
+                                indentstyle = '  '
+                        end
+                        to << indentstyle*ind unless ind<1
+    end
+
+    def parent?
+      false;
+    end
+
+
+    # Visit all subnodes of +self+ recursively
+    def each_recursive(&block) # :yields: node
+      self.elements.each {|node|
+        block.call(node)
+        node.each_recursive(&block)
+      }
+    end
+
+    # Find (and return) first subnode (recursively) for which the block
+    # evaluates to true. Returns +nil+ if none was found.
+    def find_first_recursive(&block) # :yields: node
+      each_recursive {|node|
+        return node if block.call(node)
+      }
+      return nil
+    end
+
+    # Returns the position that +self+ holds in its parent's array, indexed
+    # from 1.
+    def index_in_parent
+      parent.index(self)+1
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/output.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: false
+require_relative 'encoding'
+
+module REXML
+  class Output
+    include Encoding
+
+    attr_reader :encoding
+
+    def initialize real_IO, encd="iso-8859-1"
+      @output = real_IO
+      self.encoding = encd
+
+      @to_utf = encoding != 'UTF-8'
+
+      if encoding == "UTF-16"
+        @output << "\ufeff".encode("UTF-16BE")
+        self.encoding = "UTF-16BE"
+      end
+    end
+
+    def <<( content )
+      @output << (@to_utf ? self.encode(content) : content)
+    end
+
+    def to_s
+      "Output[#{encoding}]"
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/parent.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: false
+require_relative "child"
+
+module REXML
+  # A parent has children, and has methods for accessing them.  The Parent
+  # class is never encountered except as the superclass for some other
+  # object.
+  class Parent < Child
+    include Enumerable
+
+    # Constructor
+    # @param parent if supplied, will be set as the parent of this object
+    def initialize parent=nil
+      super(parent)
+      @children = []
+    end
+
+    def add( object )
+      object.parent = self
+      @children << object
+      object
+    end
+
+    alias :push :add
+    alias :<< :push
+
+    def unshift( object )
+      object.parent = self
+      @children.unshift object
+    end
+
+    def delete( object )
+      found = false
+      @children.delete_if {|c| c.equal?(object) and found = true }
+      object.parent = nil if found
+      found ? object : nil
+    end
+
+    def each(&block)
+      @children.each(&block)
+    end
+
+    def delete_if( &block )
+      @children.delete_if(&block)
+    end
+
+    def delete_at( index )
+      @children.delete_at index
+    end
+
+    def each_index( &block )
+      @children.each_index(&block)
+    end
+
+    # Fetches a child at a given index
+    # @param index the Integer index of the child to fetch
+    def []( index )
+      @children[index]
+    end
+
+    alias :each_child :each
+
+
+
+    # Set an index entry.  See Array.[]=
+    # @param index the index of the element to set
+    # @param opt either the object to set, or an Integer length
+    # @param child if opt is an Integer, this is the child to set
+    # @return the parent (self)
+    def []=( *args )
+      args[-1].parent = self
+      @children[*args[0..-2]] = args[-1]
+    end
+
+    # Inserts an child before another child
+    # @param child1 this is either an xpath or an Element.  If an Element,
+    # child2 will be inserted before child1 in the child list of the parent.
+    # If an xpath, child2 will be inserted before the first child to match
+    # the xpath.
+    # @param child2 the child to insert
+    # @return the parent (self)
+    def insert_before( child1, child2 )
+      if child1.kind_of? String
+        child1 = XPath.first( self, child1 )
+        child1.parent.insert_before child1, child2
+      else
+        ind = index(child1)
+        child2.parent.delete(child2) if child2.parent
+        @children[ind,0] = child2
+        child2.parent = self
+      end
+      self
+    end
+
+    # Inserts an child after another child
+    # @param child1 this is either an xpath or an Element.  If an Element,
+    # child2 will be inserted after child1 in the child list of the parent.
+    # If an xpath, child2 will be inserted after the first child to match
+    # the xpath.
+    # @param child2 the child to insert
+    # @return the parent (self)
+    def insert_after( child1, child2 )
+      if child1.kind_of? String
+        child1 = XPath.first( self, child1 )
+        child1.parent.insert_after child1, child2
+      else
+        ind = index(child1)+1
+        child2.parent.delete(child2) if child2.parent
+        @children[ind,0] = child2
+        child2.parent = self
+      end
+      self
+    end
+
+    def to_a
+      @children.dup
+    end
+
+    # Fetches the index of a given child
+    # @param child the child to get the index of
+    # @return the index of the child, or nil if the object is not a child
+    # of this parent.
+    def index( child )
+      count = -1
+      @children.find { |i| count += 1 ; i.hash == child.hash }
+      count
+    end
+
+    # @return the number of children of this parent
+    def size
+      @children.size
+    end
+
+    alias :length :size
+
+    # Replaces one child with another, making sure the nodelist is correct
+    # @param to_replace the child to replace (must be a Child)
+    # @param replacement the child to insert into the nodelist (must be a
+    # Child)
+    def replace_child( to_replace, replacement )
+      @children.map! {|c| c.equal?( to_replace ) ? replacement : c }
+      to_replace.parent = nil
+      replacement.parent = self
+    end
+
+    # Deeply clones this object.  This creates a complete duplicate of this
+    # Parent, including all descendants.
+    def deep_clone
+      cl = clone()
+      each do |child|
+        if child.kind_of? Parent
+          cl << child.deep_clone
+        else
+          cl << child.clone
+        end
+      end
+      cl
+    end
+
+    alias :children :to_a
+
+    def parent?
+      true
+    end
+  end
+end