brakeman 4.10.1 → 5.0.0.pre1

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

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

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

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

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

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

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