brakeman 5.2.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/rexml-3.4.4/lib/rexml/encoding.rb

@@ -0,0 +1,48 @@
+# 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
+      encoding = encoding.upcase if encoding
+      return false if defined?(@encoding) and encoding == @encoding
+      @encoding = encoding || "UTF-8"
+      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/3.1.0/gems/rexml-3.4.4/lib/rexml/entity.rb

@@ -0,0 +1,142 @@
+# 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};"
+    PEREFERENCE_RE = /#{PEREFERENCE}/um
+    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, :value
+
+    # 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
+    # &ent; entities.
+    def unnormalized
+      document&.record_entity_expansion
+
+      return nil if @value.nil?
+
+      @unnormalized = Text::unnormalize(@value, parent,
+                                        entity_expansion_text_limit: document&.entity_expansion_text_limit)
+    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
+  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/3.1.0/gems/rexml-3.4.4/lib/rexml/formatters/pretty.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+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.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
+