brakeman 4.5.1 → 4.10.1

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

@@ -0,0 +1,51 @@
+# coding: US-ASCII
+# frozen_string_literal: false
+module REXML
+  module Encoding
+    # ID ---> Encoding name
+    attr_reader :encoding
+    def encoding=(encoding)
+      encoding = encoding.name if encoding.is_a?(Encoding)
+      if encoding.is_a?(String)
+        original_encoding = encoding
+        encoding = find_encoding(encoding)
+        unless encoding
+          raise ArgumentError, "Bad encoding name #{original_encoding}"
+        end
+      end
+      return false if defined?(@encoding) and encoding == @encoding
+      if encoding
+        @encoding = encoding.upcase
+      else
+        @encoding = 'UTF-8'
+      end
+      true
+    end
+
+    def encode(string)
+      string.encode(@encoding)
+    end
+
+    def decode(string)
+      string.encode(::Encoding::UTF_8, @encoding)
+    end
+
+    private
+    def find_encoding(name)
+      case name
+      when /\Ashift-jis\z/i
+        return "SHIFT_JIS"
+      when /\ACP-(\d+)\z/
+        name = "CP#{$1}"
+      when /\AUTF-8\z/i
+        return name
+      end
+      begin
+        ::Encoding::Converter.search_convpath(name, 'UTF-8')
+      rescue ::Encoding::ConverterNotFoundError
+        return nil
+      end
+      name
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: false
+require_relative 'child'
+require_relative 'source'
+require_relative 'xmltokens'
+
+module REXML
+  class Entity < Child
+    include XMLTokens
+    PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"
+    SYSTEMLITERAL = %Q{((?:"[^"]*")|(?:'[^']*'))}
+    PUBIDLITERAL = %Q{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}
+    EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"
+    NDATADECL = "\\s+NDATA\\s+#{NAME}"
+    PEREFERENCE = "%#{NAME};"
+    ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}
+    PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"
+    ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
+    PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
+    GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
+    ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
+
+    attr_reader :name, :external, :ref, :ndata, :pubid
+
+    # Create a new entity.  Simple entities can be constructed by passing a
+    # name, value to the constructor; this creates a generic, plain entity
+    # reference. For anything more complicated, you have to pass a Source to
+    # the constructor with the entity definition, or use the accessor methods.
+    # +WARNING+: There is no validation of entity state except when the entity
+    # is read from a stream.  If you start poking around with the accessors,
+    # you can easily create a non-conformant Entity.
+    #
+    #  e = Entity.new( 'amp', '&' )
+    def initialize stream, value=nil, parent=nil, reference=false
+      super(parent)
+      @ndata = @pubid = @value = @external = nil
+      if stream.kind_of? Array
+        @name = stream[1]
+        if stream[-1] == '%'
+          @reference = true
+          stream.pop
+        else
+          @reference = false
+        end
+        if stream[2] =~ /SYSTEM|PUBLIC/
+          @external = stream[2]
+          if @external == 'SYSTEM'
+            @ref = stream[3]
+            @ndata = stream[4] if stream.size == 5
+          else
+            @pubid = stream[3]
+            @ref = stream[4]
+          end
+        else
+          @value = stream[2]
+        end
+      else
+        @reference = reference
+        @external = nil
+        @name = stream
+        @value = value
+      end
+    end
+
+    # Evaluates whether the given string matches an entity definition,
+    # returning true if so, and false otherwise.
+    def Entity::matches? string
+      (ENTITYDECL =~ string) == 0
+    end
+
+    # Evaluates to the unnormalized value of this entity; that is, replacing
+    # all entities -- both %ent; and &ent; entities.  This differs from
+    # +value()+ in that +value+ only replaces %ent; entities.
+    def unnormalized
+      document.record_entity_expansion unless document.nil?
+      v = value()
+      return nil if v.nil?
+      @unnormalized = Text::unnormalize(v, parent)
+      @unnormalized
+    end
+
+    #once :unnormalized
+
+    # Returns the value of this entity unprocessed -- raw.  This is the
+    # normalized value; that is, with all %ent; and &ent; entities intact
+    def normalized
+      @value
+    end
+
+    # Write out a fully formed, correct entity definition (assuming the Entity
+    # object itself is valid.)
+    #
+    # out::
+    #   An object implementing <TT>&lt;&lt;</TT> to which the entity will be
+    #   output
+    # indent::
+    #   *DEPRECATED* and ignored
+    def write out, indent=-1
+      out << '<!ENTITY '
+      out << '% ' if @reference
+      out << @name
+      out << ' '
+      if @external
+        out << @external << ' '
+        if @pubid
+          q = @pubid.include?('"')?"'":'"'
+          out << q << @pubid << q << ' '
+        end
+        q = @ref.include?('"')?"'":'"'
+        out << q << @ref << q
+        out << ' NDATA ' << @ndata if @ndata
+      else
+        q = @value.include?('"')?"'":'"'
+        out << q << @value << q
+      end
+      out << '>'
+    end
+
+    # Returns this entity as a string.  See write().
+    def to_s
+      rv = ''
+      write rv
+      rv
+    end
+
+    PEREFERENCE_RE = /#{PEREFERENCE}/um
+    # Returns the value of this entity.  At the moment, only internal entities
+    # are processed.  If the value contains internal references (IE,
+    # %blah;), those are replaced with their values.  IE, if the doctype
+    # contains:
+    #  <!ENTITY % foo "bar">
+    #  <!ENTITY yada "nanoo %foo; nanoo>
+    # then:
+    #  doctype.entity('yada').value   #-> "nanoo bar nanoo"
+    def value
+      if @value
+        matches = @value.scan(PEREFERENCE_RE)
+        rv = @value.clone
+        if @parent
+          sum = 0
+          matches.each do |entity_reference|
+            entity_value = @parent.entity( entity_reference[0] )
+            if sum + entity_value.bytesize > Security.entity_expansion_text_limit
+              raise "entity expansion has grown too large"
+            else
+              sum += entity_value.bytesize
+            end
+            rv.gsub!( /%#{entity_reference.join};/um, entity_value )
+          end
+        end
+        return rv
+      end
+      nil
+    end
+  end
+
+  # This is a set of entity constants -- the ones defined in the XML
+  # specification.  These are +gt+, +lt+, +amp+, +quot+ and +apos+.
+  # CAUTION: these entities does not have parent and document
+  module EntityConst
+    # +>+
+    GT = Entity.new( 'gt', '>' )
+    # +<+
+    LT = Entity.new( 'lt', '<' )
+    # +&+
+    AMP = Entity.new( 'amp', '&' )
+    # +"+
+    QUOT = Entity.new( 'quot', '"' )
+    # +'+
+    APOS = Entity.new( 'apos', "'" )
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: false
+
+module REXML
+  module Formatters
+    class Default
+      # Prints out the XML document with no formatting -- except if ie_hack is
+      # set.
+      #
+      # ie_hack::
+      #   If set to true, then inserts whitespace before the close of an empty
+      #   tag, so that IE's bad XML parser doesn't choke.
+      def initialize( ie_hack=false )
+        @ie_hack = ie_hack
+      end
+
+      # Writes the node to some output.
+      #
+      # node::
+      #   The node to write
+      # output::
+      #   A class implementing <TT>&lt;&lt;</TT>.  Pass in an Output object to
+      #   change the output encoding.
+      def write( node, output )
+        case node
+
+        when Document
+          if node.xml_decl.encoding != 'UTF-8' && !output.kind_of?(Output)
+            output = Output.new( output, node.xml_decl.encoding )
+          end
+          write_document( node, output )
+
+        when Element
+          write_element( node, output )
+
+        when Declaration, ElementDecl, NotationDecl, ExternalEntity, Entity,
+             Attribute, AttlistDecl
+          node.write( output,-1 )
+
+        when Instruction
+          write_instruction( node, output )
+
+        when DocType, XMLDecl
+          node.write( output )
+
+        when Comment
+          write_comment( node, output )
+
+        when CData
+          write_cdata( node, output )
+
+        when Text
+          write_text( node, output )
+
+        else
+          raise Exception.new("XML FORMATTING ERROR")
+
+        end
+      end
+
+      protected
+      def write_document( node, output )
+        node.children.each { |child| write( child, output ) }
+      end
+
+      def write_element( node, output )
+        output << "<#{node.expanded_name}"
+
+        node.attributes.to_a.map { |a|
+          Hash === a ? a.values : a
+        }.flatten.sort_by {|attr| attr.name}.each do |attr|
+          output << " "
+          attr.write( output )
+        end unless node.attributes.empty?
+
+        if node.children.empty?
+          output << " " if @ie_hack
+          output << "/"
+        else
+          output << ">"
+          node.children.each { |child|
+            write( child, output )
+          }
+          output << "</#{node.expanded_name}"
+        end
+        output << ">"
+      end
+
+      def write_text( node, output )
+        output << node.to_s()
+      end
+
+      def write_comment( node, output )
+        output << Comment::START
+        output << node.to_s
+        output << Comment::STOP
+      end
+
+      def write_cdata( node, output )
+        output << CData::START
+        output << node.to_s
+        output << CData::STOP
+      end
+
+      def write_instruction( node, output )
+        output << Instruction::START
+        output << node.target
+        content = node.content
+        if content
+          output << ' '
+          output << content
+        end
+        output << Instruction::STOP
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: false
+require_relative 'default'
+
+module REXML
+  module Formatters
+    # Pretty-prints an XML document.  This destroys whitespace in text nodes
+    # and will insert carriage returns and indentations.
+    #
+    # TODO: Add an option to print attributes on new lines
+    class Pretty < Default
+
+      # If compact is set to true, then the formatter will attempt to use as
+      # little space as possible
+      attr_accessor :compact
+      # The width of a page.  Used for formatting text
+      attr_accessor :width
+
+      # Create a new pretty printer.
+      #
+      # output::
+      #   An object implementing '<<(String)', to which the output will be written.
+      # indentation::
+      #   An integer greater than 0.  The indentation of each level will be
+      #   this number of spaces.  If this is < 1, the behavior of this object
+      #   is undefined.  Defaults to 2.
+      # ie_hack::
+      #   If true, the printer will insert whitespace before closing empty
+      #   tags, thereby allowing Internet Explorer's XML parser to
+      #   function. Defaults to false.
+      def initialize( indentation=2, ie_hack=false )
+        @indentation = indentation
+        @level = 0
+        @ie_hack = ie_hack
+        @width = 80
+        @compact = false
+      end
+
+      protected
+      def write_element(node, output)
+        output << ' '*@level
+        output << "<#{node.expanded_name}"
+
+        node.attributes.each_attribute do |attr|
+          output << " "
+          attr.write( output )
+        end unless node.attributes.empty?
+
+        if node.children.empty?
+          if @ie_hack
+            output << " "
+          end
+          output << "/"
+        else
+          output << ">"
+          # If compact and all children are text, and if the formatted output
+          # is less than the specified width, then try to print everything on
+          # one line
+          skip = false
+          if compact
+            if node.children.inject(true) {|s,c| s & c.kind_of?(Text)}
+              string = ""
+              old_level = @level
+              @level = 0
+              node.children.each { |child| write( child, string ) }
+              @level = old_level
+              if string.length < @width
+                output << string
+                skip = true
+              end
+            end
+          end
+          unless skip
+            output << "\n"
+            @level += @indentation
+            node.children.each { |child|
+              next if child.kind_of?(Text) and child.to_s.strip.length == 0
+              write( child, output )
+              output << "\n"
+            }
+            @level -= @indentation
+            output << ' '*@level
+          end
+          output << "</#{node.expanded_name}"
+        end
+        output << ">"
+      end
+
+      def write_text( node, output )
+        s = node.to_s()
+        s.gsub!(/\s/,' ')
+        s.squeeze!(" ")
+        s = wrap(s, @width - @level)
+        s = indent_text(s, @level, " ", true)
+        output << (' '*@level + s)
+      end
+
+      def write_comment( node, output)
+        output << ' ' * @level
+        super
+      end
+
+      def write_cdata( node, output)
+        output << ' ' * @level
+        super
+      end
+
+      def write_document( node, output )
+        # Ok, this is a bit odd.  All XML documents have an XML declaration,
+        # but it may not write itself if the user didn't specifically add it,
+        # either through the API or in the input document.  If it doesn't write
+        # itself, then we don't need a carriage return... which makes this
+        # logic more complex.
+        node.children.each { |child|
+          next if child == node.children[-1] and child.instance_of?(Text)
+          unless child == node.children[0] or child.instance_of?(Text) or
+            (child == node.children[1] and !node.children[0].writethis)
+            output << "\n"
+          end
+          write( child, output )
+        }
+      end
+
+      private
+      def indent_text(string, level=1, style="\t", indentfirstline=true)
+        return string if level < 0
+        string.gsub(/\n/, "\n#{style*level}")
+      end
+
+      def wrap(string, width)
+        parts = []
+        while string.length > width and place = string.rindex(' ', width)
+          parts << string[0...place]
+          string = string[place+1..-1]
+        end
+        parts << string
+        parts.join("\n")
+      end
+
+    end
+  end
+end
+