brakeman 4.5.1 → 4.10.1

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: false
+require_relative 'validationexception'
+
+module REXML
+  module Validation
+    module Validator
+      NILEVENT = [ nil ]
+      def reset
+        @current = @root
+        @root.reset
+        @root.previous = true
+        @attr_stack = []
+        self
+      end
+      def dump
+        puts @root.inspect
+      end
+      def validate( event )
+        @attr_stack = [] unless defined? @attr_stack
+        match = @current.next(event)
+        raise ValidationException.new( "Validation error.  Expected: "+
+          @current.expected.join( " or " )+" from #{@current.inspect} "+
+          " but got #{Event.new( event[0], event[1] ).inspect}" ) unless match
+        @current = match
+
+        # Check for attributes
+        case event[0]
+        when :start_element
+          @attr_stack << event[2]
+          begin
+            sattr = [:start_attribute, nil]
+            eattr = [:end_attribute]
+            text = [:text, nil]
+            k, = event[2].find { |key,value|
+              sattr[1] = key
+              m = @current.next( sattr )
+              if m
+                # If the state has text children...
+                if m.matches?( eattr )
+                  @current = m
+                else
+                  text[1] = value
+                  m = m.next( text )
+                  text[1] = nil
+                  return false unless m
+                  @current = m if m
+                end
+                m = @current.next( eattr )
+                if m
+                  @current = m
+                  true
+                else
+                  false
+                end
+              else
+                false
+              end
+            }
+            event[2].delete(k) if k
+          end while k
+        when :end_element
+          attrs = @attr_stack.pop
+          raise ValidationException.new( "Validation error.  Illegal "+
+            " attributes: #{attrs.inspect}") if attrs.length > 0
+        end
+      end
+    end
+
+    class Event
+      def initialize(event_type, event_arg=nil )
+        @event_type = event_type
+        @event_arg = event_arg
+      end
+
+      attr_reader :event_type
+      attr_accessor :event_arg
+
+      def done?
+        @done
+      end
+
+      def single?
+        return (@event_type != :start_element and @event_type != :start_attribute)
+      end
+
+      def matches?( event )
+        return false unless event[0] == @event_type
+        case event[0]
+        when nil
+          return true
+        when :start_element
+          return true if event[1] == @event_arg
+        when :end_element
+          return true
+        when :start_attribute
+          return true if event[1] == @event_arg
+        when :end_attribute
+          return true
+        when :end_document
+          return true
+        when :text
+          return (@event_arg.nil? or @event_arg == event[1])
+=begin
+        when :processing_instruction
+          false
+        when :xmldecl
+          false
+        when :start_doctype
+          false
+        when :end_doctype
+          false
+        when :externalentity
+          false
+        when :elementdecl
+          false
+        when :entity
+          false
+        when :attlistdecl
+          false
+        when :notationdecl
+          false
+        when :end_doctype
+          false
+=end
+        else
+          false
+        end
+      end
+
+      def ==( other )
+        return false unless other.kind_of? Event
+        @event_type == other.event_type and @event_arg == other.event_arg
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        "#{@event_type.inspect}( #@event_arg )"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: false
+module REXML
+  module Validation
+    class ValidationException < RuntimeError
+      def initialize msg
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: false
+
+require_relative 'encoding'
+require_relative 'source'
+
+module REXML
+  # NEEDS DOCUMENTATION
+  class XMLDecl < Child
+    include Encoding
+
+    DEFAULT_VERSION = "1.0"
+    DEFAULT_ENCODING = "UTF-8"
+    DEFAULT_STANDALONE = "no"
+    START = "<?xml"
+    STOP = "?>"
+
+    attr_accessor :version, :standalone
+    attr_reader :writeencoding, :writethis
+
+    def initialize(version=DEFAULT_VERSION, encoding=nil, standalone=nil)
+      @writethis = true
+      @writeencoding = !encoding.nil?
+      if version.kind_of? XMLDecl
+        super()
+        @version = version.version
+        self.encoding = version.encoding
+        @writeencoding = version.writeencoding
+        @standalone = version.standalone
+        @writethis = version.writethis
+      else
+        super()
+        @version = version
+        self.encoding = encoding
+        @standalone = standalone
+      end
+      @version = DEFAULT_VERSION if @version.nil?
+    end
+
+    def clone
+      XMLDecl.new(self)
+    end
+
+    # indent::
+    #   Ignored.  There must be no whitespace before an XML declaration
+    # transitive::
+    #   Ignored
+    # ie_hack::
+    #   Ignored
+    def write(writer, indent=-1, transitive=false, ie_hack=false)
+      return nil unless @writethis or writer.kind_of? Output
+      writer << START
+      writer << " #{content encoding}"
+      writer << STOP
+    end
+
+    def ==( other )
+      other.kind_of?(XMLDecl) and
+      other.version == @version and
+      other.encoding == self.encoding and
+      other.standalone == @standalone
+    end
+
+    def xmldecl version, encoding, standalone
+      @version = version
+      self.encoding = encoding
+      @standalone = standalone
+    end
+
+    def node_type
+      :xmldecl
+    end
+
+    alias :stand_alone? :standalone
+    alias :old_enc= :encoding=
+
+    def encoding=( enc )
+      if enc.nil?
+        self.old_enc = "UTF-8"
+        @writeencoding = false
+      else
+        self.old_enc = enc
+        @writeencoding = true
+      end
+      self.dowrite
+    end
+
+    # Only use this if you do not want the XML declaration to be written;
+    # this object is ignored by the XML writer.  Otherwise, instantiate your
+    # own XMLDecl and add it to the document.
+    #
+    # Note that XML 1.1 documents *must* include an XML declaration
+    def XMLDecl.default
+      rv = XMLDecl.new( "1.0" )
+      rv.nowrite
+      rv
+    end
+
+    def nowrite
+      @writethis = false
+    end
+
+    def dowrite
+      @writethis = true
+    end
+
+    def inspect
+      "#{START} ... #{STOP}"
+    end
+
+    private
+    def content(enc)
+      context = nil
+      context = parent.context if parent
+      if context and context[:prologue_quote] == :quote
+        quote = "\""
+      else
+        quote = "'"
+      end
+
+      rv = "version=#{quote}#{@version}#{quote}"
+      if @writeencoding or enc !~ /\Autf-8\z/i
+        rv << " encoding=#{quote}#{enc}#{quote}"
+      end
+      if @standalone
+        rv << " standalone=#{quote}#{@standalone}#{quote}"
+      end
+      rv
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: false
+module REXML
+  # Defines a number of tokens used for parsing XML.  Not for general
+  # consumption.
+  module XMLTokens
+    # From http://www.w3.org/TR/REC-xml/#sec-common-syn
+    #
+    #   [4] NameStartChar ::=
+    #         ":" |
+    #         [A-Z] |
+    #         "_" |
+    #         [a-z] |
+    #         [#xC0-#xD6] |
+    #         [#xD8-#xF6] |
+    #         [#xF8-#x2FF] |
+    #         [#x370-#x37D] |
+    #         [#x37F-#x1FFF] |
+    #         [#x200C-#x200D] |
+    #         [#x2070-#x218F] |
+    #         [#x2C00-#x2FEF] |
+    #         [#x3001-#xD7FF] |
+    #         [#xF900-#xFDCF] |
+    #         [#xFDF0-#xFFFD] |
+    #         [#x10000-#xEFFFF]
+    name_start_chars = [
+      ":",
+      "A-Z",
+      "_",
+      "a-z",
+      "\\u00C0-\\u00D6",
+      "\\u00D8-\\u00F6",
+      "\\u00F8-\\u02FF",
+      "\\u0370-\\u037D",
+      "\\u037F-\\u1FFF",
+      "\\u200C-\\u200D",
+      "\\u2070-\\u218F",
+      "\\u2C00-\\u2FEF",
+      "\\u3001-\\uD7FF",
+      "\\uF900-\\uFDCF",
+      "\\uFDF0-\\uFFFD",
+      "\\u{10000}-\\u{EFFFF}",
+    ]
+    # From http://www.w3.org/TR/REC-xml/#sec-common-syn
+    #
+    #   [4a] NameChar ::=
+    #      NameStartChar |
+    #      "-" |
+    #      "." |
+    #      [0-9] |
+    #      #xB7 |
+    #      [#x0300-#x036F] |
+    #      [#x203F-#x2040]
+    name_chars = name_start_chars + [
+      "\\-",
+      "\\.",
+      "0-9",
+      "\\u00B7",
+      "\\u0300-\\u036F",
+      "\\u203F-\\u2040",
+    ]
+    NAME_START_CHAR = "[#{name_start_chars.join('')}]"
+    NAME_CHAR = "[#{name_chars.join('')}]"
+    NAMECHAR = NAME_CHAR # deprecated. Use NAME_CHAR instead.
+
+    # From http://www.w3.org/TR/xml-names11/#NT-NCName
+    #
+    #   [6] NCNameStartChar ::= NameStartChar - ':'
+    ncname_start_chars = name_start_chars - [":"]
+    # From http://www.w3.org/TR/xml-names11/#NT-NCName
+    #
+    #   [5] NCNameChar ::= NameChar - ':'
+    ncname_chars = name_chars - [":"]
+    NCNAME_STR = "[#{ncname_start_chars.join('')}][#{ncname_chars.join('')}]*"
+    NAME_STR = "(?:#{NCNAME_STR}:)?#{NCNAME_STR}"
+
+    NAME = "(#{NAME_START_CHAR}#{NAME_CHAR}*)"
+    NMTOKEN = "(?:#{NAME_CHAR})+"
+    NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*"
+    REFERENCE = "(?:&#{NAME};|&#\\d+;|&#x[0-9a-fA-F]+;)"
+
+    #REFERENCE = "(?:#{ENTITYREF}|#{CHARREF})"
+    #ENTITYREF = "&#{NAME};"
+    #CHARREF = "&#\\d+;|&#x[0-9a-fA-F]+;"
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: false
+require_relative 'functions'
+require_relative 'xpath_parser'
+
+module REXML
+  # Wrapper class.  Use this class to access the XPath functions.
+  class XPath
+    include Functions
+    # A base Hash object, supposing to be used when initializing a
+    # default empty namespaces set, but is currently unused.
+    # TODO: either set the namespaces=EMPTY_HASH, or deprecate this.
+    EMPTY_HASH = {}
+
+    # Finds and returns the first node that matches the supplied xpath.
+    # element::
+    #   The context element
+    # path::
+    #   The xpath to search for.  If not supplied or nil, returns the first
+    #   node matching '*'.
+    # namespaces::
+    #   If supplied, a Hash which defines a namespace mapping.
+    # variables::
+    #   If supplied, a Hash which maps $variables in the query
+    #   to values. This can be used to avoid XPath injection attacks
+    #   or to automatically handle escaping string values.
+    #
+    #  XPath.first( node )
+    #  XPath.first( doc, "//b"} )
+    #  XPath.first( node, "a/x:b", { "x"=>"http://doofus" } )
+    #  XPath.first( node, '/book/publisher/text()=$publisher', {}, {"publisher"=>"O'Reilly"})
+    def XPath::first(element, path=nil, namespaces=nil, variables={}, options={})
+      raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)
+      raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)
+      parser = XPathParser.new(**options)
+      parser.namespaces = namespaces
+      parser.variables = variables
+      path = "*" unless path
+      element = [element] unless element.kind_of? Array
+      parser.parse(path, element).flatten[0]
+    end
+
+    # Iterates over nodes that match the given path, calling the supplied
+    # block with the match.
+    # element::
+    #   The context element
+    # path::
+    #   The xpath to search for.  If not supplied or nil, defaults to '*'
+    # namespaces::
+    #   If supplied, a Hash which defines a namespace mapping
+    # variables::
+    #   If supplied, a Hash which maps $variables in the query
+    #   to values. This can be used to avoid XPath injection attacks
+    #   or to automatically handle escaping string values.
+    #
+    #  XPath.each( node ) { |el| ... }
+    #  XPath.each( node, '/*[@attr='v']' ) { |el| ... }
+    #  XPath.each( node, 'ancestor::x' ) { |el| ... }
+    #  XPath.each( node, '/book/publisher/text()=$publisher', {}, {"publisher"=>"O'Reilly"}) \
+    #    {|el| ... }
+    def XPath::each(element, path=nil, namespaces=nil, variables={}, options={}, &block)
+      raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)
+      raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)
+      parser = XPathParser.new(**options)
+      parser.namespaces = namespaces
+      parser.variables = variables
+      path = "*" unless path
+      element = [element] unless element.kind_of? Array
+      parser.parse(path, element).each( &block )
+    end
+
+    # Returns an array of nodes matching a given XPath.
+    def XPath::match(element, path=nil, namespaces=nil, variables={}, options={})
+      parser = XPathParser.new(**options)
+      parser.namespaces = namespaces
+      parser.variables = variables
+      path = "*" unless path
+      element = [element] unless element.kind_of? Array
+      parser.parse(path,element)
+    end
+  end
+end