...
+ ele.has_attributes? # => true
+
+Use method REXML::Element#attributes to return the hash
+containing the attributes for the element.
+Each hash key is a string attribute name;
+each hash value is an REXML::Attribute object.
+
+ ele = doc.root # => ...
+ attrs = ele.attributes # => {}
+
+ ele = ele.elements.first # => ...
+ attrs = ele.attributes # => {"category"=>category='cooking'}
+ attrs.size # => 1
+ attr_name = attrs.keys.first # => "category"
+ attr_name.class # => String
+ attr_value = attrs.values.first # => category='cooking'
+ attr_value.class # => REXML::Attribute
+
+Use method REXML::Element#[] to retrieve the string value for a given attribute,
+which may be given as either a string or a symbol:
+
+ ele = doc.root.elements.first # => ...
+ attr_value = ele['category'] # => "cooking"
+ attr_value.class # => String
+ ele['nosuch'] # => nil
+
+Use method REXML::Element#attribute to retrieve the value of a named attribute:
+
+ my_xml = ""
+ my_doc = REXML::Document.new(my_xml)
+ my_doc.root.attribute("x") # => x='x'
+ my_doc.root.attribute("x", "a") # => a:x='a:x'
+
+== Whitespace
+
+Use method REXML::Element#ignore_whitespace_nodes to determine whether
+whitespace nodes were ignored when the XML was parsed;
+returns +true+ if so, +nil+ otherwise.
+
+Use method REXML::Element#whitespace to determine whether whitespace
+is respected for the element; returns +true+ if so, +false+ otherwise.
+
+== Namespaces
+
+Use method REXML::Element#namespace to retrieve the string namespace URI
+for the element, which may derive from one of its ancestors:
+
+ xml_string = <<-EOT
+
+
+
+
+
+
+ EOT
+ d = Document.new(xml_string)
+ b = d.elements['//b']
+ b.namespace # => "1"
+ b.namespace('y') # => "2"
+ b.namespace('nosuch') # => nil
+
+Use method REXML::Element#namespaces to retrieve a hash of all defined namespaces
+in the element and its ancestors:
+
+ xml_string = <<-EOT
+
+
+
+
+
+
+ EOT
+ d = Document.new(xml_string)
+ d.elements['//a'].namespaces # => {"x"=>"1", "y"=>"2"}
+ d.elements['//b'].namespaces # => {"x"=>"1", "y"=>"2"}
+ d.elements['//c'].namespaces # => {"x"=>"1", "y"=>"2", "z"=>"3"}
+
+Use method REXML::Element#prefixes to retrieve an array of the string prefixes (names)
+of all defined namespaces in the element and its ancestors:
+
+ xml_string = <<-EOT
+
+
+
+
+
+
+ EOT
+ d = Document.new(xml_string, {compress_whitespace: :all})
+ d.elements['//a'].prefixes # => ["x", "y"]
+ d.elements['//b'].prefixes # => ["x", "y"]
+ d.elements['//c'].prefixes # => ["x", "y", "z"]
+
+== Traversing
+
+You can use certain methods to traverse children of the element.
+Each child that meets given criteria is yielded to the given block.
+
+[Traverse All Children]
+
+ Use inherited method REXML::Parent#each (or its alias #each_child) to traverse
+ all children of the element:
+
+ doc.root.each {|child| p [child.class, child] }
+
+ Output:
+
+ [REXML::Text, "\n\n"]
+ [REXML::Element, ... ]
+ [REXML::Text, "\n\n"]
+ [REXML::Element, ... ]
+ [REXML::Text, "\n\n"]
+ [REXML::Element, ... ]
+ [REXML::Text, "\n\n"]
+ [REXML::Element, ... ]
+ [REXML::Text, "\n\n"]
+
+[Traverse Element Children]
+
+ Use method REXML::Element#each_element to traverse only the element children
+ of the element:
+
+ doc.root.each_element {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ... ]
+ [REXML::Element, ... ]
+ [REXML::Element, ... ]
+ [REXML::Element, ... ]
+
+[Traverse Element Children with Attribute]
+
+ Use method REXML::Element#each_element_with_attribute with the single argument
+ +attr_name+ to traverse each element child that has the given attribute:
+
+ my_doc = Document.new ''
+ my_doc.root.each_element_with_attribute('id') {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ]
+ [REXML::Element, ]
+ [REXML::Element, ]
+
+ Use the same method with a second argument +value+ to traverse
+ each element child element that has the given attribute and value:
+
+ my_doc.root.each_element_with_attribute('id', '1') {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ]
+ [REXML::Element, ]
+
+ Use the same method with a third argument +max+ to traverse
+ no more than the given number of element children:
+
+ my_doc.root.each_element_with_attribute('id', '1', 1) {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ]
+
+ Use the same method with a fourth argument +xpath+ to traverse
+ only those element children that match the given xpath:
+
+ my_doc.root.each_element_with_attribute('id', '1', 2, '//d') {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ]
+
+[Traverse Element Children with Text]
+
+ Use method REXML::Element#each_element_with_text with no arguments
+ to traverse those element children that have text:
+
+ my_doc = Document.new 'bbd'
+ my_doc.root.each_element_with_text {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ... ]
+ [REXML::Element, ... ]
+ [REXML::Element, ... ]
+
+ Use the same method with the single argument +text+ to traverse
+ those element children that have exactly that text:
+
+ my_doc.root.each_element_with_text('b') {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ... ]
+ [REXML::Element, ... ]
+
+ Use the same method with additional second argument +max+ to traverse
+ no more than the given number of element children:
+
+ my_doc.root.each_element_with_text('b', 1) {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ... ]
+
+ Use the same method with additional third argument +xpath+ to traverse
+ only those element children that also match the given xpath:
+
+ my_doc.root.each_element_with_text('b', 2, '//c') {|e| p [e.class, e] }
+
+ Output:
+
+ [REXML::Element, ... ]
+
+[Traverse Element Children's Indexes]
+
+ Use inherited method REXML::Parent#each_index to traverse all children's indexes
+ (not just those of element children):
+
+ doc.root.each_index {|i| print i }
+
+ Output:
+
+ 012345678
+
+[Traverse Children Recursively]
+
+ Use included method REXML::Node#each_recursive to traverse all children recursively:
+
+ doc.root.each_recursive {|child| p [child.class, child] }
+
+ Output:
+
+ [REXML::Element, ... ]
+ [REXML::Element, ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <year> ... </>]
+ [REXML::Element, <price> ... </>]
+ [REXML::Element, <book category='children'> ... </>]
+ [REXML::Element, <title lang='en'> ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <year> ... </>]
+ [REXML::Element, <price> ... </>]
+ [REXML::Element, <book category='web'> ... </>]
+ [REXML::Element, <title lang='en'> ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <year> ... </>]
+ [REXML::Element, <price> ... </>]
+ [REXML::Element, <book category='web' cover='paperback'> ... </>]
+ [REXML::Element, <title lang='en'> ... </>]
+ [REXML::Element, <author> ... </>]
+ [REXML::Element, <year> ... </>]
+ [REXML::Element, <price> ... </>]
+
+== Searching
+
+You can use certain methods to search among the descendants of an element.
+
+Use method REXML::Element#get_elements to retrieve all element children of the element
+that match the given +xpath+:
+
+ xml_string = <<-EOT
+ <root>
+ <a level='1'>
+ <a level='2'/>
+ </a>
+ </root>
+ EOT
+ d = Document.new(xml_string)
+ d.root.get_elements('//a') # => [<a level='1'> ... </>, <a level='2'/>]
+
+Use method REXML::Element#get_text with no argument to retrieve the first text node
+in the first child:
+
+ my_doc = Document.new "<p>some text <b>this is bold!</b> more text</p>"
+ text_node = my_doc.root.get_text
+ text_node.class # => REXML::Text
+ text_node.to_s # => "some text "
+
+Use the same method with argument +xpath+ to retrieve the first text node
+in the first child that matches the xpath:
+
+ my_doc.root.get_text(1) # => "this is bold!"
+
+Use method REXML::Element#text with no argument to retrieve the text
+from the first text node in the first child:
+
+ my_doc = Document.new "<p>some text <b>this is bold!</b> more text</p>"
+ text_node = my_doc.root.text
+ text_node.class # => String
+ text_node # => "some text "
+
+Use the same method with argument +xpath+ to retrieve the text from the first text node
+in the first child that matches the xpath:
+
+ my_doc.root.text(1) # => "this is bold!"
+
+Use included method REXML::Node#find_first_recursive
+to retrieve the first descendant element
+for which the given block returns a truthy value, or +nil+ if none:
+
+ doc.root.find_first_recursive do |ele|
+ ele.name == 'price'
+ end # => <price> ... </>
+ doc.root.find_first_recursive do |ele|
+ ele.name == 'nosuch'
+ end # => nil
+
+== Editing
+
+=== Editing a Document
+
+[Creating a Document]
+
+ Create a new document with method REXML::Document::new:
+
+ doc = Document.new(source_string)
+ empty_doc = REXML::Document.new
+
+[Adding to the Document]
+
+ Add an XML declaration with method REXML::Document#add
+ and an argument of type REXML::XMLDecl:
+
+ my_doc = Document.new
+ my_doc.xml_decl.to_s # => ""
+ my_doc.add(XMLDecl.new('2.0'))
+ my_doc.xml_decl.to_s # => "<?xml version='2.0'?>"
+
+ Add a document type with method REXML::Document#add
+ and an argument of type REXML::DocType:
+
+ my_doc = Document.new
+ my_doc.doctype.to_s # => ""
+ my_doc.add(DocType.new('foo'))
+ my_doc.doctype.to_s # => "<!DOCTYPE foo>"
+
+ Add a node of any other REXML type with method REXML::Document#add and an argument
+ that is not of type REXML::XMLDecl or REXML::DocType:
+
+ my_doc = Document.new
+ my_doc.add(Element.new('foo'))
+ my_doc.to_s # => "<foo/>"
+
+ Add an existing element as the root element with method REXML::Document#add_element:
+
+ ele = Element.new('foo')
+ my_doc = Document.new
+ my_doc.add_element(ele)
+ my_doc.root # => <foo/>
+
+ Create and add an element as the root element with method REXML::Document#add_element:
+
+ my_doc = Document.new
+ my_doc.add_element('foo')
+ my_doc.root # => <foo/>
+
+=== Editing an Element
+
+==== Creating an Element
+
+Create a new element with method REXML::Element::new:
+
+ ele = Element.new('foo') # => <foo/>
+
+==== Setting Element Properties
+
+Set the context for an element with method REXML::Element#context=
+(see {Element Context}[../context_rdoc.html]):
+
+ ele.context # => nil
+ ele.context = {ignore_whitespace_nodes: :all}
+ ele.context # => {:ignore_whitespace_nodes=>:all}
+
+Set the parent for an element with inherited method REXML::Child#parent=
+
+ ele.parent # => nil
+ ele.parent = Element.new('bar')
+ ele.parent # => <bar/>
+
+Set the text for an element with method REXML::Element#text=:
+
+ ele.text # => nil
+ ele.text = 'bar'
+ ele.text # => "bar"
+
+==== Adding to an Element
+
+Add a node as the last child with inherited method REXML::Parent#add (or its alias #push):
+
+ ele = Element.new('foo') # => <foo/>
+ ele.push(Text.new('bar'))
+ ele.push(Element.new('baz'))
+ ele.children # => ["bar", <baz/>]
+
+Add a node as the first child with inherited method REXML::Parent#unshift:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.unshift(Element.new('bar'))
+ ele.unshift(Text.new('baz'))
+ ele.children # => ["bar", <baz/>]
+
+Add an element as the last child with method REXML::Element#add_element:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_element(Element.new('baz'))
+ ele.children # => [<bar/>, <baz/>]
+
+Add a text node as the last child with method REXML::Element#add_text:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_text('bar')
+ ele.add_text(Text.new('baz'))
+ ele.children # => ["bar", "baz"]
+
+Insert a node before a given node with method REXML::Parent#insert_before:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_text('bar')
+ ele.add_text(Text.new('baz'))
+ ele.children # => ["bar", "baz"]
+ target = ele[1] # => "baz"
+ ele.insert_before(target, Text.new('bat'))
+ ele.children # => ["bar", "bat", "baz"]
+
+Insert a node after a given node with method REXML::Parent#insert_after:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_text('bar')
+ ele.add_text(Text.new('baz'))
+ ele.children # => ["bar", "baz"]
+ target = ele[0] # => "bar"
+ ele.insert_after(target, Text.new('bat'))
+ ele.children # => ["bar", "bat", "baz"]
+
+Add an attribute with method REXML::Element#add_attribute:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_attribute('bar', 'baz')
+ ele.add_attribute(Attribute.new('bat', 'bam'))
+ ele.attributes # => {"bar"=>bar='baz', "bat"=>bat='bam'}
+
+Add multiple attributes with method REXML::Element#add_attributes:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_attributes({'bar' => 'baz', 'bat' => 'bam'})
+ ele.add_attributes([['ban', 'bap'], ['bah', 'bad']])
+ ele.attributes # => {"bar"=>bar='baz', "bat"=>bat='bam', "ban"=>ban='bap', "bah"=>bah='bad'}
+
+Add a namespace with method REXML::Element#add_namespace:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_namespace('bar')
+ ele.add_namespace('baz', 'bat')
+ ele.namespaces # => {"xmlns"=>"bar", "baz"=>"bat"}
+
+==== Deleting from an Element
+
+Delete a specific child object with inherited method REXML::Parent#delete:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.children # => [<bar/>, "baz"]
+ target = ele[1] # => "baz"
+ ele.delete(target) # => "baz"
+ ele.children # => [<bar/>]
+ target = ele[0] # => <baz/>
+ ele.delete(target) # => <baz/>
+ ele.children # => []
+
+Delete a child at a specific index with inherited method REXML::Parent#delete_at:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.children # => [<bar/>, "baz"]
+ ele.delete_at(1)
+ ele.children # => [<bar/>]
+ ele.delete_at(0)
+ ele.children # => []
+
+Delete all children meeting a specified criterion with inherited method
+REXML::Parent#delete_if:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.add_element('bat')
+ ele.add_text('bam')
+ ele.children # => [<bar/>, "baz", <bat/>, "bam"]
+ ele.delete_if {|child| child.instance_of?(Text) }
+ ele.children # => [<bar/>, <bat/>]
+
+Delete an element at a specific 1-based index with method REXML::Element#delete_element:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.add_element('bat')
+ ele.add_text('bam')
+ ele.children # => [<bar/>, "baz", <bat/>, "bam"]
+ ele.delete_element(2) # => <bat/>
+ ele.children # => [<bar/>, "baz", "bam"]
+ ele.delete_element(1) # => <bar/>
+ ele.children # => ["baz", "bam"]
+
+Delete a specific element with the same method:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.add_element('bat')
+ ele.add_text('bam')
+ ele.children # => [<bar/>, "baz", <bat/>, "bam"]
+ target = ele.elements[2] # => <bat/>
+ ele.delete_element(target) # => <bat/>
+ ele.children # => [<bar/>, "baz", "bam"]
+
+Delete an element matching an xpath using the same method:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.add_element('bat')
+ ele.add_text('bam')
+ ele.children # => [<bar/>, "baz", <bat/>, "bam"]
+ ele.delete_element('./bat') # => <bat/>
+ ele.children # => [<bar/>, "baz", "bam"]
+ ele.delete_element('./bar') # => <bar/>
+ ele.children # => ["baz", "bam"]
+
+Delete an attribute by name with method REXML::Element#delete_attribute:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_attributes({'bar' => 'baz', 'bam' => 'bat'})
+ ele.attributes # => {"bar"=>bar='baz', "bam"=>bam='bat'}
+ ele.delete_attribute('bam')
+ ele.attributes # => {"bar"=>bar='baz'}
+
+Delete a namespace with method REXML::Element#delete_namespace:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_namespace('bar')
+ ele.add_namespace('baz', 'bat')
+ ele.namespaces # => {"xmlns"=>"bar", "baz"=>"bat"}
+ ele.delete_namespace('xmlns')
+ ele.namespaces # => {} # => {"baz"=>"bat"}
+ ele.delete_namespace('baz')
+ ele.namespaces # => {} # => {}
+
+Remove an element from its parent with inherited method REXML::Child#remove:
+
+ ele = Element.new('foo') # => <foo/>
+ parent = Element.new('bar') # => <bar/>
+ parent.add_element(ele) # => <foo/>
+ parent.children.size # => 1
+ ele.remove # => <foo/>
+ parent.children.size # => 0
+
+==== Replacing Nodes
+
+Replace the node at a given 0-based index with inherited method REXML::Parent#[]=:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.add_element('bat')
+ ele.add_text('bam')
+ ele.children # => [<bar/>, "baz", <bat/>, "bam"]
+ ele[2] = Text.new('bad') # => "bad"
+ ele.children # => [<bar/>, "baz", "bad", "bam"]
+
+Replace a given node with another node with inherited method REXML::Parent#replace_child:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.add_element('bat')
+ ele.add_text('bam')
+ ele.children # => [<bar/>, "baz", <bat/>, "bam"]
+ target = ele[2] # => <bat/>
+ ele.replace_child(target, Text.new('bah'))
+ ele.children # => [<bar/>, "baz", "bah", "bam"]
+
+Replace +self+ with a given node with inherited method REXML::Child#replace_with:
+
+ ele = Element.new('foo') # => <foo/>
+ ele.add_element('bar')
+ ele.add_text('baz')
+ ele.add_element('bat')
+ ele.add_text('bam')
+ ele.children # => [<bar/>, "baz", <bat/>, "bam"]
+ target = ele[2] # => <bat/>
+ target.replace_with(Text.new('bah'))
+ ele.children # => [<bar/>, "baz", "bah", "bam"]
+
+=== Cloning
+
+Create a shallow clone of an element with method REXML::Element#clone.
+The clone contains the name and attributes, but not the parent or children:
+
+ ele = Element.new('foo')
+ ele.add_attributes({'bar' => 0, 'baz' => 1})
+ ele.clone # => <foo bar='0' baz='1'/>
+
+Create a shallow clone of a document with method REXML::Document#clone.
+The XML declaration is copied; the document type and root element are not cloned:
+
+ my_xml = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo><root/>'
+ my_doc = Document.new(my_xml)
+ clone_doc = my_doc.clone
+
+ my_doc.xml_decl # => <?xml ... ?>
+ clone_doc.xml_decl # => <?xml ... ?>
+
+ my_doc.doctype.to_s # => "<?xml version='1.0' encoding='UTF-8'?>"
+ clone_doc.doctype.to_s # => ""
+
+ my_doc.root # => <root/>
+ clone_doc.root # => nil
+
+Create a deep clone of an element with inherited method REXML::Parent#deep_clone.
+All nodes and attributes are copied:
+
+ doc.to_s.size # => 825
+ clone = doc.deep_clone
+ clone.to_s.size # => 825
+
+== Writing the Document
+
+Write a document to an \IO stream (defaults to <tt>$stdout</tt>)
+with method REXML::Document#write:
+
+ doc.write
+
+Output:
+
+ <?xml version='1.0' encoding='UTF-8'?>
+ <bookstore>
+
+ <book category='cooking'>
+ <title lang='en'>Everyday Italian
+ Giada De Laurentiis
+ 2005
+ 30.00
+
+
+
+ Harry Potter
+ J K. Rowling
+ 2005
+ 29.99
+
+
+
+ XQuery Kick Start
+ James McGovern
+ Per Bothner
+ Kurt Cagle
+ James Linn
+ Vaidyanathan Nagarajan
+ 2003
+ 49.99
+
+
+
+ Learning XML
+ Erik T. Ray
+ 2003
+ 39.95
+
+
+
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml.rb
new file mode 100644
index 0000000..eee246e
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml.rb
@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rexml/document"
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/attlistdecl.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/attlistdecl.rb
new file mode 100644
index 0000000..44a91d6
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/attlistdecl.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: false
+#vim:ts=2 sw=2 noexpandtab:
+require_relative 'child'
+require_relative 'source'
+
+module REXML
+ # This class needs:
+ # * Documentation
+ # * Work! Not all types of attlists are intelligently parsed, so we just
+ # spew back out what we get in. This works, but it would be better if
+ # we formatted the output ourselves.
+ #
+ # AttlistDecls provide *just* enough support to allow namespace
+ # declarations. If you need some sort of generalized support, or have an
+ # interesting idea about how to map the hideous, terrible design of DTD
+ # AttlistDecls onto an intuitive Ruby interface, let me know. I'm desperate
+ # for anything to make DTDs more palateable.
+ class AttlistDecl < Child
+ include Enumerable
+
+ # What is this? Got me.
+ attr_reader :element_name
+
+ # Create an AttlistDecl, pulling the information from a Source. Notice
+ # that this isn't very convenient; to create an AttlistDecl, you basically
+ # have to format it yourself, and then have the initializer parse it.
+ # Sorry, but for the foreseeable future, DTD support in REXML is pretty
+ # weak on convenience. Have I mentioned how much I hate DTDs?
+ def initialize(source)
+ super()
+ if (source.kind_of? Array)
+ @element_name, @pairs, @contents = *source
+ end
+ end
+
+ # Access the attlist attribute/value pairs.
+ # value = attlist_decl[ attribute_name ]
+ def [](key)
+ @pairs[key]
+ end
+
+ # Whether an attlist declaration includes the given attribute definition
+ # if attlist_decl.include? "xmlns:foobar"
+ def include?(key)
+ @pairs.keys.include? key
+ end
+
+ # Iterate over the key/value pairs:
+ # attlist_decl.each { |attribute_name, attribute_value| ... }
+ def each(&block)
+ @pairs.each(&block)
+ end
+
+ # Write out exactly what we got in.
+ def write out, indent=-1
+ out << @contents
+ end
+
+ def node_type
+ :attlistdecl
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/attribute.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/attribute.rb
new file mode 100644
index 0000000..c567324
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/attribute.rb
@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require_relative "namespace"
+require_relative 'text'
+
+module REXML
+ # Defines an Element Attribute; IE, a attribute=value pair, as in:
+ # . Attributes can be in their own
+ # namespaces. General users of REXML will not interact with the
+ # Attribute class much.
+ class Attribute
+ include Node
+ include Namespace
+
+ # The element to which this attribute belongs
+ attr_reader :element
+ PATTERN = /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um
+
+ NEEDS_A_SECOND_CHECK = /(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um
+
+ # Constructor.
+ # FIXME: The parser doesn't catch illegal characters in attributes
+ #
+ # first::
+ # Either: an Attribute, which this new attribute will become a
+ # clone of; or a String, which is the name of this attribute
+ # second::
+ # If +first+ is an Attribute, then this may be an Element, or nil.
+ # If nil, then the Element parent of this attribute is the parent
+ # of the +first+ Attribute. If the first argument is a String,
+ # then this must also be a String, and is the content of the attribute.
+ # If this is the content, it must be fully normalized (contain no
+ # illegal characters).
+ # parent::
+ # Ignored unless +first+ is a String; otherwise, may be the Element
+ # parent of this attribute, or nil.
+ #
+ #
+ # Attribute.new( attribute_to_clone )
+ # Attribute.new( attribute_to_clone, parent_element )
+ # Attribute.new( "attr", "attr_value" )
+ # Attribute.new( "attr", "attr_value", parent_element )
+ def initialize( first, second=nil, parent=nil )
+ @normalized = @unnormalized = @element = nil
+ if first.kind_of? Attribute
+ self.name = first.expanded_name
+ @unnormalized = first.value
+ if second.kind_of? Element
+ @element = second
+ else
+ @element = first.element
+ end
+ elsif first.kind_of? String
+ @element = parent
+ self.name = first
+ @normalized = second.to_s
+ else
+ raise "illegal argument #{first.class.name} to Attribute constructor"
+ end
+ end
+
+ # Returns the namespace of the attribute.
+ #
+ # e = Element.new( "elns:myelement" )
+ # e.add_attribute( "nsa:a", "aval" )
+ # e.add_attribute( "b", "bval" )
+ # e.attributes.get_attribute( "a" ).prefix # -> "nsa"
+ # e.attributes.get_attribute( "b" ).prefix # -> ""
+ # a = Attribute.new( "x", "y" )
+ # a.prefix # -> ""
+ def prefix
+ super
+ end
+
+ # Returns the namespace URL, if defined, or nil otherwise
+ #
+ # e = Element.new("el")
+ # e.add_namespace("ns", "http://url")
+ # e.add_attribute("ns:a", "b")
+ # e.add_attribute("nsx:a", "c")
+ # e.attribute("ns:a").namespace # => "http://url"
+ # e.attribute("nsx:a").namespace # => nil
+ #
+ # This method always returns "" for no namespace attribute. Because
+ # the default namespace doesn't apply to attribute names.
+ #
+ # From https://www.w3.org/TR/xml-names/#uniqAttrs
+ #
+ # > the default namespace does not apply to attribute names
+ #
+ # e = REXML::Element.new("el")
+ # e.add_namespace("", "http://example.com/")
+ # e.namespace # => "http://example.com/"
+ # e.add_attribute("a", "b")
+ # e.attribute("a").namespace # => ""
+ def namespace arg=nil
+ arg = prefix if arg.nil?
+ if arg == ""
+ ""
+ else
+ @element.namespace(arg)
+ end
+ end
+
+ # Returns true if other is an Attribute and has the same name and value,
+ # false otherwise.
+ def ==( other )
+ other.kind_of?(Attribute) and other.name==name and other.value==value
+ end
+
+ # Creates (and returns) a hash from both the name and value
+ def hash
+ name.hash + value.hash
+ end
+
+ # Returns this attribute out as XML source, expanding the name
+ #
+ # a = Attribute.new( "x", "y" )
+ # a.to_string # -> "x='y'"
+ # b = Attribute.new( "ns:x", "y" )
+ # b.to_string # -> "ns:x='y'"
+ def to_string
+ value = to_s
+ if @element and @element.context and @element.context[:attribute_quote] == :quote
+ value = value.gsub('"', '"') if value.include?('"')
+ %Q^#@expanded_name="#{value}"^
+ else
+ value = value.gsub("'", ''') if value.include?("'")
+ "#@expanded_name='#{value}'"
+ end
+ end
+
+ def doctype
+ @element&.document&.doctype
+ end
+
+ # Returns the attribute value, with entities replaced
+ def to_s
+ return @normalized if @normalized
+
+ @normalized = Text::normalize( @unnormalized, doctype )
+ @normalized
+ end
+
+ # Returns the UNNORMALIZED value of this attribute. That is, entities
+ # have been expanded to their values
+ def value
+ return @unnormalized if @unnormalized
+
+ @unnormalized = Text::unnormalize(@normalized, doctype,
+ entity_expansion_text_limit: @element&.document&.entity_expansion_text_limit)
+ end
+
+ # The normalized value of this attribute. That is, the attribute with
+ # entities intact.
+ def normalized=(new_normalized)
+ @normalized = new_normalized
+ @unnormalized = nil
+ end
+
+ # Returns a copy of this attribute
+ def clone
+ Attribute.new self
+ end
+
+ # Sets the element of which this object is an attribute. Normally, this
+ # is not directly called.
+ #
+ # Returns this attribute
+ def element=( element )
+ @element = element
+
+ if @normalized
+ Text.check( @normalized, NEEDS_A_SECOND_CHECK )
+ end
+
+ self
+ end
+
+ # Removes this Attribute from the tree, and returns true if successful
+ #
+ # This method is usually not called directly.
+ def remove
+ @element.attributes.delete self.name unless @element.nil?
+ end
+
+ # Writes this attribute (EG, puts 'key="value"' to the output)
+ def write( output, indent=-1 )
+ output << to_string
+ end
+
+ def node_type
+ :attribute
+ end
+
+ def inspect
+ rv = +""
+ write( rv )
+ rv
+ end
+
+ def xpath
+ @element.xpath + "/@#{self.expanded_name}"
+ end
+
+ def document
+ @element&.document
+ end
+ end
+end
+#vim:ts=2 sw=2 noexpandtab:
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/cdata.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/cdata.rb
new file mode 100644
index 0000000..264ad64
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/cdata.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: false
+require_relative "text"
+
+module REXML
+ class CData < Text
+ START = ''
+ ILLEGAL = /(\]\]>)/
+
+ # Constructor. CData is data between
+ #
+ # _Examples_
+ # CData.new( source )
+ # CData.new( "Here is some CDATA" )
+ # CData.new( "Some unprocessed data", respect_whitespace_TF, parent_element )
+ def initialize( first, whitespace=true, parent=nil )
+ super( first, whitespace, parent, false, true, ILLEGAL )
+ end
+
+ # Make a copy of this object
+ #
+ # _Examples_
+ # c = CData.new( "Some text" )
+ # d = c.clone
+ # d.to_s # -> "Some text"
+ def clone
+ CData.new self
+ end
+
+ # Returns the content of this CData object
+ #
+ # _Examples_
+ # c = CData.new( "Some text" )
+ # c.to_s # -> "Some text"
+ def to_s
+ @string
+ end
+
+ def value
+ @string
+ end
+
+ # == DEPRECATED
+ # See the rexml/formatters package
+ #
+ # Generates XML output of this object
+ #
+ # output::
+ # Where to write the string. Defaults to $stdout
+ # indent::
+ # The amount to indent this node by
+ # transitive::
+ # Ignored
+ # ie_hack::
+ # Ignored
+ #
+ # _Examples_
+ # c = CData.new( " Some text " )
+ # c.write( $stdout ) #->
+ def write( output=$stdout, indent=-1, transitive=false, ie_hack=false )
+ Kernel.warn( "#{self.class.name}#write is deprecated", uplevel: 1)
+ indent( output, indent )
+ output << START
+ output << @string
+ output << STOP
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/child.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/child.rb
new file mode 100644
index 0000000..2718040
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/child.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: false
+require_relative "node"
+
+module REXML
+ ##
+ # A Child object is something contained by a parent, and this class
+ # contains methods to support that. Most user code will not use this
+ # class directly.
+ class Child
+ include Node
+ attr_reader :parent # The Parent of this object
+
+ # Constructor. Any inheritors of this class should call super to make
+ # sure this method is called.
+ # parent::
+ # if supplied, the parent of this child will be set to the
+ # supplied value, and self will be added to the parent
+ def initialize( parent = nil )
+ @parent = nil
+ # Declare @parent, but don't define it. The next line sets the
+ # parent.
+ parent.add( self ) if parent
+ end
+
+ # Replaces this object with another object. Basically, calls
+ # Parent.replace_child
+ #
+ # Returns:: self
+ def replace_with( child )
+ @parent.replace_child( self, child )
+ self
+ end
+
+ # Removes this child from the parent.
+ #
+ # Returns:: self
+ def remove
+ unless @parent.nil?
+ @parent.delete self
+ end
+ self
+ end
+
+ # Sets the parent of this child to the supplied argument.
+ #
+ # other::
+ # Must be a Parent object. If this object is the same object as the
+ # existing parent of this child, no action is taken. Otherwise, this
+ # child is removed from the current parent (if one exists), and is added
+ # to the new parent.
+ # Returns:: The parent added
+ def parent=( other )
+ return @parent if @parent == other
+ @parent.delete self if defined? @parent and @parent
+ @parent = other
+ end
+
+ alias :next_sibling :next_sibling_node
+ alias :previous_sibling :previous_sibling_node
+
+ # Sets the next sibling of this child. This can be used to insert a child
+ # after some other child.
+ # a = Element.new("a")
+ # b = a.add_element("b")
+ # c = Element.new("c")
+ # b.next_sibling = c
+ # # =>
+ def next_sibling=( other )
+ parent.insert_after self, other
+ end
+
+ # Sets the previous sibling of this child. This can be used to insert a
+ # child before some other child.
+ # a = Element.new("a")
+ # b = a.add_element("b")
+ # c = Element.new("c")
+ # b.previous_sibling = c
+ # # =>
+ def previous_sibling=(other)
+ parent.insert_before self, other
+ end
+
+ # Returns:: the document this child belongs to, or nil if this child
+ # belongs to no document
+ def document
+ parent&.document
+ end
+
+ # This doesn't yet handle encodings
+ def bytes
+ document&.encoding
+
+ to_s
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/comment.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/comment.rb
new file mode 100644
index 0000000..e7e104d
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/comment.rb
@@ -0,0 +1,80 @@
+# frozen_string_literal: false
+require_relative "child"
+
+module REXML
+ ##
+ # Represents an XML comment; that is, text between \
+ class Comment < Child
+ include Comparable
+ START = ""
+
+ # The content text
+
+ attr_accessor :string
+
+ ##
+ # Constructor. The first argument can be one of three types:
+ # @param first If String, the contents of this comment are set to the
+ # argument. If Comment, the argument is duplicated. If
+ # Source, the argument is scanned for a comment.
+ # @param second If the first argument is a Source, this argument
+ # should be nil, not supplied, or a Parent to be set as the parent
+ # of this object
+ def initialize( first, second = nil )
+ super(second)
+ if first.kind_of? String
+ @string = first
+ elsif first.kind_of? Comment
+ @string = first.string
+ end
+ end
+
+ def clone
+ Comment.new self
+ end
+
+ # == DEPRECATED
+ # See REXML::Formatters
+ #
+ # output::
+ # Where to write the string
+ # indent::
+ # An integer. If -1, no indenting will be used; otherwise, the
+ # indentation will be this number of spaces, and children will be
+ # indented an additional amount.
+ # transitive::
+ # Ignored by this class. The contents of comments are never modified.
+ # ie_hack::
+ # Needed for conformity to the child API, but not used by this class.
+ def write( output, indent=-1, transitive=false, ie_hack=false )
+ Kernel.warn("#{self.class.name}#write is deprecated. See REXML::Formatters", uplevel: 1)
+ indent( output, indent )
+ output << START
+ output << @string
+ output << STOP
+ end
+
+ alias :to_s :string
+
+ ##
+ # Compares this Comment to another; the contents of the comment are used
+ # in the comparison.
+ def <=>(other)
+ other.to_s <=> @string
+ end
+
+ ##
+ # Compares this Comment to another; the contents of the comment are used
+ # in the comparison.
+ def ==( other )
+ other.kind_of? Comment and
+ (other <=> self) == 0
+ end
+
+ def node_type
+ :comment
+ end
+ end
+end
+#vim:ts=2 sw=2 noexpandtab:
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/doctype.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/doctype.rb
new file mode 100644
index 0000000..a9cf9f7
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/doctype.rb
@@ -0,0 +1,306 @@
+# frozen_string_literal: false
+require_relative "parent"
+require_relative "parseexception"
+require_relative "namespace"
+require_relative 'entity'
+require_relative 'attlistdecl'
+require_relative 'xmltokens'
+
+module REXML
+ class ReferenceWriter
+ def initialize(id_type,
+ public_id_literal,
+ system_literal,
+ context=nil)
+ @id_type = id_type
+ @public_id_literal = public_id_literal
+ @system_literal = system_literal
+ if context and context[:prologue_quote] == :apostrophe
+ @default_quote = "'"
+ else
+ @default_quote = "\""
+ end
+ end
+
+ def write(output)
+ output << " #{@id_type}"
+ if @public_id_literal
+ if @public_id_literal.include?("'")
+ quote = "\""
+ else
+ quote = @default_quote
+ end
+ output << " #{quote}#{@public_id_literal}#{quote}"
+ end
+ if @system_literal
+ if @system_literal.include?("'")
+ quote = "\""
+ elsif @system_literal.include?("\"")
+ quote = "'"
+ else
+ quote = @default_quote
+ end
+ output << " #{quote}#{@system_literal}#{quote}"
+ end
+ end
+ end
+
+ # Represents an XML DOCTYPE declaration; that is, the contents of . DOCTYPES can be used to declare the DTD of a document, as well as
+ # being used to declare entities used in the document.
+ class DocType < Parent
+ include XMLTokens
+ START = ""
+ SYSTEM = "SYSTEM"
+ PUBLIC = "PUBLIC"
+ DEFAULT_ENTITIES = {
+ 'gt'=>EntityConst::GT,
+ 'lt'=>EntityConst::LT,
+ 'quot'=>EntityConst::QUOT,
+ "apos"=>EntityConst::APOS
+ }
+
+ # name is the name of the doctype
+ # external_id is the referenced DTD, if given
+ attr_reader :name, :external_id, :entities, :namespaces
+
+ # Constructor
+ #
+ # dt = DocType.new( 'foo', '-//I/Hate/External/IDs' )
+ # #
+ # dt = DocType.new( doctype_to_clone )
+ # # Incomplete. Shallow clone of doctype
+ #
+ # +Note+ that the constructor:
+ #
+ # Doctype.new( Source.new( "" ) )
+ #
+ # is _deprecated_. Do not use it. It will probably disappear.
+ def initialize( first, parent=nil )
+ @entities = DEFAULT_ENTITIES
+ @long_name = @uri = nil
+ if first.kind_of? String
+ super()
+ @name = first
+ @external_id = parent
+ elsif first.kind_of? DocType
+ super( parent )
+ @name = first.name
+ @external_id = first.external_id
+ @long_name = first.instance_variable_get(:@long_name)
+ @uri = first.instance_variable_get(:@uri)
+ elsif first.kind_of? Array
+ super( parent )
+ @name = first[0]
+ @external_id = first[1]
+ @long_name = first[2]
+ @uri = first[3]
+ elsif first.kind_of? Source
+ super( parent )
+ parser = Parsers::BaseParser.new( first )
+ event = parser.pull
+ if event[0] == :start_doctype
+ @name, @external_id, @long_name, @uri, = event[1..-1]
+ end
+ else
+ super()
+ end
+ end
+
+ def node_type
+ :doctype
+ end
+
+ def attributes_of element
+ rv = []
+ each do |child|
+ child.each do |key,val|
+ rv << Attribute.new(key,val)
+ end if child.kind_of? AttlistDecl and child.element_name == element
+ end
+ rv
+ end
+
+ def attribute_of element, attribute
+ att_decl = find do |child|
+ child.kind_of? AttlistDecl and
+ child.element_name == element and
+ child.include? attribute
+ end
+ return nil unless att_decl
+ att_decl[attribute]
+ end
+
+ def clone
+ DocType.new self
+ end
+
+ # output::
+ # Where to write the string
+ # indent::
+ # An integer. If -1, no indentation will be used; otherwise, the
+ # indentation will be this number of spaces, and children will be
+ # indented an additional amount.
+ # transitive::
+ # Ignored
+ # ie_hack::
+ # Ignored
+ def write( output, indent=0, transitive=false, ie_hack=false )
+ f = REXML::Formatters::Default.new
+ indent( output, indent )
+ output << START
+ output << ' '
+ output << @name
+ if @external_id
+ reference_writer = ReferenceWriter.new(@external_id,
+ @long_name,
+ @uri,
+ context)
+ reference_writer.write(output)
+ end
+ unless @children.empty?
+ output << ' ['
+ @children.each { |child|
+ output << "\n"
+ f.write( child, output )
+ }
+ output << "\n]"
+ end
+ output << STOP
+ end
+
+ def context
+ @parent&.context
+ end
+
+ def entity( name )
+ @entities[name]&.unnormalized
+ end
+
+ def add child
+ super(child)
+ @entities = DEFAULT_ENTITIES.clone if @entities == DEFAULT_ENTITIES
+ @entities[ child.name ] = child if child.kind_of? Entity
+ end
+
+ # This method retrieves the public identifier identifying the document's
+ # DTD.
+ #
+ # Method contributed by Henrik Martensson
+ def public
+ case @external_id
+ when "SYSTEM"
+ nil
+ when "PUBLIC"
+ @long_name
+ end
+ end
+
+ # This method retrieves the system identifier identifying the document's DTD
+ #
+ # Method contributed by Henrik Martensson
+ def system
+ case @external_id
+ when "SYSTEM"
+ @long_name
+ when "PUBLIC"
+ @uri.kind_of?(String) ? @uri : nil
+ end
+ end
+
+ # This method returns a list of notations that have been declared in the
+ # _internal_ DTD subset. Notations in the external DTD subset are not
+ # listed.
+ #
+ # Method contributed by Henrik Martensson
+ def notations
+ children().select {|node| node.kind_of?(REXML::NotationDecl)}
+ end
+
+ # Retrieves a named notation. Only notations declared in the internal
+ # DTD subset can be retrieved.
+ #
+ # Method contributed by Henrik Martensson
+ def notation(name)
+ notations.find { |notation_decl|
+ notation_decl.name == name
+ }
+ end
+ end
+
+ # We don't really handle any of these since we're not a validating
+ # parser, so we can be pretty dumb about them. All we need to be able
+ # to do is spew them back out on a write()
+
+ # This is an abstract class. You never use this directly; it serves as a
+ # parent class for the specific declarations.
+ class Declaration < Child
+ def initialize src
+ super()
+ @string = src
+ end
+
+ def to_s
+ @string+'>'
+ end
+
+ # == DEPRECATED
+ # See REXML::Formatters
+ #
+ def write( output, indent )
+ output << to_s
+ end
+ end
+
+ public
+ class ElementDecl < Declaration
+ def initialize( src )
+ super
+ end
+ end
+
+ class ExternalEntity < Child
+ def initialize( src )
+ super()
+ @entity = src
+ end
+ def to_s
+ @entity
+ end
+ def write( output, indent )
+ output << @entity
+ end
+ end
+
+ class NotationDecl < Child
+ attr_accessor :public, :system
+ def initialize name, middle, pub, sys
+ super(nil)
+ @name = name
+ @middle = middle
+ @public = pub
+ @system = sys
+ end
+
+ def to_s
+ context = parent&.context
+ notation = ""
+ notation
+ end
+
+ def write( output, indent=-1 )
+ output << to_s
+ end
+
+ # This method retrieves the name of the notation.
+ #
+ # Method contributed by Henrik Martensson
+ def name
+ @name
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/document.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/document.rb
new file mode 100644
index 0000000..bd3a004
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/document.rb
@@ -0,0 +1,471 @@
+# frozen_string_literal: false
+require_relative "security"
+require_relative "element"
+require_relative "xmldecl"
+require_relative "source"
+require_relative "comment"
+require_relative "doctype"
+require_relative "instruction"
+require_relative "rexml"
+require_relative "parseexception"
+require_relative "output"
+require_relative "parsers/baseparser"
+require_relative "parsers/streamparser"
+require_relative "parsers/treeparser"
+
+module REXML
+ # Represents an XML document.
+ #
+ # A document may have:
+ #
+ # - A single child that may be accessed via method #root.
+ # - An XML declaration.
+ # - A document type.
+ # - Processing instructions.
+ #
+ # == In a Hurry?
+ #
+ # If you're somewhat familiar with XML
+ # and have a particular task in mind,
+ # you may want to see the
+ # {tasks pages}[../doc/rexml/tasks/tocs/master_toc_rdoc.html],
+ # and in particular, the
+ # {tasks page for documents}[../doc/rexml/tasks/tocs/document_toc_rdoc.html].
+ #
+ class Document < Element
+ # A convenient default XML declaration. Use:
+ #
+ # mydoc << XMLDecl.default
+ #
+ DECLARATION = XMLDecl.default
+
+ # :call-seq:
+ # new(string = nil, context = {}) -> new_document
+ # new(io_stream = nil, context = {}) -> new_document
+ # new(document = nil, context = {}) -> new_document
+ #
+ # Returns a new \REXML::Document object.
+ #
+ # When no arguments are given,
+ # returns an empty document:
+ #
+ # d = REXML::Document.new
+ # d.to_s # => ""
+ #
+ # When argument +string+ is given, it must be a string
+ # containing a valid XML document:
+ #
+ # xml_string = 'FooBar'
+ # d = REXML::Document.new(xml_string)
+ # d.to_s # => "FooBar"
+ #
+ # When argument +io_stream+ is given, it must be an \IO object
+ # that is opened for reading, and when read must return a valid XML document:
+ #
+ # File.write('t.xml', xml_string)
+ # d = File.open('t.xml', 'r') do |io|
+ # REXML::Document.new(io)
+ # end
+ # d.to_s # => "FooBar"
+ #
+ # When argument +document+ is given, it must be an existing
+ # document object, whose context and attributes (but not children)
+ # are cloned into the new document:
+ #
+ # d = REXML::Document.new(xml_string)
+ # d.children # => [ ... ]
+ # d.context = {raw: :all, compress_whitespace: :all}
+ # d.add_attributes({'bar' => 0, 'baz' => 1})
+ # d1 = REXML::Document.new(d)
+ # d1.children # => []
+ # d1.context # => {:raw=>:all, :compress_whitespace=>:all}
+ # d1.attributes # => {"bar"=>bar='0', "baz"=>baz='1'}
+ #
+ # When argument +context+ is given, it must be a hash
+ # containing context entries for the document;
+ # see {Element Context}[../doc/rexml/context_rdoc.html]:
+ #
+ # context = {raw: :all, compress_whitespace: :all}
+ # d = REXML::Document.new(xml_string, context)
+ # d.context # => {:raw=>:all, :compress_whitespace=>:all}
+ #
+ def initialize( source = nil, context = {} )
+ @entity_expansion_count = 0
+ @entity_expansion_limit = Security.entity_expansion_limit
+ @entity_expansion_text_limit = Security.entity_expansion_text_limit
+ super()
+ @context = context
+ # `source = ""` is an invalid usage because no root element XML is an invalid XML.
+ # But we accept `""` for backward compatibility.
+ return if source.nil? or source == ""
+ if source.kind_of? Document
+ @context = source.context
+ super source
+ else
+ build( source )
+ end
+ end
+
+ # :call-seq:
+ # node_type -> :document
+ #
+ # Returns the symbol +:document+.
+ #
+ def node_type
+ :document
+ end
+
+ # :call-seq:
+ # clone -> new_document
+ #
+ # Returns the new document resulting from executing
+ # Document.new(self). See Document.new.
+ #
+ def clone
+ Document.new self
+ end
+
+ # :call-seq:
+ # expanded_name -> empty_string
+ #
+ # Returns an empty string.
+ #
+ def expanded_name
+ ''
+ #d = doc_type
+ #d ? d.name : "UNDEFINED"
+ end
+ alias :name :expanded_name
+
+ # :call-seq:
+ # add(xml_decl) -> self
+ # add(doc_type) -> self
+ # add(object) -> self
+ #
+ # Adds an object to the document; returns +self+.
+ #
+ # When argument +xml_decl+ is given,
+ # it must be an REXML::XMLDecl object,
+ # which becomes the XML declaration for the document,
+ # replacing the previous XML declaration if any:
+ #
+ # d = REXML::Document.new
+ # d.xml_decl.to_s # => ""
+ # d.add(REXML::XMLDecl.new('2.0'))
+ # d.xml_decl.to_s # => ""
+ #
+ # When argument +doc_type+ is given,
+ # it must be an REXML::DocType object,
+ # which becomes the document type for the document,
+ # replacing the previous document type, if any:
+ #
+ # d = REXML::Document.new
+ # d.doctype.to_s # => ""
+ # d.add(REXML::DocType.new('foo'))
+ # d.doctype.to_s # => ""
+ #
+ # When argument +object+ (not an REXML::XMLDecl or REXML::DocType object)
+ # is given it is added as the last child:
+ #
+ # d = REXML::Document.new
+ # d.add(REXML::Element.new('foo'))
+ # d.to_s # => ""
+ #
+ def add( child )
+ if child.kind_of? XMLDecl
+ if @children[0].kind_of? XMLDecl
+ @children[0] = child
+ else
+ @children.unshift child
+ end
+ child.parent = self
+ elsif child.kind_of? DocType
+ # Find first Element or DocType node and insert the decl right
+ # before it. If there is no such node, just insert the child at the
+ # end. If there is a child and it is an DocType, then replace it.
+ insert_before_index = @children.find_index { |x|
+ x.kind_of?(Element) || x.kind_of?(DocType)
+ }
+ if insert_before_index # Not null = not end of list
+ if @children[ insert_before_index ].kind_of? DocType
+ @children[ insert_before_index ] = child
+ else
+ @children[ insert_before_index-1, 0 ] = child
+ end
+ else # Insert at end of list
+ @children << child
+ end
+ child.parent = self
+ else
+ rv = super
+ raise "attempted adding second root element to document" if @elements.size > 1
+ rv
+ end
+ end
+ alias :<< :add
+
+ # :call-seq:
+ # add_element(name_or_element = nil, attributes = nil) -> new_element
+ #
+ # Adds an element to the document by calling REXML::Element.add_element:
+ #
+ # REXML::Element.add_element(name_or_element, attributes)
+ def add_element(arg=nil, arg2=nil)
+ rv = super
+ raise "attempted adding second root element to document" if @elements.size > 1
+ rv
+ end
+
+ # :call-seq:
+ # root -> root_element or nil
+ #
+ # Returns the root element of the document, if it exists, otherwise +nil+:
+ #
+ # d = REXML::Document.new('')
+ # d.root # =>
+ # d = REXML::Document.new('')
+ # d.root # => nil
+ #
+ def root
+ elements[1]
+ #self
+ #@children.find { |item| item.kind_of? Element }
+ end
+
+ # :call-seq:
+ # doctype -> doc_type or nil
+ #
+ # Returns the DocType object for the document, if it exists, otherwise +nil+:
+ #
+ # d = REXML::Document.new('')
+ # d.doctype.class # => REXML::DocType
+ # d = REXML::Document.new('')
+ # d.doctype.class # => nil
+ #
+ def doctype
+ @children.find { |item| item.kind_of? DocType }
+ end
+
+ # :call-seq:
+ # xml_decl -> xml_decl
+ #
+ # Returns the XMLDecl object for the document, if it exists,
+ # otherwise the default XMLDecl object:
+ #
+ # d = REXML::Document.new('')
+ # d.xml_decl.class # => REXML::XMLDecl
+ # d.xml_decl.to_s # => ""
+ # d = REXML::Document.new('')
+ # d.xml_decl.class # => REXML::XMLDecl
+ # d.xml_decl.to_s # => ""
+ #
+ def xml_decl
+ rv = @children[0]
+ return rv if rv.kind_of? XMLDecl
+ @children.unshift(XMLDecl.default)[0]
+ end
+
+ # :call-seq:
+ # version -> version_string
+ #
+ # Returns the XMLDecl version of this document as a string,
+ # if it has been set, otherwise the default version:
+ #
+ # d = REXML::Document.new('')
+ # d.version # => "2.0"
+ # d = REXML::Document.new('')
+ # d.version # => "1.0"
+ #
+ def version
+ xml_decl().version
+ end
+
+ # :call-seq:
+ # encoding -> encoding_string
+ #
+ # Returns the XMLDecl encoding of the document,
+ # if it has been set, otherwise the default encoding:
+ #
+ # d = REXML::Document.new('')
+ # d.encoding # => "UTF-16"
+ # d = REXML::Document.new('')
+ # d.encoding # => "UTF-8"
+ #
+ def encoding
+ xml_decl().encoding
+ end
+
+ # :call-seq:
+ # stand_alone?
+ #
+ # Returns the XMLDecl standalone value of the document as a string,
+ # if it has been set, otherwise the default standalone value:
+ #
+ # d = REXML::Document.new('')
+ # d.stand_alone? # => "yes"
+ # d = REXML::Document.new('')
+ # d.stand_alone? # => nil
+ #
+ def stand_alone?
+ xml_decl().stand_alone?
+ end
+
+ # :call-seq:
+ # doc.write(output=$stdout, indent=-1, transitive=false, ie_hack=false, encoding=nil)
+ # doc.write(options={:output => $stdout, :indent => -1, :transitive => false, :ie_hack => false, :encoding => nil})
+ #
+ # Write the XML tree out, optionally with indent. This writes out the
+ # entire XML document, including XML declarations, doctype declarations,
+ # and processing instructions (if any are given).
+ #
+ # A controversial point is whether Document should always write the XML
+ # declaration () whether or not one is given by the
+ # user (or source document). REXML does not write one if one was not
+ # specified, because it adds unnecessary bandwidth to applications such
+ # as XML-RPC.
+ #
+ # Accept Nth argument style and options Hash style as argument.
+ # The recommended style is options Hash style for one or more
+ # arguments case.
+ #
+ # _Examples_
+ # Document.new("").write
+ #
+ # output = ""
+ # Document.new("").write(output)
+ #
+ # output = ""
+ # Document.new("").write(:output => output, :indent => 2)
+ #
+ # See also the classes in the rexml/formatters package for the proper way
+ # to change the default formatting of XML output.
+ #
+ # _Examples_
+ #
+ # output = ""
+ # tr = Transitive.new
+ # tr.write(Document.new(""), output)
+ #
+ # output::
+ # output an object which supports '<< string'; this is where the
+ # document will be written.
+ # indent::
+ # An integer. If -1, no indenting will be used; otherwise, the
+ # indentation will be twice this number of spaces, and children will be
+ # indented an additional amount. For a value of 3, every item will be
+ # indented 3 more levels, or 6 more spaces (2 * 3). Defaults to -1
+ # transitive::
+ # If transitive is true and indent is >= 0, then the output will be
+ # pretty-printed in such a way that the added whitespace does not affect
+ # the absolute *value* of the document -- that is, it leaves the value
+ # and number of Text nodes in the document unchanged.
+ # ie_hack::
+ # This hack inserts a space before the /> on empty tags to address
+ # a limitation of Internet Explorer. Defaults to false
+ # encoding::
+ # Encoding name as String. Change output encoding to specified encoding
+ # instead of encoding in XML declaration.
+ # Defaults to nil. It means encoding in XML declaration is used.
+ def write(*arguments)
+ if arguments.size == 1 and arguments[0].class == Hash
+ options = arguments[0]
+
+ output = options[:output]
+ indent = options[:indent]
+ transitive = options[:transitive]
+ ie_hack = options[:ie_hack]
+ encoding = options[:encoding]
+ else
+ output, indent, transitive, ie_hack, encoding, = *arguments
+ end
+
+ output ||= $stdout
+ indent ||= -1
+ transitive = false if transitive.nil?
+ ie_hack = false if ie_hack.nil?
+ encoding ||= xml_decl.encoding
+
+ if encoding != 'UTF-8' && !output.kind_of?(Output)
+ output = Output.new( output, encoding )
+ end
+ formatter = if indent > -1
+ if transitive
+ require_relative "formatters/transitive"
+ REXML::Formatters::Transitive.new( indent, ie_hack )
+ else
+ REXML::Formatters::Pretty.new( indent, ie_hack )
+ end
+ else
+ REXML::Formatters::Default.new( ie_hack )
+ end
+ formatter.write( self, output )
+ end
+
+
+ def Document::parse_stream( source, listener )
+ Parsers::StreamParser.new( source, listener ).parse
+ end
+
+ # Set the entity expansion limit. By default the limit is set to 10000.
+ #
+ # Deprecated. Use REXML::Security.entity_expansion_limit= instead.
+ def Document::entity_expansion_limit=( val )
+ Security.entity_expansion_limit = val
+ end
+
+ # Get the entity expansion limit. By default the limit is set to 10000.
+ #
+ # Deprecated. Use REXML::Security.entity_expansion_limit= instead.
+ def Document::entity_expansion_limit
+ Security.entity_expansion_limit
+ end
+
+ # Set the entity expansion limit. By default the limit is set to 10240.
+ #
+ # Deprecated. Use REXML::Security.entity_expansion_text_limit= instead.
+ def Document::entity_expansion_text_limit=( val )
+ Security.entity_expansion_text_limit = val
+ end
+
+ # Get the entity expansion limit. By default the limit is set to 10240.
+ #
+ # Deprecated. Use REXML::Security.entity_expansion_text_limit instead.
+ def Document::entity_expansion_text_limit
+ Security.entity_expansion_text_limit
+ end
+
+ attr_reader :entity_expansion_count
+ attr_writer :entity_expansion_limit
+ attr_accessor :entity_expansion_text_limit
+
+ def record_entity_expansion
+ @entity_expansion_count += 1
+ if @entity_expansion_count > @entity_expansion_limit
+ raise "number of entity expansions exceeded, processing aborted."
+ end
+ end
+
+ def document
+ self
+ end
+
+ private
+
+ attr_accessor :namespaces_cache
+
+ # New document level cache is created and available in this block.
+ # This API is thread unsafe. Users can't change this document in this block.
+ def enable_cache
+ @namespaces_cache = {}
+ begin
+ yield
+ ensure
+ @namespaces_cache = nil
+ end
+ end
+
+ def build( source )
+ Parsers::TreeParser.new( source, self ).parse
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/attlistdecl.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/attlistdecl.rb
new file mode 100644
index 0000000..1326cb2
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/attlistdecl.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: false
+require_relative "../child"
+module REXML
+ module DTD
+ class AttlistDecl < Child
+ START = ")/um
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/dtd.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/dtd.rb
new file mode 100644
index 0000000..8b0f2d7
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/dtd.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: false
+require_relative "elementdecl"
+require_relative "entitydecl"
+require_relative "../comment"
+require_relative "notationdecl"
+require_relative "attlistdecl"
+require_relative "../parent"
+
+module REXML
+ module DTD
+ class Parser
+ def Parser.parse( input )
+ case input
+ when String
+ parse_helper input
+ when File
+ parse_helper input.read
+ end
+ end
+
+ # Takes a String and parses it out
+ def Parser.parse_helper( input )
+ contents = Parent.new
+ while input.size > 0
+ case input
+ when ElementDecl.PATTERN_RE
+ match = $&
+ contents << ElementDecl.new( match )
+ when AttlistDecl.PATTERN_RE
+ matchdata = $~
+ contents << AttlistDecl.new( matchdata )
+ when EntityDecl.PATTERN_RE
+ matchdata = $~
+ contents << EntityDecl.new( matchdata )
+ when Comment.PATTERN_RE
+ matchdata = $~
+ contents << Comment.new( matchdata )
+ when NotationDecl.PATTERN_RE
+ matchdata = $~
+ contents << NotationDecl.new( matchdata )
+ end
+ end
+ contents
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/elementdecl.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/elementdecl.rb
new file mode 100644
index 0000000..20ed023
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/elementdecl.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: false
+require_relative "../child"
+module REXML
+ module DTD
+ class ElementDecl < Child
+ START = "/um
+ PATTERN_RE = /^\s*#{START}\s+((?:[:\w][-\.\w]*:)?[-!\*\.\w]*)(.*?)>/
+ #\s*((((["']).*?\5)|[^\/'">]*)*?)(\/)?>/um, true)
+
+ def initialize match
+ @name = match[1]
+ @rest = match[2]
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/entitydecl.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/entitydecl.rb
new file mode 100644
index 0000000..312df65
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/entitydecl.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: false
+require_relative "../child"
+module REXML
+ module DTD
+ class EntityDecl < Child
+ START = "/um
+ SYSTEM = /^\s*#{START}\s+(?:%\s+)?(\w+)\s+SYSTEM\s+((["']).*?\3)(?:\s+NDATA\s+\w+)?\s*>/um
+ PLAIN = /^\s*#{START}\s+(\w+)\s+((["']).*?\3)\s*>/um
+ PERCENT = /^\s*#{START}\s+%\s+(\w+)\s+((["']).*?\3)\s*>/um
+ #
+ #
+ def initialize src
+ super()
+ md = nil
+ if src.match( PUBLIC )
+ md = src.match( PUBLIC, true )
+ @middle = "PUBLIC"
+ @content = "#{md[2]} #{md[4]}"
+ elsif src.match( SYSTEM )
+ md = src.match( SYSTEM, true )
+ @middle = "SYSTEM"
+ @content = md[2]
+ elsif src.match( PLAIN )
+ md = src.match( PLAIN, true )
+ @middle = ""
+ @content = md[2]
+ elsif src.match( PERCENT )
+ md = src.match( PERCENT, true )
+ @middle = ""
+ @content = md[2]
+ end
+ raise ParseException.new("failed Entity match", src) if md.nil?
+ @name = md[1]
+ end
+
+ def to_s
+ rv = " 0
+ rv << @content
+ rv
+ end
+
+ def write( output, indent )
+ indent( output, indent )
+ output << to_s
+ end
+
+ def EntityDecl.parse_source source, listener
+ md = source.match( PATTERN_RE, true )
+ thing = md[0].squeeze(" \t\n\r")
+ listener.send inspect.downcase, thing
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/notationdecl.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/notationdecl.rb
new file mode 100644
index 0000000..04a9b08
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/dtd/notationdecl.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: false
+require_relative "../child"
+module REXML
+ module DTD
+ class NotationDecl < Child
+ START = "/um
+ SYSTEM = /^\s*#{START}\s+(\w[\w-]*)\s+(SYSTEM)\s+((["']).*?\4)\s*>/um
+ def initialize src
+ super()
+ if src.match( PUBLIC )
+ md = src.match( PUBLIC, true )
+ elsif src.match( SYSTEM )
+ md = src.match( SYSTEM, true )
+ else
+ raise ParseException.new( "error parsing notation: no matching pattern", src )
+ end
+ @name = md[1]
+ @middle = md[2]
+ @rest = md[3]
+ end
+
+ def to_s
+ ""
+ end
+
+ def write( output, indent )
+ indent( output, indent )
+ output << to_s
+ end
+
+ def NotationDecl.parse_source source, listener
+ md = source.match( PATTERN_RE, true )
+ thing = md[0].squeeze(" \t\n\r")
+ listener.send inspect.downcase, thing
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/element.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/element.rb
new file mode 100644
index 0000000..0d74811
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/element.rb
@@ -0,0 +1,2578 @@
+# frozen_string_literal: false
+require_relative "parent"
+require_relative "namespace"
+require_relative "attribute"
+require_relative "cdata"
+require_relative "xpath"
+require_relative "parseexception"
+
+module REXML
+ # An \REXML::Element object represents an XML element.
+ #
+ # An element:
+ #
+ # - Has a name (string).
+ # - May have a parent (another element).
+ # - Has zero or more children
+ # (other elements, text, CDATA, processing instructions, and comments).
+ # - Has zero or more siblings
+ # (other elements, text, CDATA, processing instructions, and comments).
+ # - Has zero or more named attributes.
+ #
+ # == In a Hurry?
+ #
+ # If you're somewhat familiar with XML
+ # and have a particular task in mind,
+ # you may want to see the
+ # {tasks pages}[../doc/rexml/tasks/tocs/master_toc_rdoc.html],
+ # and in particular, the
+ # {tasks page for elements}[../doc/rexml/tasks/tocs/element_toc_rdoc.html].
+ #
+ # === Name
+ #
+ # An element has a name, which is initially set when the element is created:
+ #
+ # e = REXML::Element.new('foo')
+ # e.name # => "foo"
+ #
+ # The name may be changed:
+ #
+ # e.name = 'bar'
+ # e.name # => "bar"
+ #
+ #
+ # === \Parent
+ #
+ # An element may have a parent.
+ #
+ # Its parent may be assigned explicitly when the element is created:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar', e0)
+ # e1.parent # => ...
+ #
+ # Note: the representation of an element always shows the element's name.
+ # If the element has children, the representation indicates that
+ # by including an ellipsis (...).
+ #
+ # The parent may be assigned explicitly at any time:
+ #
+ # e2 = REXML::Element.new('baz')
+ # e1.parent = e2
+ # e1.parent # =>
+ #
+ # When an element is added as a child, its parent is set automatically:
+ #
+ # e1.add_element(e0)
+ # e0.parent # => ...
+ #
+ # For an element that has no parent, method +parent+ returns +nil+.
+ #
+ # === Children
+ #
+ # An element has zero or more children.
+ # The children are an ordered collection
+ # of all objects whose parent is the element itself.
+ #
+ # The children may include any combination of elements, text, comments,
+ # processing instructions, and CDATA.
+ # (This example keeps things clean by controlling whitespace
+ # via a +context+ setting.)
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ # text 0
+ #
+ #
+ #
+ #
+ # text 1
+ #
+ #
+ #
+ #
+ # EOT
+ # context = {ignore_whitespace_nodes: :all, compress_whitespace: :all}
+ # d = REXML::Document.new(xml_string, context)
+ # root = d.root
+ # root.children.size # => 10
+ # root.each {|child| p "#{child.class}: #{child}" }
+ #
+ # Output:
+ #
+ # "REXML::Element: "
+ # "REXML::Text: \n text 0\n "
+ # "REXML::Comment: comment 0"
+ # "REXML::Instruction: "
+ # "REXML::CData: cdata 0"
+ # "REXML::Element: "
+ # "REXML::Text: \n text 1\n "
+ # "REXML::Comment: comment 1"
+ # "REXML::Instruction: "
+ # "REXML::CData: cdata 1"
+ #
+ # A child may be added using inherited methods
+ # Parent#insert_before or Parent#insert_after:
+ #
+ # xml_string = ''
+ # d = REXML::Document.new(xml_string)
+ # root = d.root
+ # c = d.root[1] # =>
+ # root.insert_before(c, REXML::Element.new('b'))
+ # root.to_a # => [, , , ]
+ #
+ # A child may be replaced using Parent#replace_child:
+ #
+ # root.replace_child(c, REXML::Element.new('x'))
+ # root.to_a # => [, , , ]
+ #
+ # A child may be removed using Parent#delete:
+ #
+ # x = root[2] # =>
+ # root.delete(x)
+ # root.to_a # => [, , ]
+ #
+ # === Siblings
+ #
+ # An element has zero or more siblings,
+ # which are the other children of the element's parent.
+ #
+ # In the example above, element +ele_1+ is between a CDATA sibling
+ # and a text sibling:
+ #
+ # ele_1 = root[5] # =>
+ # ele_1.previous_sibling # => "cdata 0"
+ # ele_1.next_sibling # => "\n text 1\n "
+ #
+ # === \Attributes
+ #
+ # An element has zero or more named attributes.
+ #
+ # A new element has no attributes:
+ #
+ # e = REXML::Element.new('foo')
+ # e.attributes # => {}
+ #
+ # Attributes may be added:
+ #
+ # e.add_attribute('bar', 'baz')
+ # e.add_attribute('bat', 'bam')
+ # e.attributes.size # => 2
+ # e['bar'] # => "baz"
+ # e['bat'] # => "bam"
+ #
+ # An existing attribute may be modified:
+ #
+ # e.add_attribute('bar', 'bad')
+ # e.attributes.size # => 2
+ # e['bar'] # => "bad"
+ #
+ # An existing attribute may be deleted:
+ #
+ # e.delete_attribute('bar')
+ # e.attributes.size # => 1
+ # e['bar'] # => nil
+ #
+ # == What's Here
+ #
+ # To begin with, what's elsewhere?
+ #
+ # \Class \REXML::Element inherits from its ancestor classes:
+ #
+ # - REXML::Child
+ # - REXML::Parent
+ #
+ # \REXML::Element itself and its ancestors also include modules:
+ #
+ # - {Enumerable}[https://docs.ruby-lang.org/en/master/Enumerable.html]
+ # - REXML::Namespace
+ # - REXML::Node
+ # - REXML::XMLTokens
+ #
+ # === Methods for Creating an \Element
+ #
+ # ::new:: Returns a new empty element.
+ # #clone:: Returns a clone of another element.
+ #
+ # === Methods for Attributes
+ #
+ # {[attribute_name]}[#method-i-5B-5D]:: Returns an attribute value.
+ # #add_attribute:: Adds a new attribute.
+ # #add_attributes:: Adds multiple new attributes.
+ # #attribute:: Returns the attribute value for a given name and optional namespace.
+ # #delete_attribute:: Removes an attribute.
+ #
+ # === Methods for Children
+ #
+ # {[index]}[#method-i-5B-5D]:: Returns the child at the given offset.
+ # #add_element:: Adds an element as the last child.
+ # #delete_element:: Deletes a child element.
+ # #each_element:: Calls the given block with each child element.
+ # #each_element_with_attribute:: Calls the given block with each child element
+ # that meets given criteria,
+ # which can include the attribute name.
+ # #each_element_with_text:: Calls the given block with each child element
+ # that meets given criteria,
+ # which can include text.
+ # #get_elements:: Returns an array of element children that match a given xpath.
+ #
+ # === Methods for \Text Children
+ #
+ # #add_text:: Adds a text node to the element.
+ # #get_text:: Returns a text node that meets specified criteria.
+ # #text:: Returns the text string from the first node that meets specified criteria.
+ # #texts:: Returns an array of the text children of the element.
+ # #text=:: Adds, removes, or replaces the first text child of the element
+ #
+ # === Methods for Other Children
+ #
+ # #cdatas:: Returns an array of the cdata children of the element.
+ # #comments:: Returns an array of the comment children of the element.
+ # #instructions:: Returns an array of the instruction children of the element.
+ #
+ # === Methods for Namespaces
+ #
+ # #add_namespace:: Adds a namespace to the element.
+ # #delete_namespace:: Removes a namespace from the element.
+ # #namespace:: Returns the string namespace URI for the element.
+ # #namespaces:: Returns a hash of all defined namespaces in the element.
+ # #prefixes:: Returns an array of the string prefixes (names)
+ # of all defined namespaces in the element
+ #
+ # === Methods for Querying
+ #
+ # #document:: Returns the document, if any, that the element belongs to.
+ # #root:: Returns the most distant element (not document) ancestor of the element.
+ # #root_node:: Returns the most distant ancestor of the element.
+ # #xpath:: Returns the string xpath to the element
+ # relative to the most distant parent
+ # #has_attributes?:: Returns whether the element has attributes.
+ # #has_elements?:: Returns whether the element has elements.
+ # #has_text?:: Returns whether the element has text.
+ # #next_element:: Returns the next sibling that is an element.
+ # #previous_element:: Returns the previous sibling that is an element.
+ # #raw:: Returns whether raw mode is set for the element.
+ # #whitespace:: Returns whether whitespace is respected for the element.
+ # #ignore_whitespace_nodes:: Returns whether whitespace nodes
+ # are to be ignored for the element.
+ # #node_type:: Returns symbol :element.
+ #
+ # === One More Method
+ #
+ # #inspect:: Returns a string representation of the element.
+ #
+ # === Accessors
+ #
+ # #elements:: Returns the REXML::Elements object for the element.
+ # #attributes:: Returns the REXML::Attributes object for the element.
+ # #context:: Returns or sets the context hash for the element.
+ #
+ class Element < Parent
+ include Namespace
+
+ UNDEFINED = "UNDEFINED"; # The default name
+
+ # Mechanisms for accessing attributes and child elements of this
+ # element.
+ attr_reader :attributes, :elements
+ # The context holds information about the processing environment, such as
+ # whitespace handling.
+ attr_accessor :context
+
+ # :call-seq:
+ # Element.new(name = 'UNDEFINED', parent = nil, context = nil) -> new_element
+ # Element.new(element, parent = nil, context = nil) -> new_element
+ #
+ # Returns a new \REXML::Element object.
+ #
+ # When no arguments are given,
+ # returns an element with name 'UNDEFINED':
+ #
+ # e = REXML::Element.new # =>
+ # e.class # => REXML::Element
+ # e.name # => "UNDEFINED"
+ #
+ # When only argument +name+ is given,
+ # returns an element of the given name:
+ #
+ # REXML::Element.new('foo') # =>
+ #
+ # When only argument +element+ is given, it must be an \REXML::Element object;
+ # returns a shallow copy of the given element:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new(e0) # =>
+ #
+ # When argument +parent+ is also given, it must be an REXML::Parent object:
+ #
+ # e = REXML::Element.new('foo', REXML::Parent.new)
+ # e.parent # => #]>
+ #
+ # When argument +context+ is also given, it must be a hash
+ # representing the context for the element;
+ # see {Element Context}[../doc/rexml/context_rdoc.html]:
+ #
+ # e = REXML::Element.new('foo', nil, {raw: :all})
+ # e.context # => {:raw=>:all}
+ #
+ def initialize( arg = UNDEFINED, parent=nil, context=nil )
+ super(parent)
+
+ @elements = Elements.new(self)
+ @attributes = Attributes.new(self)
+ @context = context
+
+ if arg.kind_of? String
+ self.name = arg
+ elsif arg.kind_of? Element
+ self.name = arg.expanded_name
+ arg.attributes.each_attribute{ |attribute|
+ @attributes << Attribute.new( attribute )
+ }
+ @context = arg.context
+ end
+ end
+
+ # :call-seq:
+ # inspect -> string
+ #
+ # Returns a string representation of the element.
+ #
+ # For an element with no attributes and no children, shows the element name:
+ #
+ # REXML::Element.new.inspect # => ""
+ #
+ # Shows attributes, if any:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_attributes({'bar' => 0, 'baz' => 1})
+ # e.inspect # => ""
+ #
+ # Shows an ellipsis (...), if there are child elements:
+ #
+ # e.add_element(REXML::Element.new('bar'))
+ # e.add_element(REXML::Element.new('baz'))
+ # e.inspect # => " ... "
+ #
+ def inspect
+ rv = "<#@expanded_name"
+
+ @attributes.each_attribute do |attr|
+ rv << " "
+ attr.write( rv, 0 )
+ end
+
+ if children.size > 0
+ rv << "> ... "
+ else
+ rv << "/>"
+ end
+ end
+
+ # :call-seq:
+ # clone -> new_element
+ #
+ # Returns a shallow copy of the element, containing the name and attributes,
+ # but not the parent or children:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_attributes({'bar' => 0, 'baz' => 1})
+ # e.clone # =>
+ #
+ def clone
+ self.class.new self
+ end
+
+ # :call-seq:
+ # root_node -> document or element
+ #
+ # Returns the most distant ancestor of +self+.
+ #
+ # When the element is part of a document,
+ # returns the root node of the document.
+ # Note that the root node is different from the document element;
+ # in this example +a+ is document element and the root node is its parent:
+ #
+ # d = REXML::Document.new('')
+ # top_element = d.first # => ...
+ # child = top_element.first # => ...
+ # d.root_node == d # => true
+ # top_element.root_node == d # => true
+ # child.root_node == d # => true
+ #
+ # When the element is not part of a document, but does have ancestor elements,
+ # returns the most distant ancestor element:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar')
+ # e1.parent = e0
+ # e2 = REXML::Element.new('baz')
+ # e2.parent = e1
+ # e2.root_node == e0 # => true
+ #
+ # When the element has no ancestor elements,
+ # returns +self+:
+ #
+ # e = REXML::Element.new('foo')
+ # e.root_node == e # => true
+ #
+ # Related: #root, #document.
+ #
+ def root_node
+ parent.nil? ? self : parent.root_node
+ end
+
+ # :call-seq:
+ # root -> element
+ #
+ # Returns the most distant _element_ (not document) ancestor of the element:
+ #
+ # d = REXML::Document.new('')
+ # top_element = d.first
+ # child = top_element.first
+ # top_element.root == top_element # => true
+ # child.root == top_element # => true
+ #
+ # For a document, returns the topmost element:
+ #
+ # d.root == top_element # => true
+ #
+ # Related: #root_node, #document.
+ #
+ def root
+ target = self
+ while target
+ return target.elements[1] if target.kind_of? Document
+ parent = target.parent
+ return target if parent.kind_of? Document or parent.nil?
+ target = parent
+ end
+ nil
+ end
+
+ # :call-seq:
+ # document -> document or nil
+ #
+ # If the element is part of a document, returns that document:
+ #
+ # d = REXML::Document.new('')
+ # top_element = d.first
+ # child = top_element.first
+ # top_element.document == d # => true
+ # child.document == d # => true
+ #
+ # If the element is not part of a document, returns +nil+:
+ #
+ # REXML::Element.new.document # => nil
+ #
+ # For a document, returns +self+:
+ #
+ # d.document == d # => true
+ #
+ # Related: #root, #root_node.
+ #
+ def document
+ root&.parent
+ end
+
+ # :call-seq:
+ # whitespace
+ #
+ # Returns +true+ if whitespace is respected for this element,
+ # +false+ otherwise.
+ #
+ # See {Element Context}[../doc/rexml/context_rdoc.html].
+ #
+ # The evaluation is tested against the element's +expanded_name+,
+ # and so is namespace-sensitive.
+ def whitespace
+ @whitespace = nil
+ if @context
+ if @context[:respect_whitespace]
+ @whitespace = (@context[:respect_whitespace] == :all or
+ @context[:respect_whitespace].include? expanded_name)
+ end
+ @whitespace = false if (@context[:compress_whitespace] and
+ (@context[:compress_whitespace] == :all or
+ @context[:compress_whitespace].include? expanded_name)
+ )
+ end
+ @whitespace = true unless @whitespace == false
+ @whitespace
+ end
+
+ # :call-seq:
+ # ignore_whitespace_nodes
+ #
+ # Returns +true+ if whitespace nodes are ignored for the element.
+ #
+ # See {Element Context}[../doc/rexml/context_rdoc.html].
+ #
+ def ignore_whitespace_nodes
+ @ignore_whitespace_nodes = false
+ if @context
+ if @context[:ignore_whitespace_nodes]
+ @ignore_whitespace_nodes =
+ (@context[:ignore_whitespace_nodes] == :all or
+ @context[:ignore_whitespace_nodes].include? expanded_name)
+ end
+ end
+ end
+
+ # :call-seq:
+ # raw
+ #
+ # Returns +true+ if raw mode is set for the element.
+ #
+ # See {Element Context}[../doc/rexml/context_rdoc.html].
+ #
+ # The evaluation is tested against +expanded_name+, and so is namespace
+ # sensitive.
+ def raw
+ @raw = (@context and @context[:raw] and
+ (@context[:raw] == :all or
+ @context[:raw].include? expanded_name))
+ @raw
+ end
+
+ #once :whitespace, :raw, :ignore_whitespace_nodes
+
+ #################################################
+ # Namespaces #
+ #################################################
+
+ # :call-seq:
+ # prefixes -> array_of_namespace_prefixes
+ #
+ # Returns an array of the string prefixes (names) of all defined namespaces
+ # in the element and its ancestors:
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string, {compress_whitespace: :all})
+ # d.elements['//a'].prefixes # => ["x", "y"]
+ # d.elements['//b'].prefixes # => ["x", "y"]
+ # d.elements['//c'].prefixes # => ["x", "y", "z"]
+ #
+ def prefixes
+ prefixes = []
+ prefixes = parent.prefixes if parent
+ prefixes |= attributes.prefixes
+ prefixes
+ end
+
+ # :call-seq:
+ # namespaces -> array_of_namespace_names
+ #
+ # Returns a hash of all defined namespaces
+ # in the element and its ancestors:
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # d.elements['//a'].namespaces # => {"x"=>"1", "y"=>"2"}
+ # d.elements['//b'].namespaces # => {"x"=>"1", "y"=>"2"}
+ # d.elements['//c'].namespaces # => {"x"=>"1", "y"=>"2", "z"=>"3"}
+ #
+ def namespaces
+ namespaces_cache = document&.__send__(:namespaces_cache)
+ if namespaces_cache
+ namespaces_cache[self] ||= calculate_namespaces
+ else
+ calculate_namespaces
+ end
+ end
+
+ # :call-seq:
+ # namespace(prefix = nil) -> string_uri or nil
+ #
+ # Returns the string namespace URI for the element,
+ # possibly deriving from one of its ancestors.
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # b = d.elements['//b']
+ # b.namespace # => "1"
+ # b.namespace('y') # => "2"
+ # b.namespace('nosuch') # => nil
+ #
+ def namespace(prefix=nil)
+ if prefix.nil?
+ prefix = prefix()
+ end
+ prefix = (prefix == '') ? 'xmlns' : prefix.delete_prefix("xmlns:")
+ ns = namespaces[prefix]
+
+ ns = '' if ns.nil? and prefix == 'xmlns'
+ ns
+ end
+
+ # :call-seq:
+ # add_namespace(prefix, uri = nil) -> self
+ #
+ # Adds a namespace to the element; returns +self+.
+ #
+ # With the single argument +prefix+,
+ # adds a namespace using the given +prefix+ and the namespace URI:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_namespace('bar')
+ # e.namespaces # => {"xmlns"=>"bar"}
+ #
+ # With both arguments +prefix+ and +uri+ given,
+ # adds a namespace using both arguments:
+ #
+ # e.add_namespace('baz', 'bat')
+ # e.namespaces # => {"xmlns"=>"bar", "baz"=>"bat"}
+ #
+ def add_namespace( prefix, uri=nil )
+ unless uri
+ @attributes["xmlns"] = prefix
+ else
+ prefix = "xmlns:#{prefix}" unless prefix =~ /^xmlns:/
+ @attributes[ prefix ] = uri
+ end
+ self
+ end
+
+ # :call-seq:
+ # delete_namespace(namespace = 'xmlns') -> self
+ #
+ # Removes a namespace from the element.
+ #
+ # With no argument, removes the default namespace:
+ #
+ # d = REXML::Document.new ""
+ # d.to_s # => ""
+ # d.root.delete_namespace # =>
+ # d.to_s # => ""
+ #
+ # With argument +namespace+, removes the specified namespace:
+ #
+ # d.root.delete_namespace('foo')
+ # d.to_s # => ""
+ #
+ # Does nothing if no such namespace is found:
+ #
+ # d.root.delete_namespace('nosuch')
+ # d.to_s # => ""
+ #
+ def delete_namespace namespace="xmlns"
+ namespace = "xmlns:#{namespace}" unless namespace == 'xmlns'
+ attribute = attributes.get_attribute(namespace)
+ attribute.remove unless attribute.nil?
+ self
+ end
+
+ #################################################
+ # Elements #
+ #################################################
+
+ # :call-seq:
+ # add_element(name, attributes = nil) -> new_element
+ # add_element(element, attributes = nil) -> element
+ #
+ # Adds a child element, optionally setting attributes
+ # on the added element; returns the added element.
+ #
+ # With string argument +name+, creates a new element with that name
+ # and adds the new element as a child:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e0.add_element('bar')
+ # e0[0] # =>
+ #
+ #
+ # With argument +name+ and hash argument +attributes+,
+ # sets attributes on the new element:
+ #
+ # e0.add_element('baz', {'bat' => '0', 'bam' => '1'})
+ # e0[1] # =>
+ #
+ # With element argument +element+, adds that element as a child:
+ #
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar')
+ # e0.add_element(e1)
+ # e0[0] # =>
+ #
+ # With argument +element+ and hash argument +attributes+,
+ # sets attributes on the added element:
+ #
+ # e0.add_element(e1, {'bat' => '0', 'bam' => '1'})
+ # e0[1] # =>
+ #
+ def add_element element, attrs=nil
+ raise "First argument must be either an element name, or an Element object" if element.nil?
+ el = @elements.add(element)
+ attrs.each do |key, value|
+ el.attributes[key]=value
+ end if attrs.kind_of? Hash
+ el
+ end
+
+ # :call-seq:
+ # delete_element(index) -> removed_element or nil
+ # delete_element(element) -> removed_element or nil
+ # delete_element(xpath) -> removed_element or nil
+ #
+ # Deletes a child element.
+ #
+ # When 1-based integer argument +index+ is given,
+ # removes and returns the child element at that offset if it exists;
+ # indexing does not include text nodes;
+ # returns +nil+ if the element does not exist:
+ #
+ # d = REXML::Document.new 'text'
+ # a = d.root # => ...
+ # a.delete_element(1) # =>
+ # a.delete_element(1) # =>
+ # a.delete_element(1) # => nil
+ #
+ # When element argument +element+ is given,
+ # removes and returns that child element if it exists,
+ # otherwise returns +nil+:
+ #
+ # d = REXML::Document.new 'text'
+ # a = d.root # => ...
+ # c = a[2] # =>
+ # a.delete_element(c) # =>
+ # a.delete_element(c) # => nil
+ #
+ # When xpath argument +xpath+ is given,
+ # removes and returns the element at xpath if it exists,
+ # otherwise returns +nil+:
+ #
+ # d = REXML::Document.new 'text'
+ # a = d.root # => ...
+ # a.delete_element('//c') # =>
+ # a.delete_element('//c') # => nil
+ #
+ def delete_element element
+ @elements.delete element
+ end
+
+ # :call-seq:
+ # has_elements?
+ #
+ # Returns +true+ if the element has one or more element children,
+ # +false+ otherwise:
+ #
+ # d = REXML::Document.new 'text'
+ # a = d.root # => ...
+ # a.has_elements? # => true
+ # b = a[0] # =>
+ # b.has_elements? # => false
+ #
+ def has_elements?
+ !@elements.empty?
+ end
+
+ # :call-seq:
+ # each_element_with_attribute(attr_name, value = nil, max = 0, xpath = nil) {|e| ... }
+ #
+ # Calls the given block with each child element that meets given criteria.
+ #
+ # When only string argument +attr_name+ is given,
+ # calls the block with each child element that has that attribute:
+ #
+ # d = REXML::Document.new ''
+ # a = d.root
+ # a.each_element_with_attribute('id') {|e| p e }
+ #
+ # Output:
+ #
+ #
+ #
+ #
+ #
+ # With argument +attr_name+ and string argument +value+ given,
+ # calls the block with each child element that has that attribute
+ # with that value:
+ #
+ # a.each_element_with_attribute('id', '1') {|e| p e }
+ #
+ # Output:
+ #
+ #
+ #
+ #
+ # With arguments +attr_name+, +value+, and integer argument +max+ given,
+ # calls the block with at most +max+ child elements:
+ #
+ # a.each_element_with_attribute('id', '1', 1) {|e| p e }
+ #
+ # Output:
+ #
+ #
+ #
+ # With all arguments given, including +xpath+,
+ # calls the block with only those child elements
+ # that meet the first three criteria,
+ # and also match the given +xpath+:
+ #
+ # a.each_element_with_attribute('id', '1', 2, '//d') {|e| p e }
+ #
+ # Output:
+ #
+ #
+ #
+ def each_element_with_attribute( key, value=nil, max=0, name=nil, &block ) # :yields: Element
+ each_with_something( proc {|child|
+ if value.nil?
+ child.attributes[key] != nil
+ else
+ child.attributes[key]==value
+ end
+ }, max, name, &block )
+ end
+
+ # :call-seq:
+ # each_element_with_text(text = nil, max = 0, xpath = nil) {|e| ... }
+ #
+ # Calls the given block with each child element that meets given criteria.
+ #
+ # With no arguments, calls the block with each child element that has text:
+ #
+ # d = REXML::Document.new 'bbd'
+ # a = d.root
+ # a.each_element_with_text {|e| p e }
+ #
+ # Output:
+ #
+ # ...
+ # ...
+ # ...
+ #
+ # With the single string argument +text+,
+ # calls the block with each element that has exactly that text:
+ #
+ # a.each_element_with_text('b') {|e| p e }
+ #
+ # Output:
+ #
+ # ...
+ # ...
+ #
+ # With argument +text+ and integer argument +max+,
+ # calls the block with at most +max+ elements:
+ #
+ # a.each_element_with_text('b', 1) {|e| p e }
+ #
+ # Output:
+ #
+ # ...
+ #
+ # With all arguments given, including +xpath+,
+ # calls the block with only those child elements
+ # that meet the first two criteria,
+ # and also match the given +xpath+:
+ #
+ # a.each_element_with_text('b', 2, '//c') {|e| p e }
+ #
+ # Output:
+ #
+ # ...
+ #
+ def each_element_with_text( text=nil, max=0, name=nil, &block ) # :yields: Element
+ each_with_something( proc {|child|
+ if text.nil?
+ child.has_text?
+ else
+ child.text == text
+ end
+ }, max, name, &block )
+ end
+
+ # :call-seq:
+ # each_element {|e| ... }
+ #
+ # Calls the given block with each child element:
+ #
+ # d = REXML::Document.new 'bbd'
+ # a = d.root
+ # a.each_element {|e| p e }
+ #
+ # Output:
+ #
+ # ...
+ # ...
+ # ...
+ #
+ #
+ def each_element( xpath=nil, &block ) # :yields: Element
+ @elements.each( xpath, &block )
+ end
+
+ # :call-seq:
+ # get_elements(xpath)
+ #
+ # Returns an array of the elements that match the given +xpath+:
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # d.root.get_elements('//a') # => [ ... , ]
+ #
+ def get_elements( xpath )
+ @elements.to_a( xpath )
+ end
+
+ # :call-seq:
+ # next_element
+ #
+ # Returns the next sibling that is an element if it exists,
+ # +niL+ otherwise:
+ #
+ # d = REXML::Document.new 'text'
+ # d.root.elements['b'].next_element #->
+ # d.root.elements['c'].next_element #-> nil
+ #
+ def next_element
+ element = next_sibling
+ element = element.next_sibling until element.nil? or element.kind_of? Element
+ element
+ end
+
+ # :call-seq:
+ # previous_element
+ #
+ # Returns the previous sibling that is an element if it exists,
+ # +niL+ otherwise:
+ #
+ # d = REXML::Document.new 'text'
+ # d.root.elements['c'].previous_element #->
+ # d.root.elements['b'].previous_element #-> nil
+ #
+ def previous_element
+ element = previous_sibling
+ element = element.previous_sibling until element.nil? or element.kind_of? Element
+ element
+ end
+
+
+ #################################################
+ # Text #
+ #################################################
+
+ # :call-seq:
+ # has_text? -> true or false
+ #
+ # Returns +true+ if the element has one or more text noded,
+ # +false+ otherwise:
+ #
+ # d = REXML::Document.new 'text'
+ # a = d.root
+ # a.has_text? # => true
+ # b = a[0]
+ # b.has_text? # => false
+ #
+ def has_text?
+ not text().nil?
+ end
+
+ # :call-seq:
+ # text(xpath = nil) -> text_string or nil
+ #
+ # Returns the text string from the first text node child
+ # in a specified element, if it exists, +nil+ otherwise.
+ #
+ # With no argument, returns the text from the first text node in +self+:
+ #
+ # d = REXML::Document.new "some text this is bold! more text
"
+ # d.root.text.class # => String
+ # d.root.text # => "some text "
+ #
+ # With argument +xpath+, returns text from the first text node
+ # in the element that matches +xpath+:
+ #
+ # d.root.text(1) # => "this is bold!"
+ #
+ # Note that an element may have multiple text nodes,
+ # possibly separated by other non-text children, as above.
+ # Even so, the returned value is the string text from the first such node.
+ #
+ # Note also that the text note is retrieved by method get_text,
+ # and so is always normalized text.
+ #
+ def text( path = nil )
+ rv = get_text(path)
+ rv&.value
+ end
+
+ # :call-seq:
+ # get_text(xpath = nil) -> text_node or nil
+ #
+ # Returns the first text node child in a specified element, if it exists,
+ # +nil+ otherwise.
+ #
+ # With no argument, returns the first text node from +self+:
+ #
+ # d = REXML::Document.new "some text this is bold! more text
"
+ # d.root.get_text.class # => REXML::Text
+ # d.root.get_text # => "some text "
+ #
+ # With argument +xpath+, returns the first text node from the element
+ # that matches +xpath+:
+ #
+ # d.root.get_text(1) # => "this is bold!"
+ #
+ def get_text path = nil
+ rv = nil
+ if path
+ element = @elements[ path ]
+ rv = element.get_text unless element.nil?
+ else
+ rv = @children.find { |node| node.kind_of? Text }
+ end
+ rv
+ end
+
+ # :call-seq:
+ # text = string -> string
+ # text = nil -> nil
+ #
+ # Adds, replaces, or removes the first text node child in the element.
+ #
+ # With string argument +string+,
+ # creates a new \REXML::Text node containing that string,
+ # honoring the current settings for whitespace and row,
+ # then places the node as the first text child in the element;
+ # returns +string+.
+ #
+ # If the element has no text child, the text node is added:
+ #
+ # d = REXML::Document.new ''
+ # d.root.text = 'foo' #-> 'foo'
+ #
+ # If the element has a text child, it is replaced:
+ #
+ # d.root.text = 'bar' #-> 'bar'
+ #
+ # With argument +nil+, removes the first text child:
+ #
+ # d.root.text = nil #-> ''
+ #
+ def text=( text )
+ if text.kind_of? String
+ text = Text.new( text, whitespace(), nil, raw() )
+ elsif !text.nil? and !text.kind_of? Text
+ text = Text.new( text.to_s, whitespace(), nil, raw() )
+ end
+ old_text = get_text
+ if text.nil?
+ old_text.remove unless old_text.nil?
+ else
+ if old_text.nil?
+ self << text
+ else
+ old_text.replace_with( text )
+ end
+ end
+ self
+ end
+
+ # :call-seq:
+ # add_text(string) -> nil
+ # add_text(text_node) -> self
+ #
+ # Adds text to the element.
+ #
+ # When string argument +string+ is given, returns +nil+.
+ #
+ # If the element has no child text node,
+ # creates a \REXML::Text object using the string,
+ # honoring the current settings for whitespace and raw,
+ # then adds that node to the element:
+ #
+ # d = REXML::Document.new('')
+ # a = d.root
+ # a.add_text('foo')
+ # a.to_a # => [, "foo"]
+ #
+ # If the element has child text nodes,
+ # appends the string to the _last_ text node:
+ #
+ # d = REXML::Document.new('foobar')
+ # a = d.root
+ # a.add_text('baz')
+ # a.to_a # => ["foo", , "barbaz"]
+ # a.add_text('baz')
+ # a.to_a # => ["foo", , "barbazbaz"]
+ #
+ # When text node argument +text_node+ is given,
+ # appends the node as the last text node in the element;
+ # returns +self+:
+ #
+ # d = REXML::Document.new('foobar')
+ # a = d.root
+ # a.add_text(REXML::Text.new('baz'))
+ # a.to_a # => ["foo", , "bar", "baz"]
+ # a.add_text(REXML::Text.new('baz'))
+ # a.to_a # => ["foo", , "bar", "baz", "baz"]
+ #
+ def add_text( text )
+ if text.kind_of? String
+ if @children[-1].kind_of? Text
+ @children[-1] << text
+ return
+ end
+ text = Text.new( text, whitespace(), nil, raw() )
+ end
+ self << text unless text.nil?
+ self
+ end
+
+ # :call-seq:
+ # node_type -> :element
+ #
+ # Returns symbol :element:
+ #
+ # d = REXML::Document.new('')
+ # a = d.root # =>
+ # a.node_type # => :element
+ #
+ def node_type
+ :element
+ end
+
+ # :call-seq:
+ # xpath -> string_xpath
+ #
+ # Returns the string xpath to the element
+ # relative to the most distant parent:
+ #
+ # d = REXML::Document.new('')
+ # a = d.root # => ...
+ # b = a[0] # => ...
+ # c = b[0] # =>
+ # d.xpath # => ""
+ # a.xpath # => "/a"
+ # b.xpath # => "/a/b"
+ # c.xpath # => "/a/b/c"
+ #
+ # If there is no parent, returns the expanded name of the element:
+ #
+ # e = REXML::Element.new('foo')
+ # e.xpath # => "foo"
+ #
+ def xpath
+ path_elements = []
+ cur = self
+ path_elements << __to_xpath_helper( self )
+ while cur.parent
+ cur = cur.parent
+ path_elements << __to_xpath_helper( cur )
+ end
+ path_elements.reverse.join( "/" )
+ end
+
+ #################################################
+ # Attributes #
+ #################################################
+
+ # :call-seq:
+ # [index] -> object
+ # [attr_name] -> attr_value
+ # [attr_sym] -> attr_value
+ #
+ # With integer argument +index+ given,
+ # returns the child at offset +index+, or +nil+ if none:
+ #
+ # d = REXML::Document.new '>textmore'
+ # root = d.root
+ # (0..root.size).each do |index|
+ # node = root[index]
+ # p "#{index}: #{node} (#{node.class})"
+ # end
+ #
+ # Output:
+ #
+ # "0: (REXML::Element)"
+ # "1: text (REXML::Text)"
+ # "2: (REXML::Element)"
+ # "3: more (REXML::Text)"
+ # "4: (REXML::Element)"
+ # "5: (NilClass)"
+ #
+ # With string argument +attr_name+ given,
+ # returns the string value for the given attribute name if it exists,
+ # otherwise +nil+:
+ #
+ # d = REXML::Document.new('')
+ # root = d.root
+ # root['attr'] # => "value"
+ # root['nosuch'] # => nil
+ #
+ # With symbol argument +attr_sym+ given,
+ # returns [attr_sym.to_s]:
+ #
+ # root[:attr] # => "value"
+ # root[:nosuch] # => nil
+ #
+ def [](name_or_index)
+ case name_or_index
+ when String
+ attributes[name_or_index]
+ when Symbol
+ attributes[name_or_index.to_s]
+ else
+ super
+ end
+ end
+
+
+ # :call-seq:
+ # attribute(name, namespace = nil)
+ #
+ # Returns the string value for the given attribute name.
+ #
+ # With only argument +name+ given,
+ # returns the value of the named attribute if it exists, otherwise +nil+:
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # root = d.root
+ # a = root[1] # =>
+ # a.attribute('attr') # => attr='value'
+ # a.attribute('nope') # => nil
+ #
+ # With arguments +name+ and +namespace+ given,
+ # returns the value of the named attribute if it exists, otherwise +nil+:
+ #
+ # xml_string = ""
+ # document = REXML::Document.new(xml_string)
+ # document.root.attribute("x") # => x='x'
+ # document.root.attribute("x", "a") # => a:x='a:x'
+ #
+ def attribute( name, namespace=nil )
+ prefix = namespaces.key(namespace) if namespace
+ prefix = nil if prefix == 'xmlns'
+
+ ret_val =
+ attributes.get_attribute( prefix ? "#{prefix}:#{name}" : name )
+
+ return ret_val unless ret_val.nil?
+ return nil if prefix.nil?
+
+ # now check that prefix'es namespace is not the same as the
+ # default namespace
+ return nil unless ( namespaces[ prefix ] == namespaces[ 'xmlns' ] )
+
+ attributes.get_attribute( name )
+ end
+
+ # :call-seq:
+ # has_attributes? -> true or false
+ #
+ # Returns +true+ if the element has attributes, +false+ otherwise:
+ #
+ # d = REXML::Document.new('')
+ # a, b = *d.root
+ # a.has_attributes? # => true
+ # b.has_attributes? # => false
+ #
+ def has_attributes?
+ !@attributes.empty?
+ end
+
+ # :call-seq:
+ # add_attribute(name, value) -> value
+ # add_attribute(attribute) -> attribute
+ #
+ # Adds an attribute to this element, overwriting any existing attribute
+ # by the same name.
+ #
+ # With string argument +name+ and object +value+ are given,
+ # adds the attribute created with that name and value:
+ #
+ # e = REXML::Element.new
+ # e.add_attribute('attr', 'value') # => "value"
+ # e['attr'] # => "value"
+ # e.add_attribute('attr', 'VALUE') # => "VALUE"
+ # e['attr'] # => "VALUE"
+ #
+ # With only attribute object +attribute+ given,
+ # adds the given attribute:
+ #
+ # a = REXML::Attribute.new('attr', 'value')
+ # e.add_attribute(a) # => attr='value'
+ # e['attr'] # => "value"
+ # a = REXML::Attribute.new('attr', 'VALUE')
+ # e.add_attribute(a) # => attr='VALUE'
+ # e['attr'] # => "VALUE"
+ #
+ def add_attribute( key, value=nil )
+ if key.kind_of? Attribute
+ @attributes << key
+ else
+ @attributes[key] = value
+ end
+ end
+
+ # :call-seq:
+ # add_attributes(hash) -> hash
+ # add_attributes(array)
+ #
+ # Adds zero or more attributes to the element;
+ # returns the argument.
+ #
+ # If hash argument +hash+ is given,
+ # each key must be a string;
+ # adds each attribute created with the key/value pair:
+ #
+ # e = REXML::Element.new
+ # h = {'foo' => 'bar', 'baz' => 'bat'}
+ # e.add_attributes(h)
+ #
+ # If argument +array+ is given,
+ # each array member must be a 2-element array [name, value];
+ # each name must be a string:
+ #
+ # e = REXML::Element.new
+ # a = [['foo' => 'bar'], ['baz' => 'bat']]
+ # e.add_attributes(a)
+ #
+ def add_attributes hash
+ if hash.kind_of? Hash
+ hash.each_pair {|key, value| @attributes[key] = value }
+ elsif hash.kind_of? Array
+ hash.each { |value| @attributes[ value[0] ] = value[1] }
+ end
+ end
+
+ # :call-seq:
+ # delete_attribute(name) -> removed_attribute or nil
+ #
+ # Removes a named attribute if it exists;
+ # returns the removed attribute if found, otherwise +nil+:
+ #
+ # e = REXML::Element.new('foo')
+ # e.add_attribute('bar', 'baz')
+ # e.delete_attribute('bar') # =>
+ # e.delete_attribute('bar') # => nil
+ #
+ def delete_attribute(key)
+ attr = @attributes.get_attribute(key)
+ attr.remove unless attr.nil?
+ end
+
+ #################################################
+ # Other Utilities #
+ #################################################
+
+ # :call-seq:
+ # cdatas -> array_of_cdata_children
+ #
+ # Returns a frozen array of the REXML::CData children of the element:
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # cds = d.root.cdatas # => ["foo", "bar"]
+ # cds.frozen? # => true
+ # cds.map {|cd| cd.class } # => [REXML::CData, REXML::CData]
+ #
+ def cdatas
+ find_all { |child| child.kind_of? CData }.freeze
+ end
+
+ # :call-seq:
+ # comments -> array_of_comment_children
+ #
+ # Returns a frozen array of the REXML::Comment children of the element:
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # cs = d.root.comments
+ # cs.frozen? # => true
+ # cs.map {|c| c.class } # => [REXML::Comment, REXML::Comment]
+ # cs.map {|c| c.to_s } # => ["foo", "bar"]
+ #
+ def comments
+ find_all { |child| child.kind_of? Comment }.freeze
+ end
+
+ # :call-seq:
+ # instructions -> array_of_instruction_children
+ #
+ # Returns a frozen array of the REXML::Instruction children of the element:
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # is = d.root.instructions
+ # is.frozen? # => true
+ # is.map {|i| i.class } # => [REXML::Instruction, REXML::Instruction]
+ # is.map {|i| i.to_s } # => ["", ""]
+ #
+ def instructions
+ find_all { |child| child.kind_of? Instruction }.freeze
+ end
+
+ # :call-seq:
+ # texts -> array_of_text_children
+ #
+ # Returns a frozen array of the REXML::Text children of the element:
+ #
+ # xml_string = 'textmore'
+ # d = REXML::Document.new(xml_string)
+ # ts = d.root.texts
+ # ts.frozen? # => true
+ # ts.map {|t| t.class } # => [REXML::Text, REXML::Text]
+ # ts.map {|t| t.to_s } # => ["text", "more"]
+ #
+ def texts
+ find_all { |child| child.kind_of? Text }.freeze
+ end
+
+ # == DEPRECATED
+ # See REXML::Formatters
+ #
+ # Writes out this element, and recursively, all children.
+ # output::
+ # output an object which supports '<< string'; this is where the
+ # document will be written.
+ # indent::
+ # An integer. If -1, no indenting will be used; otherwise, the
+ # indentation will be this number of spaces, and children will be
+ # indented an additional amount. Defaults to -1
+ # transitive::
+ # If transitive is true and indent is >= 0, then the output will be
+ # pretty-printed in such a way that the added whitespace does not affect
+ # the parse tree of the document
+ # ie_hack::
+ # This hack inserts a space before the /> on empty tags to address
+ # a limitation of Internet Explorer. Defaults to false
+ #
+ # out = ''
+ # doc.write( out ) #-> doc is written to the string 'out'
+ # doc.write( $stdout ) #-> doc written to the console
+ def write(output=$stdout, indent=-1, transitive=false, ie_hack=false)
+ Kernel.warn("#{self.class.name}#write is deprecated. See REXML::Formatters", uplevel: 1)
+ formatter = if indent > -1
+ if transitive
+ require_relative "formatters/transitive"
+ REXML::Formatters::Transitive.new( indent, ie_hack )
+ else
+ REXML::Formatters::Pretty.new( indent, ie_hack )
+ end
+ else
+ REXML::Formatters::Default.new( ie_hack )
+ end
+ formatter.write( self, output )
+ end
+
+ private
+ def calculate_namespaces
+ if parent
+ parent.namespaces.merge(attributes.namespaces)
+ else
+ attributes.namespaces
+ end
+ end
+
+ def __to_xpath_helper node
+ rv = node.expanded_name.clone
+ if node.parent
+ results = node.parent.find_all {|n|
+ n.kind_of?(REXML::Element) and n.expanded_name == node.expanded_name
+ }
+ if results.length > 1
+ idx = results.index( node )
+ rv << "[#{idx+1}]"
+ end
+ end
+ rv
+ end
+
+ # A private helper method
+ def each_with_something( test, max=0, name=nil )
+ num = 0
+ @elements.each( name ){ |child|
+ yield child if test.call(child) and num += 1
+ return if max>0 and num == max
+ }
+ end
+ end
+
+ ########################################################################
+ # ELEMENTS #
+ ########################################################################
+
+ # A class which provides filtering of children for Elements, and
+ # XPath search support. You are expected to only encounter this class as
+ # the element.elements object. Therefore, you are
+ # _not_ expected to instantiate this yourself.
+ #
+ # xml_string = <<-EOT
+ #
+ #
+ #
+ # Everyday Italian
+ # Giada De Laurentiis
+ # 2005
+ # 30.00
+ #
+ #
+ # Harry Potter
+ # J K. Rowling
+ # 2005
+ # 29.99
+ #
+ #
+ # XQuery Kick Start
+ # James McGovern
+ # Per Bothner
+ # Kurt Cagle
+ # James Linn
+ # Vaidyanathan Nagarajan
+ # 2003
+ # 49.99
+ #
+ #
+ # Learning XML
+ # Erik T. Ray
+ # 2003
+ # 39.95
+ #
+ #
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements # => # ... >
+ #
+ class Elements
+ include Enumerable
+ # :call-seq:
+ # new(parent) -> new_elements_object
+ #
+ # Returns a new \Elements object with the given +parent+.
+ # Does _not_ assign parent.elements = self:
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = REXML::Elements.new(d.root)
+ # eles # => # ... >
+ # eles == d.root.elements # => false
+ #
+ def initialize parent
+ @element = parent
+ end
+
+ # :call-seq:
+ # parent
+ #
+ # Returns the parent element cited in creating the \Elements object.
+ # This element is also the default starting point for searching
+ # in the \Elements object.
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = REXML::Elements.new(d.root)
+ # elements.parent == d.root # => true
+ #
+ def parent
+ @element
+ end
+
+ # :call-seq:
+ # elements[index] -> element or nil
+ # elements[xpath] -> element or nil
+ # elements[n, name] -> element or nil
+ #
+ # Returns the first \Element object selected by the arguments,
+ # if any found, or +nil+ if none found.
+ #
+ # Notes:
+ # - The +index+ is 1-based, not 0-based, so that:
+ # - The first element has index 1
+ # - The _nth_ element has index +n+.
+ # - The selection ignores non-\Element nodes.
+ #
+ # When the single argument +index+ is given,
+ # returns the element given by the index, if any; otherwise, +nil+:
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = d.root.elements
+ # eles # => # ... >
+ # eles[1] # => ...
+ # eles.size # => 4
+ # eles[4] # => ...
+ # eles[5] # => nil
+ #
+ # The node at this index is not an \Element, and so is not returned:
+ #
+ # eles = d.root.first.first # => ... </>
+ # eles.to_a # => ["Everyday Italian"]
+ # eles[1] # => nil
+ #
+ # When the single argument +xpath+ is given,
+ # returns the first element found via that +xpath+, if any; otherwise, +nil+:
+ #
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles['/bookstore'] # => <bookstore> ... </>
+ # eles['//book'] # => <book category='cooking'> ... </>
+ # eles['//book [@category="children"]'] # => <book category='children'> ... </>
+ # eles['/nosuch'] # => nil
+ # eles['//nosuch'] # => nil
+ # eles['//book [@category="nosuch"]'] # => nil
+ # eles['.'] # => <bookstore> ... </>
+ # eles['..'].class # => REXML::Document
+ #
+ # With arguments +n+ and +name+ given,
+ # returns the _nth_ found element that has the given +name+,
+ # or +nil+ if there is no such _nth_ element:
+ #
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles[1, 'book'] # => <book category='cooking'> ... </>
+ # eles[4, 'book'] # => <book category='web' cover='paperback'> ... </>
+ # eles[5, 'book'] # => nil
+ #
+ def []( index, name=nil)
+ if index.kind_of? Integer
+ raise "index (#{index}) must be >= 1" if index < 1
+ name = literalize(name) if name
+ num = 0
+ @element.find { |child|
+ child.kind_of? Element and
+ (name.nil? ? true : child.has_name?( name )) and
+ (num += 1) == index
+ }
+ else
+ XPath::first( @element, index )
+ end
+ end
+
+ # :call-seq:
+ # elements[] = index, replacement_element -> replacement_element or nil
+ #
+ # Replaces or adds an element.
+ #
+ # When <tt>eles[index]</tt> exists, replaces it with +replacement_element+
+ # and returns +replacement_element+:
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles[1] # => <book category='cooking'> ... </>
+ # eles[1] = REXML::Element.new('foo')
+ # eles[1] # => <foo/>
+ #
+ # Does nothing (or raises an exception)
+ # if +replacement_element+ is not an \Element:
+ # eles[2] # => <book category='web' cover='paperback'> ... </>
+ # eles[2] = REXML::Text.new('bar')
+ # eles[2] # => <book category='web' cover='paperback'> ... </>
+ #
+ # When <tt>eles[index]</tt> does not exist,
+ # adds +replacement_element+ to the element and returns
+ #
+ # d = REXML::Document.new(xml_string)
+ # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>>
+ # eles.size # => 4
+ # eles[50] = REXML::Element.new('foo') # => <foo/>
+ # eles.size # => 5
+ # eles[5] # => <foo/>
+ #
+ # Does nothing (or raises an exception)
+ # if +replacement_element+ is not an \Element:
+ #
+ # eles[50] = REXML::Text.new('bar') # => "bar"
+ # eles.size # => 5
+ #
+ def []=( index, element )
+ previous = self[index]
+ if previous.nil?
+ @element.add element
+ else
+ previous.replace_with element
+ end
+ previous
+ end
+
+ # :call-seq:
+ # empty? -> true or false
+ #
+ # Returns +true+ if there are no children, +false+ otherwise.
+ #
+ # d = REXML::Document.new('')
+ # d.elements.empty? # => true
+ # d = REXML::Document.new(xml_string)
+ # d.elements.empty? # => false
+ #
+ def empty?
+ @element.find{ |child| child.kind_of? Element}.nil?
+ end
+
+ # :call-seq:
+ # index(element)
+ #
+ # Returns the 1-based index of the given +element+, if found;
+ # otherwise, returns -1:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # ele_1, ele_2, ele_3, ele_4 = *elements
+ # elements.index(ele_4) # => 4
+ # elements.delete(ele_3)
+ # elements.index(ele_4) # => 3
+ # elements.index(ele_3) # => -1
+ #
+ def index element
+ rv = 0
+ found = @element.find do |child|
+ child.kind_of? Element and
+ (rv += 1) and
+ child == element
+ end
+ return rv if found == element
+ -1
+ end
+
+ # :call-seq:
+ # delete(index) -> removed_element or nil
+ # delete(element) -> removed_element or nil
+ # delete(xpath) -> removed_element or nil
+ #
+ # Removes an element; returns the removed element, or +nil+ if none removed.
+ #
+ # With integer argument +index+ given,
+ # removes the child element at that offset:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.size # => 4
+ # elements[2] # => <book category='children'> ... </>
+ # elements.delete(2) # => <book category='children'> ... </>
+ # elements.size # => 3
+ # elements[2] # => <book category='web'> ... </>
+ # elements.delete(50) # => nil
+ #
+ # With element argument +element+ given,
+ # removes that child element:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # ele_1, ele_2, ele_3, ele_4 = *elements
+ # elements.size # => 4
+ # elements[2] # => <book category='children'> ... </>
+ # elements.delete(ele_2) # => <book category='children'> ... </>
+ # elements.size # => 3
+ # elements[2] # => <book category='web'> ... </>
+ # elements.delete(ele_2) # => nil
+ #
+ # With string argument +xpath+ given,
+ # removes the first element found via that xpath:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.delete('//book') # => <book category='cooking'> ... </>
+ # elements.delete('//book [@category="children"]') # => <book category='children'> ... </>
+ # elements.delete('//nosuch') # => nil
+ #
+ def delete element
+ if element.kind_of? Element
+ @element.delete element
+ else
+ el = self[element]
+ el.remove if el
+ end
+ end
+
+ # :call-seq:
+ # delete_all(xpath)
+ #
+ # Removes all elements found via the given +xpath+;
+ # returns the array of removed elements, if any, else +nil+.
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.size # => 4
+ # deleted_elements = elements.delete_all('//book [@category="web"]')
+ # deleted_elements.size # => 2
+ # elements.size # => 2
+ # deleted_elements = elements.delete_all('//book')
+ # deleted_elements.size # => 2
+ # elements.size # => 0
+ # elements.delete_all('//book') # => []
+ #
+ def delete_all( xpath )
+ rv = []
+ XPath::each( @element, xpath) {|element|
+ rv << element if element.kind_of? Element
+ }
+ rv.each do |element|
+ @element.delete element
+ element.remove
+ end
+ rv
+ end
+
+ # :call-seq:
+ # add -> new_element
+ # add(name) -> new_element
+ # add(element) -> element
+ #
+ # Adds an element; returns the element added.
+ #
+ # With no argument, creates and adds a new element.
+ # The new element has:
+ #
+ # - No name.
+ # - \Parent from the \Elements object.
+ # - Context from the that parent.
+ #
+ # Example:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # parent = elements.parent # => <bookstore> ... </>
+ # parent.context = {raw: :all}
+ # elements.size # => 4
+ # new_element = elements.add # => </>
+ # elements.size # => 5
+ # new_element.name # => nil
+ # new_element.parent # => <bookstore> ... </>
+ # new_element.context # => {:raw=>:all}
+ #
+ # With string argument +name+, creates and adds a new element.
+ # The new element has:
+ #
+ # - Name +name+.
+ # - \Parent from the \Elements object.
+ # - Context from the that parent.
+ #
+ # Example:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # parent = elements.parent # => <bookstore> ... </>
+ # parent.context = {raw: :all}
+ # elements.size # => 4
+ # new_element = elements.add('foo') # => <foo/>
+ # elements.size # => 5
+ # new_element.name # => "foo"
+ # new_element.parent # => <bookstore> ... </>
+ # new_element.context # => {:raw=>:all}
+ #
+ # With argument +element+,
+ # creates and adds a clone of the given +element+.
+ # The new element has name, parent, and context from the given +element+.
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.size # => 4
+ # e0 = REXML::Element.new('foo')
+ # e1 = REXML::Element.new('bar', e0, {raw: :all})
+ # element = elements.add(e1) # => <bar/>
+ # elements.size # => 5
+ # element.name # => "bar"
+ # element.parent # => <bookstore> ... </>
+ # element.context # => {:raw=>:all}
+ #
+ def add element=nil
+ if element.nil?
+ Element.new("", self, @element.context)
+ elsif not element.kind_of?(Element)
+ Element.new(element, self, @element.context)
+ else
+ @element << element
+ element.context = @element.context
+ element
+ end
+ end
+
+ alias :<< :add
+
+ # :call-seq:
+ # each(xpath = nil) {|element| ... } -> self
+ #
+ # Iterates over the elements.
+ #
+ # With no argument, calls the block with each element:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.each {|element| p element }
+ #
+ # Output:
+ #
+ # <book category='cooking'> ... </>
+ # <book category='children'> ... </>
+ # <book category='web'> ... </>
+ # <book category='web' cover='paperback'> ... </>
+ #
+ # With argument +xpath+, calls the block with each element
+ # that matches the given +xpath+:
+ #
+ # elements.each('//book [@category="web"]') {|element| p element }
+ #
+ # Output:
+ #
+ # <book category='web'> ... </>
+ # <book category='web' cover='paperback'> ... </>
+ #
+ def each( xpath=nil )
+ XPath::each( @element, xpath ) {|e| yield e if e.kind_of? Element }
+ end
+
+ # :call-seq:
+ # collect(xpath = nil) {|element| ... } -> array
+ #
+ # Iterates over the elements; returns the array of block return values.
+ #
+ # With no argument, iterates over all elements:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.collect {|element| element.size } # => [9, 9, 17, 9]
+ #
+ # With argument +xpath+, iterates over elements that match
+ # the given +xpath+:
+ #
+ # xpath = '//book [@category="web"]'
+ # elements.collect(xpath) {|element| element.size } # => [17, 9]
+ #
+ def collect( xpath=nil )
+ collection = []
+ XPath::each( @element, xpath ) {|e|
+ collection << yield(e) if e.kind_of?(Element)
+ }
+ collection
+ end
+
+ # :call-seq:
+ # inject(xpath = nil, initial = nil) -> object
+ #
+ # Calls the block with elements; returns the last block return value.
+ #
+ # With no argument, iterates over the elements, calling the block
+ # <tt>elements.size - 1</tt> times.
+ #
+ # - The first call passes the first and second elements.
+ # - The second call passes the first block return value and the third element.
+ # - The third call passes the second block return value and the fourth element.
+ # - And so on.
+ #
+ # In this example, the block returns the passed element,
+ # which is then the object argument to the next call:
+ #
+ # d = REXML::Document.new(xml_string)
+ # elements = d.root.elements
+ # elements.inject do |object, element|
+ # p [elements.index(object), elements.index(element)]
+ # element
+ # end
+ #
+ # Output:
+ #
+ # [1, 2]
+ # [2, 3]
+ # [3, 4]
+ #
+ # With the single argument +xpath+, calls the block only with
+ # elements matching that xpath:
+ #
+ # elements.inject('//book [@category="web"]') do |object, element|
+ # p [elements.index(object), elements.index(element)]
+ # element
+ # end
+ #
+ # Output:
+ #
+ # [3, 4]
+ #
+ # With argument +xpath+ given as +nil+
+ # and argument +initial+ also given,
+ # calls the block once for each element.
+ #
+ # - The first call passes the +initial+ and the first element.
+ # - The second call passes the first block return value and the second element.
+ # - The third call passes the second block return value and the third element.
+ # - And so on.
+ #
+ # In this example, the first object index is <tt>-1</tt>
+ #
+ # elements.inject(nil, 'Initial') do |object, element|
+ # p [elements.index(object), elements.index(element)]
+ # element
+ # end
+ #
+ # Output:
+ #
+ # [-1, 1]
+ # [1, 2]
+ # [2, 3]
+ # [3, 4]
+ #
+ # In this form the passed object can be used as an accumulator:
+ #
+ # elements.inject(nil, 0) do |total, element|
+ # total += element.size
+ # end # => 44
+ #
+ # With both arguments +xpath+ and +initial+ are given,
+ # calls the block only with elements matching that xpath:
+ #
+ # elements.inject('//book [@category="web"]', 0) do |total, element|
+ # total += element.size
+ # end # => 26
+ #
+ def inject( xpath=nil, initial=nil )
+ first = true
+ XPath::each( @element, xpath ) {|e|
+ if (e.kind_of? Element)
+ if (first and initial == nil)
+ initial = e
+ first = false
+ else
+ initial = yield( initial, e ) if e.kind_of? Element
+ end
+ end
+ }
+ initial
+ end
+
+ # :call-seq:
+ # size -> integer
+ #
+ # Returns the count of \Element children:
+ #
+ # d = REXML::Document.new '<a>sean<b/>elliott<b/>russell<b/></a>'
+ # d.root.elements.size # => 3 # Three elements.
+ # d.root.size # => 6 # Three elements plus three text nodes..
+ #
+ def size
+ count = 0
+ @element.each {|child| count+=1 if child.kind_of? Element }
+ count
+ end
+
+ # :call-seq:
+ # to_a(xpath = nil) -> array_of_elements
+ #
+ # Returns an array of element children (not including non-element children).
+ #
+ # With no argument, returns an array of all element children:
+ #
+ # d = REXML::Document.new '<a>sean<b/>elliott<c/></a>'
+ # elements = d.root.elements
+ # elements.to_a # => [<b/>, <c/>] # Omits non-element children.
+ # children = d.root.children
+ # children # => ["sean", <b/>, "elliott", <c/>] # Includes non-element children.
+ #
+ # With argument +xpath+, returns an array of element children
+ # that match the xpath:
+ #
+ # elements.to_a('//c') # => [<c/>]
+ #
+ def to_a( xpath=nil )
+ rv = XPath.match( @element, xpath )
+ return rv.find_all{|e| e.kind_of? Element} if xpath
+ rv
+ end
+
+ private
+ # Private helper class. Removes quotes from quoted strings
+ def literalize name
+ name = name[1..-2] if name[0] == ?' or name[0] == ?" #'
+ name
+ end
+ end
+
+ ########################################################################
+ # ATTRIBUTES #
+ ########################################################################
+
+ # A class that defines the set of Attributes of an Element and provides
+ # operations for accessing elements in that set.
+ class Attributes < Hash
+
+ # :call-seq:
+ # new(element)
+ #
+ # Creates and returns a new \REXML::Attributes object.
+ # The element given by argument +element+ is stored,
+ # but its own attributes are not modified:
+ #
+ # ele = REXML::Element.new('foo')
+ # attrs = REXML::Attributes.new(ele)
+ # attrs.object_id == ele.attributes.object_id # => false
+ #
+ # Other instance methods in class \REXML::Attributes may refer to:
+ #
+ # - +element.document+.
+ # - +element.prefix+.
+ # - +element.expanded_name+.
+ #
+ def initialize element
+ @element = element
+ end
+
+ # :call-seq:
+ # [name] -> attribute_value or nil
+ #
+ # Returns the value for the attribute given by +name+,
+ # if it exists; otherwise +nil+.
+ # The value returned is the unnormalized attribute value,
+ # with entities expanded:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes['att'] # => "<"
+ # ele.attributes['bar:att'] # => "2"
+ # ele.attributes['nosuch'] # => nil
+ #
+ # Related: get_attribute (returns an \Attribute object).
+ #
+ def [](name)
+ attr = get_attribute(name)
+ attr&.value
+ end
+
+ # :call-seq:
+ # to_a -> array_of_attribute_objects
+ #
+ # Returns an array of \REXML::Attribute objects representing
+ # the attributes:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes.to_a # => [foo:att='1', bar:att='2', att='<']
+ # attrs.first.class # => REXML::Attribute
+ #
+ def to_a
+ enum_for(:each_attribute).to_a
+ end
+
+ # :call-seq:
+ # length
+ #
+ # Returns the count of attributes:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes.length # => 3
+ #
+ def length
+ c = 0
+ each_attribute { c+=1 }
+ c
+ end
+ alias :size :length
+
+ # :call-seq:
+ # each_attribute {|attr| ... }
+ #
+ # Calls the given block with each \REXML::Attribute object:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes.each_attribute do |attr|
+ # p [attr.class, attr]
+ # end
+ #
+ # Output:
+ #
+ # [REXML::Attribute, foo:att='1']
+ # [REXML::Attribute, bar:att='2']
+ # [REXML::Attribute, att='<']
+ #
+ def each_attribute # :yields: attribute
+ return to_enum(__method__) unless block_given?
+ each_value do |val|
+ if val.kind_of? Attribute
+ yield val
+ else
+ val.each_value { |atr| yield atr }
+ end
+ end
+ end
+
+ # :call-seq:
+ # each {|expanded_name, value| ... }
+ #
+ # Calls the given block with each expanded-name/value pair:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # ele.attributes.each do |expanded_name, value|
+ # p [expanded_name, value]
+ # end
+ #
+ # Output:
+ #
+ # ["foo:att", "1"]
+ # ["bar:att", "2"]
+ # ["att", "<"]
+ #
+ def each
+ return to_enum(__method__) unless block_given?
+ each_attribute do |attr|
+ yield [attr.expanded_name, attr.value]
+ end
+ end
+
+ # :call-seq:
+ # get_attribute(name) -> attribute_object or nil
+ #
+ # Returns the \REXML::Attribute object for the given +name+:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.get_attribute('foo:att') # => foo:att='1'
+ # attrs.get_attribute('foo:att').class # => REXML::Attribute
+ # attrs.get_attribute('bar:att') # => bar:att='2'
+ # attrs.get_attribute('att') # => att='<'
+ # attrs.get_attribute('nosuch') # => nil
+ #
+ def get_attribute( name )
+ attr = fetch( name, nil )
+ if attr.nil?
+ return nil if name.nil?
+ # Look for prefix
+ name =~ Namespace::NAMESPLIT
+ prefix, n = $1, $2
+ if prefix
+ attr = fetch( n, nil )
+ # check prefix
+ if attr == nil
+ elsif attr.kind_of? Attribute
+ return attr if prefix == attr.prefix
+ else
+ attr = attr[ prefix ]
+ return attr
+ end
+ end
+ doctype = @element.document&.doctype
+ if doctype
+ expn = @element.expanded_name
+ expn = doctype.name if expn.size == 0
+ attr_val = doctype.attribute_of(expn, name)
+ return Attribute.new( name, attr_val ) if attr_val
+ end
+ return nil
+ end
+ if attr.kind_of? Hash
+ attr = attr[ @element.prefix ]
+ end
+ attr
+ end
+
+ # :call-seq:
+ # [name] = value -> value
+ #
+ # When +value+ is non-+nil+,
+ # assigns that to the attribute for the given +name+,
+ # overwriting the previous value if it exists:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs['foo:att'] = '2' # => "2"
+ # attrs['baz:att'] = '3' # => "3"
+ #
+ # When +value+ is +nil+, deletes the attribute if it exists:
+ #
+ # attrs['baz:att'] = nil
+ # attrs.include?('baz:att') # => false
+ #
+ def []=( name, value )
+ if value.nil? # Delete the named attribute
+ attr = get_attribute(name)
+ delete attr
+ return
+ end
+
+ unless value.kind_of? Attribute
+ doctype = @element.document&.doctype
+ if doctype
+ value = Text::normalize( value, doctype )
+ else
+ value = Text::normalize( value, nil )
+ end
+ value = Attribute.new(name, value)
+ end
+ value.element = @element
+ old_attr = fetch(value.name, nil)
+ if old_attr.nil?
+ store(value.name, value)
+ elsif old_attr.kind_of? Hash
+ old_attr[value.prefix] = value
+ elsif old_attr.prefix != value.prefix
+ store value.name, {old_attr.prefix => old_attr,
+ value.prefix => value}
+ else
+ store value.name, value
+ end
+ @element
+ end
+
+ # :call-seq:
+ # prefixes -> array_of_prefix_strings
+ #
+ # Returns an array of prefix strings in the attributes.
+ # The array does not include the default
+ # namespace declaration, if one exists.
+ #
+ # xml_string = '<a xmlns="foo" xmlns:x="bar" xmlns:y="twee" z="glorp"/>'
+ # d = REXML::Document.new(xml_string)
+ # d.root.attributes.prefixes # => ["x", "y"]
+ #
+ def prefixes
+ ns = []
+ each_attribute do |attribute|
+ ns << attribute.name if attribute.prefix == 'xmlns'
+ end
+ doctype = @element.document&.doctype
+ if doctype
+ expn = @element.expanded_name
+ expn = doctype.name if expn.size == 0
+ doctype.attributes_of(expn).each {
+ |attribute|
+ ns << attribute.name if attribute.prefix == 'xmlns'
+ }
+ end
+ ns
+ end
+
+ # :call-seq:
+ # namespaces
+ #
+ # Returns a hash of name/value pairs for the namespaces:
+ #
+ # xml_string = '<a xmlns="foo" xmlns:x="bar" xmlns:y="twee" z="glorp"/>'
+ # d = REXML::Document.new(xml_string)
+ # d.root.attributes.namespaces # => {"xmlns"=>"foo", "x"=>"bar", "y"=>"twee"}
+ #
+ def namespaces
+ namespaces = {}
+ each_attribute do |attribute|
+ namespaces[attribute.name] = attribute.value if attribute.prefix == 'xmlns' or attribute.name == 'xmlns'
+ end
+ doctype = @element.document&.doctype
+ if doctype
+ expn = @element.expanded_name
+ expn = doctype.name if expn.size == 0
+ doctype.attributes_of(expn).each {
+ |attribute|
+ namespaces[attribute.name] = attribute.value if attribute.prefix == 'xmlns' or attribute.name == 'xmlns'
+ }
+ end
+ namespaces
+ end
+
+ # :call-seq:
+ # delete(name) -> element
+ # delete(attribute) -> element
+ #
+ # Removes a specified attribute if it exists;
+ # returns the attributes' element.
+ #
+ # When string argument +name+ is given,
+ # removes the attribute of that name if it exists:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.delete('foo:att') # => <ele bar:att='2' att='<'/>
+ # attrs.delete('foo:att') # => <ele bar:att='2' att='<'/>
+ #
+ # When attribute argument +attribute+ is given,
+ # removes that attribute if it exists:
+ #
+ # attr = REXML::Attribute.new('bar:att', '2')
+ # attrs.delete(attr) # => <ele att='<'/> # => <ele att='<'/>
+ # attrs.delete(attr) # => <ele att='<'/> # => <ele/>
+ #
+ def delete( attribute )
+ name = nil
+ prefix = nil
+ if attribute.kind_of? Attribute
+ name = attribute.name
+ prefix = attribute.prefix
+ else
+ attribute =~ Namespace::NAMESPLIT
+ prefix, name = $1, $2
+ prefix = '' unless prefix
+ end
+ old = fetch(name, nil)
+ if old.kind_of? Hash # the supplied attribute is one of many
+ old.delete(prefix)
+ if old.size == 1
+ repl = nil
+ old.each_value{|v| repl = v}
+ store name, repl
+ end
+ elsif old # the supplied attribute is a top-level one
+ super(name)
+ end
+ @element
+ end
+
+ # :call-seq:
+ # add(attribute) -> attribute
+ #
+ # Adds attribute +attribute+, replacing the previous
+ # attribute of the same name if it exists;
+ # returns +attribute+:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs # => {"att"=>{"foo"=>foo:att='1', "bar"=>bar:att='2', ""=>att='<'}}
+ # attrs.add(REXML::Attribute.new('foo:att', '2')) # => foo:att='2'
+ # attrs.add(REXML::Attribute.new('baz', '3')) # => baz='3'
+ # attrs.include?('baz') # => true
+ #
+ def add( attribute )
+ self[attribute.name] = attribute
+ end
+
+ alias :<< :add
+
+ # :call-seq:
+ # delete_all(name) -> array_of_removed_attributes
+ #
+ # Removes all attributes matching the given +name+;
+ # returns an array of the removed attributes:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.delete_all('att') # => [att='<']
+ #
+ def delete_all( name )
+ rv = []
+ each_attribute { |attribute|
+ rv << attribute if attribute.expanded_name == name
+ }
+ rv.each{ |attr| attr.remove }
+ rv
+ end
+
+ # :call-seq:
+ # get_attribute_ns(namespace, name)
+ #
+ # Returns the \REXML::Attribute object among the attributes
+ # that matches the given +namespace+ and +name+:
+ #
+ # xml_string = <<-EOT
+ # <root xmlns:foo="http://foo" xmlns:bar="http://bar">
+ # <ele foo:att='1' bar:att='2' att='<'/>
+ # </root>
+ # EOT
+ # d = REXML::Document.new(xml_string)
+ # ele = d.root.elements['//ele'] # => <a foo:att='1' bar:att='2' att='<'/>
+ # attrs = ele.attributes
+ # attrs.get_attribute_ns('http://foo', 'att') # => foo:att='1'
+ # attrs.get_attribute_ns('http://foo', 'nosuch') # => nil
+ #
+ def get_attribute_ns(namespace, name)
+ result = nil
+ each_attribute() { |attribute|
+ if name == attribute.name &&
+ namespace == attribute.namespace() &&
+ ( !namespace.empty? || !attribute.fully_expanded_name.index(':') )
+ # foo will match xmlns:foo, but only if foo isn't also an attribute
+ result = attribute if !result or !namespace.empty? or
+ !attribute.fully_expanded_name.index(':')
+ end
+ }
+ result
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/encoding.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/encoding.rb
new file mode 100644
index 0000000..7eb05f4
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/entity.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/entity.rb
new file mode 100644
index 0000000..1ba5a7b
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.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><<</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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/formatters/default.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/formatters/default.rb
new file mode 100644
index 0000000..811b2ff
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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><<</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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/formatters/pretty.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/formatters/pretty.rb
new file mode 100644
index 0000000..a838d83
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.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
+
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/formatters/transitive.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/formatters/transitive.rb
new file mode 100644
index 0000000..5ff51e1
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/formatters/transitive.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: false
+require_relative 'pretty'
+
+module REXML
+ module Formatters
+ # The Transitive formatter writes an XML document that parses to an
+ # identical document as the source document. This means that no extra
+ # whitespace nodes are inserted, and whitespace within text nodes is
+ # preserved. Within these constraints, the document is pretty-printed,
+ # with whitespace inserted into the metadata to introduce formatting.
+ #
+ # Note that this is only useful if the original XML is not already
+ # formatted. Since this formatter does not alter whitespace nodes, the
+ # results of formatting already formatted XML will be odd.
+ class Transitive < Default
+ def initialize( indentation=2, ie_hack=false )
+ @indentation = indentation
+ @level = 0
+ @ie_hack = ie_hack
+ end
+
+ protected
+ def write_element( node, output )
+ output << "<#{node.expanded_name}"
+
+ node.attributes.each_attribute do |attr|
+ output << " "
+ attr.write( output )
+ end unless node.attributes.empty?
+
+ output << "\n"
+ output << ' '*@level
+ if node.children.empty?
+ output << " " if @ie_hack
+ 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
+ @level += @indentation
+ node.children.each { |child|
+ write( child, output )
+ }
+ @level -= @indentation
+ output << "</#{node.expanded_name}"
+ output << "\n"
+ output << ' '*@level
+ end
+ output << ">"
+ end
+
+ def write_text( node, output )
+ output << node.to_s()
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/functions.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/functions.rb
new file mode 100644
index 0000000..60ae34e
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/functions.rb
@@ -0,0 +1,446 @@
+# frozen_string_literal: false
+module REXML
+ # If you add a method, keep in mind two things:
+ # (1) the first argument will always be a list of nodes from which to
+ # filter. In the case of context methods (such as position), the function
+ # should return an array with a value for each child in the array.
+ # (2) all method calls from XML will have "-" replaced with "_".
+ # Therefore, in XML, "local-name()" is identical (and actually becomes)
+ # "local_name()"
+ module Functions
+ @@available_functions = {}
+ @@context = nil
+ @@namespace_context = {}
+ @@variables = {}
+
+ INTERNAL_METHODS = [
+ :namespace_context,
+ :namespace_context=,
+ :variables,
+ :variables=,
+ :context=,
+ :get_namespace,
+ :send,
+ ]
+ class << self
+ def singleton_method_added(name)
+ unless INTERNAL_METHODS.include?(name)
+ @@available_functions[name] = true
+ end
+ end
+ end
+
+ def Functions::namespace_context=(x) ; @@namespace_context=x ; end
+ def Functions::variables=(x) ; @@variables=x ; end
+ def Functions::namespace_context ; @@namespace_context ; end
+ def Functions::variables ; @@variables ; end
+
+ def Functions::context=(value); @@context = value; end
+
+ def Functions::text( )
+ if @@context[:node].node_type == :element
+ @@context[:node].find_all{|n| n.node_type == :text}.collect{|n| n.value}
+ elsif @@context[:node].node_type == :text
+ @@context[:node].value
+ else
+ false
+ end
+ end
+
+ # Returns the last node of the given list of nodes.
+ def Functions::last( )
+ @@context[:size]
+ end
+
+ def Functions::position( )
+ @@context[:index]
+ end
+
+ # Returns the size of the given list of nodes.
+ def Functions::count( node_set )
+ node_set.size
+ end
+
+ # Since REXML is non-validating, this method is not implemented as it
+ # requires a DTD
+ def Functions::id( object )
+ end
+
+ def Functions::local_name(node_set=nil)
+ get_namespace(node_set) do |node|
+ return node.local_name
+ end
+ ""
+ end
+
+ def Functions::namespace_uri( node_set=nil )
+ get_namespace( node_set ) {|node| node.namespace}
+ end
+
+ def Functions::name( node_set=nil )
+ get_namespace( node_set ) do |node|
+ node.expanded_name
+ end
+ end
+
+ # Helper method.
+ def Functions::get_namespace( node_set = nil )
+ if node_set == nil
+ yield @@context[:node] if @@context[:node].respond_to?(:namespace)
+ else
+ if node_set.respond_to? :each
+ result = []
+ node_set.each do |node|
+ result << yield(node) if node.respond_to?(:namespace)
+ end
+ result
+ elsif node_set.respond_to? :namespace
+ yield node_set
+ end
+ end
+ end
+
+ # A node-set is converted to a string by returning the string-value of the
+ # node in the node-set that is first in document order. If the node-set is
+ # empty, an empty string is returned.
+ #
+ # A number is converted to a string as follows
+ #
+ # NaN is converted to the string NaN
+ #
+ # positive zero is converted to the string 0
+ #
+ # negative zero is converted to the string 0
+ #
+ # positive infinity is converted to the string Infinity
+ #
+ # negative infinity is converted to the string -Infinity
+ #
+ # if the number is an integer, the number is represented in decimal form
+ # as a Number with no decimal point and no leading zeros, preceded by a
+ # minus sign (-) if the number is negative
+ #
+ # otherwise, the number is represented in decimal form as a Number
+ # including a decimal point with at least one digit before the decimal
+ # point and at least one digit after the decimal point, preceded by a
+ # minus sign (-) if the number is negative; there must be no leading zeros
+ # before the decimal point apart possibly from the one required digit
+ # immediately before the decimal point; beyond the one required digit
+ # after the decimal point there must be as many, but only as many, more
+ # digits as are needed to uniquely distinguish the number from all other
+ # IEEE 754 numeric values.
+ #
+ # The boolean false value is converted to the string false. The boolean
+ # true value is converted to the string true.
+ #
+ # An object of a type other than the four basic types is converted to a
+ # string in a way that is dependent on that type.
+ def Functions::string( object=@@context[:node] )
+ if object.respond_to?(:node_type)
+ case object.node_type
+ when :attribute
+ object.value
+ when :element
+ string_value(object)
+ when :document
+ string_value(object.root)
+ when :processing_instruction
+ object.content
+ else
+ object.to_s
+ end
+ else
+ case object
+ when Array
+ string(object[0])
+ when Float
+ if object.nan?
+ "NaN"
+ else
+ integer = object.to_i
+ if object == integer
+ "%d" % integer
+ else
+ object.to_s
+ end
+ end
+ else
+ object.to_s
+ end
+ end
+ end
+
+ # A node-set is converted to a string by
+ # returning the concatenation of the string-value
+ # of each of the children of the node in the
+ # node-set that is first in document order.
+ # If the node-set is empty, an empty string is returned.
+ def Functions::string_value( o )
+ rv = ""
+ o.children.each { |e|
+ if e.node_type == :text
+ rv << e.to_s
+ elsif e.node_type == :element
+ rv << string_value( e )
+ end
+ }
+ rv
+ end
+
+ def Functions::concat( *objects )
+ concatenated = ""
+ objects.each do |object|
+ concatenated << string(object)
+ end
+ concatenated
+ end
+
+ # Fixed by Mike Stok
+ def Functions::starts_with( string, test )
+ string(string).index(string(test)) == 0
+ end
+
+ # Fixed by Mike Stok
+ def Functions::contains( string, test )
+ string(string).include?(string(test))
+ end
+
+ # Kouhei fixed this
+ def Functions::substring_before( string, test )
+ ruby_string = string(string)
+ ruby_index = ruby_string.index(string(test))
+ if ruby_index.nil?
+ ""
+ else
+ ruby_string[ 0...ruby_index ]
+ end
+ end
+
+ # Kouhei fixed this too
+ def Functions::substring_after( string, test )
+ ruby_string = string(string)
+ return $1 if ruby_string =~ /#{test}(.*)/
+ ""
+ end
+
+ # Take equal portions of Mike Stok and Sean Russell; mix
+ # vigorously, and pour into a tall, chilled glass. Serves 10,000.
+ def Functions::substring( string, start, length=nil )
+ ruby_string = string(string)
+ ruby_length = if length.nil?
+ ruby_string.length.to_f
+ else
+ number(length)
+ end
+ ruby_start = number(start)
+
+ # Handle the special cases
+ return '' if (
+ ruby_length.nan? or
+ ruby_start.nan? or
+ ruby_start.infinite?
+ )
+
+ infinite_length = ruby_length.infinite? == 1
+ ruby_length = ruby_string.length if infinite_length
+
+ # Now, get the bounds. The XPath bounds are 1..length; the ruby bounds
+ # are 0..length. Therefore, we have to offset the bounds by one.
+ ruby_start = round(ruby_start) - 1
+ ruby_length = round(ruby_length)
+
+ if ruby_start < 0
+ ruby_length += ruby_start unless infinite_length
+ ruby_start = 0
+ end
+ return '' if ruby_length <= 0
+ ruby_string[ruby_start,ruby_length]
+ end
+
+ # UNTESTED
+ def Functions::string_length( string )
+ string(string).length
+ end
+
+ def Functions::normalize_space( string=nil )
+ string = string(@@context[:node]) if string.nil?
+ if string.kind_of? Array
+ string.collect{|x| x.to_s.strip.gsub(/\s+/um, ' ') if x}
+ else
+ string.to_s.strip.gsub(/\s+/um, ' ')
+ end
+ end
+
+ # This is entirely Mike Stok's beast
+ def Functions::translate( string, tr1, tr2 )
+ from = string(tr1)
+ to = string(tr2)
+
+ # the map is our translation table.
+ #
+ # if a character occurs more than once in the
+ # from string then we ignore the second &
+ # subsequent mappings
+ #
+ # if a character maps to nil then we delete it
+ # in the output. This happens if the from
+ # string is longer than the to string
+ #
+ # there's nothing about - or ^ being special in
+ # http://www.w3.org/TR/xpath#function-translate
+ # so we don't build ranges or negated classes
+
+ map = Hash.new
+ 0.upto(from.length - 1) { |pos|
+ from_char = from[pos]
+ unless map.has_key? from_char
+ map[from_char] =
+ if pos < to.length
+ to[pos]
+ else
+ nil
+ end
+ end
+ }
+
+ if ''.respond_to? :chars
+ string(string).chars.collect { |c|
+ if map.has_key? c then map[c] else c end
+ }.compact.join
+ else
+ string(string).unpack('U*').collect { |c|
+ if map.has_key? c then map[c] else c end
+ }.compact.pack('U*')
+ end
+ end
+
+ def Functions::boolean(object=@@context[:node])
+ case object
+ when true, false
+ object
+ when Float
+ return false if object.zero?
+ return false if object.nan?
+ true
+ when Numeric
+ not object.zero?
+ when String
+ not object.empty?
+ when Array
+ not object.empty?
+ else
+ object ? true : false
+ end
+ end
+
+ # UNTESTED
+ def Functions::not( object )
+ not boolean( object )
+ end
+
+ # UNTESTED
+ def Functions::true( )
+ true
+ end
+
+ # UNTESTED
+ def Functions::false( )
+ false
+ end
+
+ # UNTESTED
+ def Functions::lang( language )
+ lang = false
+ node = @@context[:node]
+ attr = nil
+ until node.nil?
+ if node.node_type == :element
+ attr = node.attributes["xml:lang"]
+ unless attr.nil?
+ lang = compare_language(string(language), attr)
+ break
+ else
+ end
+ end
+ node = node.parent
+ end
+ lang
+ end
+
+ def Functions::compare_language lang1, lang2
+ lang2.downcase.index(lang1.downcase) == 0
+ end
+
+ # a string that consists of optional whitespace followed by an optional
+ # minus sign followed by a Number followed by whitespace is converted to
+ # the IEEE 754 number that is nearest (according to the IEEE 754
+ # round-to-nearest rule) to the mathematical value represented by the
+ # string; any other string is converted to NaN
+ #
+ # boolean true is converted to 1; boolean false is converted to 0
+ #
+ # a node-set is first converted to a string as if by a call to the string
+ # function and then converted in the same way as a string argument
+ #
+ # an object of a type other than the four basic types is converted to a
+ # number in a way that is dependent on that type
+ def Functions::number(object=@@context[:node])
+ case object
+ when true
+ Float(1)
+ when false
+ Float(0)
+ when Array
+ number(string(object))
+ when Numeric
+ object.to_f
+ else
+ str = string(object)
+ case str.strip
+ when /\A\s*(-?(?:\d+(?:\.\d*)?|\.\d+))\s*\z/
+ $1.to_f
+ else
+ Float::NAN
+ end
+ end
+ end
+
+ def Functions::sum( nodes )
+ nodes = [nodes] unless nodes.kind_of? Array
+ nodes.inject(0) { |r,n| r + number(string(n)) }
+ end
+
+ def Functions::floor( number )
+ number(number).floor
+ end
+
+ def Functions::ceiling( number )
+ number(number).ceil
+ end
+
+ def Functions::round( number )
+ number = number(number)
+ begin
+ neg = number.negative?
+ number = number.abs.round
+ neg ? -number : number
+ rescue FloatDomainError
+ number
+ end
+ end
+
+ def Functions::processing_instruction( node )
+ node.node_type == :processing_instruction
+ end
+
+ def Functions::send(name, *args)
+ if @@available_functions[name.to_sym]
+ super
+ else
+ # TODO: Maybe, this is not XPath spec behavior.
+ # This behavior must be reconsidered.
+ XPath.match(@@context[:node], name.to_s)
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/instruction.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/instruction.rb
new file mode 100644
index 0000000..a3dfbbe
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/light/node.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/light/node.rb
new file mode 100644
index 0000000..3dab885
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/light/node.rb
@@ -0,0 +1,188 @@
+# frozen_string_literal: false
+require_relative '../xmltokens'
+
+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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/namespace.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/namespace.rb
new file mode 100644
index 0000000..232b7ca
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/namespace.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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
+ NAME_WITHOUT_NAMESPACE = /\A#{NCNAME_STR}\z/
+ NAMESPLIT = /^(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})/u
+
+ # Sets the name and the expanded name
+ def name=( name )
+ @expanded_name = name
+ if name.match?(NAME_WITHOUT_NAMESPACE)
+ @prefix = ""
+ @namespace = ""
+ @name = name
+ elsif name =~ NAMESPLIT
+ if $1
+ @prefix = $1
+ else
+ @prefix = ""
+ @namespace = ""
+ end
+ @name = $2
+ elsif name == ""
+ @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
+ namespace() == ns and name() == other
+ elsif other.include? ":"
+ fully_expanded_name == other
+ else
+ 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
+ @name
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/node.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/node.rb
new file mode 100644
index 0000000..bccacc5
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/node.rb
@@ -0,0 +1,80 @@
+# 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
+ stack = []
+ each { |child| stack.unshift child if child.node_type == :element }
+ until stack.empty?
+ child = stack.pop
+ yield child
+ n = stack.size
+ child.each { |grandchild| stack.insert n, grandchild if grandchild.node_type == :element }
+ end
+ 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)
+ }
+ 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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/output.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/output.rb
new file mode 100644
index 0000000..88a5fb3
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parent.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parent.rb
new file mode 100644
index 0000000..6a53b37
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parseexception.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parseexception.rb
new file mode 100644
index 0000000..e57d05f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parseexception.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: false
+module REXML
+ class ParseException < RuntimeError
+ attr_accessor :source, :parser, :continued_exception
+
+ def initialize( message, source=nil, parser=nil, exception=nil )
+ super(message)
+ @source = source
+ @parser = parser
+ @continued_exception = exception
+ end
+
+ def to_s
+ # Quote the original exception, if there was one
+ if @continued_exception
+ err = @continued_exception.inspect
+ err << "\n"
+ err << @continued_exception.backtrace.join("\n")
+ err << "\n...\n"
+ else
+ err = ""
+ end
+
+ # Get the stack trace and error message
+ err << super
+
+ # Add contextual information
+ if @source
+ err << "\nLine: #{line}\n"
+ err << "Position: #{position}\n"
+ err << "Last 80 unconsumed characters:\n"
+ err.force_encoding("ASCII-8BIT")
+ err << @source.buffer[0..80].force_encoding("ASCII-8BIT").gsub(/\n/, ' ')
+ end
+
+ err
+ end
+
+ def position
+ @source.current_line[0] if @source and defined? @source.current_line and
+ @source.current_line
+ end
+
+ def line
+ @source.current_line[2] if @source and defined? @source.current_line and
+ @source.current_line
+ end
+
+ def context
+ @source.current_line
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/baseparser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/baseparser.rb
new file mode 100644
index 0000000..8fe287a
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/baseparser.rb
@@ -0,0 +1,949 @@
+# frozen_string_literal: true
+require_relative '../parseexception'
+require_relative '../undefinednamespaceexception'
+require_relative '../security'
+require_relative '../source'
+require 'set'
+require "strscan"
+
+module REXML
+ module Parsers
+ unless [].respond_to?(:tally)
+ module EnumerableTally
+ refine Enumerable do
+ def tally
+ counts = {}
+ each do |item|
+ counts[item] ||= 0
+ counts[item] += 1
+ end
+ counts
+ end
+ end
+ end
+ using EnumerableTally
+ end
+
+ if StringScanner::Version < "3.0.8"
+ module StringScannerCaptures
+ refine StringScanner do
+ def captures
+ values_at(*(1...size))
+ end
+ end
+ end
+ using StringScannerCaptures
+ end
+
+ # = Using the Pull Parser
+ # <em>This API is experimental, and subject to change.</em>
+ # parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )
+ # while parser.has_next?
+ # res = parser.next
+ # puts res[1]['att'] if res.start_tag? and res[0] == 'b'
+ # end
+ # See the PullEvent class for information on the content of the results.
+ # The data is identical to the arguments passed for the various events to
+ # the StreamListener API.
+ #
+ # Notice that:
+ # parser = PullParser.new( "<a>BAD DOCUMENT" )
+ # while parser.has_next?
+ # res = parser.next
+ # raise res[1] if res.error?
+ # end
+ #
+ # Nat Price gave me some good ideas for the API.
+ class BaseParser
+ LETTER = '[:alpha:]'
+ DIGIT = '[:digit:]'
+
+ COMBININGCHAR = '' # TODO
+ EXTENDER = '' # TODO
+
+ NCNAME_STR= "[#{LETTER}_][-[:alnum:]._#{COMBININGCHAR}#{EXTENDER}]*"
+ QNAME_STR= "(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})"
+ QNAME = /(#{QNAME_STR})/
+
+ # Just for backward compatibility. For example, kramdown uses this.
+ # It's not used in REXML.
+ UNAME_STR= "(?:#{NCNAME_STR}:)?#{NCNAME_STR}"
+
+ NAMECHAR = '[\-\w\.:]'
+ NAME = "([\\w:]#{NAMECHAR}*)"
+ NMTOKEN = "(?:#{NAMECHAR})+"
+ NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*"
+ REFERENCE = "&(?:#{NAME};|#\\d+;|#x[0-9a-fA-F]+;)"
+ REFERENCE_RE = /#{REFERENCE}/
+
+ DOCTYPE_START = /\A\s*<!DOCTYPE\s/um
+ DOCTYPE_END = /\A\s*\]\s*>/um
+ ATTRIBUTE_PATTERN = /\s*(#{QNAME_STR})\s*=\s*(["'])(.*?)\4/um
+ COMMENT_START = /\A<!--/u
+ COMMENT_PATTERN = /<!--(.*?)-->/um
+ CDATA_START = /\A<!\[CDATA\[/u
+ CDATA_END = /\A\s*\]\s*>/um
+ CDATA_PATTERN = /<!\[CDATA\[(.*?)\]\]>/um
+ XMLDECL_START = /\A<\?xml\s/u;
+ XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>/um
+ INSTRUCTION_START = /\A<\?/u
+ INSTRUCTION_PATTERN = /<\?#{NAME}(\s+.*?)?\?>/um
+ TAG_MATCH = /\A<((?>#{QNAME_STR}))/um
+ CLOSE_MATCH = /\A\s*<\/(#{QNAME_STR})\s*>/um
+
+ VERSION = /\bversion\s*=\s*["'](.*?)['"]/um
+ ENCODING = /\bencoding\s*=\s*["'](.*?)['"]/um
+ STANDALONE = /\bstandalone\s*=\s*["'](.*?)['"]/um
+
+ ENTITY_START = /\A\s*<!ENTITY/
+ ELEMENTDECL_START = /\A\s*<!ELEMENT/um
+ ELEMENTDECL_PATTERN = /\A\s*(<!ELEMENT.*?)>/um
+ SYSTEMENTITY = /\A\s*(%.*?;)\s*$/um
+ ENUMERATION = "\\(\\s*#{NMTOKEN}(?:\\s*\\|\\s*#{NMTOKEN})*\\s*\\)"
+ NOTATIONTYPE = "NOTATION\\s+\\(\\s*#{NAME}(?:\\s*\\|\\s*#{NAME})*\\s*\\)"
+ ENUMERATEDTYPE = "(?:(?:#{NOTATIONTYPE})|(?:#{ENUMERATION}))"
+ ATTTYPE = "(CDATA|ID|IDREF|IDREFS|ENTITY|ENTITIES|NMTOKEN|NMTOKENS|#{ENUMERATEDTYPE})"
+ ATTVALUE = "(?:\"((?:[^<&\"]|#{REFERENCE})*)\")|(?:'((?:[^<&']|#{REFERENCE})*)')"
+ DEFAULTDECL = "(#REQUIRED|#IMPLIED|(?:(#FIXED\\s+)?#{ATTVALUE}))"
+ ATTDEF = "\\s+#{NAME}\\s+#{ATTTYPE}\\s+#{DEFAULTDECL}"
+ ATTDEF_RE = /#{ATTDEF}/
+ ATTLISTDECL_START = /\A\s*<!ATTLIST/um
+ ATTLISTDECL_PATTERN = /\A\s*<!ATTLIST\s+#{NAME}(?:#{ATTDEF})*\s*>/um
+
+ TEXT_PATTERN = /\A([^<]*)/um
+
+ # Entity constants
+ 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})|\s*(?:#{PEDECL})/um
+
+ NOTATIONDECL_START = /\A\s*<!NOTATION/um
+ EXTERNAL_ID_PUBLIC = /\A\s*PUBLIC\s+#{PUBIDLITERAL}\s+#{SYSTEMLITERAL}\s*/um
+ EXTERNAL_ID_SYSTEM = /\A\s*SYSTEM\s+#{SYSTEMLITERAL}\s*/um
+ PUBLIC_ID = /\A\s*PUBLIC\s+#{PUBIDLITERAL}\s*/um
+
+ EREFERENCE = /&(?!#{NAME};)/
+
+ DEFAULT_ENTITIES = {
+ 'gt' => [/>/, '>', '>', />/],
+ 'lt' => [/</, '<', '<', /</],
+ 'quot' => [/"/, '"', '"', /"/],
+ "apos" => [/'/, "'", "'", /'/]
+ }
+
+ module Private
+ PEREFERENCE_PATTERN = /#{PEREFERENCE}/um
+ TAG_PATTERN = /((?>#{QNAME_STR}))\s*/um
+ CLOSE_PATTERN = /(#{QNAME_STR})\s*>/um
+ EQUAL_PATTERN = /\s*=\s*/um
+ ATTLISTDECL_END = /\s+#{NAME}(?:#{ATTDEF})*\s*>/um
+ NAME_PATTERN = /#{NAME}/um
+ GEDECL_PATTERN = "\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
+ PEDECL_PATTERN = "\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
+ ENTITYDECL_PATTERN = /(?:#{GEDECL_PATTERN})|(?:#{PEDECL_PATTERN})/um
+ CARRIAGE_RETURN_NEWLINE_PATTERN = /\r\n?/
+ CHARACTER_REFERENCES = /&#((?:\d+)|(?:x[a-fA-F0-9]+));/
+ DEFAULT_ENTITIES_PATTERNS = {}
+ default_entities = ['gt', 'lt', 'quot', 'apos', 'amp']
+ default_entities.each do |term|
+ DEFAULT_ENTITIES_PATTERNS[term] = /&#{term};/
+ end
+ XML_PREFIXED_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
+ end
+ private_constant :Private
+
+ def initialize( source )
+ self.stream = source
+ @listeners = []
+ @prefixes = Set.new
+ @entity_expansion_count = 0
+ @entity_expansion_limit = Security.entity_expansion_limit
+ @entity_expansion_text_limit = Security.entity_expansion_text_limit
+ @source.ensure_buffer
+ @version = nil
+ end
+
+ def add_listener( listener )
+ @listeners << listener
+ end
+
+ attr_reader :source
+ attr_reader :entity_expansion_count
+ attr_writer :entity_expansion_limit
+ attr_writer :entity_expansion_text_limit
+
+ def stream=( source )
+ @source = SourceFactory.create_from( source )
+ reset
+ end
+
+ def reset
+ @closed = nil
+ @have_root = false
+ @document_status = nil
+ @tags = []
+ @stack = []
+ @entities = []
+ @namespaces = {"xml" => Private::XML_PREFIXED_NAMESPACE}
+ @namespaces_restore_stack = []
+ end
+
+ def position
+ if @source.respond_to? :position
+ @source.position
+ else
+ # FIXME
+ 0
+ end
+ end
+
+ # Returns true if there are no more events
+ def empty?
+ (@source.empty? and @stack.empty?)
+ end
+
+ # Returns true if there are more events. Synonymous with !empty?
+ def has_next?
+ !(@source.empty? and @stack.empty?)
+ end
+
+ # Push an event back on the head of the stream. This method
+ # has (theoretically) infinite depth.
+ def unshift token
+ @stack.unshift(token)
+ end
+
+ # Peek at the +depth+ event in the stack. The first element on the stack
+ # is at depth 0. If +depth+ is -1, will parse to the end of the input
+ # stream and return the last event, which is always :end_document.
+ # Be aware that this causes the stream to be parsed up to the +depth+
+ # event, so you can effectively pre-parse the entire document (pull the
+ # entire thing into memory) using this method.
+ def peek depth=0
+ raise %Q[Illegal argument "#{depth}"] if depth < -1
+ temp = []
+ if depth == -1
+ temp.push(pull()) until empty?
+ else
+ while @stack.size+temp.size < depth+1
+ temp.push(pull())
+ end
+ end
+ @stack += temp if temp.size > 0
+ @stack[depth]
+ end
+
+ # Returns the next event. This is a +PullEvent+ object.
+ def pull
+ @source.drop_parsed_content
+
+ pull_event.tap do |event|
+ @listeners.each do |listener|
+ listener.receive event
+ end
+ end
+ end
+
+ def pull_event
+ if @closed
+ x, @closed = @closed, nil
+ return [ :end_element, x ]
+ end
+ if empty?
+ if @document_status == :in_doctype
+ raise ParseException.new("Malformed DOCTYPE: unclosed", @source)
+ end
+ unless @tags.empty?
+ path = "/" + @tags.join("/")
+ raise ParseException.new("Missing end tag for '#{path}'", @source)
+ end
+
+ unless @document_status == :in_element
+ raise ParseException.new("Malformed XML: No root element", @source)
+ end
+
+ return [ :end_document ]
+ end
+ return @stack.shift if @stack.size > 0
+ #STDERR.puts @source.encoding
+ #STDERR.puts "BUFFER = #{@source.buffer.inspect}"
+
+ @source.ensure_buffer
+ if @document_status == nil
+ start_position = @source.position
+ if @source.match?("<?", true)
+ return process_instruction
+ elsif @source.match?("<!", true)
+ if @source.match?("--", true)
+ return [ :comment, process_comment ]
+ elsif @source.match?("DOCTYPE", true)
+ base_error_message = "Malformed DOCTYPE"
+ unless @source.skip_spaces
+ if @source.match?(">")
+ message = "#{base_error_message}: name is missing"
+ else
+ message = "#{base_error_message}: invalid name"
+ end
+ @source.position = start_position
+ raise REXML::ParseException.new(message, @source)
+ end
+ name = parse_name(base_error_message)
+ @source.skip_spaces
+ if @source.match?("[", true)
+ id = [nil, nil, nil]
+ @document_status = :in_doctype
+ elsif @source.match?(">", true)
+ id = [nil, nil, nil]
+ @document_status = :after_doctype
+ @source.ensure_buffer
+ else
+ id = parse_id(base_error_message,
+ accept_external_id: true,
+ accept_public_id: false)
+ if id[0] == "SYSTEM"
+ # For backward compatibility
+ id[1], id[2] = id[2], nil
+ end
+ @source.skip_spaces
+ if @source.match?("[", true)
+ @document_status = :in_doctype
+ elsif @source.match?(">", true)
+ @document_status = :after_doctype
+ @source.ensure_buffer
+ else
+ message = "#{base_error_message}: garbage after external ID"
+ raise REXML::ParseException.new(message, @source)
+ end
+ end
+ args = [:start_doctype, name, *id]
+ if @document_status == :after_doctype
+ @source.skip_spaces
+ @stack << [ :end_doctype ]
+ end
+ return args
+ else
+ message = "Invalid XML"
+ raise REXML::ParseException.new(message, @source)
+ end
+ end
+ end
+ if @document_status == :in_doctype
+ @source.skip_spaces
+ start_position = @source.position
+ if @source.match?("<!", true)
+ if @source.match?("ELEMENT", true)
+ md = @source.match(/(.*?)>/um, true)
+ raise REXML::ParseException.new( "Bad ELEMENT declaration!", @source ) if md.nil?
+ return [ :elementdecl, "<!ELEMENT" + md[1] ]
+ elsif @source.match?("ENTITY", true)
+ match_data = @source.match(Private::ENTITYDECL_PATTERN, true)
+ unless match_data
+ raise REXML::ParseException.new("Malformed entity declaration", @source)
+ end
+ match = [:entitydecl, *match_data.captures.compact]
+ ref = false
+ if match[1] == '%'
+ ref = true
+ match.delete_at 1
+ end
+ # Now we have to sort out what kind of entity reference this is
+ if match[2] == 'SYSTEM'
+ # External reference
+ match[3] = match[3][1..-2] # PUBID
+ match.delete_at(4) if match.size > 4 # Chop out NDATA decl
+ # match is [ :entity, name, SYSTEM, pubid(, ndata)? ]
+ elsif match[2] == 'PUBLIC'
+ # External reference
+ match[3] = match[3][1..-2] # PUBID
+ match[4] = match[4][1..-2] # HREF
+ match.delete_at(5) if match.size > 5 # Chop out NDATA decl
+ # match is [ :entity, name, PUBLIC, pubid, href(, ndata)? ]
+ elsif Private::PEREFERENCE_PATTERN.match?(match[2])
+ raise REXML::ParseException.new("Parameter entity references forbidden in internal subset: #{match[2]}", @source)
+ else
+ match[2] = match[2][1..-2]
+ match.pop if match.size == 4
+ # match is [ :entity, name, value ]
+ end
+ match << '%' if ref
+ return match
+ elsif @source.match?("ATTLIST", true)
+ md = @source.match(Private::ATTLISTDECL_END, true)
+ raise REXML::ParseException.new( "Bad ATTLIST declaration!", @source ) if md.nil?
+ element = md[1]
+ contents = "<!ATTLIST" + md[0]
+
+ pairs = {}
+ values = md[0].strip.scan( ATTDEF_RE )
+ values.each do |attdef|
+ unless attdef[3] == "#IMPLIED"
+ attdef.compact!
+ val = attdef[3]
+ val = attdef[4] if val == "#FIXED "
+ pairs[attdef[0]] = val
+ if attdef[0] =~ /^xmlns:(.*)/
+ @namespaces[$1] = val
+ end
+ end
+ end
+ return [ :attlistdecl, element, pairs, contents ]
+ elsif @source.match?("NOTATION", true)
+ base_error_message = "Malformed notation declaration"
+ unless @source.skip_spaces
+ if @source.match?(">")
+ message = "#{base_error_message}: name is missing"
+ else
+ message = "#{base_error_message}: invalid name"
+ end
+ @source.position = start_position
+ raise REXML::ParseException.new(message, @source)
+ end
+ name = parse_name(base_error_message)
+ id = parse_id(base_error_message,
+ accept_external_id: true,
+ accept_public_id: true)
+ @source.skip_spaces
+ unless @source.match?(">", true)
+ message = "#{base_error_message}: garbage before end >"
+ raise REXML::ParseException.new(message, @source)
+ end
+ return [:notationdecl, name, *id]
+ elsif @source.match?("--", true)
+ return [ :comment, process_comment ]
+ else
+ raise REXML::ParseException.new("Malformed node: Started with '<!' but not a comment nor ELEMENT,ENTITY,ATTLIST,NOTATION", @source)
+ end
+ elsif match = @source.match(/(%.*?;)\s*/um, true)
+ return [ :externalentity, match[1] ]
+ elsif @source.match?(/\]\s*>/um, true)
+ @document_status = :after_doctype
+ return [ :end_doctype ]
+ else
+ raise ParseException.new("Malformed DOCTYPE: invalid declaration", @source)
+ end
+ end
+ if @document_status == :after_doctype
+ @source.skip_spaces
+ end
+ begin
+ start_position = @source.position
+ if @source.match?("<", true)
+ # :text's read_until may remain only "<" in buffer. In the
+ # case, buffer is empty here. So we need to fill buffer
+ # here explicitly.
+ @source.ensure_buffer
+ if @source.match?("/", true)
+ @namespaces_restore_stack.pop
+ last_tag = @tags.pop
+ md = @source.match(Private::CLOSE_PATTERN, true)
+ if md and !last_tag
+ message = "Unexpected top-level end tag (got '#{md[1]}')"
+ raise REXML::ParseException.new(message, @source)
+ end
+ if md.nil? or last_tag != md[1]
+ message = "Missing end tag for '#{last_tag}'"
+ message += " (got '#{md[1]}')" if md
+ @source.position = start_position if md.nil?
+ raise REXML::ParseException.new(message, @source)
+ end
+ return [ :end_element, last_tag ]
+ elsif @source.match?("!", true)
+ #STDERR.puts "SOURCE BUFFER = #{source.buffer}, #{source.buffer.size}"
+ if @source.match?("--", true)
+ return [ :comment, process_comment ]
+ elsif @source.match?("[CDATA[", true)
+ text = @source.read_until("]]>")
+ if text.chomp!("]]>")
+ return [ :cdata, text ]
+ else
+ raise REXML::ParseException.new("Malformed CDATA: Missing end ']]>'", @source)
+ end
+ else
+ raise REXML::ParseException.new("Malformed node: Started with '<!' but not a comment nor CDATA", @source)
+ end
+ elsif @source.match?("?", true)
+ return process_instruction
+ else
+ # Get the next tag
+ md = @source.match(Private::TAG_PATTERN, true)
+ unless md
+ @source.position = start_position
+ raise REXML::ParseException.new("malformed XML: missing tag start", @source)
+ end
+ tag = md[1]
+ @document_status = :in_element
+ @prefixes.clear
+ @prefixes << md[2] if md[2]
+ push_namespaces_restore
+ attributes, closed = parse_attributes(@prefixes)
+ # Verify that all of the prefixes have been defined
+ for prefix in @prefixes
+ unless @namespaces.key?(prefix)
+ raise UndefinedNamespaceException.new(prefix,@source,self)
+ end
+ end
+
+ if closed
+ @closed = tag
+ pop_namespaces_restore
+ else
+ if @tags.empty? and @have_root
+ raise ParseException.new("Malformed XML: Extra tag at the end of the document (got '<#{tag}')", @source)
+ end
+ @tags.push( tag )
+ end
+ @have_root = true
+ return [ :start_element, tag, attributes ]
+ end
+ else
+ text = @source.read_until("<")
+ if text.chomp!("<")
+ @source.position -= "<".bytesize
+ end
+ if @tags.empty?
+ unless /\A\s*\z/.match?(text)
+ if @have_root
+ raise ParseException.new("Malformed XML: Extra content at the end of the document (got '#{text}')", @source)
+ else
+ raise ParseException.new("Malformed XML: Content at the start of the document (got '#{text}')", @source)
+ end
+ end
+ return pull_event if @have_root
+ end
+ return [ :text, text ]
+ end
+ rescue REXML::UndefinedNamespaceException
+ raise
+ rescue REXML::ParseException
+ raise
+ rescue => error
+ raise REXML::ParseException.new( "Exception parsing",
+ @source, self, (error ? error : $!) )
+ end
+ # NOTE: The end of the method never runs, because it is unreachable.
+ # All branches of code above have explicit unconditional return or raise statements.
+ end
+ private :pull_event
+
+ def entity( reference, entities )
+ return unless entities
+
+ value = entities[ reference ]
+ return if value.nil?
+
+ record_entity_expansion
+ unnormalize( value, entities )
+ end
+
+ # Escapes all possible entities
+ def normalize( input, entities=nil, entity_filter=nil )
+ copy = input.clone
+ # Doing it like this rather than in a loop improves the speed
+ copy.gsub!( EREFERENCE, '&' )
+ entities.each do |key, value|
+ copy.gsub!( value, "&#{key};" ) unless entity_filter and
+ entity_filter.include?(entity)
+ end if entities
+ copy.gsub!( EREFERENCE, '&' )
+ DEFAULT_ENTITIES.each do |key, value|
+ copy.gsub!( value[3], value[1] )
+ end
+ copy
+ end
+
+ # Unescapes all possible entities
+ def unnormalize( string, entities=nil, filter=nil )
+ if string.include?("\r")
+ rv = string.gsub( Private::CARRIAGE_RETURN_NEWLINE_PATTERN, "\n" )
+ else
+ rv = string.dup
+ end
+ matches = rv.scan( REFERENCE_RE )
+ return rv if matches.size == 0
+ rv.gsub!( Private::CHARACTER_REFERENCES ) {
+ m=$1
+ if m.start_with?("x")
+ code_point = Integer(m[1..-1], 16)
+ else
+ code_point = Integer(m, 10)
+ end
+ [code_point].pack('U*')
+ }
+ matches.collect!{|x|x[0]}.compact!
+ if filter
+ matches.reject! do |entity_reference|
+ filter.include?(entity_reference)
+ end
+ end
+ if matches.size > 0
+ matches.tally.each do |entity_reference, n|
+ entity_expansion_count_before = @entity_expansion_count
+ entity_value = entity( entity_reference, entities )
+ if entity_value
+ if n > 1
+ entity_expansion_count_delta =
+ @entity_expansion_count - entity_expansion_count_before
+ record_entity_expansion(entity_expansion_count_delta * (n - 1))
+ end
+ re = Private::DEFAULT_ENTITIES_PATTERNS[entity_reference] || /&#{entity_reference};/
+ rv.gsub!( re, entity_value )
+ if rv.bytesize > @entity_expansion_text_limit
+ raise "entity expansion has grown too large"
+ end
+ else
+ er = DEFAULT_ENTITIES[entity_reference]
+ rv.gsub!( er[0], er[2] ) if er
+ end
+ end
+ rv.gsub!( Private::DEFAULT_ENTITIES_PATTERNS['amp'], '&' )
+ end
+ rv
+ end
+
+ private
+ def add_namespace(prefix, uri)
+ @namespaces_restore_stack.last[prefix] = @namespaces[prefix]
+ if uri.nil?
+ @namespaces.delete(prefix)
+ else
+ @namespaces[prefix] = uri
+ end
+ end
+
+ def push_namespaces_restore
+ namespaces_restore = {}
+ @namespaces_restore_stack.push(namespaces_restore)
+ namespaces_restore
+ end
+
+ def pop_namespaces_restore
+ namespaces_restore = @namespaces_restore_stack.pop
+ namespaces_restore.each do |prefix, uri|
+ if uri.nil?
+ @namespaces.delete(prefix)
+ else
+ @namespaces[prefix] = uri
+ end
+ end
+ end
+
+ def record_entity_expansion(delta=1)
+ @entity_expansion_count += delta
+ if @entity_expansion_count > @entity_expansion_limit
+ raise "number of entity expansions exceeded, processing aborted."
+ end
+ end
+
+ def need_source_encoding_update?(xml_declaration_encoding)
+ return false if xml_declaration_encoding.nil?
+ return false if /\AUTF-16\z/i =~ xml_declaration_encoding
+ true
+ end
+
+ def normalize_xml_declaration_encoding(xml_declaration_encoding)
+ /\AUTF-16(?:BE|LE)\z/i.match?(xml_declaration_encoding) ? "UTF-16" : nil
+ end
+
+ def parse_name(base_error_message)
+ md = @source.match(Private::NAME_PATTERN, true)
+ unless md
+ if @source.match?(/\S/um)
+ message = "#{base_error_message}: invalid name"
+ else
+ message = "#{base_error_message}: name is missing"
+ end
+ raise REXML::ParseException.new(message, @source)
+ end
+ md[0]
+ end
+
+ def parse_id(base_error_message,
+ accept_external_id:,
+ accept_public_id:)
+ if accept_external_id and (md = @source.match(EXTERNAL_ID_PUBLIC, true))
+ pubid = system = nil
+ pubid_literal = md[1]
+ pubid = pubid_literal[1..-2] if pubid_literal # Remove quote
+ system_literal = md[2]
+ system = system_literal[1..-2] if system_literal # Remove quote
+ ["PUBLIC", pubid, system]
+ elsif accept_public_id and (md = @source.match(PUBLIC_ID, true))
+ pubid = system = nil
+ pubid_literal = md[1]
+ pubid = pubid_literal[1..-2] if pubid_literal # Remove quote
+ ["PUBLIC", pubid, nil]
+ elsif accept_external_id and (md = @source.match(EXTERNAL_ID_SYSTEM, true))
+ system = nil
+ system_literal = md[1]
+ system = system_literal[1..-2] if system_literal # Remove quote
+ ["SYSTEM", nil, system]
+ else
+ details = parse_id_invalid_details(accept_external_id: accept_external_id,
+ accept_public_id: accept_public_id)
+ message = "#{base_error_message}: #{details}"
+ raise REXML::ParseException.new(message, @source)
+ end
+ end
+
+ def parse_id_invalid_details(accept_external_id:,
+ accept_public_id:)
+ public = /\A\s*PUBLIC/um
+ system = /\A\s*SYSTEM/um
+ if (accept_external_id or accept_public_id) and @source.match?(/#{public}/um)
+ if @source.match?(/#{public}(?:\s+[^'"]|\s*[\[>])/um)
+ return "public ID literal is missing"
+ end
+ unless @source.match?(/#{public}\s+#{PUBIDLITERAL}/um)
+ return "invalid public ID literal"
+ end
+ if accept_public_id
+ if @source.match?(/#{public}\s+#{PUBIDLITERAL}\s+[^'"]/um)
+ return "system ID literal is missing"
+ end
+ unless @source.match?(/#{public}\s+#{PUBIDLITERAL}\s+#{SYSTEMLITERAL}/um)
+ return "invalid system literal"
+ end
+ "garbage after system literal"
+ else
+ "garbage after public ID literal"
+ end
+ elsif accept_external_id and @source.match?(/#{system}/um)
+ if @source.match?(/#{system}(?:\s+[^'"]|\s*[\[>])/um)
+ return "system literal is missing"
+ end
+ unless @source.match?(/#{system}\s+#{SYSTEMLITERAL}/um)
+ return "invalid system literal"
+ end
+ "garbage after system literal"
+ else
+ unless @source.match?(/\A\s*(?:PUBLIC|SYSTEM)\s/um)
+ return "invalid ID type"
+ end
+ "ID type is missing"
+ end
+ end
+
+ def process_comment
+ text = @source.read_until("-->")
+ unless text.chomp!("-->")
+ raise REXML::ParseException.new("Unclosed comment: Missing end '-->'", @source)
+ end
+
+ if text.include? "--" or text.end_with?("-")
+ raise REXML::ParseException.new("Malformed comment", @source)
+ end
+ text
+ end
+
+ def process_instruction
+ name = parse_name("Malformed XML: Invalid processing instruction node")
+ if name == "xml"
+ xml_declaration
+ else # PITarget
+ if @source.skip_spaces # e.g. <?name content?>
+ start_position = @source.position
+ content = @source.read_until("?>")
+ unless content.chomp!("?>")
+ @source.position = start_position
+ raise ParseException.new("Malformed XML: Unclosed processing instruction: <#{name}>", @source)
+ end
+ else # e.g. <?name?>
+ content = nil
+ unless @source.match?("?>", true)
+ raise ParseException.new("Malformed XML: Unclosed processing instruction: <#{name}>", @source)
+ end
+ end
+ [:processing_instruction, name, content]
+ end
+ end
+
+ def xml_declaration
+ unless @version.nil?
+ raise ParseException.new("Malformed XML: XML declaration is duplicated", @source)
+ end
+ if @document_status
+ raise ParseException.new("Malformed XML: XML declaration is not at the start", @source)
+ end
+ unless @source.skip_spaces
+ raise ParseException.new("Malformed XML: XML declaration misses spaces before version", @source)
+ end
+ unless @source.match?("version", true)
+ raise ParseException.new("Malformed XML: XML declaration misses version", @source)
+ end
+ @version = parse_attribute_value_with_equal("xml")
+ unless @source.skip_spaces
+ unless @source.match?("?>", true)
+ raise ParseException.new("Malformed XML: Unclosed XML declaration", @source)
+ end
+ encoding = normalize_xml_declaration_encoding(@source.encoding)
+ return [ :xmldecl, @version, encoding, nil ] # e.g. <?xml version="1.0"?>
+ end
+
+ if @source.match?("encoding", true)
+ encoding = parse_attribute_value_with_equal("xml")
+ unless @source.skip_spaces
+ unless @source.match?("?>", true)
+ raise ParseException.new("Malformed XML: Unclosed XML declaration", @source)
+ end
+ if need_source_encoding_update?(encoding)
+ @source.encoding = encoding
+ end
+ encoding ||= normalize_xml_declaration_encoding(@source.encoding)
+ return [ :xmldecl, @version, encoding, nil ] # e.g. <?xml version="1.1" encoding="UTF-8"?>
+ end
+ end
+
+ if @source.match?("standalone", true)
+ standalone = parse_attribute_value_with_equal("xml")
+ case standalone
+ when "yes", "no"
+ else
+ raise ParseException.new("Malformed XML: XML declaration standalone is not yes or no : <#{standalone}>", @source)
+ end
+ end
+ @source.skip_spaces
+ unless @source.match?("?>", true)
+ raise ParseException.new("Malformed XML: Unclosed XML declaration", @source)
+ end
+
+ if need_source_encoding_update?(encoding)
+ @source.encoding = encoding
+ end
+ encoding ||= normalize_xml_declaration_encoding(@source.encoding)
+
+ # e.g. <?xml version="1.0" ?>
+ # <?xml version="1.1" encoding="UTF-8" ?>
+ # <?xml version="1.1" standalone="yes"?>
+ # <?xml version="1.1" encoding="UTF-8" standalone="yes" ?>
+ [ :xmldecl, @version, encoding, standalone ]
+ end
+
+ if StringScanner::Version < "3.1.1"
+ def scan_quote
+ @source.match(/(['"])/, true)&.[](1)
+ end
+ else
+ def scan_quote
+ case @source.peek_byte
+ when 34 # '"'.ord
+ @source.scan_byte
+ '"'
+ when 39 # "'".ord
+ @source.scan_byte
+ "'"
+ else
+ nil
+ end
+ end
+ end
+
+ def parse_attribute_value_with_equal(name)
+ unless @source.match?(Private::EQUAL_PATTERN, true)
+ message = "Missing attribute equal: <#{name}>"
+ raise REXML::ParseException.new(message, @source)
+ end
+ unless quote = scan_quote
+ message = "Missing attribute value start quote: <#{name}>"
+ raise REXML::ParseException.new(message, @source)
+ end
+ start_position = @source.position
+ value = @source.read_until(quote)
+ unless value.chomp!(quote)
+ @source.position = start_position
+ message = "Missing attribute value end quote: <#{name}>: <#{quote}>"
+ raise REXML::ParseException.new(message, @source)
+ end
+ value
+ end
+
+ def parse_attributes(prefixes)
+ attributes = {}
+ expanded_names = {}
+ closed = false
+ while true
+ if @source.match?(">", true)
+ return attributes, closed
+ elsif @source.match?("/>", true)
+ closed = true
+ return attributes, closed
+ elsif match = @source.match(QNAME, true)
+ name = match[1]
+ prefix = match[2]
+ local_part = match[3]
+ value = parse_attribute_value_with_equal(name)
+ @source.skip_spaces
+ if prefix == "xmlns"
+ if local_part == "xml"
+ if value != Private::XML_PREFIXED_NAMESPACE
+ msg = "The 'xml' prefix must not be bound to any other namespace "+
+ "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
+ raise REXML::ParseException.new( msg, @source, self )
+ end
+ elsif local_part == "xmlns"
+ msg = "The 'xmlns' prefix must not be declared "+
+ "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
+ raise REXML::ParseException.new( msg, @source, self)
+ end
+ add_namespace(local_part, value)
+ elsif prefix
+ prefixes << prefix unless prefix == "xml"
+ end
+
+ if attributes[name]
+ msg = "Duplicate attribute #{name.inspect}"
+ raise REXML::ParseException.new(msg, @source, self)
+ end
+
+ unless prefix == "xmlns"
+ uri = @namespaces[prefix]
+ expanded_name = [uri, local_part]
+ existing_prefix = expanded_names[expanded_name]
+ if existing_prefix
+ message = "Namespace conflict in adding attribute " +
+ "\"#{local_part}\": " +
+ "Prefix \"#{existing_prefix}\" = \"#{uri}\" and " +
+ "prefix \"#{prefix}\" = \"#{uri}\""
+ raise REXML::ParseException.new(message, @source, self)
+ end
+ expanded_names[expanded_name] = prefix
+ end
+
+ attributes[name] = value
+ else
+ message = "Invalid attribute name: <#{@source.buffer.split(%r{[/>\s]}).first}>"
+ raise REXML::ParseException.new(message, @source)
+ end
+ end
+ end
+ end
+ end
+end
+
+=begin
+ case event[0]
+ when :start_element
+ when :text
+ when :end_element
+ when :processing_instruction
+ when :cdata
+ when :comment
+ when :xmldecl
+ when :start_doctype
+ when :end_doctype
+ when :externalentity
+ when :elementdecl
+ when :entity
+ when :attlistdecl
+ when :notationdecl
+ when :end_doctype
+ end
+=end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/lightparser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/lightparser.rb
new file mode 100644
index 0000000..bdc0827
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/lightparser.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: false
+require_relative 'streamparser'
+require_relative 'baseparser'
+require_relative '../light/node'
+
+module REXML
+ module Parsers
+ class LightParser
+ def initialize stream
+ @stream = stream
+ @parser = REXML::Parsers::BaseParser.new( stream )
+ end
+
+ def add_listener( listener )
+ @parser.add_listener( listener )
+ end
+
+ def rewind
+ @stream.rewind
+ @parser.stream = @stream
+ end
+
+ def parse
+ root = context = [ :document ]
+ while true
+ event = @parser.pull
+ case event[0]
+ when :end_document
+ break
+ when :start_element, :start_doctype
+ new_node = event
+ context << new_node
+ new_node[1,0] = [context]
+ context = new_node
+ when :end_element, :end_doctype
+ context = context[1]
+ else
+ new_node = event
+ context << new_node
+ new_node[1,0] = [context]
+ end
+ end
+ root
+ end
+ end
+
+ # An element is an array. The array contains:
+ # 0 The parent element
+ # 1 The tag name
+ # 2 A hash of attributes
+ # 3..-1 The child elements
+ # An element is an array of size > 3
+ # Text is a String
+ # PIs are [ :processing_instruction, target, data ]
+ # Comments are [ :comment, data ]
+ # DocTypes are DocType structs
+ # The root is an array with XMLDecls, Text, DocType, Array, Text
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/pullparser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/pullparser.rb
new file mode 100644
index 0000000..e0b1e94
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/pullparser.rb
@@ -0,0 +1,213 @@
+# frozen_string_literal: false
+require 'forwardable'
+
+require_relative '../parseexception'
+require_relative 'baseparser'
+require_relative '../xmltokens'
+
+module REXML
+ module Parsers
+ # = Using the Pull Parser
+ # <em>This API is experimental, and subject to change.</em>
+ # parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )
+ # while parser.has_next?
+ # res = parser.next
+ # puts res[1]['att'] if res.start_tag? and res[0] == 'b'
+ # end
+ # See the PullEvent class for information on the content of the results.
+ # The data is identical to the arguments passed for the various events to
+ # the StreamListener API.
+ #
+ # Notice that:
+ # parser = PullParser.new( "<a>BAD DOCUMENT" )
+ # while parser.has_next?
+ # res = parser.next
+ # raise res[1] if res.error?
+ # end
+ #
+ # Nat Price gave me some good ideas for the API.
+ class PullParser
+ include XMLTokens
+ extend Forwardable
+
+ def_delegators( :@parser, :has_next? )
+ def_delegators( :@parser, :entity )
+ def_delegators( :@parser, :empty? )
+ def_delegators( :@parser, :source )
+
+ def initialize stream
+ @entities = {}
+ @listeners = nil
+ @parser = BaseParser.new( stream )
+ @my_stack = []
+ end
+
+ def add_listener( listener )
+ @listeners = [] unless @listeners
+ @listeners << listener
+ end
+
+ def entity_expansion_count
+ @parser.entity_expansion_count
+ end
+
+ def entity_expansion_limit=( limit )
+ @parser.entity_expansion_limit = limit
+ end
+
+ def entity_expansion_text_limit=( limit )
+ @parser.entity_expansion_text_limit = limit
+ end
+
+ def each
+ while has_next?
+ yield self.pull
+ end
+ end
+
+ def peek depth=0
+ if @my_stack.length <= depth
+ (depth - @my_stack.length + 1).times {
+ e = PullEvent.new(@parser.pull)
+ @my_stack.push(e)
+ }
+ end
+ @my_stack[depth]
+ end
+
+ def pull
+ return @my_stack.shift if @my_stack.length > 0
+
+ event = @parser.pull
+ case event[0]
+ when :entitydecl
+ @entities[ event[1] ] =
+ event[2] unless event[2] =~ /PUBLIC|SYSTEM/
+ when :text
+ unnormalized = @parser.unnormalize( event[1], @entities )
+ event << unnormalized
+ end
+ PullEvent.new( event )
+ end
+
+ def unshift token
+ @my_stack.unshift token
+ end
+
+ def reset
+ @parser.reset
+ end
+ end
+
+ # A parsing event. The contents of the event are accessed as an +Array?,
+ # and the type is given either by the ...? methods, or by accessing the
+ # +type+ accessor. The contents of this object vary from event to event,
+ # but are identical to the arguments passed to +StreamListener+s for each
+ # event.
+ class PullEvent
+ # The type of this event. Will be one of :tag_start, :tag_end, :text,
+ # :processing_instruction, :comment, :doctype, :attlistdecl, :entitydecl,
+ # :notationdecl, :entity, :cdata, :xmldecl, or :error.
+ def initialize(arg)
+ @contents = arg
+ end
+
+ def []( start, endd=nil)
+ if start.kind_of? Range
+ @contents.slice( start.begin+1 .. start.end )
+ elsif start.kind_of? Numeric
+ if endd.nil?
+ @contents.slice( start+1 )
+ else
+ @contents.slice( start+1, endd )
+ end
+ else
+ raise "Illegal argument #{start.inspect} (#{start.class})"
+ end
+ end
+
+ def event_type
+ @contents[0]
+ end
+
+ # Content: [ String tag_name, Hash attributes ]
+ def start_element?
+ @contents[0] == :start_element
+ end
+
+ # Content: [ String tag_name ]
+ def end_element?
+ @contents[0] == :end_element
+ end
+
+ # Content: [ String raw_text, String unnormalized_text ]
+ def text?
+ @contents[0] == :text
+ end
+
+ # Content: [ String text ]
+ def instruction?
+ @contents[0] == :processing_instruction
+ end
+
+ # Content: [ String text ]
+ def comment?
+ @contents[0] == :comment
+ end
+
+ # Content: [ String name, String pub_sys, String long_name, String uri ]
+ def doctype?
+ @contents[0] == :start_doctype
+ end
+
+ # Content: [ String text ]
+ def attlistdecl?
+ @contents[0] == :attlistdecl
+ end
+
+ # Content: [ String text ]
+ def elementdecl?
+ @contents[0] == :elementdecl
+ end
+
+ # Due to the wonders of DTDs, an entity declaration can be just about
+ # anything. There's no way to normalize it; you'll have to interpret the
+ # content yourself. However, the following is true:
+ #
+ # * If the entity declaration is an internal entity:
+ # [ String name, String value ]
+ # Content: [ String text ]
+ def entitydecl?
+ @contents[0] == :entitydecl
+ end
+
+ # Content: [ String text ]
+ def notationdecl?
+ @contents[0] == :notationdecl
+ end
+
+ # Content: [ String text ]
+ def entity?
+ @contents[0] == :entity
+ end
+
+ # Content: [ String text ]
+ def cdata?
+ @contents[0] == :cdata
+ end
+
+ # Content: [ String version, String encoding, String standalone ]
+ def xmldecl?
+ @contents[0] == :xmldecl
+ end
+
+ def error?
+ @contents[0] == :error
+ end
+
+ def inspect
+ @contents[0].to_s + ": " + @contents[1..-1].inspect
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/sax2parser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/sax2parser.rb
new file mode 100644
index 0000000..a51477d
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/sax2parser.rb
@@ -0,0 +1,270 @@
+# frozen_string_literal: false
+require_relative 'baseparser'
+require_relative '../parseexception'
+require_relative '../namespace'
+require_relative '../text'
+
+module REXML
+ module Parsers
+ # SAX2Parser
+ class SAX2Parser
+ def initialize source
+ @parser = BaseParser.new(source)
+ @listeners = []
+ @procs = []
+ @namespace_stack = []
+ @has_listeners = false
+ @tag_stack = []
+ @entities = {}
+ end
+
+ def source
+ @parser.source
+ end
+
+ def entity_expansion_count
+ @parser.entity_expansion_count
+ end
+
+ def entity_expansion_limit=( limit )
+ @parser.entity_expansion_limit = limit
+ end
+
+ def entity_expansion_text_limit=( limit )
+ @parser.entity_expansion_text_limit = limit
+ end
+
+ def add_listener( listener )
+ @parser.add_listener( listener )
+ end
+
+ # Listen arguments:
+ #
+ # Symbol, Array, Block
+ # Listen to Symbol events on Array elements
+ # Symbol, Block
+ # Listen to Symbol events
+ # Array, Listener
+ # Listen to all events on Array elements
+ # Array, Block
+ # Listen to :start_element events on Array elements
+ # Listener
+ # Listen to All events
+ #
+ # Symbol can be one of: :start_element, :end_element,
+ # :start_prefix_mapping, :end_prefix_mapping, :characters,
+ # :processing_instruction, :doctype, :attlistdecl, :elementdecl,
+ # :entitydecl, :notationdecl, :cdata, :xmldecl, :comment
+ #
+ # There is an additional symbol that can be listened for: :progress.
+ # This will be called for every event generated, passing in the current
+ # stream position.
+ #
+ # Array contains regular expressions or strings which will be matched
+ # against fully qualified element names.
+ #
+ # Listener must implement the methods in SAX2Listener
+ #
+ # Block will be passed the same arguments as a SAX2Listener method would
+ # be, where the method name is the same as the matched Symbol.
+ # See the SAX2Listener for more information.
+ def listen( *args, &blok )
+ if args[0].kind_of? Symbol
+ if args.size == 2
+ args[1].each { |match| @procs << [args[0], match, blok] }
+ else
+ add( [args[0], nil, blok] )
+ end
+ elsif args[0].kind_of? Array
+ if args.size == 2
+ args[0].each { |match| add( [nil, match, args[1]] ) }
+ else
+ args[0].each { |match| add( [ :start_element, match, blok ] ) }
+ end
+ else
+ add([nil, nil, args[0]])
+ end
+ end
+
+ def deafen( listener=nil, &blok )
+ if listener
+ @listeners.delete_if {|item| item[-1] == listener }
+ @has_listeners = false if @listeners.size == 0
+ else
+ @procs.delete_if {|item| item[-1] == blok }
+ end
+ end
+
+ def parse
+ @procs.each { |sym,match,block| block.call if sym == :start_document }
+ @listeners.each { |sym,match,block|
+ block.start_document if sym == :start_document or sym.nil?
+ }
+ context = []
+ while true
+ event = @parser.pull
+ case event[0]
+ when :end_document
+ handle( :end_document )
+ break
+ when :start_doctype
+ handle( :doctype, *event[1..-1])
+ when :end_doctype
+ context = context[1]
+ when :start_element
+ @tag_stack.push(event[1])
+ # find the observers for namespaces
+ procs = get_procs( :start_prefix_mapping, event[1] )
+ listeners = get_listeners( :start_prefix_mapping, event[1] )
+ if procs or listeners
+ # break out the namespace declarations
+ # The attributes live in event[2]
+ event[2].each {|n, v| event[2][n] = @parser.normalize(v)}
+ nsdecl = event[2].find_all { |n, value| n =~ /^xmlns(:|$)/ }
+ nsdecl.collect! { |n, value| [ n[6..-1], value ] }
+ @namespace_stack.push({})
+ nsdecl.each do |n,v|
+ @namespace_stack[-1][n] = v
+ # notify observers of namespaces
+ procs.each { |ob| ob.call( n, v ) } if procs
+ listeners.each { |ob| ob.start_prefix_mapping(n, v) } if listeners
+ end
+ end
+ event[1] =~ Namespace::NAMESPLIT
+ prefix = $1
+ local = $2
+ uri = get_namespace(prefix)
+ # find the observers for start_element
+ procs = get_procs( :start_element, event[1] )
+ listeners = get_listeners( :start_element, event[1] )
+ # notify observers
+ procs.each { |ob| ob.call( uri, local, event[1], event[2] ) } if procs
+ listeners.each { |ob|
+ ob.start_element( uri, local, event[1], event[2] )
+ } if listeners
+ when :end_element
+ @tag_stack.pop
+ event[1] =~ Namespace::NAMESPLIT
+ prefix = $1
+ local = $2
+ uri = get_namespace(prefix)
+ # find the observers for start_element
+ procs = get_procs( :end_element, event[1] )
+ listeners = get_listeners( :end_element, event[1] )
+ # notify observers
+ procs.each { |ob| ob.call( uri, local, event[1] ) } if procs
+ listeners.each { |ob|
+ ob.end_element( uri, local, event[1] )
+ } if listeners
+
+ namespace_mapping = @namespace_stack.pop
+ # find the observers for namespaces
+ procs = get_procs( :end_prefix_mapping, event[1] )
+ listeners = get_listeners( :end_prefix_mapping, event[1] )
+ if procs or listeners
+ namespace_mapping.each do |ns_prefix, ns_uri|
+ # notify observers of namespaces
+ procs.each { |ob| ob.call( ns_prefix ) } if procs
+ listeners.each { |ob| ob.end_prefix_mapping(ns_prefix) } if listeners
+ end
+ end
+ when :text
+ unnormalized = @parser.unnormalize( event[1], @entities )
+ handle( :characters, unnormalized )
+ when :entitydecl
+ handle_entitydecl( event )
+ when :processing_instruction, :comment, :attlistdecl,
+ :elementdecl, :cdata, :notationdecl, :xmldecl
+ handle( *event )
+ end
+ handle( :progress, @parser.position )
+ end
+ end
+
+ private
+ def handle( symbol, *arguments )
+ tag = @tag_stack[-1]
+ procs = get_procs( symbol, tag )
+ listeners = get_listeners( symbol, tag )
+ # notify observers
+ procs.each { |ob| ob.call( *arguments ) } if procs
+ listeners.each { |l|
+ l.send( symbol.to_s, *arguments )
+ } if listeners
+ end
+
+ def handle_entitydecl( event )
+ @entities[ event[1] ] = event[2] if event.size == 3
+ parameter_reference_p = false
+ case event[2]
+ when "SYSTEM"
+ if event.size == 5
+ if event.last == "%"
+ parameter_reference_p = true
+ else
+ event[4, 0] = "NDATA"
+ end
+ end
+ when "PUBLIC"
+ if event.size == 6
+ if event.last == "%"
+ parameter_reference_p = true
+ else
+ event[5, 0] = "NDATA"
+ end
+ end
+ else
+ parameter_reference_p = (event.size == 4)
+ end
+ event[1, 0] = event.pop if parameter_reference_p
+ handle( event[0], event[1..-1] )
+ end
+
+ # The following methods are duplicates, but it is faster than using
+ # a helper
+ def get_procs( symbol, name )
+ return nil if @procs.size == 0
+ @procs.find_all do |sym, match, block|
+ (
+ (sym.nil? or symbol == sym) and
+ ((name.nil? and match.nil?) or match.nil? or (
+ (name == match) or
+ (match.kind_of? Regexp and name =~ match)
+ )
+ )
+ )
+ end.collect{|x| x[-1]}
+ end
+ def get_listeners( symbol, name )
+ return nil if @listeners.size == 0
+ @listeners.find_all do |sym, match, block|
+ (
+ (sym.nil? or symbol == sym) and
+ ((name.nil? and match.nil?) or match.nil? or (
+ (name == match) or
+ (match.kind_of? Regexp and name =~ match)
+ )
+ )
+ )
+ end.collect{|x| x[-1]}
+ end
+
+ def add( pair )
+ if pair[-1].respond_to? :call
+ @procs << pair unless @procs.include? pair
+ else
+ @listeners << pair unless @listeners.include? pair
+ @has_listeners = true
+ end
+ end
+
+ def get_namespace( prefix )
+ return nil if @namespace_stack.empty?
+
+ uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||
+ (@namespace_stack.find { |ns| not ns[nil].nil? })
+ uris[-1][prefix] unless uris.nil? or 0 == uris.size
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/streamparser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/streamparser.rb
new file mode 100644
index 0000000..6c64d97
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/streamparser.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: false
+require_relative "baseparser"
+
+module REXML
+ module Parsers
+ class StreamParser
+ def initialize source, listener
+ @listener = listener
+ @parser = BaseParser.new( source )
+ @entities = {}
+ end
+
+ def add_listener( listener )
+ @parser.add_listener( listener )
+ end
+
+ def entity_expansion_count
+ @parser.entity_expansion_count
+ end
+
+ def entity_expansion_limit=( limit )
+ @parser.entity_expansion_limit = limit
+ end
+
+ def entity_expansion_text_limit=( limit )
+ @parser.entity_expansion_text_limit = limit
+ end
+
+ def parse
+ # entity string
+ while true
+ event = @parser.pull
+ case event[0]
+ when :end_document
+ return
+ when :start_element
+ attrs = event[2].each do |n, v|
+ event[2][n] = @parser.unnormalize( v )
+ end
+ @listener.tag_start( event[1], attrs )
+ when :end_element
+ @listener.tag_end( event[1] )
+ when :text
+ unnormalized = @parser.unnormalize( event[1], @entities )
+ @listener.text( unnormalized )
+ when :processing_instruction
+ @listener.instruction( *event[1,2] )
+ when :start_doctype
+ @listener.doctype( *event[1..-1] )
+ when :end_doctype
+ # FIXME: remove this condition for milestone:3.2
+ @listener.doctype_end if @listener.respond_to? :doctype_end
+ when :comment, :attlistdecl, :cdata, :xmldecl, :elementdecl
+ @listener.send( event[0].to_s, *event[1..-1] )
+ when :entitydecl, :notationdecl
+ @entities[ event[1] ] = event[2] if event.size == 3
+ @listener.send( event[0].to_s, event[1..-1] )
+ when :externalentity
+ entity_reference = event[1]
+ content = entity_reference.gsub(/\A%|;\z/, "")
+ @listener.entity(content)
+ end
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/treeparser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/treeparser.rb
new file mode 100644
index 0000000..4565a40
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/treeparser.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: false
+require_relative '../validation/validationexception'
+require_relative '../undefinednamespaceexception'
+
+module REXML
+ module Parsers
+ class TreeParser
+ def initialize( source, build_context = Document.new )
+ @build_context = build_context
+ @parser = Parsers::BaseParser.new( source )
+ end
+
+ def add_listener( listener )
+ @parser.add_listener( listener )
+ end
+
+ def parse
+ entities = nil
+ begin
+ while true
+ event = @parser.pull
+ #STDERR.puts "TREEPARSER GOT #{event.inspect}"
+ case event[0]
+ when :end_document
+ return
+ when :start_element
+ el = @build_context = @build_context.add_element( event[1] )
+ event[2].each do |key, value|
+ el.attributes[key]=Attribute.new(key,value,self)
+ end
+ when :end_element
+ @build_context = @build_context.parent
+ when :text
+ if @build_context[-1].instance_of? Text
+ @build_context[-1] << event[1]
+ else
+ @build_context.add(
+ Text.new(event[1], @build_context.whitespace, nil, true)
+ ) unless (
+ @build_context.ignore_whitespace_nodes and
+ event[1].strip.size==0
+ )
+ end
+ when :comment
+ c = Comment.new( event[1] )
+ @build_context.add( c )
+ when :cdata
+ c = CData.new( event[1] )
+ @build_context.add( c )
+ when :processing_instruction
+ @build_context.add( Instruction.new( event[1], event[2] ) )
+ when :end_doctype
+ entities.each { |k,v| entities[k] = @build_context.entities[k].value }
+ @build_context = @build_context.parent
+ when :start_doctype
+ doctype = DocType.new( event[1..-1], @build_context )
+ @build_context = doctype
+ entities = {}
+ when :attlistdecl
+ n = AttlistDecl.new( event[1..-1] )
+ @build_context.add( n )
+ when :externalentity
+ n = ExternalEntity.new( event[1] )
+ @build_context.add( n )
+ when :elementdecl
+ n = ElementDecl.new( event[1] )
+ @build_context.add(n)
+ when :entitydecl
+ entities[ event[1] ] = event[2] unless event[2] =~ /PUBLIC|SYSTEM/
+ @build_context.add(Entity.new(event))
+ when :notationdecl
+ n = NotationDecl.new( *event[1..-1] )
+ @build_context.add( n )
+ when :xmldecl
+ x = XMLDecl.new( event[1], event[2], event[3] )
+ @build_context.add( x )
+ end
+ end
+ rescue REXML::Validation::ValidationException
+ raise
+ rescue REXML::ParseException
+ raise
+ rescue
+ raise ParseException.new( $!.message, @parser.source, @parser, $! )
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/ultralightparser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/ultralightparser.rb
new file mode 100644
index 0000000..e0029f4
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/ultralightparser.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: false
+require_relative 'streamparser'
+require_relative 'baseparser'
+
+module REXML
+ module Parsers
+ class UltraLightParser
+ def initialize stream
+ @stream = stream
+ @parser = REXML::Parsers::BaseParser.new( stream )
+ end
+
+ def add_listener( listener )
+ @parser.add_listener( listener )
+ end
+
+ def rewind
+ @stream.rewind
+ @parser.stream = @stream
+ end
+
+ def parse
+ root = context = []
+ while true
+ event = @parser.pull
+ case event[0]
+ when :end_document
+ break
+ when :end_doctype
+ context = context[1]
+ when :start_element, :start_doctype
+ context << event
+ event[1,0] = [context]
+ context = event
+ when :end_element
+ context = context[1]
+ else
+ context << event
+ end
+ end
+ root
+ end
+ end
+
+ # An element is an array. The array contains:
+ # 0 The parent element
+ # 1 The tag name
+ # 2 A hash of attributes
+ # 3..-1 The child elements
+ # An element is an array of size > 3
+ # Text is a String
+ # PIs are [ :processing_instruction, target, data ]
+ # Comments are [ :comment, data ]
+ # DocTypes are DocType structs
+ # The root is an array with XMLDecls, Text, DocType, Array, Text
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/xpathparser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/xpathparser.rb
new file mode 100644
index 0000000..a6d76fd
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/parsers/xpathparser.rb
@@ -0,0 +1,739 @@
+# frozen_string_literal: false
+
+require_relative '../namespace'
+require_relative '../xmltokens'
+
+module REXML
+ module Parsers
+ # You don't want to use this class. Really. Use XPath, which is a wrapper
+ # for this class. Believe me. You don't want to poke around in here.
+ # There is strange, dark magic at work in this code. Beware. Go back! Go
+ # back while you still can!
+ class XPathParser
+ include XMLTokens
+ LITERAL = /^'([^']*)'|^"([^"]*)"/u
+
+ def namespaces=( namespaces )
+ Functions::namespace_context = namespaces
+ @namespaces = namespaces
+ end
+
+ def parse path
+ path = path.dup
+ path.gsub!(/([\(\[])\s+/, '\1') # Strip ignorable spaces
+ path.gsub!( /\s+([\]\)])/, '\1')
+ parsed = []
+ rest = OrExpr(path, parsed)
+ if rest
+ unless rest.strip.empty?
+ raise ParseException.new("Garbage component exists at the end: " +
+ "<#{rest}>: <#{path}>")
+ end
+ end
+ parsed
+ end
+
+ def predicate path
+ parsed = []
+ Predicate( "[#{path}]", parsed )
+ parsed
+ end
+
+ def abbreviate(path_or_parsed)
+ if path_or_parsed.kind_of?(String)
+ parsed = parse(path_or_parsed)
+ else
+ parsed = path_or_parsed
+ end
+ components = []
+ component = nil
+ while parsed.size > 0
+ op = parsed.shift
+ case op
+ when :node
+ component << "node()"
+ when :attribute
+ component = "@"
+ components << component
+ when :child
+ component = ""
+ components << component
+ when :descendant_or_self
+ next_op = parsed[0]
+ if next_op == :node
+ parsed.shift
+ component = ""
+ components << component
+ else
+ component = "descendant-or-self::"
+ components << component
+ end
+ when :self
+ next_op = parsed[0]
+ if next_op == :node
+ parsed.shift
+ components << "."
+ else
+ component = "self::"
+ components << component
+ end
+ when :parent
+ next_op = parsed[0]
+ if next_op == :node
+ parsed.shift
+ components << ".."
+ else
+ component = "parent::"
+ components << component
+ end
+ when :any
+ component << "*"
+ when :text
+ component << "text()"
+ when :following, :following_sibling,
+ :ancestor, :ancestor_or_self, :descendant,
+ :namespace, :preceding, :preceding_sibling
+ component = op.to_s.tr("_", "-") << "::"
+ components << component
+ when :qname
+ prefix = parsed.shift
+ name = parsed.shift
+ component << prefix+":" if prefix.size > 0
+ component << name
+ when :predicate
+ component << '['
+ component << predicate_to_path(parsed.shift) {|x| abbreviate(x)}
+ component << ']'
+ when :document
+ components << ""
+ when :function
+ component << parsed.shift
+ component << "( "
+ component << predicate_to_path(parsed.shift[0]) {|x| abbreviate(x)}
+ component << " )"
+ when :literal
+ component << quote_literal(parsed.shift)
+ else
+ component << "UNKNOWN("
+ component << op.inspect
+ component << ")"
+ end
+ end
+ case components
+ when [""]
+ "/"
+ when ["", ""]
+ "//"
+ else
+ components.join("/")
+ end
+ end
+
+ def expand(path_or_parsed)
+ if path_or_parsed.kind_of?(String)
+ parsed = parse(path_or_parsed)
+ else
+ parsed = path_or_parsed
+ end
+ path = ""
+ document = false
+ while parsed.size > 0
+ op = parsed.shift
+ case op
+ when :node
+ path << "node()"
+ when :attribute, :child, :following, :following_sibling,
+ :ancestor, :ancestor_or_self, :descendant, :descendant_or_self,
+ :namespace, :preceding, :preceding_sibling, :self, :parent
+ path << "/" unless path.size == 0
+ path << op.to_s.tr("_", "-")
+ path << "::"
+ when :any
+ path << "*"
+ when :qname
+ prefix = parsed.shift
+ name = parsed.shift
+ path << prefix+":" if prefix.size > 0
+ path << name
+ when :predicate
+ path << '['
+ path << predicate_to_path( parsed.shift ) { |x| expand(x) }
+ path << ']'
+ when :document
+ document = true
+ else
+ path << "UNKNOWN("
+ path << op.inspect
+ path << ")"
+ end
+ end
+ path = "/"+path if document
+ path
+ end
+
+ def predicate_to_path(parsed, &block)
+ path = ""
+ case parsed[0]
+ when :and, :or, :mult, :plus, :minus, :neq, :eq, :lt, :gt, :lteq, :gteq, :div, :mod, :union
+ op = parsed.shift
+ case op
+ when :eq
+ op = "="
+ when :lt
+ op = "<"
+ when :gt
+ op = ">"
+ when :lteq
+ op = "<="
+ when :gteq
+ op = ">="
+ when :neq
+ op = "!="
+ when :union
+ op = "|"
+ end
+ left = predicate_to_path( parsed.shift, &block )
+ right = predicate_to_path( parsed.shift, &block )
+ path << left
+ path << " "
+ path << op.to_s
+ path << " "
+ path << right
+ when :function
+ parsed.shift
+ name = parsed.shift
+ path << name
+ path << "("
+ parsed.shift.each_with_index do |argument, i|
+ path << ", " if i > 0
+ path << predicate_to_path(argument, &block)
+ end
+ path << ")"
+ when :literal
+ parsed.shift
+ path << quote_literal(parsed.shift)
+ else
+ path << yield( parsed )
+ end
+ path.squeeze(" ")
+ end
+ # For backward compatibility
+ alias_method :preciate_to_string, :predicate_to_path
+
+ private
+ def quote_literal( literal )
+ case literal
+ when String
+ # XPath 1.0 does not support escape characters.
+ # Assumes literal does not contain both single and double quotes.
+ if literal.include?("'")
+ "\"#{literal}\""
+ else
+ "'#{literal}'"
+ end
+ else
+ literal.inspect
+ end
+ end
+
+ #LocationPath
+ # | RelativeLocationPath
+ # | '/' RelativeLocationPath?
+ # | '//' RelativeLocationPath
+ def LocationPath path, parsed
+ path = path.lstrip
+ if path[0] == ?/
+ parsed << :document
+ if path[1] == ?/
+ parsed << :descendant_or_self
+ parsed << :node
+ path = path[2..-1]
+ else
+ path = path[1..-1]
+ end
+ end
+ RelativeLocationPath( path, parsed ) if path.size > 0
+ end
+
+ #RelativeLocationPath
+ # | Step
+ # | (AXIS_NAME '::' | '@' | '') AxisSpecifier
+ # NodeTest
+ # Predicate
+ # | '.' | '..' AbbreviatedStep
+ # | RelativeLocationPath '/' Step
+ # | RelativeLocationPath '//' Step
+ AXIS = /^(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::/
+ def RelativeLocationPath path, parsed
+ loop do
+ original_path = path
+ path = path.lstrip
+
+ return original_path if path.empty?
+
+ # (axis or @ or <child::>) nodetest predicate >
+ # OR > / Step
+ # (. or ..) >
+ if path[0] == ?.
+ if path[1] == ?.
+ parsed << :parent
+ parsed << :node
+ path = path[2..-1]
+ else
+ parsed << :self
+ parsed << :node
+ path = path[1..-1]
+ end
+ else
+ path_before_axis_specifier = path
+ parsed_not_abberviated = []
+ if path[0] == ?@
+ parsed_not_abberviated << :attribute
+ path = path[1..-1]
+ # Goto Nodetest
+ elsif path =~ AXIS
+ parsed_not_abberviated << $1.tr('-','_').intern
+ path = $'
+ # Goto Nodetest
+ else
+ parsed_not_abberviated << :child
+ end
+
+ path_before_node_test = path
+ path = NodeTest(path, parsed_not_abberviated)
+ if path == path_before_node_test
+ return path_before_axis_specifier
+ end
+ path = Predicate(path, parsed_not_abberviated)
+
+ parsed.concat(parsed_not_abberviated)
+ end
+
+ original_path = path
+ path = path.lstrip
+ return original_path if path.empty?
+
+ return original_path if path[0] != ?/
+
+ if path[1] == ?/
+ parsed << :descendant_or_self
+ parsed << :node
+ path = path[2..-1]
+ else
+ path = path[1..-1]
+ end
+ end
+ end
+
+ # Returns a 1-1 map of the nodeset
+ # The contents of the resulting array are either:
+ # true/false, if a positive match
+ # String, if a name match
+ #NodeTest
+ # | ('*' | NCNAME ':' '*' | QNAME) NameTest
+ # | '*' ':' NCNAME NameTest since XPath 2.0
+ # | NODE_TYPE '(' ')' NodeType
+ # | PI '(' LITERAL ')' PI
+ # | '[' expr ']' Predicate
+ PREFIX_WILDCARD = /^\*:(#{NCNAME_STR})/u
+ LOCAL_NAME_WILDCARD = /^(#{NCNAME_STR}):\*/u
+ QNAME = Namespace::NAMESPLIT
+ NODE_TYPE = /^(comment|text|node)\(\s*\)/m
+ PI = /^processing-instruction\(/
+ def NodeTest path, parsed
+ original_path = path
+ path = path.lstrip
+ case path
+ when PREFIX_WILDCARD
+ prefix = nil
+ name = $1
+ path = $'
+ parsed << :qname
+ parsed << prefix
+ parsed << name
+ when /^\*/
+ path = $'
+ parsed << :any
+ when NODE_TYPE
+ type = $1
+ path = $'
+ parsed << type.tr('-', '_').intern
+ when PI
+ path = $'
+ literal = nil
+ if path =~ /^\s*\)/
+ path = $'
+ else
+ path =~ LITERAL
+ literal = $1
+ path = $'
+ raise ParseException.new("Missing ')' after processing instruction") if path[0] != ?)
+ path = path[1..-1]
+ end
+ parsed << :processing_instruction
+ parsed << (literal || '')
+ when LOCAL_NAME_WILDCARD
+ prefix = $1
+ path = $'
+ parsed << :namespace
+ parsed << prefix
+ when QNAME
+ prefix = $1
+ name = $2
+ path = $'
+ prefix = "" unless prefix
+ parsed << :qname
+ parsed << prefix
+ parsed << name
+ else
+ path = original_path
+ end
+ path
+ end
+
+ # Filters the supplied nodeset on the predicate(s)
+ def Predicate path, parsed
+ original_path = path
+ path = path.lstrip
+ return original_path unless path[0] == ?[
+ predicates = []
+ while path[0] == ?[
+ path, expr = get_group(path)
+ predicates << expr[1..-2] if expr
+ end
+ predicates.each{ |pred|
+ preds = []
+ parsed << :predicate
+ parsed << preds
+ OrExpr(pred, preds)
+ }
+ path
+ end
+
+ # The following return arrays of true/false, a 1-1 mapping of the
+ # supplied nodeset, except for axe(), which returns a filtered
+ # nodeset
+
+ #| OrExpr S 'or' S AndExpr
+ #| AndExpr
+ def OrExpr path, parsed
+ n = []
+ rest = AndExpr( path, n )
+ if rest != path
+ while rest =~ /^\s*( or )/
+ n = [ :or, n, [] ]
+ rest = AndExpr( $', n[-1] )
+ end
+ end
+ if parsed.size == 0 and n.size != 0
+ parsed.replace(n)
+ elsif n.size > 0
+ parsed << n
+ end
+ rest
+ end
+
+ #| AndExpr S 'and' S EqualityExpr
+ #| EqualityExpr
+ def AndExpr path, parsed
+ n = []
+ rest = EqualityExpr( path, n )
+ if rest != path
+ while rest =~ /^\s*( and )/
+ n = [ :and, n, [] ]
+ rest = EqualityExpr( $', n[-1] )
+ end
+ end
+ if parsed.size == 0 and n.size != 0
+ parsed.replace(n)
+ elsif n.size > 0
+ parsed << n
+ end
+ rest
+ end
+
+ #| EqualityExpr ('=' | '!=') RelationalExpr
+ #| RelationalExpr
+ def EqualityExpr path, parsed
+ n = []
+ rest = RelationalExpr( path, n )
+ if rest != path
+ while rest =~ /^\s*(!?=)\s*/
+ if $1[0] == ?!
+ n = [ :neq, n, [] ]
+ else
+ n = [ :eq, n, [] ]
+ end
+ rest = RelationalExpr( $', n[-1] )
+ end
+ end
+ if parsed.size == 0 and n.size != 0
+ parsed.replace(n)
+ elsif n.size > 0
+ parsed << n
+ end
+ rest
+ end
+
+ #| RelationalExpr ('<' | '>' | '<=' | '>=') AdditiveExpr
+ #| AdditiveExpr
+ def RelationalExpr path, parsed
+ n = []
+ rest = AdditiveExpr( path, n )
+ if rest != path
+ while rest =~ /^\s*([<>]=?)\s*/
+ if $1[0] == ?<
+ sym = "lt"
+ else
+ sym = "gt"
+ end
+ sym << "eq" if $1[-1] == ?=
+ n = [ sym.intern, n, [] ]
+ rest = AdditiveExpr( $', n[-1] )
+ end
+ end
+ if parsed.size == 0 and n.size != 0
+ parsed.replace(n)
+ elsif n.size > 0
+ parsed << n
+ end
+ rest
+ end
+
+ #| AdditiveExpr ('+' | '-') MultiplicativeExpr
+ #| MultiplicativeExpr
+ def AdditiveExpr path, parsed
+ n = []
+ rest = MultiplicativeExpr( path, n )
+ if rest != path
+ while rest =~ /^\s*(\+|-)\s*/
+ if $1[0] == ?+
+ n = [ :plus, n, [] ]
+ else
+ n = [ :minus, n, [] ]
+ end
+ rest = MultiplicativeExpr( $', n[-1] )
+ end
+ end
+ if parsed.size == 0 and n.size != 0
+ parsed.replace(n)
+ elsif n.size > 0
+ parsed << n
+ end
+ rest
+ end
+
+ #| MultiplicativeExpr ('*' | S ('div' | 'mod') S) UnaryExpr
+ #| UnaryExpr
+ def MultiplicativeExpr path, parsed
+ n = []
+ rest = UnaryExpr( path, n )
+ if rest != path
+ while rest =~ /^\s*(\*| div | mod )\s*/
+ if $1[0] == ?*
+ n = [ :mult, n, [] ]
+ elsif $1.include?( "div" )
+ n = [ :div, n, [] ]
+ else
+ n = [ :mod, n, [] ]
+ end
+ rest = UnaryExpr( $', n[-1] )
+ end
+ end
+ if parsed.size == 0 and n.size != 0
+ parsed.replace(n)
+ elsif n.size > 0
+ parsed << n
+ end
+ rest
+ end
+
+ #| '-' UnaryExpr
+ #| UnionExpr
+ def UnaryExpr path, parsed
+ path =~ /^(\-*)/
+ path = $'
+ if $1 and (($1.size % 2) != 0)
+ mult = -1
+ else
+ mult = 1
+ end
+ parsed << :neg if mult < 0
+
+ n = []
+ path = UnionExpr( path, n )
+ parsed.concat( n )
+ path
+ end
+
+ #| UnionExpr '|' PathExpr
+ #| PathExpr
+ def UnionExpr path, parsed
+ n = []
+ rest = PathExpr( path, n )
+ if rest != path
+ while rest =~ /^\s*(\|)\s*/
+ n = [ :union, n, [] ]
+ rest = PathExpr( $', n[-1] )
+ end
+ end
+ if parsed.size == 0 and n.size != 0
+ parsed.replace( n )
+ elsif n.size > 0
+ parsed << n
+ end
+ rest
+ end
+
+ #| LocationPath
+ #| FilterExpr ('/' | '//') RelativeLocationPath
+ def PathExpr path, parsed
+ path = path.lstrip
+ n = []
+ rest = FilterExpr( path, n )
+ if rest != path
+ if rest and rest[0] == ?/
+ rest = RelativeLocationPath(rest, n)
+ parsed.concat(n)
+ return rest
+ end
+ end
+ rest = LocationPath(rest, n) if rest =~ /\A[\/\.\@\[\w*]/
+ parsed.concat(n)
+ rest
+ end
+
+ #| FilterExpr Predicate
+ #| PrimaryExpr
+ def FilterExpr path, parsed
+ n = []
+ path_before_primary_expr = path
+ path = PrimaryExpr(path, n)
+ return path_before_primary_expr if path == path_before_primary_expr
+ path = Predicate(path, n)
+ parsed.concat(n)
+ path
+ end
+
+ #| VARIABLE_REFERENCE
+ #| '(' expr ')'
+ #| LITERAL
+ #| NUMBER
+ #| FunctionCall
+ VARIABLE_REFERENCE = /^\$(#{NAME_STR})/u
+ NUMBER = /^(\d*\.?\d+)/
+ NT = /^comment|text|processing-instruction|node$/
+ def PrimaryExpr path, parsed
+ case path
+ when VARIABLE_REFERENCE
+ varname = $1
+ path = $'
+ parsed << :variable
+ parsed << varname
+ #arry << @variables[ varname ]
+ when /^(\w[-\w]*)(?:\()/
+ fname = $1
+ tmp = $'
+ return path if fname =~ NT
+ path = tmp
+ parsed << :function
+ parsed << fname
+ path = FunctionCall(path, parsed)
+ when NUMBER
+ varname = $1.nil? ? $2 : $1
+ path = $'
+ parsed << :literal
+ parsed << (varname.include?('.') ? varname.to_f : varname.to_i)
+ when LITERAL
+ varname = $1.nil? ? $2 : $1
+ path = $'
+ parsed << :literal
+ parsed << varname
+ when /^\(/ #/
+ path, contents = get_group(path)
+ contents = contents[1..-2]
+ n = []
+ OrExpr( contents, n )
+ parsed.concat(n)
+ end
+ path
+ end
+
+ #| FUNCTION_NAME '(' ( expr ( ',' expr )* )? ')'
+ def FunctionCall rest, parsed
+ path, arguments = parse_args(rest)
+ argset = []
+ for argument in arguments
+ args = []
+ OrExpr( argument, args )
+ argset << args
+ end
+ parsed << argset
+ path
+ end
+
+ # get_group( '[foo]bar' ) -> ['bar', '[foo]']
+ def get_group string
+ ind = 0
+ depth = 0
+ st = string[0,1]
+ en = (st == "(" ? ")" : "]")
+ begin
+ case string[ind,1]
+ when st
+ depth += 1
+ when en
+ depth -= 1
+ end
+ ind += 1
+ end while depth > 0 and ind < string.length
+ return nil unless depth==0
+ [string[ind..-1], string[0..ind-1]]
+ end
+
+ def parse_args( string )
+ arguments = []
+ ind = 0
+ inquot = false
+ inapos = false
+ depth = 1
+ begin
+ case string[ind]
+ when ?"
+ inquot = !inquot unless inapos
+ when ?'
+ inapos = !inapos unless inquot
+ else
+ unless inquot or inapos
+ case string[ind]
+ when ?(
+ depth += 1
+ if depth == 1
+ string = string[1..-1]
+ ind -= 1
+ end
+ when ?)
+ depth -= 1
+ if depth == 0
+ s = string[0,ind].strip
+ arguments << s unless s == ""
+ string = string[ind+1..-1]
+ end
+ when ?,
+ if depth == 1
+ s = string[0,ind].strip
+ arguments << s unless s == ""
+ string = string[ind+1..-1]
+ ind = -1
+ end
+ end
+ end
+ end
+ ind += 1
+ end while depth > 0 and ind < string.length
+ return nil unless depth==0
+ [string,arguments]
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/quickpath.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/quickpath.rb
new file mode 100644
index 0000000..cded06f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/quickpath.rb
@@ -0,0 +1,267 @@
+# frozen_string_literal: false
+require_relative 'functions'
+require_relative 'xmltokens'
+
+module REXML
+ class QuickPath
+ include Functions
+ include XMLTokens
+
+ # A base Hash object to be used when initializing a
+ # default empty namespaces set.
+ EMPTY_HASH = {}
+
+ def QuickPath::first element, path, namespaces=EMPTY_HASH
+ match(element, path, namespaces)[0]
+ end
+
+ def QuickPath::each element, path, namespaces=EMPTY_HASH, &block
+ path = "*" unless path
+ match(element, path, namespaces).each( &block )
+ end
+
+ def QuickPath::match element, path, namespaces=EMPTY_HASH
+ raise "nil is not a valid xpath" unless path
+ results = nil
+ Functions::namespace_context = namespaces
+ case path
+ when /^\/([^\/]|$)/u
+ # match on root
+ path = path[1..-1]
+ return [element.root.parent] if path == ''
+ results = filter([element.root], path)
+ when /^[-\w]*::/u
+ results = filter([element], path)
+ when /^\*/u
+ results = filter(element.to_a, path)
+ when /^[\[!\w:]/u
+ # match on child
+ children = element.to_a
+ results = filter(children, path)
+ else
+ results = filter([element], path)
+ end
+ results
+ end
+
+ # Given an array of nodes it filters the array based on the path. The
+ # result is that when this method returns, the array will contain elements
+ # which match the path
+ def QuickPath::filter elements, path
+ return elements if path.nil? or path == '' or elements.size == 0
+ case path
+ when /^\/\//u # Descendant
+ axe( elements, "descendant-or-self", $' )
+ when /^\/?\b(\w[-\w]*)\b::/u # Axe
+ axe( elements, $1, $' )
+ when /^\/(?=\b([:!\w][-\.\w]*:)?[-!\*\.\w]*\b([^:(]|$)|\*)/u # Child
+ rest = $'
+ results = []
+ elements.each do |element|
+ results |= filter( element.to_a, rest )
+ end
+ results
+ when /^\/?(\w[-\w]*)\(/u # / Function
+ function( elements, $1, $' )
+ when Namespace::NAMESPLIT # Element name
+ name = $2
+ ns = $1
+ rest = $'
+ elements.delete_if do |element|
+ !(element.kind_of? Element and
+ (element.expanded_name == name or
+ (element.name == name and
+ element.namespace == Functions.namespace_context[ns])))
+ end
+ filter( elements, rest )
+ when /^\/\[/u
+ matches = []
+ elements.each do |element|
+ matches |= predicate( element.to_a, path[1..-1] ) if element.kind_of? Element
+ end
+ matches
+ when /^\[/u # Predicate
+ predicate( elements, path )
+ when /^\/?\.\.\./u # Ancestor
+ axe( elements, "ancestor", $' )
+ when /^\/?\.\./u # Parent
+ filter( elements.collect{|e|e.parent}, $' )
+ when /^\/?\./u # Self
+ filter( elements, $' )
+ when /^\*/u # Any
+ results = []
+ elements.each do |element|
+ results |= filter( [element], $' ) if element.kind_of? Element
+ #if element.kind_of? Element
+ # children = element.to_a
+ # children.delete_if { |child| !child.kind_of?(Element) }
+ # results |= filter( children, $' )
+ #end
+ end
+ results
+ else
+ []
+ end
+ end
+
+ def QuickPath::axe( elements, axe_name, rest )
+ matches = []
+ matches = filter( elements.dup, rest ) if axe_name =~ /-or-self$/u
+ case axe_name
+ when /^descendant/u
+ elements.each do |element|
+ matches |= filter( element.to_a, "descendant-or-self::#{rest}" ) if element.kind_of? Element
+ end
+ when /^ancestor/u
+ elements.each do |element|
+ while element.parent
+ matches << element.parent
+ element = element.parent
+ end
+ end
+ matches = filter( matches, rest )
+ when "self"
+ matches = filter( elements, rest )
+ when "child"
+ elements.each do |element|
+ matches |= filter( element.to_a, rest ) if element.kind_of? Element
+ end
+ when "attribute"
+ elements.each do |element|
+ matches << element.attributes[ rest ] if element.kind_of? Element
+ end
+ when "parent"
+ matches = filter(elements.collect{|element| element.parent}.uniq, rest)
+ when "following-sibling"
+ matches = filter(elements.collect{|element| element.next_sibling}.uniq,
+ rest)
+ when "previous-sibling"
+ matches = filter(elements.collect{|element|
+ element.previous_sibling}.uniq, rest )
+ end
+ matches.uniq
+ end
+
+ OPERAND_ = '((?=(?:(?!and|or).)*[^\s<>=])[^\s<>=]+)'
+ # A predicate filters a node-set with respect to an axis to produce a
+ # new node-set. For each node in the node-set to be filtered, the
+ # PredicateExpr is evaluated with that node as the context node, with
+ # the number of nodes in the node-set as the context size, and with the
+ # proximity position of the node in the node-set with respect to the
+ # axis as the context position; if PredicateExpr evaluates to true for
+ # that node, the node is included in the new node-set; otherwise, it is
+ # not included.
+ #
+ # A PredicateExpr is evaluated by evaluating the Expr and converting
+ # the result to a boolean. If the result is a number, the result will
+ # be converted to true if the number is equal to the context position
+ # and will be converted to false otherwise; if the result is not a
+ # number, then the result will be converted as if by a call to the
+ # boolean function. Thus a location path para[3] is equivalent to
+ # para[position()=3].
+ def QuickPath::predicate( elements, path )
+ ind = 1
+ bcount = 1
+ while bcount > 0
+ bcount += 1 if path[ind] == ?[
+ bcount -= 1 if path[ind] == ?]
+ ind += 1
+ end
+ ind -= 1
+ predicate = path[1..ind-1]
+ rest = path[ind+1..-1]
+
+ # have to change 'a [=<>] b [=<>] c' into 'a [=<>] b and b [=<>] c'
+ #
+ predicate.gsub!(
+ /#{OPERAND_}\s*([<>=])\s*#{OPERAND_}\s*([<>=])\s*#{OPERAND_}/u,
+ '\1 \2 \3 and \3 \4 \5' )
+ # Let's do some Ruby trickery to avoid some work:
+ predicate.gsub!( /&/u, "&&" )
+ predicate.gsub!( /=/u, "==" )
+ predicate.gsub!( /@(\w[-\w.]*)/u, 'attribute("\1")' )
+ predicate.gsub!( /\bmod\b/u, "%" )
+ predicate.gsub!( /\b(\w[-\w.]*\()/u ) {
+ fname = $1
+ fname.gsub( /-/u, "_" )
+ }
+
+ Functions.pair = [ 0, elements.size ]
+ results = []
+ elements.each do |element|
+ Functions.pair[0] += 1
+ Functions.node = element
+ res = eval( predicate )
+ case res
+ when true
+ results << element
+ when Integer
+ results << element if Functions.pair[0] == res
+ when String
+ results << element
+ end
+ end
+ filter( results, rest )
+ end
+
+ def QuickPath::attribute( name )
+ Functions.node.attributes[name] if Functions.node.kind_of? Element
+ end
+
+ def QuickPath::name()
+ Functions.node.name if Functions.node.kind_of? Element
+ end
+
+ def QuickPath::method_missing( id, *args )
+ begin
+ Functions.send( id.id2name, *args )
+ rescue Exception
+ raise "METHOD: #{id.id2name}(#{args.join ', '})\n#{$!.message}"
+ end
+ end
+
+ def QuickPath::function( elements, fname, rest )
+ args = parse_args( elements, rest )
+ Functions.pair = [0, elements.size]
+ results = []
+ elements.each do |element|
+ Functions.pair[0] += 1
+ Functions.node = element
+ res = Functions.send( fname, *args )
+ case res
+ when true
+ results << element
+ when Integer
+ results << element if Functions.pair[0] == res
+ end
+ end
+ results
+ end
+
+ def QuickPath::parse_args( element, string )
+ # /.*?(?:\)|,)/
+ arguments = []
+ buffer = ""
+ while string and string != ""
+ c = string[0]
+ string.sub!(/^./u, "")
+ case c
+ when ?,
+ # if depth = 1, then we start a new argument
+ arguments << evaluate( buffer )
+ #arguments << evaluate( string[0..count] )
+ when ?(
+ # start a new method call
+ function( element, buffer, string )
+ buffer = ""
+ when ?)
+ # close the method call and return arguments
+ return arguments
+ else
+ buffer << c
+ end
+ end
+ ""
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/rexml.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/rexml.rb
new file mode 100644
index 0000000..226e198
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/rexml.rb
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: false
+#
+# \Module \REXML provides classes and methods for parsing,
+# editing, and generating XML.
+#
+# == Implementation
+#
+# \REXML:
+# - Is pure Ruby.
+# - Provides tree, stream, SAX2, pull, and lightweight APIs.
+# - Conforms to {XML version 1.0}[https://www.w3.org/TR/REC-xml/].
+# - Fully implements {XPath version 1.0}[http://www.w3c.org/tr/xpath].
+# - Is {non-validating}[https://www.w3.org/TR/xml/].
+# - Passes 100% of the non-validating {Oasis tests}[http://www.oasis-open.org/committees/xml-conformance/xml-test-suite.shtml].
+#
+# == In a Hurry?
+#
+# If you're somewhat familiar with XML
+# and have a particular task in mind,
+# you may want to see {the tasks pages}[doc/rexml/tasks/tocs/master_toc_rdoc.html].
+#
+# == API
+#
+# Among the most important classes for using \REXML are:
+# - REXML::Document.
+# - REXML::Element.
+#
+# There's also an {REXML tutorial}[doc/rexml/tutorial_rdoc.html].
+#
+module REXML
+ COPYRIGHT = "Copyright © 2001-2008 Sean Russell <ser@germane-software.com>"
+ DATE = "2008/019"
+ VERSION = "3.4.4"
+ REVISION = ""
+
+ Copyright = COPYRIGHT
+ Version = VERSION
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/sax2listener.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/sax2listener.rb
new file mode 100644
index 0000000..5afdc80
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/sax2listener.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: false
+module REXML
+ # A template for stream parser listeners.
+ # Note that the declarations (attlistdecl, elementdecl, etc) are trivially
+ # processed; REXML doesn't yet handle doctype entity declarations, so you
+ # have to parse them out yourself.
+ # === Missing methods from SAX2
+ # ignorable_whitespace
+ # === Methods extending SAX2
+ # +WARNING+
+ # These methods are certainly going to change, until DTDs are fully
+ # supported. Be aware of this.
+ # start_document
+ # end_document
+ # doctype
+ # elementdecl
+ # attlistdecl
+ # entitydecl
+ # notationdecl
+ # cdata
+ # xmldecl
+ # comment
+ module SAX2Listener
+ def start_document
+ end
+ def end_document
+ end
+ def start_prefix_mapping prefix, uri
+ end
+ def end_prefix_mapping prefix
+ end
+ def start_element uri, localname, qname, attributes
+ end
+ def end_element uri, localname, qname
+ end
+ def characters text
+ end
+ def processing_instruction target, data
+ end
+ # Handles a doctype declaration. Any attributes of the doctype which are
+ # not supplied will be nil. # EG, <!DOCTYPE me PUBLIC "foo" "bar">
+ # @p name the name of the doctype; EG, "me"
+ # @p pub_sys "PUBLIC", "SYSTEM", or nil. EG, "PUBLIC"
+ # @p long_name the supplied long name, or nil. EG, "foo"
+ # @p uri the uri of the doctype, or nil. EG, "bar"
+ def doctype name, pub_sys, long_name, uri
+ end
+ # If a doctype includes an ATTLIST declaration, it will cause this
+ # method to be called. The content is the declaration itself, unparsed.
+ # EG, <!ATTLIST el attr CDATA #REQUIRED> will come to this method as "el
+ # attr CDATA #REQUIRED". This is the same for all of the .*decl
+ # methods.
+ def attlistdecl(element, pairs, contents)
+ end
+ # <!ELEMENT ...>
+ def elementdecl content
+ end
+ # <!ENTITY ...>
+ # The argument passed to this method is an array of the entity
+ # declaration. It can be in a number of formats, but in general it
+ # returns (example, result):
+ # <!ENTITY % YN '"Yes"'>
+ # ["%", "YN", "\"Yes\""]
+ # <!ENTITY % YN 'Yes'>
+ # ["%", "YN", "Yes"]
+ # <!ENTITY WhatHeSaid "He said %YN;">
+ # ["WhatHeSaid", "He said %YN;"]
+ # <!ENTITY open-hatch SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
+ # ["open-hatch", "SYSTEM", "http://www.textuality.com/boilerplate/OpenHatch.xml"]
+ # <!ENTITY open-hatch PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN" "http://www.textuality.com/boilerplate/OpenHatch.xml">
+ # ["open-hatch", "PUBLIC", "-//Textuality//TEXT Standard open-hatch boilerplate//EN", "http://www.textuality.com/boilerplate/OpenHatch.xml"]
+ # <!ENTITY hatch-pic SYSTEM "../grafix/OpenHatch.gif" NDATA gif>
+ # ["hatch-pic", "SYSTEM", "../grafix/OpenHatch.gif", "NDATA", "gif"]
+ def entitydecl declaration
+ end
+ # <!NOTATION ...>
+ def notationdecl name, public_or_system, public_id, system_id
+ end
+ # Called when <![CDATA[ ... ]]> is encountered in a document.
+ # @p content "..."
+ def cdata content
+ end
+ # Called when an XML PI is encountered in the document.
+ # EG: <?xml version="1.0" encoding="utf"?>
+ # @p version the version attribute value. EG, "1.0"
+ # @p encoding the encoding attribute value, or nil. EG, "utf"
+ # @p standalone the standalone attribute value, or nil. EG, nil
+ # @p spaced the declaration is followed by a line break
+ def xmldecl version, encoding, standalone
+ end
+ # Called when a comment is encountered.
+ # @p comment The content of the comment
+ def comment comment
+ end
+ def progress position
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/security.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/security.rb
new file mode 100644
index 0000000..e8e8c6b
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/security.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: false
+module REXML
+ module Security
+ @@entity_expansion_limit = 10_000
+
+ # Set the entity expansion limit. By default the limit is set to 10000.
+ def self.entity_expansion_limit=( val )
+ @@entity_expansion_limit = val
+ end
+
+ # Get the entity expansion limit. By default the limit is set to 10000.
+ def self.entity_expansion_limit
+ @@entity_expansion_limit
+ end
+
+ @@entity_expansion_text_limit = 10_240
+
+ # Set the entity expansion limit. By default the limit is set to 10240.
+ def self.entity_expansion_text_limit=( val )
+ @@entity_expansion_text_limit = val
+ end
+
+ # Get the entity expansion limit. By default the limit is set to 10240.
+ def self.entity_expansion_text_limit
+ @@entity_expansion_text_limit
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/source.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/source.rb
new file mode 100644
index 0000000..8b8ba0d
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/source.rb
@@ -0,0 +1,388 @@
+# coding: US-ASCII
+# frozen_string_literal: false
+
+require "stringio"
+require "strscan"
+
+require_relative 'encoding'
+
+module REXML
+ if StringScanner::Version < "1.0.0"
+ module StringScannerCheckScanString
+ refine StringScanner do
+ def check(pattern)
+ pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+ super(pattern)
+ end
+
+ def scan(pattern)
+ pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+ super(pattern)
+ end
+
+ def match?(pattern)
+ pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+ super(pattern)
+ end
+
+ def skip(pattern)
+ pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+ super(pattern)
+ end
+ end
+ end
+ using StringScannerCheckScanString
+ end
+
+ # Generates Source-s. USE THIS CLASS.
+ class SourceFactory
+ # Generates a Source object
+ # @param arg Either a String, or an IO
+ # @return a Source, or nil if a bad argument was given
+ def SourceFactory::create_from(arg)
+ if arg.respond_to? :read and
+ arg.respond_to? :readline and
+ arg.respond_to? :nil? and
+ arg.respond_to? :eof?
+ IOSource.new(arg)
+ elsif arg.respond_to? :to_str
+ IOSource.new(StringIO.new(arg))
+ elsif arg.kind_of? Source
+ arg
+ else
+ raise "#{arg.class} is not a valid input stream. It must walk \n"+
+ "like either a String, an IO, or a Source."
+ end
+ end
+ end
+
+ # A Source can be searched for patterns, and wraps buffers and other
+ # objects and provides consumption of text
+ class Source
+ include Encoding
+ # The line number of the last consumed text
+ attr_reader :line
+ attr_reader :encoding
+
+ module Private
+ SPACES_PATTERN = /\s+/um
+ SCANNER_RESET_SIZE = 100000
+ PRE_DEFINED_TERM_PATTERNS = {}
+ pre_defined_terms = ["'", '"', "<", "]]>", "?>"]
+ if StringScanner::Version < "3.1.1"
+ pre_defined_terms.each do |term|
+ PRE_DEFINED_TERM_PATTERNS[term] = /#{Regexp.escape(term)}/
+ end
+ else
+ pre_defined_terms.each do |term|
+ PRE_DEFINED_TERM_PATTERNS[term] = term
+ end
+ end
+ end
+ private_constant :Private
+
+ # Constructor
+ # @param arg must be a String, and should be a valid XML document
+ # @param encoding if non-null, sets the encoding of the source to this
+ # value, overriding all encoding detection
+ def initialize(arg, encoding=nil)
+ @orig = arg
+ @scanner = StringScanner.new(@orig)
+ if encoding
+ self.encoding = encoding
+ else
+ detect_encoding
+ end
+ @line = 0
+ @encoded_terms = {}
+ end
+
+ # The current buffer (what we're going to read next)
+ def buffer
+ @scanner.rest
+ end
+
+ def drop_parsed_content
+ if @scanner.pos > Private::SCANNER_RESET_SIZE
+ @scanner.string = @scanner.rest
+ end
+ end
+
+ def buffer_encoding=(encoding)
+ @scanner.string.force_encoding(encoding)
+ end
+
+ # Inherited from Encoding
+ # Overridden to support optimized en/decoding
+ def encoding=(enc)
+ return unless super
+ encoding_updated
+ end
+
+ def read(term = nil)
+ end
+
+ def read_until(term)
+ pattern = Private::PRE_DEFINED_TERM_PATTERNS[term] || /#{Regexp.escape(term)}/
+ data = @scanner.scan_until(pattern)
+ unless data
+ data = @scanner.rest
+ @scanner.pos = @scanner.string.bytesize
+ end
+ data
+ end
+
+ def ensure_buffer
+ end
+
+ def match(pattern, cons=false)
+ if cons
+ @scanner.scan(pattern).nil? ? nil : @scanner
+ else
+ @scanner.check(pattern).nil? ? nil : @scanner
+ end
+ end
+
+ def match?(pattern, cons=false)
+ if cons
+ !@scanner.skip(pattern).nil?
+ else
+ !@scanner.match?(pattern).nil?
+ end
+ end
+
+ def skip_spaces
+ @scanner.skip(Private::SPACES_PATTERN) ? true : false
+ end
+
+ def position
+ @scanner.pos
+ end
+
+ def position=(pos)
+ @scanner.pos = pos
+ end
+
+ def peek_byte
+ @scanner.peek_byte
+ end
+
+ def scan_byte
+ @scanner.scan_byte
+ end
+
+ # @return true if the Source is exhausted
+ def empty?
+ @scanner.eos?
+ end
+
+ # @return the current line in the source
+ def current_line
+ lines = @orig.split
+ res = lines.grep @scanner.rest[0..30]
+ res = res[-1] if res.kind_of? Array
+ lines.index( res ) if res
+ end
+
+ private
+
+ def detect_encoding
+ scanner_encoding = @scanner.rest.encoding
+ detected_encoding = "UTF-8"
+ begin
+ @scanner.string.force_encoding("ASCII-8BIT")
+ if @scanner.scan(/\xfe\xff/n)
+ detected_encoding = "UTF-16BE"
+ elsif @scanner.scan(/\xff\xfe/n)
+ detected_encoding = "UTF-16LE"
+ elsif @scanner.scan(/\xef\xbb\xbf/n)
+ detected_encoding = "UTF-8"
+ end
+ ensure
+ @scanner.string.force_encoding(scanner_encoding)
+ end
+ self.encoding = detected_encoding
+ end
+
+ def encoding_updated
+ if @encoding != 'UTF-8'
+ @scanner.string = decode(@scanner.rest)
+ @to_utf = true
+ else
+ @to_utf = false
+ @scanner.string.force_encoding(::Encoding::UTF_8)
+ end
+ end
+ end
+
+ # A Source that wraps an IO. See the Source class for method
+ # documentation
+ class IOSource < Source
+ #attr_reader :block_size
+
+ # block_size has been deprecated
+ def initialize(arg, block_size=500, encoding=nil)
+ @er_source = @source = arg
+ @to_utf = false
+ @pending_buffer = nil
+
+ if encoding
+ super("", encoding)
+ else
+ super(@source.read(3) || "")
+ end
+
+ if !@to_utf and
+ @orig.respond_to?(:force_encoding) and
+ @source.respond_to?(:external_encoding) and
+ @source.external_encoding != ::Encoding::UTF_8
+ @force_utf8 = true
+ else
+ @force_utf8 = false
+ end
+ end
+
+ def read(term = nil, min_bytes = 1)
+ term = encode(term) if term
+ begin
+ str = readline(term)
+ @scanner << str
+ read_bytes = str.bytesize
+ begin
+ while read_bytes < min_bytes
+ str = readline(term)
+ @scanner << str
+ read_bytes += str.bytesize
+ end
+ rescue IOError
+ end
+ true
+ rescue Exception, NameError
+ @source = nil
+ false
+ end
+ end
+
+ def read_until(term)
+ pattern = Private::PRE_DEFINED_TERM_PATTERNS[term] || /#{Regexp.escape(term)}/
+ term = @encoded_terms[term] ||= encode(term)
+ until str = @scanner.scan_until(pattern)
+ break if @source.nil?
+ break if @source.eof?
+ @scanner << readline(term)
+ end
+ if str
+ read if @scanner.eos? and @source and !@source.eof?
+ str
+ else
+ rest = @scanner.rest
+ @scanner.pos = @scanner.string.bytesize
+ rest
+ end
+ end
+
+ def ensure_buffer
+ read if @scanner.eos? && @source
+ end
+
+ def match( pattern, cons=false )
+ # To avoid performance issue, we need to increase bytes to read per scan
+ min_bytes = 1
+ while true
+ if cons
+ md = @scanner.scan(pattern)
+ else
+ md = @scanner.check(pattern)
+ end
+ break if md
+ return nil if pattern.is_a?(String)
+ return nil if @source.nil?
+ return nil unless read(nil, min_bytes)
+ min_bytes *= 2
+ end
+
+ md.nil? ? nil : @scanner
+ end
+
+ def match?( pattern, cons=false )
+ # To avoid performance issue, we need to increase bytes to read per scan
+ min_bytes = 1
+ while true
+ if cons
+ n_matched_bytes = @scanner.skip(pattern)
+ else
+ n_matched_bytes = @scanner.match?(pattern)
+ end
+ return true if n_matched_bytes
+ return false if pattern.is_a?(String)
+ return false if @source.nil?
+ return false unless read(nil, min_bytes)
+ min_bytes *= 2
+ end
+ end
+
+ def empty?
+ super and ( @source.nil? || @source.eof? )
+ end
+
+ # @return the current line in the source
+ def current_line
+ begin
+ pos = @er_source.pos # The byte position in the source
+ lineno = @er_source.lineno # The XML < position in the source
+ @er_source.rewind
+ line = 0 # The \r\n position in the source
+ begin
+ while @er_source.pos < pos
+ @er_source.readline
+ line += 1
+ end
+ rescue
+ end
+ @er_source.seek(pos)
+ rescue IOError, SystemCallError
+ pos = -1
+ line = -1
+ end
+ [pos, lineno, line]
+ end
+
+ private
+ def readline(term = nil)
+ if @pending_buffer
+ begin
+ str = @source.readline(term || @line_break)
+ rescue IOError
+ end
+ if str.nil?
+ str = @pending_buffer
+ else
+ str = @pending_buffer + str
+ end
+ @pending_buffer = nil
+ else
+ str = @source.readline(term || @line_break)
+ end
+ return nil if str.nil?
+
+ if @to_utf
+ decode(str)
+ else
+ str.force_encoding(::Encoding::UTF_8) if @force_utf8
+ str
+ end
+ end
+
+ def encoding_updated
+ case @encoding
+ when "UTF-16BE", "UTF-16LE"
+ @source.binmode
+ @source.set_encoding(@encoding, @encoding)
+ end
+ @line_break = encode(">")
+ @pending_buffer, @scanner.string = @scanner.rest, ""
+ @pending_buffer.force_encoding(@encoding)
+ super
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/streamlistener.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/streamlistener.rb
new file mode 100644
index 0000000..30c8945
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/streamlistener.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: false
+module REXML
+ # A template for stream parser listeners.
+ # Note that the declarations (attlistdecl, elementdecl, etc) are trivially
+ # processed; REXML doesn't yet handle doctype entity declarations, so you
+ # have to parse them out yourself.
+ module StreamListener
+ # Called when a tag is encountered.
+ # @p name the tag name
+ # @p attrs an array of arrays of attribute/value pairs, suitable for
+ # use with assoc or rassoc. IE, <tag attr1="value1" attr2="value2">
+ # will result in
+ # tag_start( "tag", # [["attr1","value1"],["attr2","value2"]])
+ def tag_start name, attrs
+ end
+ # Called when the end tag is reached. In the case of <tag/>, tag_end
+ # will be called immediately after tag_start
+ # @p the name of the tag
+ def tag_end name
+ end
+ # Called when text is encountered in the document
+ # @p text the text content.
+ def text text
+ end
+ # Called when an instruction is encountered. EG: <?xsl sheet='foo'?>
+ # @p name the instruction name; in the example, "xsl"
+ # @p instruction the rest of the instruction. In the example,
+ # "sheet='foo'"
+ def instruction name, instruction
+ end
+ # Called when a comment is encountered.
+ # @p comment The content of the comment
+ def comment comment
+ end
+ # Handles a doctype declaration. Any attributes of the doctype which are
+ # not supplied will be nil. # EG, <!DOCTYPE me PUBLIC "foo" "bar">
+ # @p name the name of the doctype; EG, "me"
+ # @p pub_sys "PUBLIC", "SYSTEM", or nil. EG, "PUBLIC"
+ # @p long_name the supplied long name, or nil. EG, "foo"
+ # @p uri the uri of the doctype, or nil. EG, "bar"
+ def doctype name, pub_sys, long_name, uri
+ end
+ # Called when the doctype is done
+ def doctype_end
+ end
+ # If a doctype includes an ATTLIST declaration, it will cause this
+ # method to be called. The content is the declaration itself, unparsed.
+ # EG, <!ATTLIST el attr CDATA #REQUIRED> will come to this method as "el
+ # attr CDATA #REQUIRED". This is the same for all of the .*decl
+ # methods.
+ def attlistdecl element_name, attributes, raw_content
+ end
+ # <!ELEMENT ...>
+ def elementdecl content
+ end
+ # <!ENTITY ...>
+ # The argument passed to this method is an array of the entity
+ # declaration. It can be in a number of formats, but in general it
+ # returns (example, result):
+ # <!ENTITY % YN '"Yes"'>
+ # ["YN", "\"Yes\"", "%"]
+ # <!ENTITY % YN 'Yes'>
+ # ["YN", "Yes", "%"]
+ # <!ENTITY WhatHeSaid "He said %YN;">
+ # ["WhatHeSaid", "He said %YN;"]
+ # <!ENTITY open-hatch SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
+ # ["open-hatch", "SYSTEM", "http://www.textuality.com/boilerplate/OpenHatch.xml"]
+ # <!ENTITY open-hatch PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN" "http://www.textuality.com/boilerplate/OpenHatch.xml">
+ # ["open-hatch", "PUBLIC", "-//Textuality//TEXT Standard open-hatch boilerplate//EN", "http://www.textuality.com/boilerplate/OpenHatch.xml"]
+ # <!ENTITY hatch-pic SYSTEM "../grafix/OpenHatch.gif" NDATA gif>
+ # ["hatch-pic", "SYSTEM", "../grafix/OpenHatch.gif", "gif"]
+ def entitydecl content
+ end
+ # <!NOTATION ...>
+ def notationdecl content
+ end
+ # Called when %foo; is encountered in a doctype declaration.
+ # @p content "foo"
+ def entity content
+ end
+ # Called when <![CDATA[ ... ]]> is encountered in a document.
+ # @p content "..."
+ def cdata content
+ end
+ # Called when an XML PI is encountered in the document.
+ # EG: <?xml version="1.0" encoding="utf"?>
+ # @p version the version attribute value. EG, "1.0"
+ # @p encoding the encoding attribute value, or nil. EG, "utf"
+ # @p standalone the standalone attribute value, or nil. EG, nil
+ def xmldecl version, encoding, standalone
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/text.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/text.rb
new file mode 100644
index 0000000..8d5281c
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/text.rb
@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+require_relative 'security'
+require_relative 'entity'
+require_relative 'doctype'
+require_relative 'child'
+require_relative 'doctype'
+require_relative 'parseexception'
+
+module REXML
+ # Represents text nodes in an XML document
+ class Text < Child
+ include Comparable
+ # The order in which the substitutions occur
+ SPECIALS = [ /&(?!#?[\w-]+;)/u, /</u, />/u, /"/u, /'/u, /\r/u ]
+ SUBSTITUTES = ['&', '<', '>', '"', ''', '
']
+ # Characters which are substituted in written strings
+ SLAICEPS = [ '<', '>', '"', "'", '&' ]
+ SETUTITSBUS = [ /</u, />/u, /"/u, /'/u, /&/u ]
+
+ # If +raw+ is true, then REXML leaves the value alone
+ attr_accessor :raw
+
+ NEEDS_A_SECOND_CHECK = /(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um
+ NUMERICENTITY = /�*((?:\d+)|(?:x[a-fA-F0-9]+));/
+ VALID_CHAR = [
+ 0x9, 0xA, 0xD,
+ (0x20..0xD7FF),
+ (0xE000..0xFFFD),
+ (0x10000..0x10FFFF)
+ ]
+
+ VALID_XML_CHARS = Regexp.new('^['+
+ VALID_CHAR.map { |item|
+ case item
+ when Integer
+ [item].pack('U').force_encoding('utf-8')
+ when Range
+ [item.first, '-'.ord, item.last].pack('UUU').force_encoding('utf-8')
+ end
+ }.join +
+ ']*$')
+
+ # Constructor
+ # +arg+ if a String, the content is set to the String. If a Text,
+ # the object is shallowly cloned.
+ #
+ # +respect_whitespace+ (boolean, false) if true, whitespace is
+ # respected
+ #
+ # +parent+ (nil) if this is a Parent object, the parent
+ # will be set to this.
+ #
+ # +raw+ (nil) This argument can be given three values.
+ # If true, then the value of used to construct this object is expected to
+ # contain no unescaped XML markup, and REXML will not change the text. If
+ # this value is false, the string may contain any characters, and REXML will
+ # escape any and all defined entities whose values are contained in the
+ # text. If this value is nil (the default), then the raw value of the
+ # parent will be used as the raw value for this node. If there is no raw
+ # value for the parent, and no value is supplied, the default is false.
+ # Use this field if you have entities defined for some text, and you don't
+ # want REXML to escape that text in output.
+ # Text.new( "<&", false, nil, false ) #-> "<&"
+ # Text.new( "<&", false, nil, false ) #-> "<&"
+ # Text.new( "<&", false, nil, true ) #-> Parse exception
+ # Text.new( "<&", false, nil, true ) #-> "<&"
+ # # Assume that the entity "s" is defined to be "sean"
+ # # and that the entity "r" is defined to be "russell"
+ # Text.new( "sean russell" ) #-> "&s; &r;"
+ # Text.new( "sean russell", false, nil, true ) #-> "sean russell"
+ #
+ # +entity_filter+ (nil) This can be an array of entities to match in the
+ # supplied text. This argument is only useful if +raw+ is set to false.
+ # Text.new( "sean russell", false, nil, false, ["s"] ) #-> "&s; russell"
+ # Text.new( "sean russell", false, nil, true, ["s"] ) #-> "sean russell"
+ # In the last example, the +entity_filter+ argument is ignored.
+ #
+ # +illegal+ INTERNAL USE ONLY
+ def initialize(arg, respect_whitespace=false, parent=nil, raw=nil,
+ entity_filter=nil, illegal=NEEDS_A_SECOND_CHECK )
+
+ @raw = false
+ @parent = nil
+ @entity_filter = nil
+
+ if parent
+ super( parent )
+ @raw = parent.raw
+ end
+
+ if arg.kind_of? String
+ @string = arg.dup
+ elsif arg.kind_of? Text
+ @string = arg.instance_variable_get(:@string).dup
+ @raw = arg.raw
+ @entity_filter = arg.instance_variable_get(:@entity_filter)
+ else
+ raise "Illegal argument of type #{arg.type} for Text constructor (#{arg})"
+ end
+
+ @string.squeeze!(" \n\t") unless respect_whitespace
+ @string.gsub!(/\r\n?/, "\n")
+ @raw = raw unless raw.nil?
+ @entity_filter = entity_filter if entity_filter
+ clear_cache
+
+ Text.check(@string, illegal) if @raw
+ end
+
+ def parent= parent
+ super(parent)
+ Text.check(@string, NEEDS_A_SECOND_CHECK) if @raw and @parent
+ end
+
+ # check for illegal characters
+ def Text.check string, pattern, doctype = nil
+
+ # illegal anywhere
+ if !string.match?(VALID_XML_CHARS)
+ string.chars.each do |c|
+ case c.ord
+ when *VALID_CHAR
+ else
+ raise "Illegal character #{c.inspect} in raw string #{string.inspect}"
+ end
+ end
+ end
+
+ pos = 0
+ while (index = string.index(/<|&/, pos))
+ if string[index] == "<"
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ end
+
+ unless (end_index = string.index(/[^\s];/, index + 1))
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ end
+
+ value = string[(index + 1)..end_index]
+ if /\s/.match?(value)
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ end
+
+ if value[0] == "#"
+ character_reference = value[1..-1]
+
+ unless (/\A(\d+|x[0-9a-fA-F]+)\z/.match?(character_reference))
+ if character_reference[0] == "x" || character_reference[-1] == "x"
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ else
+ raise "Illegal character #{string.inspect} in raw string #{string.inspect}"
+ end
+ end
+
+ case (character_reference[0] == "x" ? character_reference[1..-1].to_i(16) : character_reference[0..-1].to_i)
+ when *VALID_CHAR
+ else
+ raise "Illegal character #{string.inspect} in raw string #{string.inspect}"
+ end
+ elsif !(/\A#{Entity::NAME}\z/um.match?(value))
+ raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+ end
+
+ pos = end_index + 1
+ end
+
+ string
+ end
+
+ def node_type
+ :text
+ end
+
+ def empty?
+ @string.size==0
+ end
+
+
+ def clone
+ Text.new(self, true)
+ end
+
+
+ # Appends text to this text node. The text is appended in the +raw+ mode
+ # of this text node.
+ #
+ # +returns+ the text itself to enable method chain like
+ # 'text << "XXX" << "YYY"'.
+ def <<( to_append )
+ @string << to_append.gsub( /\r\n?/, "\n" )
+ clear_cache
+ self
+ end
+
+
+ # +other+ a String or a Text
+ # +returns+ the result of (to_s <=> arg.to_s)
+ def <=>( other )
+ to_s() <=> other.to_s
+ end
+
+ def doctype
+ @parent&.document&.doctype
+ end
+
+ REFERENCE = /#{Entity::REFERENCE}/
+ # Returns the string value of this text node. This string is always
+ # escaped, meaning that it is a valid XML text node string, and all
+ # entities that can be escaped, have been inserted. This method respects
+ # the entity filter set in the constructor.
+ #
+ # # Assume that the entity "s" is defined to be "sean", and that the
+ # # entity "r" is defined to be "russell"
+ # t = Text.new( "< & sean russell", false, nil, false, ['s'] )
+ # t.to_s #-> "< & &s; russell"
+ # t = Text.new( "< & &s; russell", false, nil, false )
+ # t.to_s #-> "< & &s; russell"
+ # u = Text.new( "sean russell", false, nil, true )
+ # u.to_s #-> "sean russell"
+ def to_s
+ return @string if @raw
+ @normalized ||= Text::normalize( @string, doctype, @entity_filter )
+ end
+
+ def inspect
+ @string.inspect
+ end
+
+ # Returns the string value of this text. This is the text without
+ # entities, as it might be used programmatically, or printed to the
+ # console. This ignores the 'raw' attribute setting, and any
+ # entity_filter.
+ #
+ # # Assume that the entity "s" is defined to be "sean", and that the
+ # # entity "r" is defined to be "russell"
+ # t = Text.new( "< & sean russell", false, nil, false, ['s'] )
+ # t.value #-> "< & sean russell"
+ # t = Text.new( "< & &s; russell", false, nil, false )
+ # t.value #-> "< & sean russell"
+ # u = Text.new( "sean russell", false, nil, true )
+ # u.value #-> "sean russell"
+ def value
+ @unnormalized ||= Text::unnormalize(@string, doctype,
+ entity_expansion_text_limit: document&.entity_expansion_text_limit)
+ end
+
+ # Sets the contents of this text node. This expects the text to be
+ # unnormalized. It returns self.
+ #
+ # e = Element.new( "a" )
+ # e.add_text( "foo" ) # <a>foo</a>
+ # e[0].value = "bar" # <a>bar</a>
+ # e[0].value = "<a>" # <a><a></a>
+ def value=( val )
+ @string = val.gsub( /\r\n?/, "\n" )
+ clear_cache
+ @raw = false
+ end
+
+ def wrap(string, width, addnewline=false)
+ # Recursively wrap string at width.
+ return string if string.length <= width
+ place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
+ if addnewline
+ "\n" + string[0,place] + "\n" + wrap(string[place+1..-1], width)
+ else
+ string[0,place] + "\n" + wrap(string[place+1..-1], width)
+ end
+ end
+
+ def indent_text(string, level=1, style="\t", indentfirstline=true)
+ Kernel.warn("#{self.class.name}#indent_text is deprecated. See REXML::Formatters", uplevel: 1)
+ return string if level < 0
+
+ new_string = +''
+ string.each_line { |line|
+ indent_string = style * level
+ new_line = (indent_string + line).sub(/[\s]+$/,'')
+ new_string << new_line
+ }
+ new_string.strip! unless indentfirstline
+ new_string
+ end
+
+ # == DEPRECATED
+ # See REXML::Formatters
+ #
+ def write( writer, indent=-1, transitive=false, ie_hack=false )
+ Kernel.warn("#{self.class.name}#write is deprecated. See REXML::Formatters", uplevel: 1)
+ formatter = if indent > -1
+ REXML::Formatters::Pretty.new( indent )
+ else
+ REXML::Formatters::Default.new
+ end
+ formatter.write( self, writer )
+ end
+
+ # FIXME
+ # This probably won't work properly
+ def xpath
+ @parent.xpath + "/text()"
+ end
+
+ # Writes out text, substituting special characters beforehand.
+ # +out+ A String, IO, or any other object supporting <<( String )
+ # +input+ the text to substitute and the write out
+ #
+ # z=utf8.unpack("U*")
+ # ascOut=""
+ # z.each{|r|
+ # if r < 0x100
+ # ascOut.concat(r.chr)
+ # else
+ # ascOut.concat(sprintf("&#x%x;", r))
+ # end
+ # }
+ # puts ascOut
+ def write_with_substitution out, input
+ copy = input.clone
+ # Doing it like this rather than in a loop improves the speed
+ copy.gsub!( SPECIALS[0], SUBSTITUTES[0] )
+ copy.gsub!( SPECIALS[1], SUBSTITUTES[1] )
+ copy.gsub!( SPECIALS[2], SUBSTITUTES[2] )
+ copy.gsub!( SPECIALS[3], SUBSTITUTES[3] )
+ copy.gsub!( SPECIALS[4], SUBSTITUTES[4] )
+ copy.gsub!( SPECIALS[5], SUBSTITUTES[5] )
+ out << copy
+ end
+
+ private
+ def clear_cache
+ @normalized = nil
+ @unnormalized = nil
+ end
+
+ # Reads text, substituting entities
+ def Text::read_with_substitution( input, illegal=nil )
+ copy = input.clone
+
+ if copy =~ illegal
+ raise ParseException.new( "malformed text: Illegal character #$& in \"#{copy}\"" )
+ end if illegal
+
+ copy.gsub!( /\r\n?/, "\n" )
+ if copy.include? ?&
+ copy.gsub!( SETUTITSBUS[0], SLAICEPS[0] )
+ copy.gsub!( SETUTITSBUS[1], SLAICEPS[1] )
+ copy.gsub!( SETUTITSBUS[2], SLAICEPS[2] )
+ copy.gsub!( SETUTITSBUS[3], SLAICEPS[3] )
+ copy.gsub!( SETUTITSBUS[4], SLAICEPS[4] )
+ copy.gsub!( /�*((?:\d+)|(?:x[a-f0-9]+));/ ) {
+ m=$1
+ #m='0' if m==''
+ m = "0#{m}" if m[0] == ?x
+ [Integer(m)].pack('U*')
+ }
+ end
+ copy
+ end
+
+ EREFERENCE = /&(?!#{Entity::NAME};)/
+ # Escapes all possible entities
+ def Text::normalize( input, doctype=nil, entity_filter=nil )
+ copy = input.to_s
+ # Doing it like this rather than in a loop improves the speed
+ #copy = copy.gsub( EREFERENCE, '&' )
+ copy = copy.gsub( "&", "&" ) if copy.include?("&")
+ if doctype
+ # Replace all ampersands that aren't part of an entity
+ doctype.entities.each_value do |entity|
+ copy = copy.gsub( entity.value,
+ "&#{entity.name};" ) if entity.value and
+ not( entity_filter and entity_filter.include?(entity.name) )
+ end
+ else
+ # Replace all ampersands that aren't part of an entity
+ DocType::DEFAULT_ENTITIES.each_value do |entity|
+ if copy.include?(entity.value)
+ copy = copy.gsub(entity.value, "&#{entity.name};" )
+ end
+ end
+ end
+ copy
+ end
+
+ # Unescapes all possible entities
+ def Text::unnormalize( string, doctype=nil, filter=nil, illegal=nil, entity_expansion_text_limit: nil )
+ entity_expansion_text_limit ||= Security.entity_expansion_text_limit
+ sum = 0
+ string.gsub( /\r\n?/, "\n" ).gsub( REFERENCE ) {
+ s = Text.expand($&, doctype, filter)
+ if sum + s.bytesize > entity_expansion_text_limit
+ raise "entity expansion has grown too large"
+ else
+ sum += s.bytesize
+ end
+ s
+ }
+ end
+
+ def Text.expand(ref, doctype, filter)
+ if ref[1] == ?#
+ if ref[2] == ?x
+ [ref[3...-1].to_i(16)].pack('U*')
+ else
+ [ref[2...-1].to_i].pack('U*')
+ end
+ elsif ref == '&'
+ '&'
+ elsif filter and filter.include?( ref[1...-1] )
+ ref
+ elsif doctype
+ doctype.entity( ref[1...-1] ) or ref
+ else
+ entity_value = DocType::DEFAULT_ENTITIES[ ref[1...-1] ]
+ entity_value ? entity_value.value : ref
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/undefinednamespaceexception.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/undefinednamespaceexception.rb
new file mode 100644
index 0000000..492a098
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/undefinednamespaceexception.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: false
+require_relative 'parseexception'
+module REXML
+ class UndefinedNamespaceException < ParseException
+ def initialize( prefix, source, parser )
+ super( "Undefined prefix #{prefix} found" )
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/validation/relaxng.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/validation/relaxng.rb
new file mode 100644
index 0000000..c6894dc
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/validation/relaxng.rb
@@ -0,0 +1,540 @@
+# frozen_string_literal: false
+require_relative "validation"
+require_relative "../parsers/baseparser"
+
+module REXML
+ module Validation
+ # Implemented:
+ # * empty
+ # * element
+ # * attribute
+ # * text
+ # * optional
+ # * choice
+ # * oneOrMore
+ # * zeroOrMore
+ # * group
+ # * value
+ # * interleave
+ # * mixed
+ # * ref
+ # * grammar
+ # * start
+ # * define
+ #
+ # Not implemented:
+ # * data
+ # * param
+ # * include
+ # * externalRef
+ # * notAllowed
+ # * anyName
+ # * nsName
+ # * except
+ # * name
+ class RelaxNG
+ include Validator
+
+ INFINITY = 1.0 / 0.0
+ EMPTY = Event.new( nil )
+ TEXT = [:start_element, "text"]
+ attr_accessor :current
+ attr_accessor :count
+ attr_reader :references
+
+ # FIXME: Namespaces
+ def initialize source
+ parser = REXML::Parsers::BaseParser.new( source )
+
+ @count = 0
+ @references = {}
+ @root = @current = Sequence.new(self)
+ @root.previous = true
+ states = [ @current ]
+ begin
+ event = parser.pull
+ case event[0]
+ when :start_element
+ case event[1]
+ when "empty"
+ when "element", "attribute", "text", "value"
+ states[-1] << event
+ when "optional"
+ states << Optional.new( self )
+ states[-2] << states[-1]
+ when "choice"
+ states << Choice.new( self )
+ states[-2] << states[-1]
+ when "oneOrMore"
+ states << OneOrMore.new( self )
+ states[-2] << states[-1]
+ when "zeroOrMore"
+ states << ZeroOrMore.new( self )
+ states[-2] << states[-1]
+ when "group"
+ states << Sequence.new( self )
+ states[-2] << states[-1]
+ when "interleave"
+ states << Interleave.new( self )
+ states[-2] << states[-1]
+ when "mixed"
+ states << Interleave.new( self )
+ states[-2] << states[-1]
+ states[-1] << TEXT
+ when "define"
+ states << [ event[2]["name"] ]
+ when "ref"
+ states[-1] << Ref.new( event[2]["name"] )
+ when "anyName"
+ states << AnyName.new( self )
+ states[-2] << states[-1]
+ when "nsName"
+ when "except"
+ when "name"
+ when "data"
+ when "param"
+ when "include"
+ when "grammar"
+ when "start"
+ when "externalRef"
+ when "notAllowed"
+ end
+ when :end_element
+ case event[1]
+ when "element", "attribute"
+ states[-1] << event
+ when "zeroOrMore", "oneOrMore", "choice", "optional",
+ "interleave", "group", "mixed"
+ states.pop
+ when "define"
+ ref = states.pop
+ @references[ ref.shift ] = ref
+ #when "empty"
+ end
+ when :end_document
+ states[-1] << event
+ when :text
+ states[-1] << event
+ end
+ end while event[0] != :end_document
+ end
+
+ def receive event
+ validate( event )
+ end
+ end
+
+ class State
+ def initialize( context )
+ @previous = []
+ @events = []
+ @current = 0
+ @count = context.count += 1
+ @references = context.references
+ @value = false
+ end
+
+ def reset
+ return if @current == 0
+ @current = 0
+ @events.each {|s| s.reset if s.kind_of? State }
+ end
+
+ def previous=( previous )
+ @previous << previous
+ end
+
+ def next( event )
+ #print "In next with #{event.inspect}. "
+ #p @previous
+ return @previous.pop.next( event ) if @events[@current].nil?
+ expand_ref_in( @events, @current ) if @events[@current].class == Ref
+ if ( @events[@current].kind_of? State )
+ @current += 1
+ @events[@current-1].previous = self
+ return @events[@current-1].next( event )
+ end
+ if ( @events[@current].matches?(event) )
+ @current += 1
+ if @events[@current].nil?
+ @previous.pop
+ elsif @events[@current].kind_of? State
+ @current += 1
+ @events[@current-1].previous = self
+ @events[@current-1]
+ else
+ self
+ end
+ else
+ nil
+ end
+ end
+
+ def to_s
+ # Abbreviated:
+ self.class.name =~ /(?:::)(\w)\w+$/
+ # Full:
+ #self.class.name =~ /(?:::)(\w+)$/
+ "#$1.#@count"
+ end
+
+ def inspect
+ "< #{to_s} #{@events.collect{|e|
+ pre = e == @events[@current] ? '#' : ''
+ pre + e.inspect unless self == e
+ }.join(', ')} >"
+ end
+
+ def expected
+ [@events[@current]]
+ end
+
+ def <<( event )
+ add_event_to_arry( @events, event )
+ end
+
+
+ protected
+ def expand_ref_in( arry, ind )
+ new_events = []
+ @references[ arry[ind].to_s ].each{ |evt|
+ add_event_to_arry(new_events,evt)
+ }
+ arry[ind,1] = new_events
+ end
+
+ def add_event_to_arry( arry, evt )
+ evt = generate_event( evt )
+ if evt.kind_of? String
+ arry[-1].event_arg = evt if arry[-1].kind_of? Event and @value
+ @value = false
+ else
+ arry << evt
+ end
+ end
+
+ def generate_event( event )
+ return event if event.kind_of? State or event.class == Ref
+ evt = nil
+ arg = nil
+ case event[0]
+ when :start_element
+ case event[1]
+ when "element"
+ evt = :start_element
+ arg = event[2]["name"]
+ when "attribute"
+ evt = :start_attribute
+ arg = event[2]["name"]
+ when "text"
+ evt = :text
+ when "value"
+ evt = :text
+ @value = true
+ end
+ when :text
+ return event[1]
+ when :end_document
+ return Event.new( event[0] )
+ else # then :end_element
+ case event[1]
+ when "element"
+ evt = :end_element
+ when "attribute"
+ evt = :end_attribute
+ end
+ end
+ Event.new( evt, arg )
+ end
+ end
+
+
+ class Sequence < State
+ def matches?(event)
+ @events[@current].matches?( event )
+ end
+ end
+
+
+ class Optional < State
+ def next( event )
+ if @current == 0
+ rv = super
+ return rv if rv
+ @prior = @previous.pop
+ @prior.next( event )
+ else
+ super
+ end
+ end
+
+ def matches?(event)
+ @events[@current].matches?(event) ||
+ (@current == 0 and @previous[-1].matches?(event))
+ end
+
+ def expected
+ return [ @prior.expected, @events[0] ].flatten if @current == 0
+ [@events[@current]]
+ end
+ end
+
+
+ class ZeroOrMore < Optional
+ def next( event )
+ expand_ref_in( @events, @current ) if @events[@current].class == Ref
+ if ( @events[@current].matches?(event) )
+ @current += 1
+ if @events[@current].nil?
+ @current = 0
+ self
+ elsif @events[@current].kind_of? State
+ @current += 1
+ @events[@current-1].previous = self
+ @events[@current-1]
+ else
+ self
+ end
+ else
+ @prior = @previous.pop
+ return @prior.next( event ) if @current == 0
+ nil
+ end
+ end
+
+ def expected
+ return [ @prior.expected, @events[0] ].flatten if @current == 0
+ [@events[@current]]
+ end
+ end
+
+
+ class OneOrMore < State
+ def initialize context
+ super
+ @ord = 0
+ end
+
+ def reset
+ super
+ @ord = 0
+ end
+
+ def next( event )
+ expand_ref_in( @events, @current ) if @events[@current].class == Ref
+ if ( @events[@current].matches?(event) )
+ @current += 1
+ @ord += 1
+ if @events[@current].nil?
+ @current = 0
+ self
+ elsif @events[@current].kind_of? State
+ @current += 1
+ @events[@current-1].previous = self
+ @events[@current-1]
+ else
+ self
+ end
+ else
+ return @previous.pop.next( event ) if @current == 0 and @ord > 0
+ nil
+ end
+ end
+
+ def matches?( event )
+ @events[@current].matches?(event) ||
+ (@current == 0 and @ord > 0 and @previous[-1].matches?(event))
+ end
+
+ def expected
+ if @current == 0 and @ord > 0
+ [@previous[-1].expected, @events[0]].flatten
+ else
+ [@events[@current]]
+ end
+ end
+ end
+
+
+ class Choice < State
+ def initialize context
+ super
+ @choices = []
+ end
+
+ def reset
+ super
+ @events = []
+ @choices.each { |c| c.each { |s| s.reset if s.kind_of? State } }
+ end
+
+ def <<( event )
+ add_event_to_arry( @choices, event )
+ end
+
+ def next( event )
+ # Make the choice if we haven't
+ if @events.size == 0
+ c = 0 ; max = @choices.size
+ while c < max
+ if @choices[c][0].class == Ref
+ expand_ref_in( @choices[c], 0 )
+ @choices += @choices[c]
+ @choices.delete( @choices[c] )
+ max -= 1
+ else
+ c += 1
+ end
+ end
+ @events = @choices.find { |evt| evt[0].matches? event }
+ # Remove the references
+ # Find the events
+ end
+ unless @events
+ @events = []
+ return nil
+ end
+ super
+ end
+
+ def matches?( event )
+ return @events[@current].matches?( event ) if @events.size > 0
+ !@choices.find{|evt| evt[0].matches?(event)}.nil?
+ end
+
+ def expected
+ return [@events[@current]] if @events.size > 0
+ @choices.collect do |x|
+ if x[0].kind_of? State
+ x[0].expected
+ else
+ x[0]
+ end
+ end.flatten
+ end
+
+ def inspect
+ "< #{to_s} #{@choices.collect{|e| e.collect{|f|f.to_s}.join(', ')}.join(' or ')} >"
+ end
+
+ protected
+ def add_event_to_arry( arry, evt )
+ if evt.kind_of? State or evt.class == Ref
+ arry << [evt]
+ elsif evt[0] == :text
+ if arry[-1] and
+ arry[-1][-1].kind_of?( Event ) and
+ arry[-1][-1].event_type == :text and @value
+
+ arry[-1][-1].event_arg = evt[1]
+ @value = false
+ end
+ else
+ arry << [] if evt[0] == :start_element
+ arry[-1] << generate_event( evt )
+ end
+ end
+ end
+
+
+ class Interleave < Choice
+ def initialize context
+ super
+ @choice = 0
+ end
+
+ def reset
+ @choice = 0
+ end
+
+ def next_current( event )
+ # Expand references
+ c = 0 ; max = @choices.size
+ while c < max
+ if @choices[c][0].class == Ref
+ expand_ref_in( @choices[c], 0 )
+ @choices += @choices[c]
+ @choices.delete( @choices[c] )
+ max -= 1
+ else
+ c += 1
+ end
+ end
+ @events = @choices[@choice..-1].find { |evt| evt[0].matches? event }
+ @current = 0
+ if @events
+ # reorder the choices
+ old = @choices[@choice]
+ idx = @choices.index( @events )
+ @choices[@choice] = @events
+ @choices[idx] = old
+ @choice += 1
+ end
+
+ @events = [] unless @events
+ end
+
+
+ def next( event )
+ # Find the next series
+ next_current(event) unless @events[@current]
+ return nil unless @events[@current]
+
+ expand_ref_in( @events, @current ) if @events[@current].class == Ref
+ if ( @events[@current].kind_of? State )
+ @current += 1
+ @events[@current-1].previous = self
+ return @events[@current-1].next( event )
+ end
+ return @previous.pop.next( event ) if @events[@current].nil?
+ if ( @events[@current].matches?(event) )
+ @current += 1
+ if @events[@current].nil?
+ return self unless @choices[@choice].nil?
+ @previous.pop
+ elsif @events[@current].kind_of? State
+ @current += 1
+ @events[@current-1].previous = self
+ @events[@current-1]
+ else
+ self
+ end
+ else
+ nil
+ end
+ end
+
+ def matches?( event )
+ return @events[@current].matches?( event ) if @events[@current]
+ !@choices[@choice..-1].find{|evt| evt[0].matches?(event)}.nil?
+ end
+
+ def expected
+ return [@events[@current]] if @events[@current]
+ @choices[@choice..-1].collect do |x|
+ if x[0].kind_of? State
+ x[0].expected
+ else
+ x[0]
+ end
+ end.flatten
+ end
+
+ def inspect
+ "< #{to_s} #{@choices.collect{|e| e.collect{|f|f.to_s}.join(', ')}.join(' and ')} >"
+ end
+ end
+
+ class Ref
+ def initialize value
+ @value = value
+ end
+ def to_s
+ @value
+ end
+ def inspect
+ "{#{to_s}}"
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/validation/validation.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/validation/validation.rb
new file mode 100644
index 0000000..6475c62
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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?
+ (@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
+ true
+ when :start_element
+ event[1] == @event_arg
+ when :end_element
+ true
+ when :start_attribute
+ event[1] == @event_arg
+ when :end_attribute
+ true
+ when :end_document
+ true
+ when :text
+ @event_arg.nil? || @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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/validation/validationexception.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/validation/validationexception.rb
new file mode 100644
index 0000000..78cd63f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xmldecl.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xmldecl.rb
new file mode 100644
index 0000000..d19407c
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xmltokens.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xmltokens.rb
new file mode 100644
index 0000000..392b47b
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.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
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xpath.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xpath.rb
new file mode 100644
index 0000000..eed0300
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xpath.rb
@@ -0,0 +1,70 @@
+# 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)
+ match(element, path, namespaces, variables, options).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)
+ match(element, path, namespaces, variables, options).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
+ parser.parse(path,element)
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xpath_parser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xpath_parser.rb
new file mode 100644
index 0000000..64c8846
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/rexml-3.4.4/lib/rexml/xpath_parser.rb
@@ -0,0 +1,980 @@
+# frozen_string_literal: false
+
+require "pp"
+
+require_relative 'namespace'
+require_relative 'xmltokens'
+require_relative 'attribute'
+require_relative 'parsers/xpathparser'
+
+module REXML
+ module DClonable
+ refine Object do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone
+ clone
+ end
+ end
+ refine Symbol do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone ; self ; end
+ end
+ refine Integer do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone ; self ; end
+ end
+ refine Float do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object types
+ def dclone ; self ; end
+ end
+ refine Array do
+ # provides a unified +clone+ operation, for REXML::XPathParser
+ # to use across multiple Object+ types
+ def dclone
+ klone = self.clone
+ klone.clear
+ self.each{|v| klone << v.dclone}
+ klone
+ end
+ end
+ end
+end
+
+using REXML::DClonable
+
+module REXML
+ # You don't want to use this class. Really. Use XPath, which is a wrapper
+ # for this class. Believe me. You don't want to poke around in here.
+ # There is strange, dark magic at work in this code. Beware. Go back! Go
+ # back while you still can!
+ class XPathParser
+ include XMLTokens
+ LITERAL = /^'([^']*)'|^"([^"]*)"/u
+
+ DEBUG = (ENV["REXML_XPATH_PARSER_DEBUG"] == "true")
+
+ def initialize(strict: false)
+ @debug = DEBUG
+ @parser = REXML::Parsers::XPathParser.new
+ @namespaces = nil
+ @variables = {}
+ @nest = 0
+ @strict = strict
+ end
+
+ def namespaces=( namespaces={} )
+ Functions::namespace_context = namespaces
+ @namespaces = namespaces
+ end
+
+ def variables=( vars={} )
+ Functions::variables = vars
+ @variables = vars
+ end
+
+ def parse path, node
+ path_stack = @parser.parse( path )
+ if node.is_a?(Array)
+ Kernel.warn("REXML::XPath.each, REXML::XPath.first, REXML::XPath.match dropped support for nodeset...", uplevel: 1)
+ return [] if node.empty?
+ node = node.first
+ end
+
+ document = node.document
+ if document
+ document.__send__(:enable_cache) do
+ match( path_stack, node )
+ end
+ else
+ match( path_stack, node )
+ end
+ end
+
+ def get_first path, node
+ path_stack = @parser.parse( path )
+ first( path_stack, node )
+ end
+
+ def predicate path, node
+ path_stack = @parser.parse( path )
+ match( path_stack, node )
+ end
+
+ def []=( variable_name, value )
+ @variables[ variable_name ] = value
+ end
+
+
+ # Performs a depth-first (document order) XPath search, and returns the
+ # first match. This is the fastest, lightest way to return a single result.
+ #
+ # FIXME: This method is incomplete!
+ def first( path_stack, node )
+ return nil if path.size == 0
+
+ case path[0]
+ when :document
+ # do nothing
+ first( path[1..-1], node )
+ when :child
+ for c in node.children
+ r = first( path[1..-1], c )
+ return r if r
+ end
+ when :qname
+ name = path[2]
+ if node.name == name
+ return node if path.size == 3
+ first( path[3..-1], node )
+ else
+ nil
+ end
+ when :descendant_or_self
+ r = first( path[1..-1], node )
+ return r if r
+ for c in node.children
+ r = first( path, c )
+ return r if r
+ end
+ when :node
+ first( path[1..-1], node )
+ when :any
+ first( path[1..-1], node )
+ else
+ nil
+ end
+ end
+
+
+ def match(path_stack, node)
+ nodeset = [XPathNode.new(node, position: 1)]
+ result = expr(path_stack, nodeset)
+ case result
+ when Array # nodeset
+ unnode(result).uniq
+ else
+ [result]
+ end
+ end
+
+ private
+ def strict?
+ @strict
+ end
+
+ # Returns a String namespace for a node, given a prefix
+ # The rules are:
+ #
+ # 1. Use the supplied namespace mapping first.
+ # 2. If no mapping was supplied, use the context node to look up the namespace
+ def get_namespace( node, prefix )
+ if @namespaces
+ @namespaces[prefix] || ''
+ else
+ return node.namespace( prefix ) if node.node_type == :element
+ ''
+ end
+ end
+
+
+ # Expr takes a stack of path elements and a set of nodes (either a Parent
+ # or an Array and returns an Array of matching nodes
+ def expr( path_stack, nodeset, context=nil )
+ enter(:expr, path_stack, nodeset) if @debug
+ return nodeset if path_stack.length == 0 || nodeset.length == 0
+ while path_stack.length > 0
+ trace(:while, path_stack, nodeset) if @debug
+ if nodeset.length == 0
+ path_stack.clear
+ return []
+ end
+ op = path_stack.shift
+ case op
+ when :document
+ first_raw_node = nodeset.first.raw_node
+ nodeset = [XPathNode.new(first_raw_node.root_node, position: 1)]
+ when :self
+ nodeset = step(path_stack) do
+ [nodeset]
+ end
+ when :child
+ nodeset = step(path_stack) do
+ child(nodeset)
+ end
+ when :literal
+ trace(:literal, path_stack, nodeset) if @debug
+ return path_stack.shift
+ when :attribute
+ nodeset = step(path_stack, any_type: :attribute) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.node_type == :element
+ attributes = raw_node.attributes
+ next if attributes.empty?
+ nodesets << attributes.each_attribute.collect.with_index do |attribute, i|
+ XPathNode.new(attribute, position: i + 1)
+ end
+ end
+ nodesets
+ end
+ when :namespace
+ pre_defined_namespaces = {
+ "xml" => "http://www.w3.org/XML/1998/namespace",
+ }
+ nodeset = step(path_stack, any_type: :namespace) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ case raw_node.node_type
+ when :element
+ if @namespaces
+ nodesets << pre_defined_namespaces.merge(@namespaces)
+ else
+ nodesets << pre_defined_namespaces.merge(raw_node.namespaces)
+ end
+ when :attribute
+ if @namespaces
+ nodesets << pre_defined_namespaces.merge(@namespaces)
+ else
+ nodesets << pre_defined_namespaces.merge(raw_node.element.namespaces)
+ end
+ end
+ end
+ nodesets
+ end
+ when :parent
+ nodeset = step(path_stack) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ if raw_node.node_type == :attribute
+ parent = raw_node.element
+ else
+ parent = raw_node.parent
+ end
+ nodesets << [XPathNode.new(parent, position: 1)] if parent
+ end
+ nodesets
+ end
+ when :ancestor
+ nodeset = step(path_stack) do
+ nodesets = []
+ # new_nodes = {}
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ new_nodeset = []
+ while raw_node.parent
+ raw_node = raw_node.parent
+ # next if new_nodes.key?(node)
+ new_nodeset << XPathNode.new(raw_node,
+ position: new_nodeset.size + 1)
+ # new_nodes[node] = true
+ end
+ nodesets << new_nodeset unless new_nodeset.empty?
+ end
+ nodesets
+ end
+ when :ancestor_or_self
+ nodeset = step(path_stack) do
+ nodesets = []
+ # new_nodes = {}
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.node_type == :element
+ new_nodeset = [XPathNode.new(raw_node, position: 1)]
+ # new_nodes[node] = true
+ while raw_node.parent
+ raw_node = raw_node.parent
+ # next if new_nodes.key?(node)
+ new_nodeset << XPathNode.new(raw_node,
+ position: new_nodeset.size + 1)
+ # new_nodes[node] = true
+ end
+ nodesets << new_nodeset unless new_nodeset.empty?
+ end
+ nodesets
+ end
+ when :descendant_or_self
+ nodeset = step(path_stack) do
+ descendant(nodeset, true)
+ end
+ when :descendant
+ nodeset = step(path_stack) do
+ descendant(nodeset, false)
+ end
+ when :following_sibling
+ nodeset = step(path_stack) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.respond_to?(:parent)
+ next if raw_node.parent.nil?
+ all_siblings = raw_node.parent.children
+ current_index = all_siblings.index(raw_node)
+ following_siblings = all_siblings[(current_index + 1)..-1]
+ next if following_siblings.empty?
+ nodesets << following_siblings.collect.with_index do |sibling, i|
+ XPathNode.new(sibling, position: i + 1)
+ end
+ end
+ nodesets
+ end
+ when :preceding_sibling
+ nodeset = step(path_stack, order: :reverse) do
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ next unless raw_node.respond_to?(:parent)
+ next if raw_node.parent.nil?
+ all_siblings = raw_node.parent.children
+ current_index = all_siblings.index(raw_node)
+ preceding_siblings = all_siblings[0, current_index].reverse
+ next if preceding_siblings.empty?
+ nodesets << preceding_siblings.collect.with_index do |sibling, i|
+ XPathNode.new(sibling, position: i + 1)
+ end
+ end
+ nodesets
+ end
+ when :preceding
+ nodeset = step(path_stack, order: :reverse) do
+ unnode(nodeset) do |node|
+ preceding(node)
+ end
+ end
+ when :following
+ nodeset = step(path_stack) do
+ unnode(nodeset) do |node|
+ following(node)
+ end
+ end
+ when :variable
+ var_name = path_stack.shift
+ return [@variables[var_name]]
+
+ when :eq, :neq, :lt, :lteq, :gt, :gteq
+ left = expr( path_stack.shift, nodeset.dup, context )
+ right = expr( path_stack.shift, nodeset.dup, context )
+ res = equality_relational_compare( left, op, right )
+ trace(op, left, right, res) if @debug
+ return res
+
+ when :or
+ left = expr(path_stack.shift, nodeset.dup, context)
+ return true if Functions.boolean(left)
+ right = expr(path_stack.shift, nodeset.dup, context)
+ return Functions.boolean(right)
+
+ when :and
+ left = expr(path_stack.shift, nodeset.dup, context)
+ return false unless Functions.boolean(left)
+ right = expr(path_stack.shift, nodeset.dup, context)
+ return Functions.boolean(right)
+
+ when :div, :mod, :mult, :plus, :minus
+ left = expr(path_stack.shift, nodeset, context)
+ right = expr(path_stack.shift, nodeset, context)
+ left = unnode(left) if left.is_a?(Array)
+ right = unnode(right) if right.is_a?(Array)
+ left = Functions::number(left)
+ right = Functions::number(right)
+ case op
+ when :div
+ return left / right
+ when :mod
+ return left % right
+ when :mult
+ return left * right
+ when :plus
+ return left + right
+ when :minus
+ return left - right
+ else
+ raise "[BUG] Unexpected operator: <#{op.inspect}>"
+ end
+ when :union
+ left = expr( path_stack.shift, nodeset, context )
+ right = expr( path_stack.shift, nodeset, context )
+ left = unnode(left) if left.is_a?(Array)
+ right = unnode(right) if right.is_a?(Array)
+ return (left | right)
+ when :neg
+ res = expr( path_stack, nodeset, context )
+ res = unnode(res) if res.is_a?(Array)
+ return -Functions.number(res)
+ when :not
+ when :function
+ func_name = path_stack.shift.tr('-','_')
+ arguments = path_stack.shift
+
+ if nodeset.size != 1
+ message = "[BUG] Node set size must be 1 for function call: "
+ message += "<#{func_name}>: <#{nodeset.inspect}>: "
+ message += "<#{arguments.inspect}>"
+ raise message
+ end
+
+ node = nodeset.first
+ if context
+ target_context = context
+ else
+ target_context = {:size => nodeset.size}
+ if node.is_a?(XPathNode)
+ target_context[:node] = node.raw_node
+ target_context[:index] = node.position
+ else
+ target_context[:node] = node
+ target_context[:index] = 1
+ end
+ end
+ args = arguments.dclone.collect do |arg|
+ result = expr(arg, nodeset, target_context)
+ result = unnode(result) if result.is_a?(Array)
+ result
+ end
+ Functions.context = target_context
+ return Functions.send(func_name, *args)
+
+ else
+ raise "[BUG] Unexpected path: <#{op.inspect}>: <#{path_stack.inspect}>"
+ end
+ end # while
+ return nodeset
+ ensure
+ leave(:expr, path_stack, nodeset) if @debug
+ end
+
+ def step(path_stack, any_type: :element, order: :forward)
+ nodesets = yield
+ begin
+ enter(:step, path_stack, nodesets) if @debug
+ nodesets = node_test(path_stack, nodesets, any_type: any_type)
+ while path_stack[0] == :predicate
+ path_stack.shift # :predicate
+ predicate_expression = path_stack.shift.dclone
+ nodesets = evaluate_predicate(predicate_expression, nodesets)
+ end
+ if nodesets.size == 1
+ ordered_nodeset = nodesets[0]
+ else
+ raw_nodes = []
+ nodesets.each do |nodeset|
+ nodeset.each do |node|
+ if node.respond_to?(:raw_node)
+ raw_nodes << node.raw_node
+ else
+ raw_nodes << node
+ end
+ end
+ end
+ ordered_nodeset = sort(raw_nodes, order)
+ end
+ new_nodeset = []
+ ordered_nodeset.each do |node|
+ # TODO: Remove duplicated
+ new_nodeset << XPathNode.new(node, position: new_nodeset.size + 1)
+ end
+ new_nodeset
+ ensure
+ leave(:step, path_stack, new_nodeset) if @debug
+ end
+ end
+
+ def node_test(path_stack, nodesets, any_type: :element)
+ enter(:node_test, path_stack, nodesets) if @debug
+ operator = path_stack.shift
+ case operator
+ when :qname
+ prefix = path_stack.shift
+ name = path_stack.shift
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ case raw_node.node_type
+ when :element
+ if prefix.nil?
+ raw_node.name == name
+ elsif prefix.empty?
+ if strict?
+ raw_node.name == name and raw_node.namespace == ""
+ else
+ raw_node.name == name and raw_node.namespace == get_namespace(raw_node, prefix)
+ end
+ else
+ raw_node.name == name and raw_node.namespace == get_namespace(raw_node, prefix)
+ end
+ when :attribute
+ if prefix.nil?
+ raw_node.name == name
+ elsif prefix.empty?
+ raw_node.name == name and raw_node.namespace == ""
+ else
+ raw_node.name == name and raw_node.namespace == get_namespace(raw_node.element, prefix)
+ end
+ else
+ false
+ end
+ end
+ end
+ when :namespace
+ prefix = path_stack.shift
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ case raw_node.node_type
+ when :element
+ namespaces = @namespaces || raw_node.namespaces
+ raw_node.namespace == namespaces[prefix]
+ when :attribute
+ namespaces = @namespaces || raw_node.element.namespaces
+ raw_node.namespace == namespaces[prefix]
+ else
+ false
+ end
+ end
+ end
+ when :any
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ raw_node.node_type == any_type
+ end
+ end
+ when :comment
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ raw_node.node_type == :comment
+ end
+ end
+ when :text
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ raw_node.node_type == :text
+ end
+ end
+ when :processing_instruction
+ target = path_stack.shift
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ raw_node = node.raw_node
+ (raw_node.node_type == :processing_instruction) and
+ (target.empty? or (raw_node.target == target))
+ end
+ end
+ when :node
+ new_nodesets = nodesets.collect do |nodeset|
+ filter_nodeset(nodeset) do |node|
+ true
+ end
+ end
+ else
+ message = "[BUG] Unexpected node test: " +
+ "<#{operator.inspect}>: <#{path_stack.inspect}>"
+ raise message
+ end
+ new_nodesets
+ ensure
+ leave(:node_test, path_stack, new_nodesets) if @debug
+ end
+
+ def filter_nodeset(nodeset)
+ new_nodeset = []
+ nodeset.each do |node|
+ next unless yield(node)
+ new_nodeset << XPathNode.new(node, position: new_nodeset.size + 1)
+ end
+ new_nodeset
+ end
+
+ def evaluate_predicate(expression, nodesets)
+ enter(:predicate, expression, nodesets) if @debug
+ new_nodeset_count = 0
+ new_nodesets = nodesets.collect do |nodeset|
+ new_nodeset = []
+ subcontext = { :size => nodeset.size }
+ nodeset.each_with_index do |node, index|
+ if node.is_a?(XPathNode)
+ subcontext[:node] = node.raw_node
+ subcontext[:index] = node.position
+ else
+ subcontext[:node] = node
+ subcontext[:index] = index + 1
+ end
+ result = expr(expression.dclone, [node], subcontext)
+ trace(:predicate_evaluate, expression, node, subcontext, result) if @debug
+ result = result[0] if result.kind_of? Array and result.length == 1
+ if result.kind_of? Numeric
+ if result == node.position
+ new_nodeset_count += 1
+ new_nodeset << XPathNode.new(node, position: new_nodeset_count)
+ end
+ elsif result.instance_of? Array
+ if result.size > 0 and result.inject(false) {|k,s| s or k}
+ if result.size > 0
+ new_nodeset_count += 1
+ new_nodeset << XPathNode.new(node, position: new_nodeset_count)
+ end
+ end
+ else
+ if result
+ new_nodeset_count += 1
+ new_nodeset << XPathNode.new(node, position: new_nodeset_count)
+ end
+ end
+ end
+ new_nodeset
+ end
+ new_nodesets
+ ensure
+ leave(:predicate, new_nodesets) if @debug
+ end
+
+ def trace(*args)
+ indent = " " * @nest
+ PP.pp(args, "").each_line do |line|
+ puts("#{indent}#{line}")
+ end
+ end
+
+ def enter(tag, *args)
+ trace(:enter, tag, *args)
+ @nest += 1
+ end
+
+ def leave(tag, *args)
+ @nest -= 1
+ trace(:leave, tag, *args)
+ end
+
+ # Reorders an array of nodes so that they are in document order
+ # It tries to do this efficiently.
+ #
+ # FIXME: I need to get rid of this, but the issue is that most of the XPath
+ # interpreter functions as a filter, which means that we lose context going
+ # in and out of function calls. If I knew what the index of the nodes was,
+ # I wouldn't have to do this. Maybe add a document IDX for each node?
+ # Problems with mutable documents. Or, rewrite everything.
+ def sort(array_of_nodes, order)
+ new_arry = []
+ array_of_nodes.each { |node|
+ node_idx = []
+ np = node.node_type == :attribute ? node.element : node
+ while np.parent and np.parent.node_type == :element
+ node_idx << np.parent.index( np )
+ np = np.parent
+ end
+ new_arry << [ node_idx.reverse, node ]
+ }
+ ordered = new_arry.sort_by do |index, node|
+ if order == :forward
+ index
+ else
+ index.map(&:-@)
+ end
+ end
+ ordered.collect do |_index, node|
+ node
+ end
+ end
+
+ def descendant(nodeset, include_self)
+ nodesets = []
+ nodeset.each do |node|
+ new_nodeset = []
+ new_nodes = {}
+ descendant_recursive(node.raw_node, new_nodeset, new_nodes, include_self)
+ nodesets << new_nodeset unless new_nodeset.empty?
+ end
+ nodesets
+ end
+
+ def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self)
+ if include_self
+ return if new_nodes.key?(raw_node)
+ new_nodeset << XPathNode.new(raw_node, position: new_nodeset.size + 1)
+ new_nodes[raw_node] = true
+ end
+
+ node_type = raw_node.node_type
+ if node_type == :element or node_type == :document
+ raw_node.children.each do |child|
+ descendant_recursive(child, new_nodeset, new_nodes, true)
+ end
+ end
+ end
+
+ # Builds a nodeset of all of the preceding nodes of the supplied node,
+ # in reverse document order
+ # preceding:: includes every element in the document that precedes this node,
+ # except for ancestors
+ def preceding(node)
+ ancestors = []
+ parent = node.parent
+ while parent
+ ancestors << parent
+ parent = parent.parent
+ end
+
+ precedings = []
+ preceding_node = preceding_node_of(node)
+ while preceding_node
+ if ancestors.include?(preceding_node)
+ ancestors.delete(preceding_node)
+ else
+ precedings << XPathNode.new(preceding_node,
+ position: precedings.size + 1)
+ end
+ preceding_node = preceding_node_of(preceding_node)
+ end
+ precedings
+ end
+
+ def preceding_node_of( node )
+ psn = node.previous_sibling_node
+ if psn.nil?
+ if node.parent.nil? or node.parent.class == Document
+ return nil
+ end
+ return node.parent
+ #psn = preceding_node_of( node.parent )
+ end
+ while psn and psn.kind_of? Element and psn.children.size > 0
+ psn = psn.children[-1]
+ end
+ psn
+ end
+
+ def following(node)
+ followings = []
+ following_node = next_sibling_node(node)
+ while following_node
+ followings << XPathNode.new(following_node,
+ position: followings.size + 1)
+ following_node = following_node_of(following_node)
+ end
+ followings
+ end
+
+ def following_node_of( node )
+ return node.children[0] if node.kind_of?(Element) and node.children.size > 0
+
+ next_sibling_node(node)
+ end
+
+ def next_sibling_node(node)
+ psn = node.next_sibling_node
+ while psn.nil?
+ return nil if node.parent.nil? or node.parent.class == Document
+ node = node.parent
+ psn = node.next_sibling_node
+ end
+ psn
+ end
+
+ def child(nodeset)
+ nodesets = []
+ nodeset.each do |node|
+ raw_node = node.raw_node
+ node_type = raw_node.node_type
+ # trace(:child, node_type, node)
+ case node_type
+ when :element
+ nodesets << raw_node.children.collect.with_index do |child_node, i|
+ XPathNode.new(child_node, position: i + 1)
+ end
+ when :document
+ new_nodeset = []
+ raw_node.children.each do |child|
+ case child
+ when XMLDecl, Text
+ # Ignore
+ else
+ new_nodeset << XPathNode.new(child, position: new_nodeset.size + 1)
+ end
+ end
+ nodesets << new_nodeset unless new_nodeset.empty?
+ end
+ end
+ nodesets
+ end
+
+ def norm b
+ case b
+ when true, false
+ b
+ when 'true', 'false'
+ Functions::boolean( b )
+ when /^\d+(\.\d+)?$/, Numeric
+ Functions::number( b )
+ else
+ Functions::string( b )
+ end
+ end
+
+ def equality_relational_compare(set1, op, set2)
+ set1 = unnode(set1) if set1.is_a?(Array)
+ set2 = unnode(set2) if set2.is_a?(Array)
+
+ if set1.kind_of? Array and set2.kind_of? Array
+ # If both objects to be compared are node-sets, then the
+ # comparison will be true if and only if there is a node in the
+ # first node-set and a node in the second node-set such that the
+ # result of performing the comparison on the string-values of
+ # the two nodes is true.
+ set1.product(set2).any? do |node1, node2|
+ node_string1 = Functions.string(node1)
+ node_string2 = Functions.string(node2)
+ compare(node_string1, op, node_string2)
+ end
+ elsif set1.kind_of? Array or set2.kind_of? Array
+ # If one is nodeset and other is number, compare number to each item
+ # in nodeset s.t. number op number(string(item))
+ # If one is nodeset and other is string, compare string to each item
+ # in nodeset s.t. string op string(item)
+ # If one is nodeset and other is boolean, compare boolean to each item
+ # in nodeset s.t. boolean op boolean(item)
+ if set1.kind_of? Array
+ a = set1
+ b = set2
+ else
+ a = set2
+ b = set1
+ end
+
+ case b
+ when true, false
+ each_unnode(a).any? do |unnoded|
+ compare(Functions.boolean(unnoded), op, b)
+ end
+ when Numeric
+ each_unnode(a).any? do |unnoded|
+ compare(Functions.number(unnoded), op, b)
+ end
+ when /\A\d+(\.\d+)?\z/
+ b = Functions.number(b)
+ each_unnode(a).any? do |unnoded|
+ compare(Functions.number(unnoded), op, b)
+ end
+ else
+ b = Functions::string(b)
+ each_unnode(a).any? do |unnoded|
+ compare(Functions::string(unnoded), op, b)
+ end
+ end
+ else
+ # If neither is nodeset,
+ # If op is = or !=
+ # If either boolean, convert to boolean
+ # If either number, convert to number
+ # Else, convert to string
+ # Else
+ # Convert both to numbers and compare
+ compare(set1, op, set2)
+ end
+ end
+
+ def value_type(value)
+ case value
+ when true, false
+ :boolean
+ when Numeric
+ :number
+ when String
+ :string
+ else
+ raise "[BUG] Unexpected value type: <#{value.inspect}>"
+ end
+ end
+
+ def normalize_compare_values(a, operator, b)
+ a_type = value_type(a)
+ b_type = value_type(b)
+ case operator
+ when :eq, :neq
+ if a_type == :boolean or b_type == :boolean
+ a = Functions.boolean(a) unless a_type == :boolean
+ b = Functions.boolean(b) unless b_type == :boolean
+ elsif a_type == :number or b_type == :number
+ a = Functions.number(a) unless a_type == :number
+ b = Functions.number(b) unless b_type == :number
+ else
+ a = Functions.string(a) unless a_type == :string
+ b = Functions.string(b) unless b_type == :string
+ end
+ when :lt, :lteq, :gt, :gteq
+ a = Functions.number(a) unless a_type == :number
+ b = Functions.number(b) unless b_type == :number
+ else
+ message = "[BUG] Unexpected compare operator: " +
+ "<#{operator.inspect}>: <#{a.inspect}>: <#{b.inspect}>"
+ raise message
+ end
+ [a, b]
+ end
+
+ def compare(a, operator, b)
+ a, b = normalize_compare_values(a, operator, b)
+ case operator
+ when :eq
+ a == b
+ when :neq
+ a != b
+ when :lt
+ a < b
+ when :lteq
+ a <= b
+ when :gt
+ a > b
+ when :gteq
+ a >= b
+ else
+ message = "[BUG] Unexpected compare operator: " +
+ "<#{operator.inspect}>: <#{a.inspect}>: <#{b.inspect}>"
+ raise message
+ end
+ end
+
+ def each_unnode(nodeset)
+ return to_enum(__method__, nodeset) unless block_given?
+ nodeset.each do |node|
+ if node.is_a?(XPathNode)
+ unnoded = node.raw_node
+ else
+ unnoded = node
+ end
+ yield(unnoded)
+ end
+ end
+
+ def unnode(nodeset)
+ each_unnode(nodeset).collect do |unnoded|
+ unnoded = yield(unnoded) if block_given?
+ unnoded
+ end
+ end
+ end
+
+ # @private
+ class XPathNode
+ attr_reader :raw_node, :context
+ def initialize(node, context=nil)
+ if node.is_a?(XPathNode)
+ @raw_node = node.raw_node
+ else
+ @raw_node = node
+ end
+ @context = context || {}
+ end
+
+ def position
+ @context[:position]
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/LICENSE b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/LICENSE
new file mode 100644
index 0000000..f060fab
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2012 Eloy Durán <eloy.de.enige@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/README.md b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/README.md
new file mode 100644
index 0000000..48cdc31
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/README.md
@@ -0,0 +1,95 @@
+# Xcodeproj
+
+[](https://github.com/CocoaPods/Xcodeproj/actions/workflows/Specs.yml)
+[](https://codeclimate.com/github/CocoaPods/Xcodeproj/maintainability)
+[](https://codeclimate.com/github/CocoaPods/Xcodeproj/test_coverage)
+
+Xcodeproj lets you create and modify Xcode projects from [Ruby][ruby].
+Script boring management tasks or build Xcode-friendly libraries. Also includes
+support for Xcode workspaces (`.xcworkspace`), configuration files (`.xcconfig`) and
+Xcode Scheme files (`.xcscheme`).
+
+It is used in [CocoaPods](https://github.com/CocoaPods/CocoaPods) to create a
+collection of supplemental libraries or frameworks, for all platforms Xcode supports.
+
+The API reference can be found [here](http://www.rubydoc.info/gems/xcodeproj).
+
+## Installing Xcodeproj
+
+Xcodeproj itself installs through RubyGems, the Ruby package manager. Install it
+by performing the following command:
+
+ $ [sudo] gem install xcodeproj
+
+## Quickstart
+
+To begin editing an xcodeproj file start by opening it as an Xcodeproj with:
+
+```ruby
+require 'xcodeproj'
+project_path = '/your_path/your_project.xcodeproj'
+project = Xcodeproj::Project.open(project_path)
+```
+
+#### Some Small Examples To Get You Started
+
+> Look through all targets
+
+```ruby
+project.targets.each do |target|
+ puts target.name
+end
+```
+
+> Get all source files for a target
+
+```ruby
+target = project.targets.first
+files = target.source_build_phase.files.to_a.map do |pbx_build_file|
+ pbx_build_file.file_ref.real_path.to_s
+
+end.select do |path|
+ path.end_with?(".m", ".mm", ".swift")
+
+end.select do |path|
+ File.exists?(path)
+end
+```
+
+> Set a specific build configuration to all targets
+
+```ruby
+project.targets.each do |target|
+ target.build_configurations.each do |config|
+ config.build_settings['MY_CUSTOM_FLAG'] ||= 'TRUE'
+ end
+end
+project.save
+```
+
+## Command Line Tool
+
+Installing the Xcodeproj gem will also install a command-line tool `xcodeproj` which you can
+use to generate project diffs, target diffs, output all configurations and show a YAML representation.
+
+For more information consult `xcodeproj --help`.
+
+## Collaborate
+
+All Xcodeproj development happens on [GitHub][xcodeproj]. Contributing patches
+is really easy and gratifying.
+
+Follow [@CocoaPods][twitter] to get up to date information about what's
+going on in the CocoaPods world.
+
+
+## LICENSE
+
+These works are available under the MIT license. See the [LICENSE][license] file
+for more info.
+
+[twitter]: http://twitter.com/CocoaPods
+[ruby]: http://www.ruby-lang.org/en/
+[xcodeproj]: https://github.com/cocoapods/xcodeproj
+[tickets]: https://github.com/cocoapods/xcodeproj/issues
+[license]: LICENSE
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/bin/xcodeproj b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/bin/xcodeproj
new file mode 100644
index 0000000..5d163fe
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/bin/xcodeproj
@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+if $PROGRAM_NAME == __FILE__
+ ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+ require 'bundler/setup'
+end
+
+require 'xcodeproj'
+
+Xcodeproj::Command.run(ARGV)
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj.rb
new file mode 100644
index 0000000..3a179d0
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj.rb
@@ -0,0 +1,29 @@
+module Xcodeproj
+ require 'pathname'
+ require 'claide'
+ require 'colored2'
+
+ class PlainInformative < StandardError
+ include CLAide::InformativeError
+ end
+
+ class Informative < PlainInformative
+ def message
+ super !~ /\[!\]/ ? "[!] #{super}\n".red : super
+ end
+ end
+
+ require 'xcodeproj/gem_version'
+ require 'xcodeproj/user_interface'
+
+ autoload :Command, 'xcodeproj/command'
+ autoload :Config, 'xcodeproj/config'
+ autoload :Constants, 'xcodeproj/constants'
+ autoload :Differ, 'xcodeproj/differ'
+ autoload :Helper, 'xcodeproj/helper'
+ autoload :Plist, 'xcodeproj/plist'
+ autoload :Project, 'xcodeproj/project'
+ autoload :Workspace, 'xcodeproj/workspace'
+ autoload :XCScheme, 'xcodeproj/scheme'
+ autoload :XcodebuildHelper, 'xcodeproj/xcodebuild_helper'
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command.rb
new file mode 100644
index 0000000..c11a658
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command.rb
@@ -0,0 +1,66 @@
+module Xcodeproj
+ require 'colored2'
+ require 'claide'
+
+ class Command < CLAide::Command
+ require 'xcodeproj/command/config_dump'
+ require 'xcodeproj/command/target_diff'
+ require 'xcodeproj/command/project_diff'
+ require 'xcodeproj/command/show'
+ require 'xcodeproj/command/sort'
+
+ self.abstract_command = true
+ self.command = 'xcodeproj'
+ self.version = VERSION
+ self.description = 'Xcodeproj lets you create and modify Xcode projects from Ruby.'
+ self.plugin_prefixes = %w(claide xcodeproj)
+
+ def initialize(argv)
+ super
+ unless self.ansi_output?
+ Colored2.disable!
+ String.send(:define_method, :colorize) { |string, _| string }
+ end
+ end
+
+ private
+
+ def xcodeproj_path
+ unless @xcodeproj_path
+ projects = Dir.glob('*.xcodeproj')
+ if projects.size == 1
+ xcodeproj_path = projects.first
+ elsif projects.size > 1
+ raise Informative, 'There are more than one Xcode project documents ' \
+ 'in the current working directory. Please specify ' \
+ 'the project as the first argument, or specify ' \
+ 'which to use with the --project option if using ' \
+ 'target-diff.'
+ else
+ raise Informative, 'No Xcode project document found in the current ' \
+ 'working directory. Please specify the project ' \
+ 'as the first argument, or specify which to use ' \
+ 'with the --project option if using target-diff.' \
+ end
+ @xcodeproj_path = Pathname.new(xcodeproj_path).expand_path
+ end
+ @xcodeproj_path
+ end
+
+ def open_project!(*paths)
+ if paths.empty?
+ [xcodeproj]
+ else
+ paths.map { |path| Project.open(path) }
+ end
+ end
+
+ def xcodeproj_path=(path)
+ @xcodeproj_path = path && Pathname.new(path).expand_path
+ end
+
+ def xcodeproj
+ @xcodeproj ||= Project.open(xcodeproj_path)
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/config_dump.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/config_dump.rb
new file mode 100644
index 0000000..dac7645
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/config_dump.rb
@@ -0,0 +1,91 @@
+module Xcodeproj
+ class Command
+ class ConfigDump < Command
+ self.description = <<-eos
+ Dumps the build settings of all project targets for all configurations in
+ directories named by the target in given output directory.
+
+ It extracts common build settings in a per target base.xcconfig file.
+
+ If no `PROJECT` is specified then the current work directory is searched
+ for one.
+
+ If no `OUTPUT` is specified then the project directory will be used.
+ eos
+
+ self.summary = 'Dumps the build settings of all project targets for ' \
+ 'all configurations in directories named by the target ' \
+ 'in the given output directory.'
+
+ self.arguments = [
+ CLAide::Argument.new('PROJECT', false),
+ CLAide::Argument.new('OUTPUT', false),
+ ]
+
+ def initialize(argv)
+ self.xcodeproj_path = argv.shift_argument
+ @output_path = Pathname(argv.shift_argument || '.')
+
+ super
+ end
+
+ def validate!
+ super
+
+ raise Informative, 'The output path must be a directory.' unless @output_path.directory?
+ open_project!
+ end
+
+ def run
+ dump_all_configs(xcodeproj, 'Project')
+
+ xcodeproj.targets.each do |target|
+ dump_all_configs(target, target.name)
+ end
+ end
+
+ def dump_all_configs(configurable, name)
+ path = Pathname(name)
+
+ # Dump base configuration to file
+ base_settings = extract_common_settings!(configurable.build_configurations)
+ base_file_path = path + "#{name}_base.xcconfig"
+ dump_config_to_file(base_settings, base_file_path)
+
+ # Dump each configuration to file
+ configurable.build_configurations.each do |config|
+ settings = config.build_settings
+ dump_config_to_file(settings, path + "#{name}_#{config.name.downcase}.xcconfig", [base_file_path])
+ end
+ end
+
+ def extract_common_settings!(build_configurations)
+ # Grasp all common build settings
+ all_build_settings = build_configurations.map(&:build_settings)
+ common_build_settings = all_build_settings.reduce do |settings, config_build_settings|
+ settings.select { |key, value| value == config_build_settings[key] }
+ end
+
+ # Remove all common build settings from each configuration specific build settings
+ build_configurations.each do |config|
+ config.build_settings.reject! { |key| !common_build_settings[key].nil? }
+ end
+
+ common_build_settings
+ end
+
+ def dump_config_to_file(settings, file_path, includes = [])
+ dir = @output_path + file_path + '..'
+ dir.mkpath
+
+ settings = Hash[settings.map do |k, v|
+ [k, Array(v).join(' ')]
+ end]
+
+ config = Config.new(settings)
+ config.includes = includes
+ config.save_as(@output_path + file_path)
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/project_diff.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/project_diff.rb
new file mode 100644
index 0000000..2f5d553
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/project_diff.rb
@@ -0,0 +1,56 @@
+module Xcodeproj
+ class Command
+ class ProjectDiff < Command
+ self.summary = 'Shows the difference between two projects'
+
+ self.description = summary + <<-EOS.gsub(/ {8}/, '')
+
+ It shows the difference in a UUID agnostic fashion.
+
+ To reduce the noise (and to simplify implementation) differences in the
+ order of arrays are ignored.
+ EOS
+
+ def self.options
+ [
+ ['--ignore=KEY', 'A key to ignore in the comparison. Can be specified multiple times.'],
+ ].concat(super)
+ end
+
+ self.arguments = [
+ CLAide::Argument.new('PROJECT1', true),
+ CLAide::Argument.new('PROJECT2', true),
+ ]
+
+ def initialize(argv)
+ @path_project1 = argv.shift_argument
+ @path_project2 = argv.shift_argument
+ @keys_to_ignore = argv.all_options('ignore')
+ super
+ end
+
+ def validate!
+ super
+ @project1, @project2 = open_project!(@path_project1, @path_project2)
+ end
+
+ def run
+ hash_1 = @project1.to_tree_hash.dup
+ hash_2 = @project2.to_tree_hash.dup
+ @keys_to_ignore.each do |key|
+ Differ.clean_hash!(hash_1, key)
+ Differ.clean_hash!(hash_2, key)
+ end
+
+ diff = Differ.project_diff(hash_1, hash_2, @path_project1, @path_project2)
+
+ require 'yaml'
+ yaml = diff.to_yaml
+ yaml.gsub!(@path_project1, @path_project1.cyan)
+ yaml.gsub!(@path_project2, @path_project2.magenta)
+ yaml.gsub!(':diff:', 'diff:'.yellow)
+ puts yaml
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/show.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/show.rb
new file mode 100644
index 0000000..5c36c06
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/show.rb
@@ -0,0 +1,60 @@
+module Xcodeproj
+ class Command
+ class Show < Command
+ self.summary = 'Shows an overview of a project in a YAML representation.'
+
+ def self.options
+ [
+ ['--format=[hash|tree_hash|raw]', 'YAML output format'],
+ ].concat(super)
+ end
+
+ self.arguments = [
+ CLAide::Argument.new('PROJECT', false),
+ ]
+
+ def initialize(argv)
+ self.xcodeproj_path = argv.shift_argument
+ @output_format = argv.option('format')
+ @output_format &&= @output_format.to_sym
+ super
+ end
+
+ def validate
+ super
+ unless [nil, :hash, :tree_hash, :raw].include?(@output_format)
+ help! "Unknown format `#{@output_format}`"
+ end
+ open_project!
+ end
+
+ def run
+ require 'yaml'
+
+ if @output_format
+ case @output_format
+ when :hash
+ puts xcodeproj.to_hash.to_yaml
+ when :tree_hash
+ puts xcodeproj.to_tree_hash.to_yaml
+ when :raw
+ puts xcodeproj.to_yaml
+ end
+ return
+ end
+
+ pretty_print = xcodeproj.pretty_print
+ sections = []
+ pretty_print.each do |key, value|
+ section = key.green
+ yaml = value.to_yaml
+ yaml.gsub!(/^---$/, '')
+ yaml.gsub!(/^-/, "\n-")
+ yaml.prepend(section)
+ sections << yaml
+ end
+ puts sections * "\n\n"
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/sort.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/sort.rb
new file mode 100644
index 0000000..5f4b70f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/sort.rb
@@ -0,0 +1,44 @@
+module Xcodeproj
+ class Command
+ class Sort < Command
+ self.description = <<-eos
+ Sorts the given project.
+
+ If no `PROJECT' is specified then the current work directory is searched for one.
+ eos
+
+ self.summary = 'Sorts the given project.'
+
+ def self.options
+ [
+ ['--group-option=[above|below]', 'The position of the groups when sorting. If no option is specified, sorting will interleave groups and files.'],
+ ].concat(super)
+ end
+
+ self.arguments = [
+ CLAide::Argument.new('PROJECT', false),
+ ]
+
+ def initialize(argv)
+ self.xcodeproj_path = argv.shift_argument
+ @group_option = argv.option('group-option')
+ @group_option &&= @group_option.to_sym
+ super
+ end
+
+ def validate!
+ super
+ unless [nil, :above, :below].include?(@group_option)
+ help! "Unknown format `#{@group_option}`"
+ end
+ open_project!
+ end
+
+ def run
+ xcodeproj.sort(:groups_position => @group_option)
+ xcodeproj.save
+ puts "The `#{File.basename(xcodeproj_path)}` project was sorted"
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/target_diff.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/target_diff.rb
new file mode 100644
index 0000000..7390bee
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/command/target_diff.rb
@@ -0,0 +1,43 @@
+module Xcodeproj
+ class Command
+ class TargetDiff < Command
+ self.summary = 'Shows the difference between two targets'
+
+ def self.options
+ [
+ ['--project PATH', 'The Xcode project document to use.'],
+ ].concat(super)
+ end
+
+ self.arguments = [
+ CLAide::Argument.new('TARGET1', true),
+ CLAide::Argument.new('TARGET2', true),
+ ]
+
+ def initialize(argv)
+ @target1 = argv.shift_argument
+ @target2 = argv.shift_argument
+ self.xcodeproj_path = argv.option('--project')
+ super
+ end
+
+ def validate!
+ super
+ open_project!
+ end
+
+ def run
+ require 'yaml'
+ differ = Helper::TargetDiff.new(xcodeproj, @target1, @target2)
+ files = differ.new_source_build_files.map do |build_file|
+ {
+ 'Name' => build_file.file_ref.name,
+ 'Path' => build_file.file_ref.path,
+ 'Build settings' => build_file.settings,
+ }
+ end
+ puts files.to_yaml
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/config.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/config.rb
new file mode 100644
index 0000000..e022602
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/config.rb
@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+require 'shellwords'
+require 'xcodeproj/config/other_linker_flags_parser'
+
+module Xcodeproj
+ # This class holds the data for a Xcode build settings file (xcconfig) and
+ # provides support for serialization.
+ #
+ class Config
+ require 'set'
+
+ KEY_VALUE_PATTERN = /
+ (
+ [^=\[]+ # Any char, but not an assignment operator
+ # or subscript (non-greedy)
+ (?: # One or multiple conditional subscripts
+ \[
+ [^\]]* # The subscript key
+ (?:
+ = # The subscript comparison operator
+ [^\]]* # The subscript value
+ )?
+ \]
+ )*
+ )
+ \s* # Whitespaces after the key (needed because subscripts
+ # always end with ']')
+ = # The assignment operator
+ (.*) # The value
+ /x
+ private_constant :KEY_VALUE_PATTERN
+
+ INHERITED = %w($(inherited) ${inherited}).freeze
+ private_constant :INHERITED
+
+ INHERITED_REGEXP = Regexp.union(INHERITED)
+ private_constant :INHERITED_REGEXP
+
+ # @return [Hash{String => String}] The attributes of the settings file
+ # excluding frameworks, weak_framework and libraries.
+ #
+ attr_accessor :attributes
+
+ # @return [Hash{Symbol => Set<String>}] The other linker flags by key.
+ # Xcodeproj handles them in a dedicated way to prevent duplication
+ # of the libraries and of the frameworks.
+ #
+ attr_accessor :other_linker_flags
+
+ # @return [Array] The list of the configuration files included by this
+ # configuration file (`#include "SomeConfig"`).
+ #
+ attr_accessor :includes
+
+ # @param [Hash, File, String] xcconfig_hash_or_file
+ # The initial data.
+ #
+ def initialize(xcconfig_hash_or_file = {})
+ @attributes = {}
+ @includes = []
+ @other_linker_flags = {}
+ [:simple, :frameworks, :weak_frameworks, :libraries, :arg_files, :force_load].each do |key|
+ @other_linker_flags[key] = Set.new
+ end
+ merge!(extract_hash(xcconfig_hash_or_file))
+ end
+
+ def inspect
+ to_hash.inspect
+ end
+
+ def ==(other)
+ other.attributes == attributes && other.other_linker_flags == other_linker_flags && other.includes == includes
+ end
+
+ public
+
+ # @!group Serialization
+ #-------------------------------------------------------------------------#
+
+ # Sorts the internal data by setting name and serializes it in the xcconfig
+ # format.
+ #
+ # @example
+ #
+ # config = Config.new('PODS_ROOT' => '"$(SRCROOT)/Pods"', 'OTHER_LDFLAGS' => '-lxml2')
+ # config.to_s # => "OTHER_LDFLAGS = -lxml2\nPODS_ROOT = \"$(SRCROOT)/Pods\""
+ #
+ # @return [String] The serialized internal data.
+ #
+ def to_s(prefix = nil)
+ include_lines = includes.map { |path| "#include \"#{normalized_xcconfig_path(path)}\"" }
+ settings = to_hash(prefix).sort_by(&:first).map { |k, v| "#{k} = #{v}".strip }
+ (include_lines + settings).join("\n") << "\n"
+ end
+
+ # Writes the serialized representation of the internal data to the given
+ # path.
+ #
+ # @param [Pathname] pathname
+ # The file where the data should be written to.
+ #
+ # @return [void]
+ #
+ def save_as(pathname, prefix = nil)
+ if File.exist?(pathname)
+ return if Config.new(pathname) == self
+ end
+
+ pathname.open('w') { |file| file << to_s(prefix) }
+ end
+
+ # The hash representation of the xcconfig. The hash includes the
+ # frameworks, the weak frameworks, the libraries and the simple other
+ # linker flags in the `Other Linker Flags` (`OTHER_LDFLAGS`).
+ #
+ # @note All the values are sorted to have a consistent output in Ruby
+ # 1.8.7.
+ #
+ # @return [Hash] The hash representation
+ #
+ def to_hash(prefix = nil)
+ list = []
+ list += other_linker_flags[:simple].to_a.sort
+ modifiers = {
+ :frameworks => '-framework ',
+ :weak_frameworks => '-weak_framework ',
+ :libraries => '-l',
+ :arg_files => '@',
+ :force_load => '-force_load',
+ }
+ [:libraries, :frameworks, :weak_frameworks, :arg_files, :force_load].each do |key|
+ modifier = modifiers[key]
+ sorted = other_linker_flags[key].to_a.sort
+ if key == :force_load
+ list += sorted.map { |l| %(#{modifier} #{l}) }
+ else
+ list += sorted.map { |l| %(#{modifier}"#{l}") }
+ end
+ end
+
+ result = attributes.dup
+ result['OTHER_LDFLAGS'] = list.join(' ') unless list.empty?
+ result.reject! { |_, v| INHERITED.any? { |i| i == v.to_s.strip } }
+
+ result = @includes.map do |incl|
+ path = File.expand_path(incl, @filepath.dirname)
+ if File.readable? path
+ Xcodeproj::Config.new(path).to_hash
+ else
+ {}
+ end
+ end.inject(&:merge).merge(result) unless @filepath.nil? || @includes.empty?
+
+ if prefix
+ Hash[result.map { |k, v| [prefix + k, v] }]
+ else
+ result
+ end
+ end
+
+ alias_method :to_h, :to_hash
+
+ # @return [Set<String>] The list of the frameworks required by this
+ # settings file.
+ #
+ def frameworks
+ other_linker_flags[:frameworks]
+ end
+
+ # @return [Set<String>] The list of the *weak* frameworks required by
+ # this settings file.
+ #
+ def weak_frameworks
+ other_linker_flags[:weak_frameworks]
+ end
+
+ # @return [Set<String>] The list of the libraries required by this
+ # settings file.
+ #
+ def libraries
+ other_linker_flags[:libraries]
+ end
+
+ # @return [Set<String>] The list of the arg files required by this
+ # settings file.
+ #
+ def arg_files
+ other_linker_flags[:arg_files]
+ end
+
+ public
+
+ # @!group Merging
+ #-------------------------------------------------------------------------#
+
+ # Merges the given xcconfig representation in the receiver.
+ #
+ # @example
+ #
+ # config = Config.new('PODS_ROOT' => '"$(SRCROOT)/Pods"', 'OTHER_LDFLAGS' => '-lxml2')
+ # config.merge!('OTHER_LDFLAGS' => '-lz', 'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/Headers"')
+ # config.to_hash # => { 'PODS_ROOT' => '"$(SRCROOT)/Pods"', 'OTHER_LDFLAGS' => '-lxml2 -lz', 'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/Headers"' }
+ #
+ # @note If a key in the given hash already exists in the internal data
+ # then its value is appended.
+ #
+ # @param [Hash, Config] config
+ # The xcconfig representation to merge.
+ #
+ # @todo The logic to normalize an hash should be extracted and the
+ # initializer should not call this method.
+ #
+ # @return [void]
+ #
+ def merge!(xcconfig)
+ if xcconfig.is_a? Config
+ merge_attributes!(xcconfig.attributes)
+ other_linker_flags.keys.each do |key|
+ other_linker_flags[key].merge(xcconfig.other_linker_flags[key])
+ end
+ else
+ merge_attributes!(xcconfig.to_hash)
+ if flags = attributes.delete('OTHER_LDFLAGS')
+ flags_by_key = OtherLinkerFlagsParser.parse(flags)
+ other_linker_flags.keys.each do |key|
+ other_linker_flags[key].merge(flags_by_key[key])
+ end
+ end
+ end
+ end
+ alias_method :<<, :merge!
+
+ # Creates a new #{Config} with the data of the receiver merged with the
+ # given xcconfig representation.
+ #
+ # @param [Hash, Config] config
+ # The xcconfig representation to merge.
+ #
+ # @return [Config] the new xcconfig.
+ #
+ def merge(config)
+ dup.tap { |x| x.merge!(config) }
+ end
+
+ # @return [Config] A copy of the receiver.
+ #
+ def dup
+ Xcodeproj::Config.new(to_hash.dup)
+ end
+
+ #-------------------------------------------------------------------------#
+
+ private
+
+ # @!group Private Helpers
+
+ # Returns a hash from the given argument reading it from disk if necessary.
+ #
+ # @param [String, Pathname, Hash] argument
+ # The source from where the hash should be extracted.
+ #
+ # @return [Hash]
+ #
+ def extract_hash(argument)
+ return argument if argument.is_a?(Hash)
+ if argument.respond_to? :read
+ @filepath = Pathname.new(argument.to_path)
+ hash_from_file_content(argument.read)
+ elsif File.readable?(argument.to_s)
+ @filepath = Pathname.new(argument.to_s)
+ hash_from_file_content(File.read(argument))
+ else
+ argument
+ end
+ end
+
+ # Returns a hash from the string representation of an Xcconfig file.
+ #
+ # @param [String] string
+ # The string representation of an xcconfig file.
+ #
+ # @return [Hash] the hash containing the xcconfig data.
+ #
+ def hash_from_file_content(string)
+ hash = {}
+ string.split("\n").each do |line|
+ uncommented_line = strip_comment(line)
+ if include = extract_include(uncommented_line)
+ @includes.push normalized_xcconfig_path(include)
+ else
+ key, value = extract_key_value(uncommented_line)
+ next unless key
+ value.gsub!(INHERITED_REGEXP) { |m| hash.fetch(key, m) }
+ hash[key] = value
+ end
+ end
+ hash
+ end
+
+ # Merges the given attributes hash while ensuring values are not duplicated.
+ #
+ # @param [Hash] attributes
+ # The attributes hash to merge into @attributes.
+ #
+ # @return [void]
+ #
+ def merge_attributes!(attributes)
+ @attributes.merge!(attributes) do |_, v1, v2|
+ v1 = v1.strip
+ v2 = v2.strip
+ v1_split = v1.shellsplit
+ v2_split = v2.shellsplit
+ if (v2_split - v1_split).empty? || v1_split.first(v2_split.size) == v2_split
+ v1
+ elsif v2_split.first(v1_split.size) == v1_split
+ v2
+ else
+ "#{v1} #{v2}"
+ end
+ end
+ end
+
+ # Strips the comments from a line of an xcconfig string.
+ #
+ # @param [String] line
+ # the line to process.
+ #
+ # @return [String] the uncommented line.
+ #
+ def strip_comment(line)
+ line.partition('//').first
+ end
+
+ # Returns the file included by a line of an xcconfig string if present.
+ #
+ # @param [String] line
+ # the line to process.
+ #
+ # @return [String] the included file.
+ # @return [Nil] if no include was found in the line.
+ #
+ def extract_include(line)
+ regexp = /#include\??\s*"(.+)"/
+ match = line.match(regexp)
+ match[1] if match
+ end
+
+ # Returns the key and the value described by the given line of an xcconfig.
+ #
+ # @param [String] line
+ # the line to process.
+ #
+ # @return [Array] A tuple where the first entry is the key and the second
+ # entry is the value.
+ #
+ def extract_key_value(line)
+ match = line.match(KEY_VALUE_PATTERN)
+ if match
+ key = match[1]
+ value = match[2]
+ [key.strip, value.strip]
+ else
+ []
+ end
+ end
+
+ # Normalizes the given path to an xcconfing file to be used in includes,
+ # appending the extension if necessary.
+ #
+ # @param [String] path
+ # The path of the file which will be included in the xcconfig.
+ #
+ # @return [String] The normalized path.
+ #
+ def normalized_xcconfig_path(path)
+ if File.extname(path) == '.xcconfig'
+ path
+ else
+ "#{path}.xcconfig"
+ end
+ end
+
+ #-------------------------------------------------------------------------#
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/config/other_linker_flags_parser.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/config/other_linker_flags_parser.rb
new file mode 100644
index 0000000..31eccef
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/config/other_linker_flags_parser.rb
@@ -0,0 +1,73 @@
+require 'shellwords'
+
+module Xcodeproj
+ class Config
+ # Parses other linker flags values.
+ #
+ module OtherLinkerFlagsParser
+ # @return [Hash{Symbol, Array[String]}] Splits the given
+ # other linker flags value by type.
+ #
+ # @param [String, Array] flags
+ # The other linker flags value.
+ #
+ def self.parse(flags)
+ result = {
+ :frameworks => [],
+ :weak_frameworks => [],
+ :libraries => [],
+ :arg_files => [],
+ :simple => [],
+ :force_load => [],
+ }
+
+ key = nil
+ if flags.is_a? String
+ flags = split(flags)
+ end
+ flags.each do |token|
+ case token
+ when '-framework'
+ key = :frameworks
+ when '-weak_framework'
+ key = :weak_frameworks
+ when '-l'
+ key = :libraries
+ when '@'
+ key = :arg_files
+ when '-force_load'
+ key = :force_load
+ else
+ if key
+ result[key] << token
+ key = nil
+ else
+ result[:simple] << token
+ end
+ end
+ end
+ result
+ end
+
+ # @return [Array<String>] Split the given other linker
+ # flags value, taking into account quoting and
+ # the fact that the `-l` flag might omit the
+ # space.
+ #
+ # @param [String] flags
+ # The other linker flags value.
+ #
+ def self.split(flags)
+ flags.strip.shellsplit.flat_map do |string|
+ if string =~ /\A-l.+/
+ ['-l', string[2..-1]]
+ elsif string =~ /\A@.+/
+ ['@', string[1..-1]]
+ else
+ string
+ end
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/constants.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/constants.rb
new file mode 100644
index 0000000..f7e563f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/constants.rb
@@ -0,0 +1,476 @@
+module Xcodeproj
+ # This modules groups all the constants known to Xcodeproj.
+ #
+ module Constants
+ # @return [String] The last known iOS SDK (stable).
+ #
+ LAST_KNOWN_IOS_SDK = '18.0'
+
+ # @return [String] The last known OS X SDK (stable).
+ #
+ LAST_KNOWN_OSX_SDK = '15.0'
+
+ # @return [String] The last known tvOS SDK (stable).
+ #
+ LAST_KNOWN_TVOS_SDK = '18.0'
+
+ # @return [String] The last known visionOS SDK (unstable).
+ #
+ LAST_KNOWN_VISIONOS_SDK = '2.0'
+
+ # @return [String] The last known watchOS SDK (stable).
+ #
+ LAST_KNOWN_WATCHOS_SDK = '11.0'
+
+ # @return [String] The last known archive version to Xcodeproj.
+ #
+ LAST_KNOWN_ARCHIVE_VERSION = 1
+
+ # @return [String] The last known Swift version (stable).
+ #
+ LAST_KNOWN_SWIFT_VERSION = '5.0'
+
+ # @return [String] The default object version for Xcodeproj.
+ #
+ DEFAULT_OBJECT_VERSION = 46
+
+ # @return [String] The last known object version to Xcodeproj.
+ #
+ LAST_KNOWN_OBJECT_VERSION = 77
+
+ # @return [String] The last known Xcode version to Xcodeproj.
+ #
+ LAST_UPGRADE_CHECK = '1600'
+
+ # @return [String] The last known Xcode version to Xcodeproj.
+ #
+ LAST_SWIFT_UPGRADE_CHECK = '1600'
+
+ # @return [String] The version of `.xcscheme` files supported by Xcodeproj
+ #
+ XCSCHEME_FORMAT_VERSION = '1.3'
+
+ # @return [Hash] The all the known ISAs grouped by superclass.
+ #
+ KNOWN_ISAS = {
+ 'AbstractObject' => %w(
+ PBXBuildFile
+ AbstractBuildPhase
+ PBXBuildRule
+ XCBuildConfiguration
+ XCConfigurationList
+ PBXContainerItemProxy
+ PBXFileReference
+ PBXGroup
+ PBXProject
+ PBXTargetDependency
+ PBXReferenceProxy
+ AbstractTarget
+ ),
+
+ 'AbstractBuildPhase' => %w(
+ PBXCopyFilesBuildPhase
+ PBXResourcesBuildPhase
+ PBXSourcesBuildPhase
+ PBXFrameworksBuildPhase
+ PBXHeadersBuildPhase
+ PBXShellScriptBuildPhase
+ ),
+
+ 'AbstractTarget' => %w(
+ PBXNativeTarget
+ PBXAggregateTarget
+ PBXLegacyTarget
+ ),
+
+ 'PBXGroup' => %w(
+ XCVersionGroup
+ PBXVariantGroup
+ ),
+ }.freeze
+
+ # @return [Hash] The known file types corresponding to each extension.
+ #
+ FILE_TYPES_BY_EXTENSION = {
+ 'a' => 'archive.ar',
+ 'apns' => 'text',
+ 'app' => 'wrapper.application',
+ 'appex' => 'wrapper.app-extension',
+ 'bundle' => 'wrapper.plug-in',
+ 'cpp' => 'sourcecode.cpp.cpp',
+ 'dylib' => 'compiled.mach-o.dylib',
+ 'entitlements' => 'text.plist.entitlements',
+ 'framework' => 'wrapper.framework',
+ 'gif' => 'image.gif',
+ 'gpx' => 'text.xml',
+ 'h' => 'sourcecode.c.h',
+ 'hpp' => 'sourcecode.cpp.h',
+ 'm' => 'sourcecode.c.objc',
+ 'markdown' => 'text',
+ 'mdimporter' => 'wrapper.cfbundle',
+ 'modulemap' => 'sourcecode.module',
+ 'mov' => 'video.quicktime',
+ 'mp3' => 'audio.mp3',
+ 'octest' => 'wrapper.cfbundle',
+ 'pch' => 'sourcecode.c.h',
+ 'plist' => 'text.plist.xml',
+ 'png' => 'image.png',
+ 'sh' => 'text.script.sh',
+ 'sks' => 'file.sks',
+ 'storyboard' => 'file.storyboard',
+ 'strings' => 'text.plist.strings',
+ 'swift' => 'sourcecode.swift',
+ 'xcassets' => 'folder.assetcatalog',
+ 'xcconfig' => 'text.xcconfig',
+ 'xcdatamodel' => 'wrapper.xcdatamodel',
+ 'xcodeproj' => 'wrapper.pb-project',
+ 'xctest' => 'wrapper.cfbundle',
+ 'xib' => 'file.xib',
+ 'zip' => 'archive.zip',
+ }.freeze
+
+ # @return [Hash] The compatibility version string for different object versions.
+ #
+ COMPATIBILITY_VERSION_BY_OBJECT_VERSION = {
+ 77 => 'Xcode 16.0',
+ 63 => 'Xcode 15.3',
+ 60 => 'Xcode 15.0',
+ 56 => 'Xcode 14.0',
+ 55 => 'Xcode 13.0',
+ 54 => 'Xcode 12.0',
+ 53 => 'Xcode 11.4',
+ 52 => 'Xcode 11.0',
+ 51 => 'Xcode 10.0',
+ 50 => 'Xcode 9.3',
+ 48 => 'Xcode 8.0',
+ 47 => 'Xcode 6.3',
+ 46 => 'Xcode 3.2',
+ 45 => 'Xcode 3.1',
+ }.freeze
+
+ # @return [Hash] The uniform type identifier of various product types.
+ #
+ PRODUCT_TYPE_UTI = {
+ :application => 'com.apple.product-type.application',
+ :application_on_demand_install_capable => 'com.apple.product-type.application.on-demand-install-capable',
+ :framework => 'com.apple.product-type.framework',
+ :dynamic_library => 'com.apple.product-type.library.dynamic',
+ :static_library => 'com.apple.product-type.library.static',
+ :bundle => 'com.apple.product-type.bundle',
+ :octest_bundle => 'com.apple.product-type.bundle',
+ :unit_test_bundle => 'com.apple.product-type.bundle.unit-test',
+ :ui_test_bundle => 'com.apple.product-type.bundle.ui-testing',
+ :app_extension => 'com.apple.product-type.app-extension',
+ :command_line_tool => 'com.apple.product-type.tool',
+ :watch_app => 'com.apple.product-type.application.watchapp',
+ :watch2_app => 'com.apple.product-type.application.watchapp2',
+ :watch2_app_container => 'com.apple.product-type.application.watchapp2-container',
+ :watch_extension => 'com.apple.product-type.watchkit-extension',
+ :watch2_extension => 'com.apple.product-type.watchkit2-extension',
+ :tv_extension => 'com.apple.product-type.tv-app-extension',
+ :messages_application => 'com.apple.product-type.application.messages',
+ :messages_extension => 'com.apple.product-type.app-extension.messages',
+ :sticker_pack => 'com.apple.product-type.app-extension.messages-sticker-pack',
+ :xpc_service => 'com.apple.product-type.xpc-service',
+ }.freeze
+
+ # @return [Hash] The extensions or the various product UTIs.
+ #
+ PRODUCT_UTI_EXTENSIONS = {
+ :application => 'app',
+ :application_on_demand_install_capable => 'app',
+ :framework => 'framework',
+ :dynamic_library => 'dylib',
+ :static_library => 'a',
+ :bundle => 'bundle',
+ :octest_bundle => 'octest',
+ :unit_test_bundle => 'xctest',
+ :ui_test_bundle => 'xctest',
+ :app_extension => 'appex',
+ :messages_application => 'app',
+ :messages_extension => 'appex',
+ :sticker_pack => 'appex',
+ :watch2_extension => 'appex',
+ :watch2_app => 'app',
+ :watch2_app_container => 'app',
+ }.freeze
+
+ # @return [Hash] The common build settings grouped by platform, and build
+ # configuration name.
+ #
+ COMMON_BUILD_SETTINGS = {
+ :all => {
+ # empty?
+ # come from the project settings
+ }.freeze,
+ [:debug] => {
+ # empty?
+ # come from the project settings
+ }.freeze,
+ [:release] => {
+ # empty?
+ # come from the project settings
+ }.freeze,
+ [:ios] => {
+ 'SDKROOT' => 'iphoneos',
+ }.freeze,
+ [:osx] => {
+ 'SDKROOT' => 'macosx',
+ }.freeze,
+ [:tvos] => {
+ 'SDKROOT' => 'appletvos',
+ }.freeze,
+ [:visionos] => {
+ 'SDKROOT' => 'xros',
+ }.freeze,
+ [:watchos] => {
+ 'SDKROOT' => 'watchos',
+ }.freeze,
+ [:debug, :osx] => {
+ # Empty?
+ }.freeze,
+ [:release, :osx] => {
+ # Empty?
+ }.freeze,
+ [:debug, :ios] => {
+ # Empty?
+ }.freeze,
+ [:release, :ios] => {
+ 'VALIDATE_PRODUCT' => 'YES',
+ }.freeze,
+ [:debug, :tvos] => {
+ # Empty?
+ }.freeze,
+ [:release, :tvos] => {
+ 'VALIDATE_PRODUCT' => 'YES',
+ }.freeze,
+ [:debug, :watchos] => {
+ # Empty?
+ }.freeze,
+ [:release, :watchos] => {
+ 'VALIDATE_PRODUCT' => 'YES',
+ }.freeze,
+ [:swift] => {
+ # Empty?
+ # The swift version, like deployment target, is set in
+ # ProjectHelper#common_build_settings
+ }.freeze,
+ [:debug, :application, :swift] => {
+ # Empty?
+ }.freeze,
+ [:debug, :swift] => {
+ # Swift optimization settings are provided by the project settings
+ }.freeze,
+ [:release, :swift] => {
+ # Swift optimization settings are provided by the project settings
+ }.freeze,
+ [:debug, :static_library, :swift] => {
+ }.freeze,
+ [:framework] => {
+ 'CURRENT_PROJECT_VERSION' => '1',
+ 'DEFINES_MODULE' => 'YES',
+ 'DYLIB_COMPATIBILITY_VERSION' => '1',
+ 'DYLIB_CURRENT_VERSION' => '1',
+ 'DYLIB_INSTALL_NAME_BASE' => '@rpath',
+ 'INSTALL_PATH' => '$(LOCAL_LIBRARY_DIR)/Frameworks',
+ 'PRODUCT_NAME' => '$(TARGET_NAME:c99extidentifier)',
+ 'SKIP_INSTALL' => 'YES',
+ 'VERSION_INFO_PREFIX' => '',
+ 'VERSIONING_SYSTEM' => 'apple-generic',
+ }.freeze,
+ [:ios, :framework] => {
+ 'LD_RUNPATH_SEARCH_PATHS' => '$(inherited) @executable_path/Frameworks @loader_path/Frameworks',
+ 'TARGETED_DEVICE_FAMILY' => '1,2',
+ }.freeze,
+ [:osx, :framework] => {
+ 'COMBINE_HIDPI_IMAGES' => 'YES',
+ 'LD_RUNPATH_SEARCH_PATHS' => '$(inherited) @executable_path/../Frameworks @loader_path/Frameworks',
+ }.freeze,
+ [:watchos, :framework] => {
+ 'APPLICATION_EXTENSION_API_ONLY' => 'YES',
+ 'LD_RUNPATH_SEARCH_PATHS' => '$(inherited) @executable_path/Frameworks @loader_path/Frameworks',
+ 'TARGETED_DEVICE_FAMILY' => '4',
+ }.freeze,
+ [:tvos, :framework] => {
+ 'LD_RUNPATH_SEARCH_PATHS' => '$(inherited) @executable_path/Frameworks @loader_path/Frameworks',
+ 'TARGETED_DEVICE_FAMILY' => '3',
+ }.freeze,
+ [:framework, :swift] => {
+ 'DEFINES_MODULE' => 'YES',
+ }.freeze,
+ [:osx, :static_library] => {
+ 'EXECUTABLE_PREFIX' => 'lib',
+ 'SKIP_INSTALL' => 'YES',
+ }.freeze,
+ [:ios, :static_library] => {
+ 'OTHER_LDFLAGS' => '-ObjC',
+ 'SKIP_INSTALL' => 'YES',
+ 'TARGETED_DEVICE_FAMILY' => '1,2',
+ }.freeze,
+ [:watchos, :static_library] => {
+ 'OTHER_LDFLAGS' => '-ObjC',
+ 'SKIP_INSTALL' => 'YES',
+ 'TARGETED_DEVICE_FAMILY' => '4',
+ }.freeze,
+ [:tvos, :static_library] => {
+ 'OTHER_LDFLAGS' => '-ObjC',
+ 'SKIP_INSTALL' => 'YES',
+ 'TARGETED_DEVICE_FAMILY' => '3',
+ }.freeze,
+ [:osx, :dynamic_library] => {
+ 'DYLIB_COMPATIBILITY_VERSION' => '1',
+ 'DYLIB_CURRENT_VERSION' => '1',
+ 'EXECUTABLE_PREFIX' => 'lib',
+ 'SKIP_INSTALL' => 'YES',
+ }.freeze,
+ [:application] => {
+ 'ASSETCATALOG_COMPILER_APPICON_NAME' => 'AppIcon',
+ 'ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME' => 'AccentColor',
+ }.freeze,
+ [:ios, :application] => {
+ 'LD_RUNPATH_SEARCH_PATHS' => '$(inherited) @executable_path/Frameworks',
+ 'TARGETED_DEVICE_FAMILY' => '1,2',
+ }.freeze,
+ [:osx, :application] => {
+ 'COMBINE_HIDPI_IMAGES' => 'YES',
+ 'LD_RUNPATH_SEARCH_PATHS' => '$(inherited) @executable_path/../Frameworks',
+ }.freeze,
+ [:watchos, :application] => {
+ 'SKIP_INSTALL' => 'YES',
+ 'TARGETED_DEVICE_FAMILY' => '4',
+ }.freeze,
+ [:tvos, :application] => {
+ 'ASSETCATALOG_COMPILER_APPICON_NAME' => 'App Icon & Top Shelf Image',
+ 'LD_RUNPATH_SEARCH_PATHS' => '$(inherited) @executable_path/Frameworks',
+ 'TARGETED_DEVICE_FAMILY' => '3',
+ }.freeze,
+ [:tvos, :application, :swift] => {
+ 'ENABLE_PREVIEWS' => 'YES',
+ }.freeze,
+ [:watchos, :application, :swift] => {
+ 'ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES' => 'YES',
+ }.freeze,
+ [:bundle] => {
+ 'WRAPPER_EXTENSION' => 'bundle',
+ 'SKIP_INSTALL' => 'YES',
+ }.freeze,
+ [:ios, :bundle] => {
+ 'SDKROOT' => 'iphoneos',
+ }.freeze,
+ [:osx, :bundle] => {
+ 'COMBINE_HIDPI_IMAGES' => 'YES',
+ 'INSTALL_PATH' => '$(LOCAL_LIBRARY_DIR)/Bundles',
+ 'SDKROOT' => 'macosx',
+ }.freeze,
+ }.freeze
+
+ # @return [Hash] The default build settings for a new project.
+ #
+ PROJECT_DEFAULT_BUILD_SETTINGS = {
+ :all => {
+ 'ALWAYS_SEARCH_USER_PATHS' => 'NO',
+ 'CLANG_ANALYZER_NONNULL' => 'YES',
+ 'CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION' => 'YES_AGGRESSIVE',
+ 'CLANG_CXX_LANGUAGE_STANDARD' => 'gnu++14',
+ 'CLANG_CXX_LIBRARY' => 'libc++',
+ 'CLANG_ENABLE_MODULES' => 'YES',
+ 'CLANG_ENABLE_OBJC_ARC' => 'YES',
+ 'CLANG_ENABLE_OBJC_WEAK' => 'YES',
+ 'CLANG_WARN__DUPLICATE_METHOD_MATCH' => 'YES',
+ 'CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING' => 'YES',
+ 'CLANG_WARN_BOOL_CONVERSION' => 'YES',
+ 'CLANG_WARN_COMMA' => 'YES',
+ 'CLANG_WARN_CONSTANT_CONVERSION' => 'YES',
+ 'CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS' => 'YES',
+ 'CLANG_WARN_DIRECT_OBJC_ISA_USAGE' => 'YES_ERROR',
+ 'CLANG_WARN_DOCUMENTATION_COMMENTS' => 'YES',
+ 'CLANG_WARN_EMPTY_BODY' => 'YES',
+ 'CLANG_WARN_ENUM_CONVERSION' => 'YES',
+ 'CLANG_WARN_INFINITE_RECURSION' => 'YES',
+ 'CLANG_WARN_INT_CONVERSION' => 'YES',
+ 'CLANG_WARN_NON_LITERAL_NULL_CONVERSION' => 'YES',
+ 'CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF' => 'YES',
+ 'CLANG_WARN_OBJC_LITERAL_CONVERSION' => 'YES',
+ 'CLANG_WARN_OBJC_ROOT_CLASS' => 'YES_ERROR',
+ 'CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER' => 'YES',
+ 'CLANG_WARN_RANGE_LOOP_ANALYSIS' => 'YES',
+ 'CLANG_WARN_STRICT_PROTOTYPES' => 'YES',
+ 'CLANG_WARN_SUSPICIOUS_MOVE' => 'YES',
+ 'CLANG_WARN_UNGUARDED_AVAILABILITY' => 'YES_AGGRESSIVE',
+ 'CLANG_WARN_UNREACHABLE_CODE' => 'YES',
+ 'COPY_PHASE_STRIP' => 'NO',
+ 'ENABLE_STRICT_OBJC_MSGSEND' => 'YES',
+ 'GCC_C_LANGUAGE_STANDARD' => 'gnu11',
+ 'GCC_NO_COMMON_BLOCKS' => 'YES',
+ 'GCC_WARN_64_TO_32_BIT_CONVERSION' => 'YES',
+ 'GCC_WARN_ABOUT_RETURN_TYPE' => 'YES_ERROR',
+ 'GCC_WARN_UNDECLARED_SELECTOR' => 'YES',
+ 'GCC_WARN_UNINITIALIZED_AUTOS' => 'YES_AGGRESSIVE',
+ 'GCC_WARN_UNUSED_FUNCTION' => 'YES',
+ 'GCC_WARN_UNUSED_VARIABLE' => 'YES',
+ 'MTL_FAST_MATH' => 'YES',
+ 'PRODUCT_NAME' => '$(TARGET_NAME)',
+ 'SWIFT_VERSION' => '5.0',
+ },
+ :release => {
+ 'DEBUG_INFORMATION_FORMAT' => 'dwarf-with-dsym',
+ 'ENABLE_NS_ASSERTIONS' => 'NO',
+ 'MTL_ENABLE_DEBUG_INFO' => 'NO',
+ 'SWIFT_COMPILATION_MODE' => 'wholemodule',
+ 'SWIFT_OPTIMIZATION_LEVEL' => '-O',
+ }.freeze,
+ :debug => {
+ 'DEBUG_INFORMATION_FORMAT' => 'dwarf',
+ 'ENABLE_TESTABILITY' => 'YES',
+ 'GCC_DYNAMIC_NO_PIC' => 'NO',
+ 'GCC_OPTIMIZATION_LEVEL' => '0',
+ 'GCC_PREPROCESSOR_DEFINITIONS' => ['DEBUG=1', '$(inherited)'],
+ 'MTL_ENABLE_DEBUG_INFO' => 'INCLUDE_SOURCE',
+ 'ONLY_ACTIVE_ARCH' => 'YES',
+ 'SWIFT_ACTIVE_COMPILATION_CONDITIONS' => 'DEBUG',
+ 'SWIFT_OPTIMIZATION_LEVEL' => '-Onone',
+ }.freeze,
+ }.freeze
+
+ # @return [Hash] The corresponding numeric value of each copy build phase
+ # destination.
+ #
+ COPY_FILES_BUILD_PHASE_DESTINATIONS = {
+ :absolute_path => '0',
+ :products_directory => '16',
+ :wrapper => '1',
+ :resources => '7', # default
+ :executables => '6',
+ :java_resources => '15',
+ :frameworks => '10',
+ :shared_frameworks => '11',
+ :shared_support => '12',
+ :plug_ins => '13',
+ }.freeze
+
+ # @return [Hash] The corresponding numeric value of each proxy type for
+ # PBXContainerItemProxy.
+ PROXY_TYPES = {
+ :native_target => '1',
+ :reference => '2',
+ }.freeze
+
+ # @return [Array] The extensions which are associated with header files.
+ #
+ HEADER_FILES_EXTENSIONS = %w(.h .hh .hpp .ipp .tpp .hxx .def .inl .inc).freeze
+
+ # @return [Array] The keywords Xcode use to identify a build setting can
+ # inherit values from a previous precedence level
+ INHERITED_KEYWORDS = %w(
+ $(inherited)
+ ${inherited}
+ ).freeze
+
+ # @return [Hash] Possible types for a scheme's 'ExecutionAction' node
+ #
+ EXECUTION_ACTION_TYPE = {
+ :shell_script => 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction',
+ :send_email => 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.SendEmailAction',
+ }.freeze
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/differ.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/differ.rb
new file mode 100644
index 0000000..345e7ec
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/differ.rb
@@ -0,0 +1,270 @@
+module Xcodeproj
+ # Computes the recursive diff of Hashes, Array and other objects.
+ #
+ # Useful to compare two projects. Inspired from
+ # 'active_support/core_ext/hash/diff'.
+ #
+ # @example
+ # h1 = { :common => 'value', :changed => 'v1' }
+ # h2 = { :common => 'value', :changed => 'v2', :addition => 'new_value' }
+ # h1.recursive_diff(h2) == {
+ # :changed => {
+ # :self => 'v1',
+ # :other => 'v2'
+ # },
+ # :addition => {
+ # :self => nil,
+ # :other => 'new_value'
+ # }
+ # } #=> true
+ #
+ #
+ #
+ #
+ module Differ
+ # Computes the recursive difference of two given values.
+ #
+ # @param [Object] value_1
+ # The first value to compare.
+ #
+ # @param [Object] value_2
+ # The second value to compare.
+ #
+ # @param [Object] key_1
+ # The key for the diff of value_1.
+ #
+ # @param [Object] key_2
+ # The key for the diff of value_2.
+ #
+ # @param [Object] id_key
+ # The key used to identify correspondent hashes in an array.
+ #
+ # @return [Hash] The diff
+ # @return [Nil] if the given values are equal.
+ #
+ def self.diff(value_1, value_2, options = {})
+ options[:key_1] ||= 'value_1'
+ options[:key_2] ||= 'value_2'
+ options[:id_key] ||= nil
+
+ method = if value_1.class == value_2.class
+ case value_1
+ when Hash then :hash_diff
+ when Array then :array_diff
+ else :generic_diff
+ end
+ else
+ :generic_diff
+ end
+ send(method, value_1, value_2, options)
+ end
+
+ # Optimized for reducing the noise from the tree hash of projects
+ #
+ def self.project_diff(project_1, project_2, key_1 = 'project_1', key_2 = 'project_2')
+ project_1 = project_1.to_tree_hash unless project_1.is_a?(Hash)
+ project_2 = project_2.to_tree_hash unless project_2.is_a?(Hash)
+ options = {
+ :key_1 => key_1,
+ :key_2 => key_2,
+ :id_key => 'displayName',
+ }
+ diff(project_1, project_2, options)
+ end
+
+ #-------------------------------------------------------------------------#
+
+ public
+
+ # @!group Type specific handlers
+
+ # Computes the recursive difference of two hashes.
+ #
+ # @see diff
+ #
+ def self.hash_diff(value_1, value_2, options)
+ ensure_class(value_1, Hash)
+ ensure_class(value_2, Hash)
+ return nil if value_1 == value_2
+
+ result = {}
+ all_keys = (value_1.keys + value_2.keys).uniq
+ all_keys.each do |key|
+ key_value_1 = value_1[key]
+ key_value_2 = value_2[key]
+ diff = diff(key_value_1, key_value_2, options)
+ if diff
+ result[key] = diff if diff
+ end
+ end
+ if result.empty?
+ nil
+ else
+ result
+ end
+ end
+
+ # Returns the recursive diff of two arrays.
+ #
+ # @see diff
+ #
+ def self.array_diff(value_1, value_2, options)
+ ensure_class(value_1, Array)
+ ensure_class(value_2, Array)
+ return nil if value_1 == value_2
+
+ new_objects_value_1 = array_non_unique_diff(value_1, value_2)
+ new_objects_value_2 = array_non_unique_diff(value_2, value_1)
+ return nil if value_1.empty? && value_2.empty?
+
+ matched_diff = {}
+ if id_key = options[:id_key]
+ matched_value_1 = []
+ matched_value_2 = []
+ new_objects_value_1.each do |entry_value_1|
+ if entry_value_1.is_a?(Hash)
+ id_value = entry_value_1[id_key]
+ entry_value_2 = new_objects_value_2.find do |entry|
+ entry[id_key] == id_value
+ end
+ if entry_value_2
+ matched_value_1 << entry_value_1
+ matched_value_2 << entry_value_2
+ diff = diff(entry_value_1, entry_value_2, options)
+ matched_diff[id_value] = diff if diff
+ end
+ end
+ end
+
+ new_objects_value_1 -= matched_value_1
+ new_objects_value_2 -= matched_value_2
+ end
+
+ if new_objects_value_1.empty? && new_objects_value_2.empty?
+ if matched_diff.empty?
+ nil
+ else
+ matched_diff
+ end
+ else
+ result = {}
+ result[options[:key_1]] = new_objects_value_1 unless new_objects_value_1.empty?
+ result[options[:key_2]] = new_objects_value_2 unless new_objects_value_2.empty?
+ result[:diff] = matched_diff unless matched_diff.empty?
+ result
+ end
+ end
+
+ # Returns the diff of two generic objects.
+ #
+ # @see diff
+ #
+ def self.generic_diff(value_1, value_2, options)
+ return nil if value_1 == value_2
+
+ {
+ options[:key_1] => value_1,
+ options[:key_2] => value_2,
+ }
+ end
+
+ #-------------------------------------------------------------------------#
+
+ public
+
+ # @!group Cleaning
+
+ # Returns a copy of the hash where the given key is removed recursively.
+ #
+ # @param [Hash] hash
+ # The hash to clean
+ #
+ # @param [Object] key
+ # The key to remove.
+ #
+ # @return [Hash] A copy of the hash without the key.
+ #
+ def self.clean_hash(hash, key)
+ new_hash = hash.dup
+ self.clean_hash!(new_hash, key)
+ new_hash
+ end
+
+ # Recursively cleans a key from the given hash.
+ #
+ # @param [Hash] hash
+ # The hash to clean
+ #
+ # @param [Object] key
+ # The key to remove.
+ #
+ # @return [void]
+ #
+ def self.clean_hash!(hash, key)
+ hash.delete(key)
+ hash.each do |_, value|
+ case value
+ when Hash
+ clean_hash!(value, key)
+ when Array
+ value.each { |entry| clean_hash!(entry, key) if entry.is_a?(Hash) }
+ end
+ end
+ end
+
+ #-------------------------------------------------------------------------#
+
+ private
+
+ # @! Helpers
+
+ # Ensures that the given object belongs to the given class.
+ #
+ # @param [Object] object
+ # The object to check.
+ #
+ # @param [Class] klass
+ # the expected class of the object.
+ #
+ # @raise If the object doesn't belong to the given class.
+ #
+ # @return [void]
+ #
+ def self.ensure_class(object, klass)
+ raise "Wrong type `#{object.inspect}`" unless object.is_a?(klass)
+ end
+
+ # Returns the difference between two arrays, taking into account the number of times an element
+ # repeats in both arrays.
+ #
+ # @param [Array] value_1
+ # First array to the difference operation.
+ #
+ # @param [Array] value_2
+ # Second array to the difference operation.
+ #
+ # @return [Array]
+ #
+ def self.array_non_unique_diff(value_1, value_2)
+ value_2_elements_by_count = value_2.reduce({}) do |hash, element|
+ updated_element_hash = hash.key?(element) ? { element => hash[element] + 1 } : { element => 1 }
+ hash.merge(updated_element_hash)
+ end
+
+ value_1_elements_by_deletions =
+ value_1.to_set.map do |element|
+ times_to_delete_element = value_2_elements_by_count[element] || 0
+ next [element, times_to_delete_element]
+ end.to_h
+
+ value_1.select do |element|
+ if value_1_elements_by_deletions[element] > 0
+ value_1_elements_by_deletions[element] -= 1
+ next false
+ end
+ next true
+ end
+ end
+ #-------------------------------------------------------------------------#
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/gem_version.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/gem_version.rb
new file mode 100644
index 0000000..daeb542
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/gem_version.rb
@@ -0,0 +1,5 @@
+module Xcodeproj
+ # The version of the xcodeproj gem.
+ #
+ VERSION = '1.27.0'.freeze unless defined? Xcodeproj::VERSION
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/helper.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/helper.rb
new file mode 100644
index 0000000..baaa80d
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/helper.rb
@@ -0,0 +1,30 @@
+module Xcodeproj
+ module Helper
+ class TargetDiff
+ attr_reader :project, :target1, :target2
+
+ def initialize(project, target1_name, target2_name)
+ @project = project
+ unless @target1 = @project.targets.find { |target| target.name == target1_name }
+ raise ArgumentError, "Target 1 by name `#{target1_name}' not found in the project."
+ end
+ unless @target2 = @project.targets.find { |target| target.name == target2_name }
+ raise ArgumentError, "Target 1 by name `#{target2_name}' not found in the project."
+ end
+ end
+
+ # @return [Array<PBXBuildFile>] A list of source files (that will be
+ # compiled) which are in ‘target 2’ but not in ‘target 1’. The
+ # list is sorted by file path.
+ #
+ def new_source_build_files
+ new = @target2.source_build_phase.files.reject do |target2_build_file|
+ @target1.source_build_phase.files.any? do |target1_build_file|
+ target1_build_file.file_ref.path == target2_build_file.file_ref.path
+ end
+ end
+ new.sort_by { |build_file| build_file.file_ref.path }
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/plist.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/plist.rb
new file mode 100644
index 0000000..50b0137
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/plist.rb
@@ -0,0 +1,94 @@
+autoload :Nanaimo, 'nanaimo'
+autoload :CFPropertyList, 'cfpropertylist'
+
+module Xcodeproj
+ # Provides support for loading and serializing property list files.
+ #
+ module Plist
+ # @return [Hash] Returns the native objects loaded from a property list
+ # file.
+ #
+ # @param [#to_s] path
+ # The path of the file.
+ #
+ def self.read_from_path(path)
+ path = path.to_s
+ unless File.exist?(path)
+ raise Informative, "The plist file at path `#{path}` doesn't exist."
+ end
+ contents = File.read(path)
+ if file_in_conflict?(contents)
+ raise Informative, "The file `#{path}` is in a merge conflict."
+ end
+ case Nanaimo::Reader.plist_type(contents)
+ when :xml, :binary
+ CFPropertyList.native_types(CFPropertyList::List.new(:data => contents).value)
+ else
+ Nanaimo::Reader.new(contents).parse!.as_ruby
+ end
+ end
+
+ # Serializes a hash as an XML property list file.
+ #
+ # @param [#to_hash] hash
+ # The hash to store.
+ #
+ # @param [#to_s] path
+ # The path of the file.
+ #
+ def self.write_to_path(hash, path)
+ if hash.respond_to?(:to_hash)
+ hash = hash.to_hash
+ else
+ raise TypeError, "The given `#{hash.inspect}` must respond " \
+ "to #to_hash'."
+ end
+
+ unless path.is_a?(String) || path.is_a?(Pathname)
+ raise TypeError, "The given `#{path}` must be a string or 'pathname'."
+ end
+ path = path.to_s
+ raise IOError, 'Empty path.' if path.empty?
+
+ File.open(path, 'w') do |f|
+ plist = Nanaimo::Plist.new(hash, :xml)
+ Nanaimo::Writer::XMLWriter.new(plist, :pretty => true, :output => f, :strict => false).write
+ end
+ end
+
+ # The known modules that can serialize plists.
+ #
+ KNOWN_IMPLEMENTATIONS = []
+
+ class << self
+ # @deprecated This method will be removed in 2.0
+ #
+ # @return [Nil]
+ #
+ attr_accessor :implementation
+ end
+
+ # @deprecated This method will be removed in 2.0
+ #
+ # @return [Nil]
+ #
+ def self.autoload_implementation
+ end
+
+ # @return [Bool] Checks whether there are merge conflicts in the file.
+ #
+ # @param [#to_s] contents
+ # The contents of the file.
+ #
+ def self.file_in_conflict?(contents)
+ conflict_regex = /
+ ^<{7}(?!<) # Exactly 7 left arrows at the beginning of the line
+ [\w\W]* # Anything
+ ^={7}(?!=) # Exactly 7 equality symbols at the beginning of the line
+ [\w\W]* # Anything
+ ^>{7}(?!>) # Exactly 7 right arrows at the beginning of the line
+ /xm
+ contents.match(conflict_regex)
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project.rb
new file mode 100644
index 0000000..09f61fb
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project.rb
@@ -0,0 +1,870 @@
+# frozen_string_literal: true
+require 'atomos'
+require 'fileutils'
+require 'securerandom'
+
+require 'xcodeproj/project/object'
+require 'xcodeproj/project/project_helper'
+require 'xcodeproj/project/uuid_generator'
+require 'xcodeproj/plist'
+
+module Xcodeproj
+ # This class represents a Xcode project document.
+ #
+ # It can be used to manipulate existing documents or even create new ones
+ # from scratch.
+ #
+ # An Xcode project document is a plist file where the root is a dictionary
+ # containing the following keys:
+ #
+ # - archiveVersion: the version of the document.
+ # - objectVersion: the version of the objects description.
+ # - classes: a key that apparently is always empty.
+ # - objects: a dictionary where the UUID of every object is associated to
+ # its attributes.
+ # - rootObject: the UUID identifier of the root object ({PBXProject}).
+ #
+ # Every object is in turn a dictionary that specifies an `isa` (the class of
+ # the object) and in accordance to it maintains a set attributes. Those
+ # attributes might reference one or more other objects by UUID. If the
+ # reference is a collection, it is ordered.
+ #
+ # The {Project} API returns instances of {AbstractObject} which wrap the
+ # objects described in the Xcode project document. All the attributes types
+ # are preserved from the plist, except for the relationships which are
+ # replaced with objects instead of UUIDs.
+ #
+ # An object might be referenced by multiple objects, an when no other object
+ # is references it, it becomes unreachable (the root object is referenced by
+ # the project itself). Xcodeproj takes care of adding and removing those
+ # objects from the `objects` dictionary so the project is always in a
+ # consistent state.
+ #
+ class Project
+ include Object
+
+ # @return [Pathname] the path of the project.
+ #
+ attr_reader :path
+
+ # @return [Pathname] the directory of the project
+ #
+ attr_reader :project_dir
+
+ # @param [Pathname, String] path @see path
+ # The path provided will be expanded to an absolute path.
+ # @param [Bool] skip_initialization
+ # Wether the project should be initialized from scratch.
+ # @param [Int] object_version
+ # Object version to use for serialization, defaults to Xcode 3.2 compatible.
+ #
+ # @example Creating a project
+ # Project.new("path/to/Project.xcodeproj")
+ #
+ # @note When initializing the project, Xcodeproj mimics the Xcode behaviour
+ # including the setup of a debug and release configuration. If you want a
+ # clean project without any configurations, you should override the
+ # `initialize_from_scratch` method to not add these configurations and
+ # manually set the object version.
+ #
+ def initialize(path, skip_initialization = false, object_version = Constants::DEFAULT_OBJECT_VERSION)
+ @path = Pathname.new(path).expand_path
+ @project_dir = @path.dirname
+ @objects_by_uuid = {}
+ @generated_uuids = []
+ @available_uuids = []
+ @dirty = true
+ unless skip_initialization.is_a?(TrueClass) || skip_initialization.is_a?(FalseClass)
+ raise ArgumentError, '[Xcodeproj] Initialization parameter expected to ' \
+ "be a boolean #{skip_initialization}"
+ end
+ unless skip_initialization
+ initialize_from_scratch
+ @object_version = object_version.to_s
+ unless Constants::COMPATIBILITY_VERSION_BY_OBJECT_VERSION.key?(object_version)
+ raise ArgumentError, "[Xcodeproj] Unable to find compatibility version string for object version `#{object_version}`."
+ end
+ root_object.compatibility_version = Constants::COMPATIBILITY_VERSION_BY_OBJECT_VERSION[object_version]
+ end
+ end
+
+ # Opens the project at the given path.
+ #
+ # @param [Pathname, String] path
+ # The path to the Xcode project document (xcodeproj).
+ #
+ # @raise If the project versions are more recent than the ones know to
+ # Xcodeproj to prevent it from corrupting existing projects.
+ # Naturally, this would never happen with a project generated by
+ # xcodeproj itself.
+ #
+ # @raise If it can't find the root object. This means that the project is
+ # malformed.
+ #
+ # @example Opening a project
+ # Project.open("path/to/Project.xcodeproj")
+ #
+ def self.open(path)
+ path = Pathname.pwd + path
+ unless Pathname.new(path).exist?
+ raise "[Xcodeproj] Unable to open `#{path}` because it doesn't exist."
+ end
+ project = new(path, true)
+ project.send(:initialize_from_file)
+ project
+ end
+
+ # @return [String] the archive version.
+ #
+ attr_reader :archive_version
+
+ # @return [Hash] an dictionary whose purpose is unknown.
+ #
+ attr_reader :classes
+
+ # @return [String] the objects version.
+ #
+ attr_reader :object_version
+
+ # @return [Hash{String => AbstractObject}] A hash containing all the
+ # objects of the project by UUID.
+ #
+ attr_reader :objects_by_uuid
+
+ # @return [PBXProject] the root object of the project.
+ #
+ attr_reader :root_object
+
+ # A fast way to see if two {Project} instances refer to the same projects on
+ # disk. Use this over {#eql?} when you do not need to compare the full data.
+ #
+ # This shallow comparison was chosen as the (common) `==` implementation,
+ # because it was too easy to introduce changes into the Xcodeproj code-base
+ # that were slower than O(1).
+ #
+ # @return [Boolean] whether or not the two `Project` instances refer to the
+ # same projects on disk, determined solely by {#path} and
+ # `root_object.uuid` equality.
+ #
+ # @todo If ever needed, we could also compare `uuids.sort` instead.
+ #
+ def ==(other)
+ other && path == other.path && root_object.uuid == other.root_object.uuid
+ end
+
+ # Compares the project to another one, or to a plist representation.
+ #
+ # @note This operation can be extremely expensive, because it converts a
+ # `Project` instance to a hash, and should _only_ ever be used to
+ # determine wether or not the data contents of two `Project` instances
+ # are completely equal.
+ #
+ # To simply determine wether or not two {Project} instances refer to
+ # the same projects on disk, use the {#==} method instead.
+ #
+ # @param [#to_hash] other the object to compare.
+ #
+ # @return [Boolean] whether the project is equivalent to the given object.
+ #
+ def eql?(other)
+ other.respond_to?(:to_hash) && to_hash == other.to_hash
+ end
+
+ def to_s
+ "#<#{self.class}> path:`#{path}` UUID:`#{root_object.uuid}`"
+ end
+
+ alias_method :inspect, :to_s
+
+ public
+
+ # @!group Initialization
+ #-------------------------------------------------------------------------#
+
+ # Initializes the instance from scratch.
+ #
+ def initialize_from_scratch
+ @archive_version = Constants::LAST_KNOWN_ARCHIVE_VERSION.to_s
+ @classes = {}
+
+ root_object.remove_referrer(self) if root_object
+ @root_object = new(PBXProject)
+ root_object.add_referrer(self)
+
+ root_object.main_group = new(PBXGroup)
+ root_object.product_ref_group = root_object.main_group.new_group('Products')
+
+ config_list = new(XCConfigurationList)
+ root_object.build_configuration_list = config_list
+ config_list.default_configuration_name = 'Release'
+ config_list.default_configuration_is_visible = '0'
+ add_build_configuration('Debug', :debug)
+ add_build_configuration('Release', :release)
+
+ new_group('Frameworks')
+ end
+
+ # Initializes the instance with the project stored in the `path` attribute.
+ #
+ def initialize_from_file
+ pbxproj_path = path + 'project.pbxproj'
+ plist = Plist.read_from_path(pbxproj_path.to_s)
+ root_object.remove_referrer(self) if root_object
+ @root_object = new_from_plist(plist['rootObject'], plist['objects'], self)
+ @archive_version = plist['archiveVersion']
+ @object_version = plist['objectVersion']
+ @classes = plist['classes'] || {}
+ @dirty = false
+
+ unless root_object
+ raise "[Xcodeproj] Unable to find a root object in #{pbxproj_path}."
+ end
+
+ if archive_version.to_i > Constants::LAST_KNOWN_ARCHIVE_VERSION
+ UI.warn "[Xcodeproj] Archive version (#{archive_version.to_i}) is higher than the latest supported by xcodeproj (#{Constants::LAST_KNOWN_ARCHIVE_VERSION})."
+ end
+
+ if object_version.to_i > Constants::LAST_KNOWN_OBJECT_VERSION
+ UI.warn "[Xcodeproj] Xcode project version (#{object_version.to_i}) is higher than the latest supported by xcodeproj (#{Constants::LAST_KNOWN_OBJECT_VERSION})."
+ end
+
+ # Projects can have product_ref_groups that are not listed in the main_groups["Products"]
+ root_object.product_ref_group ||= root_object.main_group['Products'] || root_object.main_group.new_group('Products')
+ end
+
+ public
+
+ # @!group Plist serialization
+ #-------------------------------------------------------------------------#
+
+ # Creates a new object from the given UUID and `objects` hash (of a plist).
+ #
+ # The method sets up any relationship of the new object, generating the
+ # destination object(s) if not already present in the project.
+ #
+ # @note This method is used to generate the root object
+ # from a plist. Subsequent invocation are called by the
+ # {AbstractObject#configure_with_plist}. Clients of {Xcodeproj} are
+ # not expected to call this method.
+ #
+ # @param [String] uuid
+ # The UUID of the object that needs to be generated.
+ #
+ # @param [Hash {String => Hash}] objects_by_uuid_plist
+ # The `objects` hash of the plist representation of the project.
+ #
+ # @param [Boolean] root_object
+ # Whether the requested object is the root object and needs to be
+ # retained by the project before configuration to add it to the
+ # `objects` hash and avoid infinite loops.
+ #
+ # @return [AbstractObject] the new object.
+ #
+ # @visibility private.
+ #
+ def new_from_plist(uuid, objects_by_uuid_plist, root_object = false)
+ attributes = objects_by_uuid_plist[uuid]
+ if attributes
+ klass = Object.const_get(attributes['isa'])
+ object = klass.new(self, uuid)
+ objects_by_uuid[uuid] = object
+ object.add_referrer(self) if root_object
+ object.configure_with_plist(objects_by_uuid_plist)
+ object
+ end
+ end
+
+ # @return [Hash] The hash representation of the project.
+ #
+ def to_hash
+ plist = {}
+ objects_dictionary = {}
+ objects.each { |obj| objects_dictionary[obj.uuid] = obj.to_hash }
+ plist['objects'] = objects_dictionary
+ plist['archiveVersion'] = archive_version.to_s
+ plist['objectVersion'] = object_version.to_s
+ plist['classes'] = classes
+ plist['rootObject'] = root_object.uuid
+ plist
+ end
+
+ def to_ascii_plist
+ plist = {}
+ objects_dictionary = {}
+ objects
+ .sort_by { |o| [o.isa, o.uuid] }
+ .each do |obj|
+ key = Nanaimo::String.new(obj.uuid, obj.ascii_plist_annotation)
+ value = obj.to_ascii_plist.tap { |a| a.annotation = nil }
+ objects_dictionary[key] = value
+ end
+ plist['archiveVersion'] = archive_version.to_s
+ plist['classes'] = classes
+ plist['objectVersion'] = object_version.to_s
+ plist['objects'] = objects_dictionary
+ plist['rootObject'] = Nanaimo::String.new(root_object.uuid, root_object.ascii_plist_annotation)
+ Nanaimo::Plist.new.tap { |p| p.root_object = plist }
+ end
+
+ # Converts the objects tree to a hash substituting the hash
+ # of the referenced to their UUID reference. As a consequence the hash of
+ # an object might appear multiple times and the information about their
+ # uniqueness is lost.
+ #
+ # This method is designed to work in conjunction with {Hash#recursive_diff}
+ # to provide a complete, yet readable, diff of two projects *not* affected
+ # by differences in UUIDs.
+ #
+ # @return [Hash] a hash representation of the project different from the
+ # plist one.
+ #
+ def to_tree_hash
+ hash = {}
+ objects_dictionary = {}
+ hash['objects'] = objects_dictionary
+ hash['archiveVersion'] = archive_version.to_s
+ hash['objectVersion'] = object_version.to_s
+ hash['classes'] = classes
+ hash['rootObject'] = root_object.to_tree_hash
+ hash
+ end
+
+ # @return [Hash{String => Hash}] A hash suitable to display the project
+ # to the user.
+ #
+ def pretty_print
+ build_configurations = root_object.build_configuration_list.build_configurations
+ {
+ 'File References' => root_object.main_group.pretty_print.values.first,
+ 'Targets' => root_object.targets.map(&:pretty_print),
+ 'Build Configurations' => build_configurations.sort_by(&:name).map(&:pretty_print),
+ }
+ end
+
+ # Serializes the project in the xcodeproj format using the path provided
+ # during initialization or the given path (`xcodeproj` file). If a path is
+ # provided file references depending on the root of the project are not
+ # updated automatically, thus clients are responsible to perform any needed
+ # modification before saving.
+ #
+ # @param [String, Pathname] path
+ # The optional path where the project should be saved.
+ #
+ # @example Saving a project
+ # project.save
+ # project.save
+ #
+ # @return [void]
+ #
+ def save(save_path = nil)
+ save_path ||= path
+ @dirty = false if save_path == path
+ FileUtils.mkdir_p(save_path)
+ file = File.join(save_path, 'project.pbxproj')
+ Atomos.atomic_write(file) do |f|
+ Nanaimo::Writer::PBXProjWriter.new(to_ascii_plist, :pretty => true, :output => f, :strict => false).write
+ end
+ end
+
+ # Marks the project as dirty, that is, modified from what is on disk.
+ #
+ # @return [void]
+ #
+ def mark_dirty!
+ @dirty = true
+ end
+
+ # @return [Boolean] Whether this project has been modified since read from
+ # disk or saved.
+ #
+ def dirty?
+ @dirty == true
+ end
+
+ # Replaces all the UUIDs in the project with deterministic MD5 checksums.
+ #
+ # @note The current sorting of the project is taken into account when
+ # generating the new UUIDs.
+ #
+ # @note This method should only be used for entirely machine-generated
+ # projects, as true UUIDs are useful for tracking changes in the
+ # project.
+ #
+ # @return [void]
+ #
+ def predictabilize_uuids
+ UUIDGenerator.new([self]).generate!
+ end
+
+ # Replaces all the UUIDs in the list of provided projects with deterministic MD5 checksums.
+ #
+ # @param [Array<Project>] projects
+ #
+ # @note The current sorting of the project is taken into account when
+ # generating the new UUIDs.
+ #
+ # @note This method should only be used for entirely machine-generated
+ # projects, as true UUIDs are useful for tracking changes in the
+ # project.
+ #
+ # @return [void]
+ #
+ def self.predictabilize_uuids(projects)
+ UUIDGenerator.new(projects).generate!
+ end
+
+ public
+
+ # @!group Creating objects
+ #-------------------------------------------------------------------------#
+
+ # Creates a new object with a suitable UUID.
+ #
+ # The object is only configured with the default values of the `:simple`
+ # attributes, for this reason it is better to use the convenience methods
+ # offered by the {AbstractObject} subclasses or by this class.
+ #
+ # @param [Class, String] klass
+ # The concrete subclass of AbstractObject for new object or its
+ # ISA.
+ #
+ # @return [AbstractObject] the new object.
+ #
+ def new(klass)
+ if klass.is_a?(String)
+ klass = Object.const_get(klass)
+ end
+ object = klass.new(self, generate_uuid)
+ object.initialize_defaults
+ object
+ end
+
+ # Generates a UUID unique for the project.
+ #
+ # @note UUIDs are not guaranteed to be generated unique because we need
+ # to trim the ones generated in the xcodeproj extension.
+ #
+ # @note Implementation detail: as objects usually are created serially
+ # this method creates a batch of UUID and stores the not colliding
+ # ones, so the search for collisions with known UUIDS (a
+ # performance bottleneck) is performed less often.
+ #
+ # @return [String] A UUID unique to the project.
+ #
+ def generate_uuid
+ generate_available_uuid_list while @available_uuids.empty?
+ @available_uuids.shift
+ end
+
+ # @return [Array<String>] the list of all the generated UUIDs.
+ #
+ # @note Used for checking new UUIDs for duplicates with UUIDs already
+ # generated but used for objects which are not yet part of the
+ # `objects` hash but which might be added at a later time.
+ #
+ attr_reader :generated_uuids
+
+ # Pre-generates the given number of UUIDs. Useful for optimizing
+ # performance when the rough number of objects that will be created is
+ # known in advance.
+ #
+ # @param [Integer] count
+ # the number of UUIDs that should be generated.
+ #
+ # @note This method might generated a minor number of uniques UUIDs than
+ # the given count, because some might be duplicated a thus will be
+ # discarded.
+ #
+ # @return [void]
+ #
+ def generate_available_uuid_list(count = 100)
+ new_uuids = (0..count).map { SecureRandom.hex(12).upcase }
+ uniques = (new_uuids - (@generated_uuids + uuids))
+ @generated_uuids += uniques
+ @available_uuids += uniques
+ end
+
+ public
+
+ # @!group Convenience accessors
+ #-------------------------------------------------------------------------#
+
+ # @return [Array<AbstractObject>] all the objects of the project.
+ #
+ def objects
+ objects_by_uuid.values
+ end
+
+ # @return [Array<String>] all the UUIDs of the project.
+ #
+ def uuids
+ objects_by_uuid.keys
+ end
+
+ # @return [Array<AbstractObject>] all the objects of the project with a
+ # given ISA.
+ #
+ def list_by_class(klass)
+ objects.select { |o| o.class == klass }
+ end
+
+ # @return [PBXGroup] the main top-level group.
+ #
+ def main_group
+ root_object.main_group
+ end
+
+ # @return [ObjectList<PBXGroup>] a list of all the groups in the
+ # project.
+ #
+ def groups
+ main_group.groups
+ end
+
+ # Returns a group at the given subpath relative to the main group.
+ #
+ # @example
+ # frameworks = project['Frameworks']
+ # frameworks.name #=> 'Frameworks'
+ # main_group.children.include? frameworks #=> True
+ #
+ # @param [String] group_path @see MobileCoreServices
+ #
+ # @return [PBXGroup] the group at the given subpath.
+ #
+ def [](group_path)
+ main_group[group_path]
+ end
+
+ # @return [ObjectList<PBXFileReference>] a list of all the files in the
+ # project.
+ #
+ def files
+ objects.grep(PBXFileReference)
+ end
+
+ # Returns the file reference for the given absolute path.
+ #
+ # @param [#to_s] absolute_path
+ # The absolute path of the file whose reference is needed.
+ #
+ # @return [PBXFileReference] The file reference.
+ # @return [Nil] If no file reference could be found.
+ #
+ def reference_for_path(absolute_path)
+ absolute_pathname = Pathname.new(absolute_path)
+
+ unless absolute_pathname.absolute?
+ raise ArgumentError, "Paths must be absolute #{absolute_path}"
+ end
+
+ objects.find do |child|
+ child.isa == 'PBXFileReference' && child.real_path == absolute_pathname
+ end
+ end
+
+ # @return [ObjectList<AbstractTarget>] A list of all the targets in the
+ # project.
+ #
+ def targets
+ root_object.targets
+ end
+
+ # @return [ObjectList<PBXNativeTarget>] A list of all the targets in the
+ # project excluding aggregate targets.
+ #
+ def native_targets
+ root_object.targets.grep(PBXNativeTarget)
+ end
+
+ # Checks the native target for any targets in the project
+ # that are dependent on the native target and would be
+ # embedded in it at build time
+ #
+ # @param [PBXNativeTarget] native target to check for
+ # embedded targets
+ #
+ #
+ # @return [Array<PBXNativeTarget>] A list of all targets that
+ # are embedded in the passed in target
+ #
+ def embedded_targets_in_native_target(native_target)
+ native_targets.select do |target|
+ host_targets_for_embedded_target(target).any? { |host| host.uuid == native_target.uuid }
+ end
+ end
+
+ # Returns the native targets, in which the embedded target is
+ # embedded. This works by traversing the targets to find those
+ # where the target is a dependency.
+ #
+ # @param [PBXNativeTarget] native target that might be embedded
+ # in another target
+ #
+ # @return [Array<PBXNativeTarget>] the native targets that host the
+ # embedded target
+ #
+ def host_targets_for_embedded_target(embedded_target)
+ native_targets.select do |native_target|
+ ((embedded_target.uuid != native_target.uuid) &&
+ (native_target.dependencies.map(&:native_target_uuid).include? embedded_target.uuid))
+ end
+ end
+
+ # @return [PBXGroup] The group which holds the product file references.
+ #
+ def products_group
+ root_object.product_ref_group
+ end
+
+ # @return [ObjectList<PBXFileReference>] A list of the product file
+ # references.
+ #
+ def products
+ products_group.children
+ end
+
+ # @return [PBXGroup] the `Frameworks` group creating it if necessary.
+ #
+ def frameworks_group
+ main_group['Frameworks'] || main_group.new_group('Frameworks')
+ end
+
+ # @return [ObjectList<XCConfigurationList>] The build configuration list of
+ # the project.
+ #
+ def build_configuration_list
+ root_object.build_configuration_list
+ end
+
+ # @return [ObjectList<XCBuildConfiguration>] A list of project wide
+ # build configurations.
+ #
+ def build_configurations
+ root_object.build_configuration_list.build_configurations
+ end
+
+ # Returns the build settings of the project wide build configuration with
+ # the given name.
+ #
+ # @param [String] name
+ # The name of a project wide build configuration.
+ #
+ # @return [Hash] The build settings.
+ #
+ def build_settings(name)
+ root_object.build_configuration_list.build_settings(name)
+ end
+
+ public
+
+ # @!group Helpers
+ #-------------------------------------------------------------------------#
+
+ # Creates a new file reference in the main group.
+ #
+ # @param @see PBXGroup#new_file
+ #
+ # @return [PBXFileReference] the new file.
+ #
+ def new_file(path, source_tree = :group)
+ main_group.new_file(path, source_tree)
+ end
+
+ # Creates a new group at the given subpath of the main group.
+ #
+ # @param @see PBXGroup#new_group
+ #
+ # @return [PBXGroup] the new group.
+ #
+ def new_group(name, path = nil, source_tree = :group)
+ main_group.new_group(name, path, source_tree)
+ end
+
+ # Creates a new target and adds it to the project.
+ #
+ # The target is configured for the given platform and its file reference it
+ # is added to the {products_group}.
+ #
+ # The target is pre-populated with common build settings, and the
+ # appropriate Framework according to the platform is added to to its
+ # Frameworks phase.
+ #
+ # @param [Symbol] type
+ # the type of target. Can be `:application`, `:framework`,
+ # `:dynamic_library` or `:static_library`.
+ #
+ # @param [String] name
+ # the name of the target product.
+ #
+ # @param [Symbol] platform
+ # the platform of the target. Can be `:ios` or `:osx`.
+ #
+ # @param [String] deployment_target
+ # the deployment target for the platform.
+ #
+ # @param [PBXGroup] product_group
+ # the product group, where to add to a file reference of the
+ # created target.
+ #
+ # @param [Symbol] language
+ # the primary language of the target, can be `:objc` or `:swift`.
+ #
+ # @return [PBXNativeTarget] the target.
+ #
+ def new_target(type, name, platform, deployment_target = nil, product_group = nil, language = nil, product_basename = nil)
+ product_group ||= products_group
+ product_basename ||= name
+ ProjectHelper.new_target(self, type, name, platform, deployment_target, product_group, language, product_basename)
+ end
+
+ # Creates a new resource bundles target and adds it to the project.
+ #
+ # The target is configured for the given platform and its file reference it
+ # is added to the {products_group}.
+ #
+ # The target is pre-populated with common build settings
+ #
+ # @param [String] name
+ # the name of the resources bundle.
+ #
+ # @param [Symbol] platform
+ # the platform of the resources bundle. Can be `:ios` or `:osx`.
+ #
+ # @return [PBXNativeTarget] the target.
+ #
+ def new_resources_bundle(name, platform, product_group = nil, product_basename = nil)
+ product_group ||= products_group
+ product_basename ||= name
+ ProjectHelper.new_resources_bundle(self, name, platform, product_group, product_basename)
+ end
+
+ # Creates a new target and adds it to the project.
+ #
+ # The target is configured for the given platform and its file reference it
+ # is added to the {products_group}.
+ #
+ # The target is pre-populated with common build settings, and the
+ # appropriate Framework according to the platform is added to to its
+ # Frameworks phase.
+ #
+ # @param [String] name
+ # the name of the target.
+ #
+ # @param [Array<AbstractTarget>] target_dependencies
+ # targets, which should be added as dependencies.
+ #
+ # @param [Symbol] platform
+ # the platform of the aggregate target. Can be `:ios` or `:osx`.
+ #
+ # @param [String] deployment_target
+ # the deployment target for the platform.
+ #
+ # @return [PBXNativeTarget] the target.
+ #
+ def new_aggregate_target(name, target_dependencies = [], platform = nil, deployment_target = nil)
+ ProjectHelper.new_aggregate_target(self, name, platform, deployment_target).tap do |aggregate_target|
+ target_dependencies.each do |dep|
+ aggregate_target.add_dependency(dep)
+ end
+ end
+ end
+
+ # Adds a new build configuration to the project and populates its with
+ # default settings according to the provided type.
+ #
+ # @param [String] name
+ # The name of the build configuration.
+ #
+ # @param [Symbol] type
+ # The type of the build configuration used to populate the build
+ # settings, must be :debug or :release.
+ #
+ # @return [XCBuildConfiguration] The new build configuration.
+ #
+ def add_build_configuration(name, type)
+ build_configuration_list = root_object.build_configuration_list
+ if build_configuration = build_configuration_list[name]
+ build_configuration
+ else
+ build_configuration = new(XCBuildConfiguration)
+ build_configuration.name = name
+ common_settings = Constants::PROJECT_DEFAULT_BUILD_SETTINGS
+ settings = ProjectHelper.deep_dup(common_settings[:all])
+ settings.merge!(ProjectHelper.deep_dup(common_settings[type]))
+ build_configuration.build_settings = settings
+ build_configuration_list.build_configurations << build_configuration
+ build_configuration
+ end
+ end
+
+ # Sorts the project.
+ #
+ # @param [Hash] options
+ # the sorting options.
+ # @option options [Symbol] :groups_position
+ # the position of the groups can be either `:above` or `:below`.
+ #
+ # @return [void]
+ #
+ def sort(options = nil)
+ root_object.sort_recursively(options)
+ end
+
+ public
+
+ # @!group Schemes
+ #-------------------------------------------------------------------------#
+
+ # Get list of shared schemes in project
+ #
+ # @param [String] path
+ # project path
+ #
+ # @return [Array]
+ #
+ def self.schemes(project_path)
+ schemes = Dir[File.join(project_path, 'xcshareddata', 'xcschemes', '*.xcscheme')].map do |scheme|
+ File.basename(scheme, '.xcscheme')
+ end
+ schemes << File.basename(project_path, '.xcodeproj') if schemes.empty?
+ schemes
+ end
+
+ # Recreates the user schemes of the project from scratch (removes the
+ # folder) and optionally hides them.
+ #
+ # @param [Bool] visible
+ # Whether the schemes should be visible or hidden.
+ #
+ # @return [void]
+ #
+ def recreate_user_schemes(visible = true)
+ schemes_dir = XCScheme.user_data_dir(path)
+ FileUtils.rm_rf(schemes_dir)
+ FileUtils.mkdir_p(schemes_dir)
+
+ xcschememanagement = {}
+ xcschememanagement['SchemeUserState'] = {}
+ xcschememanagement['SuppressBuildableAutocreation'] = {}
+
+ targets.each do |target|
+ scheme = XCScheme.new
+
+ test_target = target if target.respond_to?(:test_target_type?) && target.test_target_type?
+ launch_target = target.respond_to?(:launchable_target_type?) && target.launchable_target_type?
+ scheme.configure_with_targets(target, test_target, :launch_target => launch_target)
+
+ yield scheme, target if block_given?
+ scheme.save_as(path, target.name, false)
+ xcschememanagement['SchemeUserState']["#{target.name}.xcscheme"] = {}
+ xcschememanagement['SchemeUserState']["#{target.name}.xcscheme"]['isShown'] = visible
+ end
+
+ xcschememanagement_path = schemes_dir + 'xcschememanagement.plist'
+ Plist.write_to_path(xcschememanagement, xcschememanagement_path)
+ end
+
+ #-------------------------------------------------------------------------#
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/case_converter.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/case_converter.rb
new file mode 100644
index 0000000..1f2fe1d
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/case_converter.rb
@@ -0,0 +1,90 @@
+module Xcodeproj
+ class Project
+ module Object
+ # Converts between camel case names used in the xcodeproj plist files
+ # and the ruby symbols used to represent them.
+ #
+ module CaseConverter
+ # @return [String] The plist equivalent of the given Ruby name.
+ #
+ # @param [Symbol, String] name
+ # The name to convert
+ #
+ # @param [Symbol, Nil] type
+ # The type of conversion. Pass `nil` for normal camel case and
+ # `:lower` for camel case starting with a lower case letter.
+ #
+ # @example
+ # CaseConverter.convert_to_plist(:project_ref) #=> ProjectRef
+ #
+ def self.convert_to_plist(name, type = nil)
+ case name
+ when :remote_global_id_string
+ 'remoteGlobalIDString'
+ else
+ if type == :lower
+ cache = plist_cache[:lower] ||= {}
+ cache[name] ||= camelize(name, :uppercase_first_letter => false)
+ else
+ cache = plist_cache[:normal] ||= {}
+ cache[name] ||= camelize(name)
+ end
+ end
+ end
+
+ # The following two methods are taken from activesupport,
+ # https://github.com/rails/rails/blob/v5.0.2/activesupport/lib/active_support/inflector/methods.rb
+ # all credit for them goes to the original authors.
+ #
+ # The code is used under the MIT license.
+
+ def self.camelize(term, uppercase_first_letter: true)
+ string = term.to_s
+ string = if uppercase_first_letter
+ string.sub(/^[a-z\d]*/, &:capitalize)
+ else
+ string.sub(/^(?:(?=a)b(?=\b|[A-Z_])|\w)/, &:downcase)
+ end
+ string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+ string.gsub!('/'.freeze, '::'.freeze)
+ string
+ end
+ private_class_method :camelize
+
+ def self.underscore(camel_cased_word)
+ return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+ word = camel_cased_word.to_s.gsub('::'.freeze, '/'.freeze)
+ word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)((?=a)b)(?=\b|[^a-z])/) { "#{Regexp.last_match(1) && '_'.freeze}#{Regexp.last_match(2).downcase}" }
+ word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+ word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+ word.tr!('-'.freeze, '_'.freeze)
+ word.downcase!
+ word
+ end
+ private_class_method :underscore
+
+ # @return [Symbol] The Ruby equivalent of the given plist name.
+ #
+ # @param [String] name
+ # The name to convert
+ #
+ # @example
+ # CaseConverter.convert_to_ruby('ProjectRef') #=> :project_ref
+ #
+ def self.convert_to_ruby(name)
+ underscore(name.to_s).to_sym
+ end
+
+ # @return [Hash] A cache for the conversion to the Plist format.
+ #
+ # @note A cache is used because this operation is performed for each
+ # attribute of the project when it is saved and caching it has
+ # an important performance benefit.
+ #
+ def self.plist_cache
+ @plist_cache ||= {}
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object.rb
new file mode 100644
index 0000000..ce582c0
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object.rb
@@ -0,0 +1,537 @@
+module Xcodeproj
+ class Project
+ # This is the namespace in which all the classes that wrap the objects in
+ # a Xcode project reside.
+ #
+ # The base class from which all classes inherit is AbstractObject.
+ #
+ # If you need to deal with these classes directly, it's possible to include
+ # this namespace into yours, making it unnecessary to prefix them with
+ # Xcodeproj::Project::Object.
+ #
+ # @example
+ # class SourceFileSorter
+ # include Xcodeproj::Project::Object
+ # end
+ #
+ module Object
+ # @abstract
+ #
+ # This is the base class of all object types that can exist in a Xcode
+ # project. As such it provides common behavior, but you can only use
+ # instances of subclasses of AbstractObject, because this class does
+ # not exist in actual Xcode projects.
+ #
+ # Almost all the methods implemented by this class are not expected to be
+ # used by {Xcodeproj} clients.
+ #
+ # Subclasses should clearly identify which methods reflect the xcodeproj
+ # document model and which methods are offered as convenience. Object
+ # lists always represent a relationship to many of the model while simple
+ # arrays represent dynamically generated values offered a convenience for
+ # clients.
+ #
+ class AbstractObject
+ # @!group AbstractObject
+
+ # @return [String] the ISA of the class.
+ #
+ def self.isa
+ @isa ||= name.split('::').last
+ end
+
+ # @return [String] the object's class name.
+ #
+ attr_reader :isa
+
+ # It is not recommended to instantiate objects through this
+ # constructor. To create objects manually is easier to use
+ # the {Project#new}. Otherwise, it is possible to use the convenience
+ # methods offered by {Xcodeproj} which take care of configuring the
+ # objects for common usage cases.
+ #
+ # @param [Project] project
+ # the project that will host the object.
+ #
+ # @param [String] uuid
+ # the UUID of the new object.
+ #
+ # @visibility private
+ #
+ def initialize(project, uuid)
+ @project = project
+ @uuid = uuid
+ @isa = self.class.isa
+ @referrers = []
+ unless @isa =~ /^(PBX|XC)/
+ raise "[Xcodeproj] Attempt to initialize an abstract class (#{self.class})."
+ end
+ end
+
+ # Initializes the object with the default values of simple attributes.
+ #
+ # This method is called by the {Project#new} and is not performed on
+ # initialization to prevent adding defaults to objects generated by a
+ # plist.
+ #
+ # @return [void]
+ #
+ # @visibility private
+ #
+ def initialize_defaults
+ simple_attributes.each { |a| a.set_default(self) }
+ end
+
+ # @return [String] the object universally unique identifier.
+ #
+ attr_reader :uuid
+
+ # @return [Project] the project that owns the object.
+ #
+ attr_reader :project
+
+ # Removes the object from the project by asking to its referrers to
+ # remove the reference to it.
+ #
+ # @note The root object is owned by the project and should not be
+ # manipulated with this method.
+ #
+ # @return [void]
+ #
+ def remove_from_project
+ mark_project_as_dirty!
+ project.objects_by_uuid.delete(uuid)
+
+ referrers.dup.each do |referrer|
+ referrer.remove_reference(self)
+ end
+
+ to_one_attributes.each do |attrb|
+ object = attrb.get_value(self)
+ object.remove_referrer(self) if object
+ end
+
+ to_many_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ list.clear
+ end
+
+ unless referrers.count == 0
+ raise "[Xcodeproj] BUG: #{self} should have no referrers instead" \
+ "the following objects are still referencing it #{referrers}"
+ end
+ end
+
+ # Returns the value of the name attribute or returns a generic name for
+ # the object.
+ #
+ # @note Not all concrete classes implement the name attribute and this
+ # method prevents from overriding it in plist.
+ #
+ # @return [String] a name for the object.
+ #
+ def display_name
+ declared_name = name if self.respond_to?(:name)
+ if declared_name && !declared_name.empty?
+ declared_name
+ else
+ isa.gsub(/^(PBX|XC)/, '')
+ end
+ end
+ alias_method :to_s, :display_name
+
+ # Sorts the to many attributes of the object according to the display
+ # name.
+ #
+ def sort(_options = nil)
+ to_many_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ list.sort! do |x, y|
+ x.display_name.downcase <=> y.display_name.downcase
+ end
+ end
+ end
+
+ # Sorts the object and the objects that it references.
+ #
+ # @param [Hash] options
+ # the sorting options.
+ # @option options [Symbol] :groups_position
+ # the position of the groups can be either `:above` or
+ # `:below`.
+ #
+ # @note Some objects may in turn refer back to objects higher in the
+ # object tree, which will lead to stack level deep errors.
+ # These objects should **not** try to perform a recursive sort,
+ # also because these objects would get sorted through other
+ # paths in the tree anyways.
+ #
+ # At the time of writing the only known case is
+ # `PBXTargetDependency`.
+ #
+ def sort_recursively(options = nil)
+ to_one_attributes.each do |attrb|
+ value = attrb.get_value(self)
+ value.sort_recursively(options) if value
+ end
+
+ to_many_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ list.each { |entry| entry.sort_recursively(options) }
+ end
+
+ sort(options)
+ end
+
+ # @!group Reference counting
+
+ # @return [Array<ObjectList>] The list of the objects that have a
+ # reference to this object.
+ #
+ # @visibility private
+ #
+ attr_reader :referrers
+
+ # Informs the object that another object is referencing it. If the
+ # object had no previous references it is added to the project UUIDs
+ # hash.
+ #
+ # @return [void]
+ #
+ # @visibility private
+ #
+ def add_referrer(referrer)
+ @referrers << referrer
+ @project.objects_by_uuid[uuid] = self
+ end
+
+ # Informs the object that another object stopped referencing it. If the
+ # object has no other references it is removed from the project UUIDs
+ # hash because it is unreachable.
+ #
+ # @return [void]
+ #
+ # @visibility private
+ #
+ def remove_referrer(referrer)
+ @referrers.delete(referrer)
+ if @referrers.count == 0
+ mark_project_as_dirty!
+ @project.objects_by_uuid.delete(uuid)
+ end
+ end
+
+ # Removes all the references to a given object.
+ #
+ # @return [void]
+ #
+ # @visibility private
+ #
+ def remove_reference(object)
+ to_one_attributes.each do |attrb|
+ value = attrb.get_value(self)
+ attrb.set_value(self, nil) if value.equal?(object)
+ end
+
+ to_many_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ list.delete(object)
+ end
+
+ references_by_keys_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ list.each { |dictionary| dictionary.remove_reference(object) }
+ end
+ end
+
+ # Marks the project that this object belongs to as having been modified.
+ #
+ # @return [void]
+ #
+ # @visibility private
+ #
+ def mark_project_as_dirty!
+ project.mark_dirty!
+ end
+
+ #---------------------------------------------------------------------#
+
+ public
+
+ # @!group Plist related methods
+
+ # Configures the object with the objects hash from a plist.
+ #
+ # **Implementation detail**: it is important that the attributes for a
+ # given concrete class are unique because the value is removed from the
+ # array at each iteration and duplicate would result in nil values.
+ #
+ # @return [void]
+ #
+ # @visibility private
+ #
+ def configure_with_plist(objects_by_uuid_plist)
+ object_plist = objects_by_uuid_plist[uuid].dup
+
+ unless object_plist['isa'] == isa
+ raise "[Xcodeproj] Attempt to initialize `#{isa}` from plist with " \
+ "different isa `#{object_plist}`"
+ end
+ object_plist.delete('isa')
+
+ simple_attributes.each do |attrb|
+ attrb.set_value(self, object_plist[attrb.plist_name])
+ object_plist.delete(attrb.plist_name)
+ end
+
+ to_one_attributes.each do |attrb|
+ ref_uuid = object_plist[attrb.plist_name]
+ if ref_uuid
+ ref = object_with_uuid(ref_uuid, objects_by_uuid_plist, attrb)
+ attrb.set_value(self, ref) if ref
+ end
+ object_plist.delete(attrb.plist_name)
+ end
+
+ to_many_attributes.each do |attrb|
+ ref_uuids = object_plist[attrb.plist_name] || []
+ list = attrb.get_value(self)
+ ref_uuids.each do |uuid|
+ ref = object_with_uuid(uuid, objects_by_uuid_plist, attrb)
+ list << ref if ref
+ end
+ object_plist.delete(attrb.plist_name)
+ end
+
+ references_by_keys_attributes.each do |attrb|
+ hashes = object_plist[attrb.plist_name] || {}
+ list = attrb.get_value(self)
+ hashes.each do |hash|
+ dictionary = ObjectDictionary.new(attrb, self)
+ hash.each do |key, uuid|
+ ref = object_with_uuid(uuid, objects_by_uuid_plist, attrb)
+ dictionary[key] = ref if ref
+ end
+ list << dictionary
+ end
+ object_plist.delete(attrb.plist_name)
+ end
+
+ unless object_plist.empty?
+ UI.warn "[!] Xcodeproj doesn't know about the following " \
+ "attributes #{object_plist.inspect} for the '#{isa}' isa." \
+ "\nIf this attribute was generated by Xcode please file " \
+ 'an issue: https://github.com/CocoaPods/Xcodeproj/issues/new'
+ end
+ end
+
+ # Initializes and returns the object with the given UUID.
+ #
+ # @param [String] uuid
+ # The UUID of the object that should be initialized.
+ #
+ # @param [Hash{String=>String}] objects_by_uuid_plist
+ # The hash contained by `objects` key of the plist containing
+ # the information about the object that should be initialized.
+ #
+ # @param [AbstractObjectAttribute] attribute
+ # The attribute that requested the object. It is used only for
+ # exceptions.
+ #
+ # @raise If the hash for the given UUID contains an unknown ISA.
+ #
+ # @return [AbstractObject] the initialized object.
+ # @return [Nil] if the UUID could not be found in the objects hash. In
+ # this case a warning is printed to STDERR.
+ #
+ # @visibility private
+ #
+ def object_with_uuid(uuid, objects_by_uuid_plist, attribute)
+ unless object = project.objects_by_uuid[uuid] || project.new_from_plist(uuid, objects_by_uuid_plist)
+ UI.warn "`#{inspect}` attempted to initialize an object with " \
+ "an unknown UUID. `#{uuid}` for attribute: " \
+ "`#{attribute.name}`. This can be the result of a merge and " \
+ 'the unknown UUID is being discarded.'
+ end
+ object
+ rescue NameError
+ attributes = objects_by_uuid_plist[uuid]
+ raise "`#{isa}` attempted to initialize an object with unknown ISA "\
+ "`#{attributes['isa']}` from attributes: `#{attributes}`\n" \
+ 'If this ISA was generated by Xcode please file an issue: ' \
+ 'https://github.com/CocoaPods/Xcodeproj/issues/new'
+ end
+
+ # Returns a cascade representation of the object with UUIDs.
+ #
+ # @return [Hash] a hash representation of the project.
+ #
+ # @visibility public
+ #
+ # @note the key for simple and to_one attributes usually appears only
+ # if there is a value. To-many keys always appear with an empty
+ # array.
+ #
+ def to_hash
+ to_hash_as
+ end
+
+ def to_hash_as(method = :to_hash)
+ plist = {}
+ plist['isa'] = isa
+
+ simple_attributes.each do |attrb|
+ value = attrb.get_value(self)
+ plist[attrb.plist_name] = value if value
+ end
+
+ to_one_attributes.each do |attrb|
+ obj = attrb.get_value(self)
+ plist[attrb.plist_name] = nested_object_for_hash(obj, method) if obj
+ end
+
+ to_many_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ plist[attrb.plist_name] = list.map { |o| nested_object_for_hash(o, method) }
+ end
+
+ references_by_keys_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ plist[attrb.plist_name] = list.map(&method)
+ end
+
+ plist
+ end
+ private :to_hash_as
+
+ def nested_object_for_hash(object, method)
+ case method
+ when :to_ascii_plist
+ Nanaimo::String.new(object.uuid, object.ascii_plist_annotation)
+ else
+ object.uuid
+ end
+ end
+
+ def ascii_plist_annotation
+ " #{display_name} "
+ end
+
+ def to_ascii_plist
+ Nanaimo::Dictionary.new(to_hash_as(:to_ascii_plist), ascii_plist_annotation)
+ end
+
+ # Returns a cascade representation of the object without UUIDs.
+ #
+ # This method is designed to work in conjunction with
+ # {Hash#recursive_diff} to provide a complete, yet readable, diff of
+ # two projects *not* affected by ISA differences.
+ #
+ # @todo The current implementation might lead to infinite loops.
+ #
+ # @return [Hash] a hash representation of the project different from
+ # the plist one.
+ #
+ # @visibility private
+ #
+ def to_tree_hash
+ hash = {}
+ hash['displayName'] = display_name
+ hash['isa'] = isa
+
+ simple_attributes.each do |attrb|
+ value = attrb.get_value(self)
+ hash[attrb.plist_name] = value if value
+ end
+
+ to_one_attributes.each do |attrb|
+ obj = attrb.get_value(self)
+ hash[attrb.plist_name] = obj.to_tree_hash if obj
+ end
+
+ to_many_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ hash[attrb.plist_name] = list.map(&:to_tree_hash)
+ end
+
+ references_by_keys_attributes.each do |attrb|
+ list = attrb.get_value(self)
+ hash[attrb.plist_name] = list.map(&:to_tree_hash)
+ end
+
+ hash
+ end
+
+ # @return [Hash{String => Hash}] A hash suitable to display the object
+ # to the user.
+ #
+ def pretty_print
+ if to_many_attributes.count == 1
+ children = to_many_attributes.first.get_value(self)
+ { display_name => children.map(&:pretty_print) }
+ else
+ display_name
+ end
+ end
+
+ #---------------------------------------------------------------------#
+
+ public
+
+ # @!group Object methods
+
+ def ==(other)
+ other.is_a?(AbstractObject) && to_hash == other.to_hash
+ end
+
+ def <=>(other)
+ uuid <=> other.uuid
+ end
+
+ def inspect
+ optional = ''
+ optional << " name=`#{name}`" if respond_to?(:name) && name
+ optional << " path=`#{path}`" if respond_to?(:path) && path
+ "<#{isa}#{optional} UUID=`#{uuid}`>"
+ end
+ end
+ end
+ end
+end
+
+require 'xcodeproj/project/case_converter'
+require 'xcodeproj/project/object_attributes'
+require 'xcodeproj/project/object_dictionary'
+require 'xcodeproj/project/object_list'
+
+# Required because some classes have cyclical references to each other.
+#
+# @todo I'm sure that there is a method to achieve the same result which
+# doesn't present the risk of some rubist laughing at me :-)
+#
+Xcodeproj::Constants::KNOWN_ISAS.each do |superclass_name, isas|
+ superklass = Xcodeproj::Project::Object.const_get(superclass_name)
+ isas.each do |isa|
+ c = Class.new(superklass)
+ Xcodeproj::Project::Object.const_set(isa, c)
+ end
+end
+
+# Now load the concrete subclasses.
+require 'xcodeproj/project/object/swift_package_remote_reference'
+require 'xcodeproj/project/object/swift_package_local_reference'
+require 'xcodeproj/project/object/swift_package_product_dependency'
+require 'xcodeproj/project/object/build_configuration'
+require 'xcodeproj/project/object/build_file'
+require 'xcodeproj/project/object/build_phase'
+require 'xcodeproj/project/object/build_rule'
+require 'xcodeproj/project/object/configuration_list'
+require 'xcodeproj/project/object/container_item_proxy'
+require 'xcodeproj/project/object/file_reference'
+require 'xcodeproj/project/object/group'
+require 'xcodeproj/project/object/native_target'
+require 'xcodeproj/project/object/root_object'
+require 'xcodeproj/project/object/target_dependency'
+require 'xcodeproj/project/object/reference_proxy'
+require 'xcodeproj/project/object/file_system_synchronized_root_group'
+require 'xcodeproj/project/object/file_system_synchronized_exception_set'
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_configuration.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_configuration.rb
new file mode 100644
index 0000000..624e8c8
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_configuration.rb
@@ -0,0 +1,271 @@
+require 'xcodeproj/project/object/file_system_synchronized_root_group'
+
+module Xcodeproj
+ class Project
+ module Object
+ # Encapsulates the information a specific build configuration referenced
+ # by a {XCConfigurationList} which in turn might be referenced by a
+ # {PBXProject} or a {PBXNativeTarget}.
+ #
+ class XCBuildConfiguration < AbstractObject
+ MUTUAL_RECURSION_SENTINEL = 'xcodeproj.mutual_recursion_sentinel'.freeze
+
+ private_constant :MUTUAL_RECURSION_SENTINEL
+
+ # @!group Attributes
+
+ # @return [String] the name of the configuration.
+ #
+ attribute :name, String
+
+ # @return [Hash] the build settings to use for building the target.
+ #
+ attribute :build_settings, Hash, {}
+
+ # @return [PBXFileReference] an optional file reference to a
+ # configuration file (`.xcconfig`).
+ #
+ has_one :base_configuration_reference, PBXFileReference
+
+ # @return [PBXFileSystemSynchronizedRootGroup] an optional reference to a group
+ # synchronized with the file system that contains a configuration file (`.xcconfig`).
+ #
+ # @note the configuration file relative path must be provided in `base_configuration_reference_relative_path`
+ #
+ has_one :base_configuration_reference_anchor, PBXFileSystemSynchronizedRootGroup
+
+ # @return [String] the relative path of a configuration file (`.xcconfig`)
+ # inside a group synchronized with the file system.
+ #
+ # @note the configuration file group must be provided in `base_configuration_reference_anchor`
+ #
+ attribute :base_configuration_reference_relative_path, String
+
+ public
+
+ # @!group AbstractObject Hooks
+ #---------------------------------------------------------------------#
+
+ # @return [Hash{String => Hash}] A hash suitable to display the object
+ # to the user.
+ #
+ def pretty_print
+ data = {}
+ data['Build Settings'] = sorted_build_settings
+ if base_configuration_reference
+ data['Base Configuration'] = base_configuration_reference.pretty_print
+ end
+ { name => data }
+ end
+
+ def to_hash_as(method = :to_hash)
+ super.tap do |hash|
+ normalize_array_settings(hash['buildSettings'])
+ end
+ end
+
+ # Sorts the build settings. Valid only in Ruby > 1.9.2 because in
+ # previous versions the hash are not sorted.
+ #
+ # @return [void]
+ #
+ def sort(_options = nil)
+ self.build_settings = sorted_build_settings
+ end
+
+ # @return [Boolean] Whether this configuration is configured for
+ # debugging.
+ #
+ def debug?
+ gcc_preprocessor_definitions = resolve_build_setting('GCC_PREPROCESSOR_DEFINITIONS')
+ gcc_preprocessor_definitions && gcc_preprocessor_definitions.include?('DEBUG=1')
+ end
+
+ # @return [Symbol] The symbolic type of this configuration, either
+ # `:debug` or `:release`.
+ #
+ def type
+ debug? ? :debug : :release
+ end
+
+ # @!group Helpers
+ #---------------------------------------------------------------------#
+
+ # Gets the value for the given build setting considering any configuration
+ # file present and resolving inheritance between them. It also takes in
+ # consideration environment variables.
+ #
+ # @param [String] key
+ # the key of the build setting.
+ #
+ # @param [PBXNativeTarget] root_target
+ # use this to resolve complete recursion between project and targets.
+ #
+ # @param [String] previous_key
+ # use this to resolve complete recursion between different build settings.
+ #
+ # @return [String] The value of the build setting
+ #
+ def resolve_build_setting(key, root_target = nil, previous_key = nil)
+ setting = build_settings[key]
+ setting = resolve_variable_substitution(key, setting, root_target, previous_key)
+
+ config_setting = config[key]
+ config_setting = resolve_variable_substitution(key, config_setting, root_target, previous_key)
+
+ project_setting = project.build_configuration_list[name]
+ project_setting = nil if equal?(project_setting)
+ project_setting &&= project_setting.resolve_build_setting(key, root_target)
+
+ defaults = {
+ 'CONFIGURATION' => name,
+ 'SRCROOT' => project.project_dir.to_s,
+ }
+
+ # if previous_key is nil, it means that we're back at the first call, so we can replace our sentinel string
+ # used to prevent recursion with nil
+ if previous_key.nil? && setting == MUTUAL_RECURSION_SENTINEL
+ setting = nil
+ end
+
+ [defaults[key], project_setting, config_setting, setting, ENV[key]].compact.reduce(nil) do |inherited, value|
+ expand_build_setting(value, inherited)
+ end
+ end
+
+ #---------------------------------------------------------------------#
+
+ private
+
+ VARIABLE_NAME_PATTERN =
+ '( # capture block
+ [_a-zA-Z0-9]+? # non-greedy lookup for everything contained in this list
+ )'.freeze
+ private_constant :VARIABLE_NAME_PATTERN
+
+ CAPTURE_VARIABLE_IN_BUILD_CONFIG = /
+ \$ # matches dollar sign literally
+ (?: # non-capturing group
+ [{] # matches a single character on this list
+ #{VARIABLE_NAME_PATTERN}
+ [}] # matches a single character on this list
+ | # or
+ [(] # matches a single character on this list
+ #{VARIABLE_NAME_PATTERN}
+ [)] # matches a single character on this list
+ )
+ /x
+ private_constant :CAPTURE_VARIABLE_IN_BUILD_CONFIG
+
+ def expand_build_setting(build_setting_value, config_value)
+ if build_setting_value.is_a?(Array) && config_value.is_a?(String)
+ config_value = split_build_setting_array_to_string(config_value)
+ elsif build_setting_value.is_a?(String) && config_value.is_a?(Array)
+ build_setting_value = split_build_setting_array_to_string(build_setting_value)
+ end
+
+ default = build_setting_value.is_a?(String) ? '' : []
+ inherited = config_value || default
+
+ return build_setting_value.gsub(Regexp.union(Constants::INHERITED_KEYWORDS), inherited) if build_setting_value.is_a? String
+ build_setting_value.flat_map { |value| Constants::INHERITED_KEYWORDS.include?(value) ? inherited : value }
+ end
+
+ def resolve_variable_substitution(key, value, root_target, previous_key = nil)
+ case value
+ when Array
+ return value.map { |v| resolve_variable_substitution(key, v, root_target) }
+ when nil
+ return
+ when String
+ # we know how to resolve strings!
+ nil
+ else
+ raise ArgumentError, "Settings values can only be nil, string, or array, got #{value.inspect} for #{key}"
+ end
+
+ unless variable_match_data = value.match(CAPTURE_VARIABLE_IN_BUILD_CONFIG)
+ # no variables left, return the value unchanged
+ return value
+ end
+ variable_reference, variable = *variable_match_data.values_at(0, 1, 2).compact
+
+ case variable
+ when 'inherited'
+ # this is handled separately, after resolving all other variable references
+ value
+ when key
+ # to prevent infinite recursion
+ nil
+ when previous_key
+ # to prevent infinite recursion; we don't return nil as for the self recursion because it needs to be
+ # distinguished outside this method too
+ MUTUAL_RECURSION_SENTINEL
+ else
+ configuration_to_resolve_against = root_target ? root_target.build_configuration_list[name] : self
+ resolved_value_for_variable = configuration_to_resolve_against.resolve_build_setting(variable, root_target, key) || ''
+
+ # we use this sentinel string instead of nil, because, otherwise, it would be swallowed by the default empty
+ # string from the preceding line, and we want to distinguish between mutual recursion and other cases
+ if resolved_value_for_variable == MUTUAL_RECURSION_SENTINEL
+ return MUTUAL_RECURSION_SENTINEL
+ end
+
+ value = value.gsub(variable_reference, resolved_value_for_variable)
+ resolve_variable_substitution(key, value, root_target)
+ end
+ end
+
+ def sorted_build_settings
+ sorted = {}
+ build_settings.keys.sort.each do |key|
+ sorted[key] = build_settings[key]
+ end
+ sorted
+ end
+
+ def normalize_array_settings(settings)
+ return unless settings
+
+ array_settings = BuildSettingsArraySettingsByObjectVersion[project.object_version]
+
+ settings.keys.each do |key|
+ next unless value = settings[key]
+ stripped_key = key.sub(/\[[^\]]+\]$/, '')
+ case value
+ when String
+ next unless array_settings.include?(stripped_key)
+ array_value = split_build_setting_array_to_string(value)
+ next unless array_value.size > 1
+ settings[key] = array_value
+ when Array
+ next if value.size > 1 && array_settings.include?(stripped_key)
+ settings[key] = value.join(' ')
+ end
+ end
+ end
+
+ def split_build_setting_array_to_string(string)
+ regexp = / *((['"]?).*?[^\\]\2)(?=( |\z))/
+ string.scan(regexp).map(&:first)
+ end
+
+ def config
+ return {} unless base_configuration_reference
+ @config ||=
+ if base_configuration_reference.real_path.exist?
+ Xcodeproj::Config.new(base_configuration_reference.real_path).to_hash.tap do |hash|
+ normalize_array_settings(hash)
+ end
+ else
+ {}
+ end
+ end
+
+ #---------------------------------------------------------------------#
+ end
+ end
+ end
+end
+
+require 'xcodeproj/project/object/helpers/build_settings_array_settings_by_object_version'
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_file.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_file.rb
new file mode 100644
index 0000000..2e6a9fc
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_file.rb
@@ -0,0 +1,84 @@
+module Xcodeproj
+ class Project
+ module Object
+ # Contains the information about the build settings of a file used by an
+ # {AbstractBuildPhase}.
+ #
+ class PBXBuildFile < AbstractObject
+ # @!group Attributes
+
+ # @return [Hash] the list of build settings for this file.
+ #
+ # @note The contents of this array depend on the phase of the build
+ # file.
+ #
+ # For PBXHeadersBuildPhase is `{ "ATTRIBUTES" => [:value] }`
+ # where `:value` can be `Public`, `Private`, or nil
+ # (Protected).
+ #
+ attribute :settings, Hash
+
+ # @return [PBXFileReference] the file to build.
+ #
+ # @todo I think that is possible to add any kind of group (for
+ # example folders linked to a path).
+ #
+ has_one :file_ref, [
+ PBXFileReference,
+ PBXGroup,
+ PBXVariantGroup,
+ XCVersionGroup,
+ PBXReferenceProxy,
+ ]
+
+ # @return [XCSwiftPackageProductDependency] the Swift Package file to build.
+ #
+ has_one :product_ref, XCSwiftPackageProductDependency
+
+ # @return [String] the platform filter for this build file.
+ #
+ attribute :platform_filter, String
+
+ # @return [Array<String>] the platform filters for this build file.
+ #
+ attribute :platform_filters, Array
+
+ #---------------------------------------------------------------------#
+
+ public
+
+ # @!group AbstractObject Hooks
+
+ # @return [String] A name suitable for displaying the object to the
+ # user.
+ #
+ def display_name
+ if product_ref
+ product_ref.display_name
+ elsif file_ref
+ file_ref.display_name
+ else
+ super
+ end
+ end
+
+ # @return [Hash{String => Hash}, String] A hash suitable to display the
+ # object to the user.
+ #
+ def pretty_print
+ if settings.nil? || settings.empty?
+ display_name
+ else
+ { display_name => settings }
+ end
+ end
+
+ def ascii_plist_annotation
+ " #{display_name} in #{GroupableHelper.parent(self).display_name} "
+ end
+
+ #---------------------------------------------------------------------#
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_phase.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_phase.rb
new file mode 100644
index 0000000..340dee2
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_phase.rb
@@ -0,0 +1,369 @@
+module Xcodeproj
+ class Project
+ module Object
+ # @abstract
+ #
+ # This class is abstract and it doesn't appear in the project document.
+ #
+ class AbstractBuildPhase < AbstractObject
+ # @!group Attributes
+
+ # @return [ObjectList<PBXBuildFile>] the files processed by this build
+ # configuration.
+ #
+ has_many :files, PBXBuildFile
+
+ # @return [String] some kind of magic number which usually is
+ # '2147483647' (can be also `8` and `12` in
+ # PBXCopyFilesBuildPhase, one of the masks is
+ # run_only_for_deployment_postprocessing).
+ #
+ attribute :build_action_mask, String, '2147483647'
+
+ # @return [String] whether or not this should only be processed before
+ # deployment. Can be either '0', or '1'.
+ #
+ # @note This option is exposed in Xcode in the UI of
+ # PBXCopyFilesBuildPhase as `Copy only when installing` or in
+ # PBXShellScriptBuildPhase as `Run script only when
+ # installing`.
+ #
+ attribute :run_only_for_deployment_postprocessing, String, '0'
+
+ # @return [String] whether or not this run script will be forced to
+ # run even on incremental builds. Can be either '1', or
+ # missing. By default this option is disabled in Xcode.
+ #
+ # @note This setting is exposed in Xcode in the UI of
+ # PBXShellScriptBuildPhase as `Based on
+ # dependency analysis` (selected by default).
+ #
+ attribute :always_out_of_date, String
+
+ # @return [String] Comments associated with this build phase.
+ #
+ # @note This is apparently no longer used by Xcode.
+ #
+ attribute :comments, String
+
+ #--------------------------------------#
+
+ public
+
+ # @!group Helpers
+
+ # @return [Array<PBXFileReference>] the list of all the files
+ # referenced by this build phase.
+ #
+ def files_references
+ files.map(&:file_ref)
+ end
+
+ # @return [Array<String>] The display name of the build files.
+ #
+ def file_display_names
+ files.map(&:display_name)
+ end
+
+ # @return [PBXBuildFile] the first build file associated with the given
+ # file reference if one exists.
+ #
+ def build_file(file_ref)
+ (file_ref.referrers & files).first
+ end
+
+ # Returns whether a build file for the given file reference exists.
+ #
+ # @param [PBXFileReference] file_ref
+ #
+ # @return [Bool] whether the reference is already present.
+ #
+ def include?(file_ref)
+ !build_file(file_ref).nil?
+ end
+
+ # Adds a new build file, initialized with the given file reference, to
+ # the phase.
+ #
+ # @param [PBXFileReference] file_ref
+ # The file reference that should be added to the build phase.
+ #
+ # @return [PBXBuildFile] the build file generated.
+ #
+ def add_file_reference(file_ref, avoid_duplicates = false)
+ if avoid_duplicates && existing = build_file(file_ref)
+ existing
+ else
+ build_file = project.new(PBXBuildFile)
+ build_file.file_ref = file_ref
+ files << build_file
+ build_file
+ end
+ end
+
+ # Removes the build file associated with the given file reference from
+ # the phase.
+ #
+ # @param [PBXFileReference] file_ref
+ # The file to remove
+ #
+ # @return [void]
+ #
+ def remove_file_reference(file_ref)
+ build_file = files.find { |bf| bf.file_ref == file_ref }
+ remove_build_file(build_file) if build_file
+ end
+
+ # Removes a build file from the phase and clears its relationship to
+ # the file reference.
+ #
+ # @param [PBXBuildFile] build_file the file to remove
+ #
+ # @return [void]
+ #
+ def remove_build_file(build_file)
+ build_file.file_ref = nil
+ build_file.remove_from_project
+ end
+
+ # Removes all the build files from the phase and clears their
+ # relationship to the file reference.
+ #
+ # @return [void]
+ #
+ def clear
+ files.objects.each do |bf|
+ remove_build_file(bf)
+ end
+ end
+ alias_method :clear_build_files, :clear
+
+ def display_name
+ super.gsub(/BuildPhase$/, '')
+ end
+
+ def ascii_plist_annotation
+ " #{display_name} "
+ end
+
+ # Sorts the build files of the phase according to the display
+ # name or the path.
+ #
+ # @param [Hash] _options
+ # Not used.
+ #
+ # @return [void]
+ #
+ def sort(_options = nil)
+ files.sort! do |x, y|
+ result = File.basename(x.display_name.downcase, '.*') <=> File.basename(y.display_name.downcase, '.*')
+ if result.zero?
+ result = File.extname(x.display_name.downcase) <=> File.extname(y.display_name.downcase)
+ if result.zero? && x.file_ref.respond_to?(:full_path) && y.file_ref.respond_to?(:full_path)
+ result = x.file_ref.full_path.to_s.downcase <=> y.file_ref.full_path.to_s.downcase
+ end
+ end
+ result
+ end
+ end
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # The phase responsible of copying headers. Known as `Copy Headers` in
+ # the UI.
+ #
+ # @note This phase can appear only once in a target.
+ #
+ class PBXHeadersBuildPhase < AbstractBuildPhase
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # The phase responsible of compiling the files. Known as `Compile
+ # Sources` in the UI.
+ #
+ # @note This phase can appear only once in a target.
+ #
+ class PBXSourcesBuildPhase < AbstractBuildPhase
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # The phase responsible on linking with frameworks. Known as `Link Binary
+ # With Libraries` in the UI.
+ #
+ # @note This phase can appear only once in a target.
+ #
+ class PBXFrameworksBuildPhase < AbstractBuildPhase
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # The resources build phase apparently is a specialized copy build phase
+ # for resources. Known as `Copy Bundle Resources` in the UI. It is
+ # unclear if this is the only one capable of optimizing PNG.
+ #
+ # @note This phase can appear only once in a target.
+ #
+ class PBXResourcesBuildPhase < AbstractBuildPhase
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # Phase that copies the files to the bundle of the target (aka `Copy
+ # Files`).
+ #
+ # @note This phase can appear multiple times in a target.
+ #
+ class PBXCopyFilesBuildPhase < AbstractBuildPhase
+ # @!group Attributes
+
+ # @return [String] the name of the build phase.
+ #
+ attribute :name, String
+
+ # @return [String] the subpath of `dst_subfolder_spec` where this file
+ # should be copied to.
+ #
+ # @note Can accept environment variables like `$(PRODUCT_NAME)`.
+ #
+ attribute :dst_path, String, ''
+
+ # @return [String] the path (destination) where the files should be
+ # copied to.
+ #
+ attribute :dst_subfolder_spec, String, Constants::COPY_FILES_BUILD_PHASE_DESTINATIONS[:resources]
+
+ # @return [Hash{String => Hash}] A hash suitable to display the build
+ # phase to the user.
+ #
+ def pretty_print
+ {
+ display_name => {
+ 'Destination Path' => dst_path,
+ 'Destination Subfolder' => Constants::COPY_FILES_BUILD_PHASE_DESTINATIONS.key(dst_subfolder_spec).to_s,
+ 'Files' => files.map(&:pretty_print),
+ },
+ }
+ end
+
+ # Alias method for #dst_subfolder_spec=, which accepts symbol values
+ # instead of numeric string values.
+ #
+ # @param [Symbol] value
+ # one of `COPY_FILES_BUILD_PHASE_DESTINATIONS.keys`
+ #
+ # @raise [StandardError] if value is not a valid known key
+ #
+ def symbol_dst_subfolder_spec=(value)
+ numeric_value = Constants::COPY_FILES_BUILD_PHASE_DESTINATIONS[value]
+ raise "[Xcodeproj] Value checking error: got `#{value.inspect}` for" \
+ ' attribute: dst_subfolder_spec' if numeric_value.nil?
+ self.dst_subfolder_spec = numeric_value
+ end
+
+ # Alias method for #dst_subfolder_spec, which returns symbol values
+ # instead of numeric string values.
+ #
+ # @return [Symbol]
+ #
+ def symbol_dst_subfolder_spec
+ key = Constants::COPY_FILES_BUILD_PHASE_DESTINATIONS.find { |_, num| num == dst_subfolder_spec }
+ key ? key.first : nil
+ end
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # A phase responsible of running a shell script (aka `Run Script`).
+ #
+ # @note This phase can appear multiple times in a target.
+ #
+ class PBXShellScriptBuildPhase < AbstractBuildPhase
+ # @!group Attributes
+
+ # @return [String] the name of the build phase.
+ #
+ attribute :name, String
+
+ # @return [Array<String>] an array of the paths to pass to the script.
+ #
+ # @example
+ # "$(SRCROOT)/myfile"
+ #
+ attribute :input_paths, Array, []
+
+ # @return [Array<String>] an array of input file list paths of the script.
+ #
+ # @example
+ # "$(SRCROOT)/newInputFile.xcfilelist"
+ #
+ attribute :input_file_list_paths, Array, []
+
+ # @return [Array<String>] an array of output paths of the script.
+ #
+ # @example
+ # "$(DERIVED_FILE_DIR)/myfile"
+ #
+ attribute :output_paths, Array, []
+
+ # @return [Array<String>] an array of output file list paths of the script.
+ #
+ # @example
+ # "$(SRCROOT)/newOutputFile.xcfilelist"
+ #
+ attribute :output_file_list_paths, Array, []
+
+ # @return [String] the path to the script interpreter.
+ #
+ # @note Defaults to `/bin/sh`.
+ #
+ attribute :shell_path, String, '/bin/sh'
+
+ # @return [String] the actual script to perform.
+ #
+ # @note Defaults to a comment string.
+ #
+ attribute :shell_script, String, "# Type a script or drag a script file from your workspace to insert its path.\n"
+
+ # @return [String] whether or not the ENV variables should be shown in
+ # the build log.
+ #
+ attribute :show_env_vars_in_log, String
+
+ # @return [String] the discovered dependency file to use.
+ #
+ attribute :dependency_file, String
+
+ # @return [Hash{String => Hash}] A hash suitable to display the build
+ # phase to the user.
+ #
+ def pretty_print
+ {
+ display_name => {
+ 'Input File List Paths' => input_file_list_paths || [],
+ 'Input Paths' => input_paths || [],
+ 'Output File List Paths' => output_file_list_paths || [],
+ 'Output Paths' => output_paths || [],
+ 'Shell Path' => shell_path,
+ 'Shell Script' => shell_script,
+ },
+ }
+ end
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # Apparently a build phase named `Build Carbon Resources` (Observed for
+ # kernel extensions targets).
+ #
+ # @note This phase can appear multiple times in a target.
+ #
+ class PBXRezBuildPhase < AbstractBuildPhase
+ end
+
+ #-----------------------------------------------------------------------#
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_rule.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_rule.rb
new file mode 100644
index 0000000..a3e8cac
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/build_rule.rb
@@ -0,0 +1,109 @@
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a custom build rule of a Target.
+ #
+ class PBXBuildRule < AbstractObject
+ # @!group Attributes
+
+ # @return [String] the name of the rule.
+ #
+ attribute :name, String
+
+ # @return [String] a string representing what compiler to use.
+ #
+ # @example
+ # `com.apple.compilers.proxy.script`.
+ #
+ attribute :compiler_spec, String
+
+ # @return [String] the discovered dependency file to use.
+ #
+ # @example
+ # `$(DERIVED_FILES_DIR)/$(INPUT_FILE_NAME).d`.
+ #
+ attribute :dependency_file, String
+
+ # @return [String] the type of the files that should be processed by
+ # this rule.
+ #
+ # @example
+ # `pattern.proxy`.
+ #
+ attribute :file_type, String
+
+ # @return [String] the pattern of the files that should be processed by
+ # this rule. This attribute is an alternative to to
+ # `file_type`.
+ #
+ # @example
+ # `*.css`.
+ #
+ attribute :file_patterns, String
+
+ # @return [String] whether the rule is editable.
+ #
+ # @example
+ # `1`.
+ #
+ attribute :is_editable, String, '1'
+
+ # @return [ObjectList<PBXFileReference>] the file references for the
+ # input files files.
+ #
+ attribute :input_files, Array
+
+ # @return [ObjectList<PBXFileReference>] the file references for the
+ # output files.
+ #
+ attribute :output_files, Array
+
+ # @return [ObjectList<String>] the compiler flags used when creating the
+ # respective output files.
+ #
+ attribute :output_files_compiler_flags, Array
+
+ # @return [String] whether the rule should be run once per architecture.
+ #
+ # @example
+ # `0`.
+ #
+ attribute :run_once_per_architecture, String
+
+ # @return [String] the content of the script to use for the build rule.
+ #
+ # @note This attribute is present if the #{#compiler_spec} is
+ # `com.apple.compilers.proxy.script`
+ #
+ attribute :script, String
+
+ # @!group Helpers
+
+ # Adds an output file with the specified compiler flags.
+ #
+ # @param [PBXFileReference] file the file to add.
+ #
+ # @param [String] compiler_flags the compiler flags for the file.
+ #
+ # @return [Void]
+ #
+ def add_output_file(file, compiler_flags = '')
+ (self.output_files ||= []) << file
+ (self.output_files_compiler_flags ||= []) << compiler_flags
+ end
+
+ # @return [Array<[PBXFileReference, String]>]
+ # An array containing tuples of output files and their compiler
+ # flags.
+ #
+ def output_files_and_flags
+ (output_files || []).zip(output_files_compiler_flags || [])
+ end
+
+ def ascii_plist_annotation
+ " #{isa} "
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/configuration_list.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/configuration_list.rb
new file mode 100644
index 0000000..d39834f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/configuration_list.rb
@@ -0,0 +1,117 @@
+module Xcodeproj
+ class Project
+ module Object
+ # The primary purpose of this class is to maintain a collection of
+ # related build configurations of a {PBXProject} or a {PBXNativeTarget}.
+ #
+ class XCConfigurationList < AbstractObject
+ # @!group Attributes
+
+ # @return [String] whether the default configuration is visible.
+ # Usually `0`. The purpose of this flag and how Xcode displays
+ # it in the UI is unknown.
+ #
+ attribute :default_configuration_is_visible, String, '0'
+
+ # @return [String] the name of the default configuration.
+ # Usually `Release`. Xcode exposes this attribute as the
+ # configuration for the command line tools and only allows to
+ # set it at the project level.
+ #
+ attribute :default_configuration_name, String, 'Release'
+
+ # @return [ObjectList<XCBuildConfiguration>] the build
+ # configurations of the target.
+ #
+ has_many :build_configurations, XCBuildConfiguration
+
+ public
+
+ # @!group Helpers
+ # --------------------------------------------------------------------#
+
+ # Returns the build configuration with the given name.
+ #
+ # @param [String] name
+ # The name of the build configuration.
+ #
+ # @return [XCBuildConfiguration] The build configuration.
+ # @return [Nil] If not build configuration with the given name is found.
+ #
+ def [](name)
+ build_configurations.find { |bc| bc.name == name }
+ end
+
+ # Returns the build settings of the build configuration with
+ # the given name.
+ #
+ # @param [String] build_configuration_name
+ # The name of the build configuration.
+ #
+ # @return [Hash {String=>String}] the build settings
+ #
+ def build_settings(build_configuration_name)
+ if config = self[build_configuration_name]
+ config.build_settings
+ end
+ end
+
+ # Gets the value for the given build setting in all the build
+ # configurations.
+ #
+ # @param [String] key
+ # the key of the build setting.
+ #
+ # @param [Bool] resolve_against_xcconfig
+ # wether the retrieved setting should take in consideration any
+ # configuration file present.
+ #
+ # @param [PBXNativeTarget] root_target
+ # use this to resolve complete recursion between project and targets
+ #
+ # @return [Hash{String => String}] The value of the build setting
+ # grouped by the name of the build configuration.
+ #
+ def get_setting(key, resolve_against_xcconfig = false, root_target = nil)
+ result = {}
+ build_configurations.each do |bc|
+ result[bc.name] = resolve_against_xcconfig ? bc.resolve_build_setting(key, root_target) : bc.build_settings[key]
+ end
+ result
+ end
+
+ # Sets the given value for the build setting associated with the given
+ # key across all the build configurations.
+ #
+ # @param [String] key
+ # the key of the build setting.
+ #
+ # @param [String] value
+ # the value for the build setting.
+ #
+ # @return [void]
+ #
+ def set_setting(key, value)
+ build_configurations.each do |bc|
+ bc.build_settings[key] = value
+ end
+ end
+
+ def target
+ return project.root_object if project.build_configuration_list.uuid == uuid
+ project.targets.find { |t| t.build_configuration_list.uuid == uuid }
+ end
+
+ #---------------------------------------------------------------------#
+
+ def ascii_plist_annotation
+ if target.nil?
+ ' Build configuration list for <deleted target> '
+ else
+ " Build configuration list for #{target.isa} \"#{target}\" "
+ end
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/container_item_proxy.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/container_item_proxy.rb
new file mode 100644
index 0000000..30abdd9
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/container_item_proxy.rb
@@ -0,0 +1,116 @@
+module Xcodeproj
+ class Project
+ module Object
+ # Apparently a proxy for another object which might belong another
+ # project contained in the same workspace of the project document.
+ #
+ # This class is referenced by {PBXTargetDependency} for information about
+ # it usage see the specs of that class.
+ #
+ # @note This class references the other objects by UUID instead of
+ # creating proper relationships because the other objects might be
+ # part of another project. This implies that the references to
+ # other objects should not increase the retain count of the
+ # targets.
+ #
+ # @todo: This class needs some work to support targets across workspaces,
+ # as the container portal might not be initialized leading
+ # xcodeproj to raise because ti can't find the UUID.
+ #
+ class PBXContainerItemProxy < AbstractObject
+ # @!group Attributes
+
+ # @return [String] apparently the UUID of the root object
+ # {PBXProject} of the project containing the represented
+ # object.
+ #
+ # @todo this is an attribute because a it is usually a reference to
+ # the root object or to a file reference to another project.
+ # The reference to the root object causes a retain cycle that
+ # could cause issues (e.g. in to_tree_hash). Usually those
+ # objects are retained by at least another object (the
+ # {Project} for the root object and a {PBXGroup} for the
+ # reference to another project) and so the referenced object
+ # should be serialized.
+ #
+ # If this assumption is incorrect, there could be loss of
+ # information opening and saving an existing project.
+ #
+ # @todo This is the external reference that 'contains' other proxy
+ # items.
+ attribute :container_portal, String
+
+ # @return [String] the type of the proxy.
+ #
+ # @note @see {Constants::PROXY_TYPE.values} for valid values.
+ #
+ attribute :proxy_type, String
+
+ # @return [String] apparently the UUID of the represented
+ # object.
+ #
+ # @note If the object is in another project the UUID would not be
+ # present in the {Project#objects_by_uuid} hash. For this
+ # reason this is not an `has_one` attribute. It is assumes that
+ # if the object belongs to the project at least another object
+ # should be retaining it. This assumption is reasonable because
+ # this is a proxy class.
+ #
+ # If this assumption is incorrect, there could be loss of
+ # information opening and saving an existing project.
+ #
+ attribute :remote_global_id_string, String
+
+ # @return [String] apparently the name of the object represented by
+ # the proxy.
+ #
+ attribute :remote_info, String
+
+ # Checks whether the reference points to a remote project.
+ #
+ # @return [Bool]
+ #
+ def remote?
+ project.root_object.uuid != container_portal
+ end
+
+ # Get the proxied object
+ #
+ # @return [AbstractObject]
+ #
+ def proxied_object
+ container_portal_object.objects_by_uuid[remote_global_id_string]
+ end
+
+ def container_portal_object
+ if remote?
+ container_portal_file_ref = project.objects_by_uuid[container_portal]
+ Project.open(container_portal_file_ref.real_path)
+ else
+ project
+ end
+ end
+
+ def container_portal_annotation
+ if remote?
+ " #{File.basename(project.objects_by_uuid[container_portal].real_path)} "
+ else
+ project.root_object.ascii_plist_annotation
+ end
+ end
+
+ def to_hash_as(method = :to_hash)
+ hash = super
+ if method == :to_ascii_plist
+ hash['containerPortal'] = Nanaimo::String.new(container_portal, container_portal_annotation)
+ end
+ hash
+ end
+
+ def ascii_plist_annotation
+ " #{isa} "
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_reference.rb
new file mode 100644
index 0000000..2e32e93
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_reference.rb
@@ -0,0 +1,346 @@
+require 'xcodeproj/project/object/helpers/groupable_helper'
+
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a reference to a file in the file system.
+ #
+ class PBXFileReference < AbstractObject
+ # @!group Attributes
+
+ # @return [String] the name of the reference, often not present.
+ #
+ attribute :name, String
+
+ # @return [String] the path to the file relative to the source tree
+ #
+ attribute :path, String
+
+ # @return [String] the directory to which the path is relative.
+ #
+ # @note The accepted values are:
+ # - `<absolute>` for absolute paths
+ # - `<group>` for paths relative to the group
+ # - `SOURCE_ROOT` for paths relative to the project
+ # - `DEVELOPER_DIR` for paths relative to the developer
+ # directory.
+ # - `BUILT_PRODUCTS_DIR` for paths relative to the build
+ # products directory.
+ # - `SDKROOT` for paths relative to the SDK directory.
+ #
+ attribute :source_tree, String, 'SOURCE_ROOT'
+
+ # @return [String] the file type (apparently) used for products
+ # generated by Xcode (i.e. applications, libraries).
+ #
+ attribute :explicit_file_type, String
+
+ # @return [String] the file type guessed by Xcode.
+ #
+ # @note This attribute is not present if there is an
+ # `explicit_file_type`.
+ #
+ attribute :last_known_file_type, String
+
+ # @return [String] whether this file should be indexed. It can
+ # be either `0` or `1`.
+ #
+ # @note Apparently present only for products generated by Xcode with
+ # a value of `0`.
+ #
+ attribute :include_in_index, String, '1'
+
+ # @return [String] a string containing a number which represents the
+ # encoding format of the file.
+ #
+ attribute :fileEncoding, String
+
+ # @return [String] a string that specifies the UTI for the syntax
+ # highlighting.
+ #
+ # @example
+ # `xcode.lang.ruby`
+ #
+ attribute :xc_language_specification_identifier, String
+
+ # @return [String] a string that specifies the UTI for the structure of
+ # a plist file.
+ #
+ # @example
+ # `com.apple.xcode.plist.structure-definition.iphone.info-plist`
+ #
+ attribute :plist_structure_definition_identifier, String
+
+ # @return [String] Whether Xcode should use tabs for text alignment.
+ #
+ # @example
+ # `1`
+ #
+ attribute :uses_tabs, String
+
+ # @return [String] The width of the indent.
+ #
+ # @example
+ # `2`
+ #
+ attribute :indent_width, String
+
+ # @return [String] The width of the tabs.
+ #
+ # @example
+ # `2`
+ #
+ attribute :tab_width, String
+
+ # @return [String] Whether Xcode should wrap lines.
+ #
+ # @example
+ # `1`
+ #
+ attribute :wraps_lines, String
+
+ # @return [String] Apparently whether Xcode should add, if needed, a
+ # new line feed before saving the file.
+ #
+ # @example
+ # `0`
+ #
+ attribute :line_ending, String
+
+ # @return [String] a string that specifies the signature of an external
+ # framework.
+ #
+ # @example
+ # `AppleDeveloperProgram:TEAM0ID1:Team name`
+ #
+ attribute :expected_signature, String
+
+ # @return [String] Comments associated with this file.
+ #
+ # @note This is apparently no longer used by Xcode.
+ #
+ attribute :comments, String
+
+ #---------------------------------------------------------------------#
+
+ public
+
+ # @!group Helpers
+
+ # @return [String] the name of the file taking into account the path if
+ # needed.
+ #
+ def display_name
+ if name
+ name
+ elsif (class << GroupableHelper; self; end)::SOURCE_TREES_BY_KEY[:built_products] == source_tree
+ path
+ elsif path
+ File.basename(path)
+ end
+ end
+
+ # @return [PBXGroup, PBXProject] the parent of the file.
+ #
+ def parent
+ GroupableHelper.parent(self)
+ end
+
+ # @return [Array<PBXGroup, PBXProject>] The list of the parents of the
+ # reference.
+ #
+ def parents
+ GroupableHelper.parents(self)
+ end
+
+ # @return [String] A representation of the reference hierarchy.
+ #
+ def hierarchy_path
+ GroupableHelper.hierarchy_path(self)
+ end
+
+ # Moves the reference to a new parent.
+ #
+ # @param [PBXGroup] new_parent
+ # The new parent.
+ #
+ # @return [void]
+ #
+ def move(new_parent)
+ GroupableHelper.move(self, new_parent)
+ end
+
+ # @return [Pathname] the absolute path of the file resolving the
+ # source tree.
+ #
+ def real_path
+ GroupableHelper.real_path(self)
+ end
+
+ # @return [Pathname] the path of the file without resolving the
+ # source tree.
+ #
+ def full_path
+ GroupableHelper.full_path(self)
+ end
+
+ # Sets the source tree of the reference.
+ #
+ # @param [Symbol, String] source_tree
+ # The source tree, either a string or a symbol.
+ #
+ # @return [void]
+ #
+ def set_source_tree(source_tree)
+ GroupableHelper.set_source_tree(self, source_tree)
+ end
+
+ # Allows to set the path according to the source tree of the reference.
+ #
+ # @param [#to_s] the path for the reference.
+ #
+ # @return [void]
+ #
+ def set_path(path)
+ if path
+ GroupableHelper.set_path_with_source_tree(self, path, source_tree)
+ else
+ self.path = nil
+ end
+ end
+
+ # @return [Array<PBXBuildFile>] the build files associated with the
+ # current file reference.
+ #
+ def build_files
+ referrers.grep(PBXBuildFile)
+ end
+
+ # Sets the last known file type according to the extension of the path.
+ #
+ # @return [void]
+ #
+ def set_last_known_file_type(type = nil)
+ if type
+ self.last_known_file_type = type
+ elsif path
+ extension = Pathname(path).extname[1..-1]
+ self.last_known_file_type = Constants::FILE_TYPES_BY_EXTENSION[extension]
+ end
+ end
+
+ # Sets the explicit file type according to the extension of the path,
+ # and clears the last known file type.
+ #
+ # @return [void]
+ #
+ def set_explicit_file_type(type = nil)
+ self.last_known_file_type = nil
+ if type
+ self.explicit_file_type = type
+ elsif path
+ extension = Pathname(path).extname[1..-1]
+ self.explicit_file_type = Constants::FILE_TYPES_BY_EXTENSION[extension]
+ end
+ end
+
+ #---------------------------------------------------------------------#
+
+ # Checks whether the reference is a proxy.
+ #
+ # @return [Bool] always false for this ISA.
+ #
+ def proxy?
+ false
+ end
+
+ # If this file reference represents an external Xcode project reference
+ # then this will return metadata about it which includes the reference
+ # to the 'Products' group that's created in this project (the project
+ # that includes the external project).
+ #
+ # @return [ObjectDictionary, nil] The external project metadata for
+ # this file reference or `nil` if it's not an external project.
+ #
+ def project_reference_metadata
+ project.root_object.project_references.find do |project_reference|
+ project_reference[:project_ref] == self
+ end
+ end
+
+ # If this file reference represents an external Xcode project reference
+ # then this will return the objects that are 'containers' for items
+ # contained in the external Xcode project.
+ #
+ # @return [Array<PBXContainerItemProxy>] The containers for items in
+ # the external Xcode project.
+ #
+ def proxy_containers
+ project.objects.select do |object|
+ object.isa == 'PBXContainerItemProxy' &&
+ object.container_portal == uuid
+ end
+ end
+
+ # If this file reference represents an external Xcode project reference
+ # then this will return proxies for file references contained in the
+ # external Xcode project.
+ #
+ # @return [Array<PBXReferenceProxy>] The file reference proxies for
+ # items located in the external Xcode project.
+ #
+ def file_reference_proxies
+ containers = proxy_containers
+ if containers.empty?
+ []
+ else
+ project.objects.select do |object|
+ object.isa == 'PBXReferenceProxy' &&
+ containers.include?(object.remote_ref)
+ end
+ end
+ end
+
+ # If this file reference represents an external Xcode project reference
+ # then this will return dependencies on targets contained in the
+ # external Xcode project.
+ #
+ # @return [Array<PBXTargetDependency>] The dependencies on targets
+ # located in the external Xcode project.
+ #
+ def target_dependency_proxies
+ containers = proxy_containers
+ if containers.empty?
+ []
+ else
+ project.objects.select do |object|
+ object.isa == 'PBXTargetDependency' &&
+ containers.include?(object.target_proxy)
+ end
+ end
+ end
+
+ # In addition to removing the file reference, this will also remove any
+ # items related to this reference.
+ #
+ # @see AbstractObject#remove_from_project
+ #
+ # @return [void]
+ #
+ def remove_from_project
+ if project_reference = project_reference_metadata
+ file_reference_proxies.each(&:remove_from_project)
+ target_dependency_proxies.each(&:remove_from_project)
+ project_reference[:product_group].remove_from_project
+ project.root_object.project_references.delete(project_reference)
+ end
+
+ build_files.each(&:remove_from_project)
+ super
+ end
+
+ #---------------------------------------------------------------------#
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_system_synchronized_exception_set.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_system_synchronized_exception_set.rb
new file mode 100644
index 0000000..9e61e10
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_system_synchronized_exception_set.rb
@@ -0,0 +1,62 @@
+require 'xcodeproj/project/object_attributes'
+require 'xcodeproj/project/object/helpers/groupable_helper'
+
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a file system synchronized build file exception set.
+ class PBXFileSystemSynchronizedBuildFileExceptionSet < AbstractObject
+ # @return [AbstractTarget] The target to which this exception set applies.
+ #
+ has_one :target, AbstractTarget
+
+ # @return [Array<String>] The list of files in the group that are excluded from the target.
+ #
+ attribute :membership_exceptions, Array
+
+ # @return [Array<String>] The list of public headers.
+ #
+ attribute :public_headers, Array
+
+ # @return [Array<String>] The list of private headers.
+ #
+ attribute :private_headers, Array
+
+ # @return [Hash] The files with specific compiler flags.
+ #
+ attribute :additional_compiler_flags_by_relative_path, Hash
+
+ # @return [Hash] The files with specific attributes.
+ #
+ attribute :attributes_by_relative_path, Hash
+
+ # @return [Hash] The files with a platform filter.
+ #
+ attribute :platform_filters_by_relative_path, Hash
+
+ def display_name
+ "Exceptions for \"#{GroupableHelper.parent(self).display_name}\" folder in \"#{target.name}\" target"
+ end
+ end
+
+ # This class represents a file system synchronized group build phase membership exception set.
+ class PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet < AbstractObject
+ # @return [PBXSourcesBuildPhase, PBXCopyFilesBuildPhase] The build phase to which this exception set applies.
+ #
+ has_one :build_phase, [PBXSourcesBuildPhase, PBXCopyFilesBuildPhase]
+
+ # @return [Array<String>] The list of files in the group that are excluded from the build phase.
+ #
+ attribute :membership_exceptions, Array
+
+ # @return [Hash] The files with a platform filter.
+ #
+ attribute :platform_filters_by_relative_path, Hash
+
+ def display_name
+ "Exceptions for \"#{GroupableHelper.parent(self).display_name}\" folder in \"#{build_phase.name}\" build phase"
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_system_synchronized_root_group.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_system_synchronized_root_group.rb
new file mode 100644
index 0000000..4a26bc6
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/file_system_synchronized_root_group.rb
@@ -0,0 +1,74 @@
+require 'xcodeproj/project/object/file_system_synchronized_exception_set'
+
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a file system synchronized root group.
+ class PBXFileSystemSynchronizedRootGroup < AbstractObject
+ # @return [String] the directory to which the path is relative.
+ #
+ # @note The accepted values are:
+ # - `<absolute>` for absolute paths
+ # - `<group>` for paths relative to the group
+ # - `SOURCE_ROOT` for paths relative to the project
+ # - `DEVELOPER_DIR` for paths relative to the developer
+ # directory.
+ # - `BUILT_PRODUCTS_DIR` for paths relative to the build
+ # products directory.
+ # - `SDKROOT` for paths relative to the SDK directory.
+ #
+ attribute :source_tree, String, '<group>'
+
+ # @return [String] the path to a folder in the file system.
+ #
+ attribute :path, String
+
+ # @return [String] Whether Xcode should use tabs for text alignment.
+ #
+ # @example
+ # `1`
+ #
+ attribute :uses_tabs, String
+
+ # @return [String] The width of the indent.
+ #
+ # @example
+ # `2`
+ #
+ attribute :indent_width, String
+
+ # @return [String] The width of the tabs.
+ #
+ # @example
+ # `2`
+ #
+ attribute :tab_width, String
+
+ # @return [String] Whether Xcode should wrap lines.
+ #
+ # @example
+ # `1`
+ #
+ attribute :wraps_lines, String
+
+ # @return [Array<PBXFileSystemSynchronizedBuildFileExceptionSet, PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet>]
+ # The list of exceptions applying to this group.
+ #
+ has_many :exceptions, [PBXFileSystemSynchronizedBuildFileExceptionSet, PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet]
+
+ # @return [Hash] The files in the group that have a file type defined explicitly.
+ #
+ attribute :explicit_file_types, Hash
+
+ # @return [Array] The folders in the group that are defined explicitly.
+ #
+ attribute :explicit_folders, Array
+
+ def display_name
+ return path if path
+ super
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/group.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/group.rb
new file mode 100644
index 0000000..51902dd
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/group.rb
@@ -0,0 +1,507 @@
+require 'xcodeproj/project/object/helpers/groupable_helper'
+require 'xcodeproj/project/object/helpers/file_references_factory'
+require 'xcodeproj/project/object/file_system_synchronized_root_group'
+
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a group. A group can contain other groups
+ # (PBXGroup) and file references (PBXFileReference).
+ #
+ class PBXGroup < AbstractObject
+ # @!group Attributes
+
+ # @return [ObjectList<PBXGroup, PBXFileReference>]
+ # the objects contained by the group.
+ #
+ has_many :children, [PBXGroup, PBXFileReference, PBXReferenceProxy, PBXFileSystemSynchronizedRootGroup]
+
+ # @return [String] the directory to which the path is relative.
+ #
+ # @note The accepted values are:
+ # - `<absolute>` for absolute paths
+ # - `<group>` for paths relative to the group
+ # - `SOURCE_ROOT` for paths relative to the project
+ # - `DEVELOPER_DIR` for paths relative to the developer
+ # directory.
+ # - `BUILT_PRODUCTS_DIR` for paths relative to the build
+ # products directory.
+ # - `SDKROOT` for paths relative to the SDK directory.
+ #
+ attribute :source_tree, String, '<group>'
+
+ # @return [String] the path to a folder in the file system.
+ #
+ # @note This attribute is present for groups that are linked to a
+ # folder in the file system.
+ #
+ attribute :path, String
+
+ # @return [String] the name of the group.
+ #
+ # @note If path is specified this attribute is not present.
+ #
+ attribute :name, String
+
+ # @return [String] Whether Xcode should use tabs for text alignment.
+ #
+ # @example
+ # `1`
+ #
+ attribute :uses_tabs, String
+
+ # @return [String] The width of the indent.
+ #
+ # @example
+ # `2`
+ #
+ attribute :indent_width, String
+
+ # @return [String] The width of the tabs.
+ #
+ # @example
+ # `2`
+ #
+ attribute :tab_width, String
+
+ # @return [String] Whether Xcode should wrap lines.
+ #
+ # @example
+ # `1`
+ #
+ attribute :wraps_lines, String
+
+ # @return [String] Comments associated with this group.
+ #
+ # @note This is apparently no longer used by Xcode.
+ #
+ attribute :comments, String
+
+ public
+
+ # @!group Helpers
+ #---------------------------------------------------------------------#
+
+ # @return [PBXGroup, PBXProject] The parent of the group.
+ #
+ def parent
+ GroupableHelper.parent(self)
+ end
+
+ # @return [Array<PBXGroup, PBXProject>] The list of the parents of the
+ # group.
+ #
+ def parents
+ GroupableHelper.parents(self)
+ end
+
+ # @return [String] A representation of the group hierarchy.
+ #
+ def hierarchy_path
+ GroupableHelper.hierarchy_path(self)
+ end
+
+ # Moves the group to a new parent.
+ #
+ # @param [PBXGroup] new_parent
+ # The new parent.
+ #
+ # @return [void]
+ #
+ def move(new_parent)
+ GroupableHelper.move(self, new_parent)
+ end
+
+ # @return [Pathname] the absolute path of the group resolving the
+ # source tree.
+ #
+ def real_path
+ GroupableHelper.real_path(self)
+ end
+
+ # Sets the source tree of the group.
+ #
+ # @param [Symbol, String] source_tree
+ # The source tree, either a string or a symbol.
+ #
+ # @return [void]
+ #
+ def set_source_tree(source_tree)
+ GroupableHelper.set_source_tree(self, source_tree)
+ end
+
+ # Allows to set the path according to the source tree of the group.
+ #
+ # @param [#to_s] the path for the group.
+ #
+ # @return [void]
+ #
+ def set_path(path)
+ if path
+ source_tree
+ GroupableHelper.set_path_with_source_tree(self, path, source_tree)
+ else
+ self.path = nil
+ self.source_tree = '<group>'
+ end
+ end
+
+ # @return [Array<PBXFileReference>] the file references in the group
+ # children.
+ #
+ def files
+ children.grep(PBXFileReference)
+ end
+
+ # @return [PBXFileReference] The file references whose path (regardless
+ # of the source tree) matches the give path.
+ #
+ def find_file_by_path(path)
+ files.find { |ref| ref.path == path }
+ end
+
+ # @return [Array<PBXGroup>] the groups in the group children.
+ #
+ def groups
+ # Don't grep / is_a? as this would include child classes.
+ children.select { |obj| obj.class == PBXGroup }
+ end
+
+ # @return [Array<XCVersionGroup>] the version groups in the group
+ # children.
+ #
+ def version_groups
+ children.grep(XCVersionGroup)
+ end
+
+ # @return [Array<PBXGroup,PBXFileReference,PBXReferenceProxy>] the
+ # recursive children of the group.
+ #
+ def recursive_children_groups
+ result = []
+ groups.each do |child|
+ result << child
+ result.concat(child.recursive_children_groups)
+ end
+ result
+ end
+
+ # @return [Array<PBXGroup,PBXFileReference,PBXReferenceProxy>] the
+ # recursive list of the children of the group.
+ #
+ def recursive_children
+ result = []
+ children.each do |child|
+ result << child
+ if child.is_a?(PBXGroup)
+ result.concat(child.recursive_children)
+ end
+ end
+ result
+ end
+
+ # @return [Bool] Whether the group is empty.
+ #
+ def empty?
+ children.count.zero?
+ end
+
+ # Creates a new reference with the given path and adds it to the
+ # group. The reference is configured according to the extension
+ # of the path.
+ #
+ # @param [#to_s] path
+ # The, preferably absolute, path of the reference.
+ #
+ # @param [Symbol] source_tree
+ # The source tree key to use to configure the path (@see
+ # GroupableHelper::SOURCE_TREES_BY_KEY).
+ #
+ # @return [PBXFileReference, XCVersionGroup] The new reference.
+ #
+ def new_reference(path, source_tree = :group)
+ FileReferencesFactory.new_reference(self, path, source_tree)
+ end
+ alias_method :new_file, :new_reference
+
+ # Creates a file reference to a static library and adds it to the
+ # group.
+ #
+ # @param [#to_s] product_basename
+ # The name of the static library.
+ #
+ # @return [PBXFileReference] The new file reference.
+ #
+ def new_product_ref_for_target(product_basename, product_type)
+ FileReferencesFactory.new_product_ref_for_target(self, product_basename, product_type)
+ end
+
+ # Creates a file reference to a new bundle.
+ #
+ # @param [#to_s] product_basename
+ # The name of the bundle.
+ #
+ # @return [PBXFileReference] The new file reference.
+ #
+ def new_bundle(product_basename)
+ FileReferencesFactory.new_bundle(self, product_basename)
+ end
+
+ # Creates a file reference to a new bundle and adds it to the group.
+ #
+ # @note @see new_reference
+ #
+ # @param [#to_s] name
+ # the name of the new group.
+ #
+ # @return [PBXGroup] the new group.
+ #
+ def new_group(name, path = nil, source_tree = :group)
+ group = project.new(PBXGroup)
+ children << group
+ group.name = name
+ group.set_source_tree(source_tree)
+ group.set_path(path)
+ group
+ end
+
+ # Creates a new variant group and adds it to the group
+ #
+ # @note @see new_group
+ #
+ # @param [#to_s] name
+ # the name of the new group.
+ #
+ # @param [#to_s] path
+ # The, preferably absolute, path of the variant group.
+ # Pass the path of the folder containing all the .lproj bundles,
+ # that contain files for the variant group.
+ # Do not pass the path of a specific bundle (such as en.lproj)
+ #
+ # @param [Symbol] source_tree
+ # The source tree key to use to configure the path (@see
+ # GroupableHelper::SOURCE_TREES_BY_KEY).
+ #
+ # @return [PBXVariantGroup] the new variant group.
+ #
+ def new_variant_group(name, path = nil, source_tree = :group)
+ group = project.new(PBXVariantGroup)
+ children << group
+ group.name = name
+ group.set_source_tree(source_tree)
+ group.set_path(path)
+ group
+ end
+
+ # Traverses the children groups and finds the group with the given
+ # path, if exists.
+ #
+ # @see find_subpath
+ #
+ def [](path)
+ find_subpath(path, false)
+ end
+
+ # Removes children files and groups under this group.
+ #
+ def clear
+ children.objects.each(&:remove_from_project)
+ end
+ alias_method :remove_children_recursively, :clear
+
+ # Traverses the children groups and finds the children with the given
+ # path, optionally, creating any needed group. If the given path is
+ # `nil` it returns itself.
+ #
+ # @param [String] path
+ # a string with the names of the groups separated by a '`/`'.
+ #
+ # @param [Boolean] should_create
+ # whether the path should be created.
+ #
+ # @note The path is matched against the {#display_name} of the groups.
+ #
+ # @example
+ # g = main_group['Frameworks']
+ # g.name #=> 'Frameworks'
+ #
+ # @return [PBXGroup] the group if found.
+ # @return [Nil] if the path could not be found and should create is
+ # false.
+ #
+ def find_subpath(path, should_create = false)
+ return self unless path
+ path = path.split('/') unless path.is_a?(Array)
+ child_name = path.shift
+ child = children.find { |c| c.display_name == child_name }
+ if child.nil?
+ if should_create
+ child = new_group(child_name)
+ else
+ return nil
+ end
+ end
+ if path.empty?
+ child
+ else
+ child.find_subpath(path, should_create)
+ end
+ end
+
+ # Adds an object to the group.
+ #
+ # @return [ObjectList<AbstractObject>] the children list.
+ #
+ def <<(child)
+ children << child
+ end
+
+ # Sorts the children of the group by type and then by name.
+ #
+ # @note This is safe to call in an object list because it modifies it
+ # in C in Ruby MRI. In other Ruby implementation it can cause
+ # issues if there is one call to the notification enabled
+ # methods not compensated by the corespondent opposite (loss of
+ # UUIDs and objects from the project).
+ #
+ # @return [void]
+ #
+ def sort_by_type
+ children.sort! do |x, y|
+ if x.isa == 'PBXGroup' && !(y.isa == 'PBXGroup')
+ -1
+ elsif !(x.isa == 'PBXGroup') && y.isa == 'PBXGroup'
+ 1
+ elsif x.display_name && y.display_name
+ extname_x = File.extname(x.display_name)
+ extname_y = File.extname(y.display_name)
+ if extname_x != extname_y
+ extname_x <=> extname_y
+ else
+ File.basename(x.display_name, '.*') <=> File.basename(y.display_name, '.*')
+ end
+ else
+ 0
+ end
+ end
+ end
+
+ # Sorts the group by type recursively.
+ #
+ # @return [void]
+ #
+ def sort_recursively_by_type
+ groups.each(&:sort_recursively_by_type)
+ sort_by_type
+ end
+
+ public
+
+ # @!group AbstractObject Hooks
+ #---------------------------------------------------------------------#
+
+ # @return [String] the name of the group taking into account the path
+ # or other factors if needed.
+ #
+ def display_name
+ if name
+ name
+ elsif path
+ File.basename(path)
+ elsif self.equal?(project.main_group)
+ 'Main Group'
+ end
+ end
+
+ def ascii_plist_annotation
+ super unless self.equal?(project.main_group)
+ end
+
+ # Sorts the to many attributes of the object according to the display
+ # name.
+ #
+ # @param [Hash] options
+ # the sorting options.
+ # @option options [Symbol] :groups_position
+ # the position of the groups can be either `:above` or
+ # `:below`.
+ #
+ # @return [void]
+ #
+ def sort(options = nil)
+ children.sort! do |x, y|
+ if options && groups_position = options[:groups_position]
+ raise ArgumentError unless [:above, :below].include?(groups_position)
+ if x.isa == 'PBXGroup' && !(y.isa == 'PBXGroup')
+ next groups_position == :above ? -1 : 1
+ elsif !(x.isa == 'PBXGroup') && y.isa == 'PBXGroup'
+ next groups_position == :above ? 1 : -1
+ end
+ end
+
+ result = File.basename(x.display_name.downcase, '.*') <=> File.basename(y.display_name.downcase, '.*')
+ if result.zero?
+ result = File.extname(x.display_name.downcase) <=> File.extname(y.display_name.downcase)
+ if result.zero? && !(x.path.nil? || y.path.nil?)
+ result = x.path.downcase <=> y.path.downcase
+ end
+ end
+ result
+ end
+ end
+
+ # @return [Array<PBXBuildFile>] the build files associated with the
+ # current reference proxy.
+ #
+ def build_files
+ referrers.grep(PBXBuildFile)
+ end
+
+ # In addition to removing the reference proxy, this will also remove any
+ # items related to this reference.
+ #
+ # @see AbstractObject#remove_from_project
+ #
+ # @return [void]
+ #
+ def remove_from_project
+ build_files.each(&:remove_from_project)
+ super
+ end
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # This class is used to gather localized files into one entry.
+ #
+ class PBXVariantGroup < PBXGroup
+ # @!group Attributes
+
+ # @return [String] the file type guessed by Xcode.
+ #
+ attribute :last_known_file_type, String
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # A group that contains multiple files references to the different
+ # versions of a resource.
+ #
+ # Used to contain the different versions of a `xcdatamodel`.
+ #
+ class XCVersionGroup < PBXGroup
+ # @!group Attributes
+
+ # @return [PBXFileReference] the reference to the current version.
+ #
+ has_one :current_version, PBXFileReference
+
+ # @return [String] the type of the versioned resource.
+ #
+ attribute :version_group_type, String, 'wrapper.xcdatamodel'
+ end
+
+ #-----------------------------------------------------------------------#
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/build_settings_array_settings_by_object_version.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/build_settings_array_settings_by_object_version.rb
new file mode 100644
index 0000000..431fdd1
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/build_settings_array_settings_by_object_version.rb
@@ -0,0 +1,72 @@
+require 'set'
+
+module Xcodeproj
+ class Project
+ module Object
+ class XCBuildConfiguration
+ # yes, they are case-sensitive.
+ # no, Xcode doesn't do this for other PathList settings nor other
+ # settings ending in SEARCH_PATHS.
+ module BuildSettingsArraySettingsByObjectVersion
+ ARRAY_SETTINGS = %w(
+ ALTERNATE_PERMISSIONS_FILES
+ ARCHS
+ BUILD_VARIANTS
+ EXCLUDED_SOURCE_FILE_NAMES
+ FRAMEWORK_SEARCH_PATHS
+ GCC_PREPROCESSOR_DEFINITIONS
+ GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS
+ HEADER_SEARCH_PATHS
+ INFOPLIST_PREPROCESSOR_DEFINITIONS
+ LIBRARY_SEARCH_PATHS
+ OTHER_CFLAGS
+ OTHER_CPLUSPLUSFLAGS
+ OTHER_LDFLAGS
+ REZ_SEARCH_PATHS
+ SECTORDER_FLAGS
+ WARNING_CFLAGS
+ WARNING_LDFLAGS
+ ).to_set.freeze
+ private_constant :ARRAY_SETTINGS
+
+ ARRAY_SETTINGS_OBJECT_VERSION_50 = %w(
+ ALTERNATE_PERMISSIONS_FILES
+ ARCHS
+ BUILD_VARIANTS
+ EXCLUDED_SOURCE_FILE_NAMES
+ FRAMEWORK_SEARCH_PATHS
+ GCC_PREPROCESSOR_DEFINITIONS
+ GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS
+ HEADER_SEARCH_PATHS
+ INCLUDED_SOURCE_FILE_NAMES
+ INFOPLIST_PREPROCESSOR_DEFINITIONS
+ LD_RUNPATH_SEARCH_PATHS
+ LIBRARY_SEARCH_PATHS
+ LOCALIZED_STRING_MACRO_NAMES
+ OTHER_CFLAGS
+ OTHER_CPLUSPLUSFLAGS
+ OTHER_LDFLAGS
+ REZ_SEARCH_PATHS
+ SECTORDER_FLAGS
+ SYSTEM_FRAMEWORK_SEARCH_PATHS
+ SYSTEM_HEADER_SEARCH_PATHS
+ USER_HEADER_SEARCH_PATHS
+ WARNING_CFLAGS
+ WARNING_LDFLAGS
+ ).to_set.freeze
+ private_constant :ARRAY_SETTINGS_OBJECT_VERSION_50
+
+ def self.[](object_version)
+ object_version = object_version.to_i
+
+ if object_version >= 50
+ ARRAY_SETTINGS_OBJECT_VERSION_50
+ else
+ ARRAY_SETTINGS
+ end
+ end
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/file_references_factory.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/file_references_factory.rb
new file mode 100644
index 0000000..d59f85c
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/file_references_factory.rb
@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+require 'xcodeproj/project/object/helpers/groupable_helper'
+
+module Xcodeproj
+ class Project
+ module Object
+ class FileReferencesFactory
+ class << self
+ # Creates a new reference with the given path and adds it to the
+ # given group. The reference is configured according to the extension
+ # of the path.
+ #
+ # @param [PBXGroup] group
+ # The group to which to add the reference.
+ #
+ # @param [#to_s] path
+ # The, preferably absolute, path of the reference.
+ #
+ # @param [Symbol] source_tree
+ # The source tree key to use to configure the path (@see
+ # GroupableHelper::SOURCE_TREES_BY_KEY).
+ #
+ # @return [PBXFileReference, XCVersionGroup] The new reference.
+ #
+ def new_reference(group, path, source_tree)
+ ref = case File.extname(path).downcase
+ when '.xcdatamodeld'
+ new_xcdatamodeld(group, path, source_tree)
+ when '.xcodeproj'
+ new_subproject(group, path, source_tree)
+ else
+ new_file_reference(group, path, source_tree)
+ end
+
+ configure_defaults_for_file_reference(ref)
+ ref
+ end
+
+ # Creates a file reference to a static library and adds it to the
+ # given group.
+ #
+ # @param [PBXGroup] group
+ # The group to which to add the reference.
+ #
+ # @param [#to_s] product_basename
+ # The name of the static library.
+ #
+ # @return [PBXFileReference] The new file reference.
+ #
+ def new_product_ref_for_target(group, product_basename, product_type)
+ if product_type == :static_library
+ prefix = 'lib'
+ end
+ extension = Constants::PRODUCT_UTI_EXTENSIONS[product_type]
+ path = "#{prefix}#{product_basename}"
+ path += ".#{extension}" if extension
+ ref = new_reference(group, path, :built_products)
+ ref.include_in_index = '0'
+ ref.set_explicit_file_type
+ ref
+ end
+
+ # Creates a file reference to a new bundle and adds it to the given
+ # group.
+ #
+ # @param [PBXGroup] group
+ # The group to which to add the reference.
+ #
+ # @param [#to_s] product_basename
+ # The name of the bundle.
+ #
+ # @return [PBXFileReference] The new file reference.
+ #
+ def new_bundle(group, product_basename)
+ ref = new_reference(group, "#{product_basename}.bundle", :built_products)
+ ref.include_in_index = '0'
+ ref.set_explicit_file_type('wrapper.cfbundle')
+ ref
+ end
+
+ private
+
+ # @group Private Helpers
+ #-------------------------------------------------------------------#
+
+ # Creates a new file reference with the given path and adds it to the
+ # given group.
+ #
+ # @param [PBXGroup] group
+ # The group to which to add the reference.
+ #
+ # @param [#to_s] path
+ # The, preferably absolute, path of the reference.
+ #
+ # @param [Symbol] source_tree
+ # The source tree key to use to configure the path (@see
+ # GroupableHelper::SOURCE_TREES_BY_KEY).
+ #
+ # @return [PBXFileReference] The new file reference.
+ #
+ def new_file_reference(group, path, source_tree)
+ path = Pathname.new(path)
+ ref = group.project.new(PBXFileReference)
+ group.children << ref
+ GroupableHelper.set_path_with_source_tree(ref, path, source_tree)
+ ref.set_last_known_file_type
+ ref
+ end
+
+ # Creates a new version group reference to an xcdatamodeled adding
+ # the xcdatamodel files included in the wrapper as children file
+ # references.
+ #
+ # @param [PBXGroup] group
+ # The group to which to add the reference.
+ #
+ # @param [#to_s] path
+ # The, preferably absolute, path of the reference.
+ #
+ # @param [Symbol] source_tree
+ # The source tree key to use to configure the path (@see
+ # GroupableHelper::SOURCE_TREES_BY_KEY).
+ #
+ # @note To match Xcode behaviour the current version is read from
+ # the .xccurrentversion file, if it doesn't exist the last
+ # xcdatamodel according to its path is set as the current
+ # version.
+ #
+ # @return [XCVersionGroup] The new reference.
+ #
+ def new_xcdatamodeld(group, path, source_tree)
+ path = Pathname.new(path)
+ ref = group.project.new(XCVersionGroup)
+ group.children << ref
+ GroupableHelper.set_path_with_source_tree(ref, path, source_tree)
+ ref.version_group_type = 'wrapper.xcdatamodel'
+
+ real_path = group.real_path.join(path)
+ current_version_name = nil
+ if real_path.exist?
+ real_path.children.each do |child_path|
+ if File.extname(child_path) == '.xcdatamodel'
+ new_file_reference(ref, child_path, :group)
+ elsif File.basename(child_path) == '.xccurrentversion'
+ full_path = real_path + File.basename(child_path)
+ xccurrentversion = Plist.read_from_path(full_path)
+ current_version_name = xccurrentversion['_XCCurrentVersionName']
+ end
+ end
+
+ if current_version_name
+ ref.current_version = ref.children.find do |obj|
+ obj.path.split('/').last == current_version_name
+ end
+ end
+ end
+
+ ref
+ end
+
+ # Creates a file reference to another Xcode subproject and setups the
+ # proxies to the targets.
+ #
+ # @param [PBXGroup] group
+ # The group to which to add the reference.
+ #
+ # @param [#to_s] path
+ # The, preferably absolute, path of the reference.
+ #
+ # @param [Symbol] source_tree
+ # The source tree key to use to configure the path (@see
+ # GroupableHelper::SOURCE_TREES_BY_KEY).
+ #
+ # @note To analyze the targets the given project is read and thus
+ # it should already exist in the disk.
+ #
+ # @return [PBXFileReference] The new file reference.
+ #
+ def new_subproject(group, path, source_tree)
+ ref = new_file_reference(group, path, source_tree)
+ ref.include_in_index = nil
+
+ product_group_ref = find_products_group_ref(group, true)
+
+ subproj = Project.open(path)
+ subproj.products_group.files.each do |product_reference|
+ container_proxy = group.project.new(PBXContainerItemProxy)
+ container_proxy.container_portal = ref.uuid
+ container_proxy.proxy_type = Constants::PROXY_TYPES[:reference]
+ container_proxy.remote_global_id_string = product_reference.uuid
+ container_proxy.remote_info = 'Subproject'
+
+ reference_proxy = group.project.new(PBXReferenceProxy)
+ extension = File.extname(product_reference.path)[1..-1]
+ reference_proxy.file_type = Constants::FILE_TYPES_BY_EXTENSION[extension]
+ reference_proxy.path = product_reference.path
+ reference_proxy.remote_ref = container_proxy
+ reference_proxy.source_tree = 'BUILT_PRODUCTS_DIR'
+
+ product_group_ref << reference_proxy
+ end
+
+ attribute = PBXProject.references_by_keys_attributes.find { |attrb| attrb.name == :project_references }
+ project_reference = ObjectDictionary.new(attribute, group.project.root_object)
+ project_reference[:project_ref] = ref
+ project_reference[:product_group] = product_group_ref
+ group.project.root_object.project_references << project_reference
+
+ ref
+ end
+
+ # Configures a file reference according to the extension to math
+ # Xcode behaviour.
+ #
+ # @param [PBXFileReference] ref
+ # The file reference to configure.
+ #
+ # @note To closely match the Xcode behaviour the name attribute of
+ # the file reference is set only if the path of the file is
+ # not equal to the path of the group.
+ #
+ # @return [void]
+ #
+ def configure_defaults_for_file_reference(ref)
+ if ref.path.include?('/')
+ ref.name = ref.path.split('/').last
+ end
+
+ if File.extname(ref.path).downcase == '.framework'
+ ref.include_in_index = nil
+ end
+ end
+
+ def find_products_group_ref(group, should_create = false)
+ product_group_ref =
+ (group.project.root_object.product_ref_group ||= group.project.main_group.find_subpath('Products', should_create))
+ product_group_ref
+ end
+
+ #-------------------------------------------------------------------#
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/groupable_helper.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/groupable_helper.rb
new file mode 100644
index 0000000..1ae19fb
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/helpers/groupable_helper.rb
@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+module Xcodeproj
+ class Project
+ module Object
+ class GroupableHelper
+ class << self
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to analyze.
+ #
+ # @return [PBXGroup, PBXProject] The parent of the object.
+ #
+ def parent(object)
+ referrers = object.referrers.uniq
+ if referrers.count > 1
+ referrers = referrers.grep(PBXGroup)
+ end
+
+ if referrers.count == 0
+ raise '[Xcodeproj] Consistency issue: no parent ' \
+ "for object `#{object.display_name}`: "\
+ "`#{object.referrers.join('`, `')}`"
+ elsif referrers.count > 1
+ raise '[Xcodeproj] Consistency issue: unexpected multiple parents ' \
+ "for object `#{object.display_name}`: "\
+ "#{object.referrers}"
+ end
+ referrers.first
+ end
+
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to analyze.
+ #
+ # @return [Array<PBXGroup, PBXProject>] The parents of the object.
+ #
+ def parents(object)
+ if main_group?(object)
+ []
+ else
+ parent = parent(object)
+ parents(parent).push(parent)
+ end
+ end
+
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to analyze.
+ #
+ # @return [String] A representation of the group hierarchy.
+ #
+ def hierarchy_path(object)
+ unless main_group?(object)
+ parent = parent(object)
+ parent = parent.hierarchy_path if parent.respond_to?(:hierarchy_path)
+ "#{parent}/#{object.display_name}"
+ end
+ end
+
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to analyze.
+ #
+ # @return [Bool] Wether the object is the main group of the project.
+ #
+ def main_group?(object)
+ object.equal?(object.project.main_group)
+ end
+
+ # Moves the object to a new parent.
+ #
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to move.
+ #
+ # @param [PBXGroup] new_parent
+ # The new parent.
+ #
+ # @return [void]
+ #
+ def move(object, new_parent)
+ unless object
+ raise "[Xcodeproj] Attempt to move nil object to `#{new_parent}`."
+ end
+ unless new_parent
+ raise "[Xcodeproj] Attempt to move object `#{object}` to nil parent."
+ end
+ if new_parent.equal?(object)
+ raise "[Xcodeproj] Attempt to move object `#{object}` to itself."
+ end
+ if parents(new_parent).include?(object)
+ raise "[Xcodeproj] Attempt to move object `#{object}` to a child object `#{new_parent}`."
+ end
+
+ object.parent.children.delete(object)
+ new_parent << object
+ end
+
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to analyze.
+ #
+ # @return [Pathname] The absolute path of the object resolving the
+ # source tree.
+ #
+ def real_path(object)
+ source_tree = source_tree_real_path(object)
+ path = object.path || ''.freeze
+ if source_tree
+ source_tree + path
+ else
+ Pathname(path)
+ end
+ end
+
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to analyze.
+ #
+ # @return [Pathname] The path of the object without resolving the
+ # source tree.
+ #
+ def full_path(object)
+ folder = case object.source_tree
+ when '<group>'
+ object_parent = parent(object)
+ if object_parent.isa == 'PBXProject'.freeze
+ nil
+ else
+ full_path(object_parent)
+ end
+ when 'SOURCE_ROOT'
+ nil
+ when '<absolute>'
+ Pathname.new('/'.freeze)
+ else
+ Pathname.new("${#{object.source_tree}}")
+ end
+ folder ||= Pathname.new('')
+ if object.path
+ folder + object.path
+ else
+ folder
+ end
+ end
+
+ # @param [PBXGroup, PBXFileReference] object
+ # The object to analyze.
+ #
+ # @return [Pathname] The absolute path of the source tree of the
+ # object.
+ #
+ def source_tree_real_path(object)
+ case object.source_tree
+ when '<group>'
+ object_parent = parent(object)
+ if object_parent.isa == 'PBXProject'.freeze
+ object.project.project_dir + object.project.root_object.project_dir_path
+ else
+ real_path(object_parent)
+ end
+ when 'SOURCE_ROOT'
+ object.project.project_dir
+ when '<absolute>'
+ nil
+ else
+ Pathname.new("${#{object.source_tree}}")
+ end
+ end
+
+ # @return [Hash{Symbol => String}] The source tree values by they
+ # symbol representation.
+ #
+ SOURCE_TREES_BY_KEY = {
+ :absolute => '<absolute>',
+ :group => '<group>',
+ :project => 'SOURCE_ROOT',
+ :built_products => 'BUILT_PRODUCTS_DIR',
+ :developer_dir => 'DEVELOPER_DIR',
+ :sdk_root => 'SDKROOT',
+ }.freeze
+
+ # Sets the source tree of the given object.
+ #
+ # @param [Symbol, String] source_tree
+ # The source tree, either a string or a key for
+ # {SOURCE_TREES_BY_KEY}.
+ #
+ # @return [void]
+ #
+ def set_source_tree(object, source_tree)
+ source_tree = normalize_source_tree(source_tree)
+ object.source_tree = source_tree
+ end
+
+ # Sets the path of the given object according to the provided source
+ # tree key. The path is converted to relative according to the real
+ # path of the source tree for group and project source trees, if both
+ # paths are relative or absolute. Otherwise the path is set as
+ # provided.
+ #
+ # @param [PBXGroup, PBXFileReference] object
+ # The object whose path needs to be set.
+ #
+ # @param [#to_s] path
+ # The path.
+ #
+ # @param [Symbol, String] source_tree
+ # The source tree, either a string or a key for
+ # {SOURCE_TREES_BY_KEY}.
+ #
+ # @return [void]
+ #
+ def set_path_with_source_tree(object, path, source_tree)
+ path = Pathname(path)
+ source_tree = normalize_source_tree(source_tree)
+ object.source_tree = source_tree
+
+ if source_tree == SOURCE_TREES_BY_KEY[:absolute]
+ unless path.absolute?
+ raise '[Xcodeproj] Attempt to set a relative path with an ' \
+ "absolute source tree: `#{path}`"
+ end
+ object.path = path.to_s
+ elsif source_tree == SOURCE_TREES_BY_KEY[:group] || source_tree == SOURCE_TREES_BY_KEY[:project]
+ source_tree_real_path = GroupableHelper.source_tree_real_path(object)
+ if source_tree_real_path && source_tree_real_path.absolute? == path.absolute?
+ relative_path = path.relative_path_from(source_tree_real_path)
+ object.path = relative_path.to_s
+ else
+ object.path = path.to_s
+ end
+ else
+ object.path = path.to_s
+ end
+ end
+
+ private
+
+ # @group Helpers
+ #-------------------------------------------------------------------#
+
+ # Converts the given source tree to its string value.
+ #
+ # @param [Symbol, String] source_tree
+ # The source tree, either a string or a key for
+ # {SOURCE_TREES_BY_KEY}.
+ #
+ # @return [String] the string value of the source tree.
+ #
+ def normalize_source_tree(source_tree)
+ if source_tree.is_a?(Symbol)
+ source_tree = SOURCE_TREES_BY_KEY[source_tree]
+ end
+
+ unless SOURCE_TREES_BY_KEY.values.include?(source_tree)
+ raise "[Xcodeproj] Unrecognized source tree option `#{source_tree}`"
+ end
+ source_tree
+ end
+
+ #-------------------------------------------------------------------#
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/native_target.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/native_target.rb
new file mode 100644
index 0000000..42b008c
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/native_target.rb
@@ -0,0 +1,772 @@
+module Xcodeproj
+ class Project
+ module Object
+ class AbstractTarget < AbstractObject
+ # @!group Attributes
+
+ # @return [String] The name of the Target.
+ #
+ attribute :name, String
+
+ # @return [String] the name of the build product.
+ #
+ attribute :product_name, String
+
+ # @return [String] Comments associated with this target.
+ #
+ # This is apparently no longer used by Xcode.
+ #
+ attribute :comments, String
+
+ # @return [XCConfigurationList] the list of the build configurations of
+ # the target. This list commonly include two configurations
+ # `Debug` and `Release`.
+ #
+ has_one :build_configuration_list, XCConfigurationList
+
+ # @return [ObjectList<PBXTargetDependency>] the targets necessary to
+ # build this target.
+ #
+ has_many :dependencies, PBXTargetDependency
+
+ public
+
+ # @!group Helpers
+ #--------------------------------------#
+
+ # Gets the value for the given build setting in all the build
+ # configurations or the value inheriting the value from the project
+ # ones if needed.
+ #
+ # @param [String] key
+ # the key of the build setting.
+ #
+ # @param [Bool] resolve_against_xcconfig
+ # whether the resolved setting should take in consideration any
+ # configuration file present.
+ #
+ # @return [Hash{String => String}] The value of the build setting
+ # grouped by the name of the build configuration.
+ #
+ # TODO: Full support for this would require to take into account
+ # the default values for the platform.
+ #
+ def resolved_build_setting(key, resolve_against_xcconfig = false)
+ target_settings = build_configuration_list.get_setting(key, resolve_against_xcconfig, self)
+ project_settings = project.build_configuration_list.get_setting(key, resolve_against_xcconfig)
+ target_settings.merge(project_settings) do |_key, target_val, proj_val|
+ target_includes_inherited = Constants::INHERITED_KEYWORDS.any? { |keyword| target_val.include?(keyword) } if target_val
+ if target_includes_inherited && proj_val
+ if target_val.is_a? String
+ target_val.gsub(Regexp.union(Constants::INHERITED_KEYWORDS), proj_val)
+ else
+ target_val.flat_map { |value| Constants::INHERITED_KEYWORDS.include?(value) ? proj_val : value }
+ end
+ else
+ target_val || proj_val
+ end
+ end
+ end
+
+ # Gets the value for the given build setting, properly inherited if
+ # need, if shared across the build configurations.
+ #
+ # @param [String] key
+ # the key of the build setting.
+ #
+ # @param [Boolean] resolve_against_xcconfig
+ # whether the resolved setting should take in consideration any
+ # configuration file present.
+ #
+ # @raise If the build setting has multiple values.
+ #
+ # @note As it is common not to have a setting with no value for
+ # custom build configurations nil keys are not considered to
+ # determine if the setting is unique. This is an heuristic
+ # which might not closely match Xcode behaviour.
+ #
+ # @return [String] The value of the build setting.
+ #
+ def common_resolved_build_setting(key, resolve_against_xcconfig: false)
+ values = resolved_build_setting(key, resolve_against_xcconfig).values.compact.uniq
+ if values.count <= 1
+ values.first
+ else
+ raise "[Xcodeproj] Consistency issue: build setting `#{key}` has multiple values: `#{resolved_build_setting(key)}`"
+ end
+ end
+
+ # @return [String] the SDK that the target should use.
+ #
+ def sdk
+ common_resolved_build_setting('SDKROOT')
+ end
+
+ # @return [Symbol] the name of the platform of the target.
+ #
+ def platform_name
+ return unless sdk
+ if sdk.include? 'iphoneos'
+ :ios
+ elsif sdk.include? 'macosx'
+ :osx
+ elsif sdk.include? 'appletvos'
+ :tvos
+ elsif sdk.include? 'xros'
+ :visionos
+ elsif sdk.include? 'watchos'
+ :watchos
+ end
+ end
+
+ # @return [String] the version of the SDK.
+ #
+ def sdk_version
+ return unless sdk
+ sdk.scan(/[0-9.]+/).first
+ end
+
+ # @visibility private
+ #
+ # @return [Hash<Symbol, String>]
+ # The name of the setting for the deployment target by platform
+ # name.
+ #
+ DEPLOYMENT_TARGET_SETTING_BY_PLATFORM_NAME = {
+ :ios => 'IPHONEOS_DEPLOYMENT_TARGET',
+ :osx => 'MACOSX_DEPLOYMENT_TARGET',
+ :tvos => 'TVOS_DEPLOYMENT_TARGET',
+ :visionos => 'XROS_DEPLOYMENT_TARGET',
+ :watchos => 'WATCHOS_DEPLOYMENT_TARGET',
+ }.freeze
+
+ # @return [String] the deployment target of the target according to its
+ # platform.
+ #
+ def deployment_target
+ return unless setting = DEPLOYMENT_TARGET_SETTING_BY_PLATFORM_NAME[platform_name]
+ common_resolved_build_setting(setting)
+ end
+
+ # @param [String] deployment_target the deployment target to set for
+ # the target according to its platform.
+ #
+ def deployment_target=(deployment_target)
+ return unless setting = DEPLOYMENT_TARGET_SETTING_BY_PLATFORM_NAME[platform_name]
+ build_configurations.each do |config|
+ config.build_settings[setting] = deployment_target
+ end
+ end
+
+ # @return [ObjectList<XCBuildConfiguration>] the build
+ # configurations of the target.
+ #
+ def build_configurations
+ build_configuration_list.build_configurations
+ end
+
+ # Adds a new build configuration to the target and populates its with
+ # default settings according to the provided type if one doesn't
+ # exists.
+ #
+ # @note If a build configuration with the given name is already
+ # present no new build configuration is added.
+ #
+ # @param [String] name
+ # The name of the build configuration.
+ #
+ # @param [Symbol] type
+ # The type of the build configuration used to populate the build
+ # settings, must be :debug or :release.
+ #
+ # @return [XCBuildConfiguration] the created build configuration or the
+ # existing one with the same name.
+ #
+ def add_build_configuration(name, type)
+ if existing = build_configuration_list[name]
+ existing
+ else
+ build_configuration = project.new(XCBuildConfiguration)
+ build_configuration.name = name
+ product_type = self.product_type if respond_to?(:product_type)
+ build_configuration.build_settings = ProjectHelper.common_build_settings(type, platform_name, deployment_target, product_type)
+ build_configuration_list.build_configurations << build_configuration
+ build_configuration
+ end
+ end
+
+ # @param [String] build_configuration_name
+ # the name of a build configuration.
+ #
+ # @return [Hash] the build settings of the build configuration with the
+ # given name.
+ #
+ #
+ def build_settings(build_configuration_name)
+ build_configuration_list.build_settings(build_configuration_name)
+ end
+
+ # @!group Build Phases Helpers
+
+ # @return [PBXFrameworksBuildPhase]
+ # the frameworks build phases of the target.
+ #
+ def frameworks_build_phases
+ build_phases.find { |bp| bp.class == PBXFrameworksBuildPhase }
+ end
+
+ # @return [Array<PBXCopyFilesBuildPhase>]
+ # the copy files build phases of the target.
+ #
+ def copy_files_build_phases
+ build_phases.grep(PBXCopyFilesBuildPhase)
+ end
+
+ # @return [Array<PBXShellScriptBuildPhase>]
+ # the shell script build phases of the target.
+ #
+ def shell_script_build_phases
+ build_phases.grep(PBXShellScriptBuildPhase)
+ end
+
+ # Adds a dependency on the given target.
+ #
+ # @param [AbstractTarget] target
+ # the target which should be added to the dependencies list of
+ # the receiver. The target may be a target of this target's
+ # project or of a subproject of this project. Note that the
+ # subproject must already be added to this target's project.
+ #
+ # @return [void]
+ #
+ def add_dependency(target)
+ unless dependency_for_target(target)
+ container_proxy = project.new(Xcodeproj::Project::PBXContainerItemProxy)
+ if target.project == project
+ container_proxy.container_portal = project.root_object.uuid
+ else
+ subproject_reference = project.reference_for_path(target.project.path)
+ raise ArgumentError, 'add_dependency received target that belongs to a project that is not this project and is not a subproject of this project' unless subproject_reference
+ container_proxy.container_portal = subproject_reference.uuid
+ end
+ container_proxy.proxy_type = Constants::PROXY_TYPES[:native_target]
+ container_proxy.remote_global_id_string = target.uuid
+ container_proxy.remote_info = target.name
+
+ dependency = project.new(Xcodeproj::Project::PBXTargetDependency)
+ dependency.name = target.name
+ dependency.target = target if target.project == project
+ dependency.target_proxy = container_proxy
+
+ dependencies << dependency
+ end
+ end
+
+ # Checks whether this target has a dependency on the given target.
+ #
+ # @param [AbstractTarget] target
+ # the target to search for.
+ #
+ # @return [PBXTargetDependency]
+ #
+ def dependency_for_target(target)
+ dependencies.find do |dep|
+ if dep.target_proxy.remote?
+ subproject_reference = project.reference_for_path(target.project.path)
+ uuid = subproject_reference.uuid if subproject_reference
+ dep.target_proxy.remote_global_id_string == target.uuid && dep.target_proxy.container_portal == uuid
+ else
+ dep.target.uuid == target.uuid
+ end
+ end
+ end
+
+ # Creates a new copy files build phase.
+ #
+ # @param [String] name
+ # an optional name for the phase.
+ #
+ # @return [PBXCopyFilesBuildPhase] the new phase.
+ #
+ def new_copy_files_build_phase(name = nil)
+ phase = project.new(PBXCopyFilesBuildPhase)
+ phase.name = name
+ build_phases << phase
+ phase
+ end
+
+ # Creates a new shell script build phase.
+ #
+ # @param (see #new_copy_files_build_phase)
+ #
+ # @return [PBXShellScriptBuildPhase] the new phase.
+ #
+ def new_shell_script_build_phase(name = nil)
+ phase = project.new(PBXShellScriptBuildPhase)
+ phase.name = name
+ build_phases << phase
+ phase
+ end
+
+ public
+
+ # @!group System frameworks
+ #--------------------------------------#
+
+ # Adds a file reference for one or more system framework to the project
+ # if needed and adds them to the Frameworks build phases.
+ #
+ # @param [Array<String>, String] names
+ # The name or the list of the names of the framework.
+ #
+ # @note Xcode behaviour is following: if the target has the same SDK
+ # of the project it adds the reference relative to the SDK root
+ # otherwise the reference is added relative to the Developer
+ # directory. This can create confusion or duplication of the
+ # references of frameworks linked by iOS and OS X targets. For
+ # this reason the new Xcodeproj behaviour is to add the
+ # frameworks in a subgroup according to the platform.
+ #
+ # @return [Array<PBXFileReference>] An array of the newly created file
+ # references.
+ #
+ def add_system_framework(names)
+ Array(names).map do |name|
+ case platform_name
+ when :ios
+ group = project.frameworks_group['iOS'] || project.frameworks_group.new_group('iOS')
+ path_sdk_name = 'iPhoneOS'
+ path_sdk_version = sdk_version || Constants::LAST_KNOWN_IOS_SDK
+ when :osx
+ group = project.frameworks_group['OS X'] || project.frameworks_group.new_group('OS X')
+ path_sdk_name = 'MacOSX'
+ path_sdk_version = sdk_version || Constants::LAST_KNOWN_OSX_SDK
+ when :tvos
+ group = project.frameworks_group['tvOS'] || project.frameworks_group.new_group('tvOS')
+ path_sdk_name = 'AppleTVOS'
+ path_sdk_version = sdk_version || Constants::LAST_KNOWN_TVOS_SDK
+ when :visionos
+ group = project.frameworks_group['visionOS'] || project.frameworks_group.new_group('visionOS')
+ path_sdk_name = 'XROS'
+ path_sdk_version = sdk_version || Constants::LAST_KNOWN_VISIONOS_SDK
+ when :watchos
+ group = project.frameworks_group['watchOS'] || project.frameworks_group.new_group('watchOS')
+ path_sdk_name = 'WatchOS'
+ path_sdk_version = sdk_version || Constants::LAST_KNOWN_WATCHOS_SDK
+ else
+ raise 'Unknown platform for target'
+ end
+
+ path = "Platforms/#{path_sdk_name}.platform/Developer/SDKs/#{path_sdk_name}#{path_sdk_version}.sdk/System/Library/Frameworks/#{name}.framework"
+ unless ref = group.find_file_by_path(path)
+ ref = group.new_file(path, :developer_dir)
+ end
+ frameworks_build_phase.add_file_reference(ref, true)
+ ref
+ end
+ end
+ alias_method :add_system_frameworks, :add_system_framework
+
+ # Adds a file reference for one or more system dylib libraries to the project
+ # if needed and adds them to the Frameworks build phases.
+ #
+ # @param [Array<String>, String] names
+ # The name or the list of the names of the libraries.
+ #
+ # @return [void]
+ #
+ def add_system_library(names)
+ add_system_library_extension(names, 'dylib')
+ end
+ alias_method :add_system_libraries, :add_system_library
+
+ def add_system_library_extension(names, extension)
+ Array(names).each do |name|
+ path = "usr/lib/lib#{name}.#{extension}"
+ files = project.frameworks_group.files
+ unless reference = files.find { |ref| ref.path == path }
+ reference = project.frameworks_group.new_file(path, :sdk_root)
+ end
+ frameworks_build_phase.add_file_reference(reference, true)
+ reference
+ end
+ end
+ private :add_system_library_extension
+
+ # Adds a file reference for one or more system tbd libraries to the project
+ # if needed and adds them to the Frameworks build phases.
+ #
+ # @param [Array<String>, String] names
+ # The name or the list of the names of the libraries.
+ #
+ # @return [void]
+ #
+ def add_system_library_tbd(names)
+ add_system_library_extension(names, 'tbd')
+ end
+ alias_method :add_system_libraries_tbd, :add_system_library_tbd
+
+ public
+
+ # @!group AbstractObject Hooks
+ #--------------------------------------#
+
+ # @return [Hash{String => Hash}] A hash suitable to display the object
+ # to the user.
+ #
+ def pretty_print
+ {
+ display_name => {
+ 'Build Phases' => build_phases.map(&:pretty_print),
+ 'Build Configurations' => build_configurations.map(&:pretty_print),
+ },
+ }
+ end
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # Represents a target handled by Xcode.
+ #
+ class PBXNativeTarget < AbstractTarget
+ # @!group Attributes
+
+ # @return [PBXBuildRule] the build rules of this target.
+ #
+ has_many :build_rules, PBXBuildRule
+
+ # @return [String] the build product type identifier.
+ #
+ attribute :product_type, String
+
+ # @return [PBXFileReference] the reference to the product file.
+ #
+ has_one :product_reference, PBXFileReference
+
+ # @return [ObjectList<XCSwiftPackageProductDependency>] the Swift package products necessary to
+ # build this target.
+ #
+ has_many :package_product_dependencies, XCSwiftPackageProductDependency
+
+ # @return [String] the install path of the product.
+ #
+ attribute :product_install_path, String
+
+ # @return [ObjectList<AbstractBuildPhase>] the build phases of the
+ # target.
+ #
+ # @note Apparently only PBXCopyFilesBuildPhase and
+ # PBXShellScriptBuildPhase can appear multiple times in a
+ # target.
+ #
+ has_many :build_phases, AbstractBuildPhase
+
+ # @return [ObjectList<PBXFileSystemSynchronizedRootGroup>] the file system synchronized
+ # groups containing files to include to build this target.
+ #
+ has_many :file_system_synchronized_groups, PBXFileSystemSynchronizedRootGroup
+
+ public
+
+ # @!group Helpers
+ #--------------------------------------#
+
+ # @return [Symbol] The type of the target expressed as a symbol.
+ #
+ def symbol_type
+ Constants::PRODUCT_TYPE_UTI.key(product_type)
+ end
+
+ # @return [Boolean] Whether the target is a test target.
+ #
+ def test_target_type?
+ case symbol_type
+ when :octest_bundle, :unit_test_bundle, :ui_test_bundle
+ true
+ else
+ false
+ end
+ end
+
+ # @return [Boolean] Whether the target is an extension.
+ #
+ def extension_target_type?
+ case symbol_type
+ when :app_extension, :watch_extension, :watch2_extension, :tv_extension, :messages_extension
+ true
+ else
+ false
+ end
+ end
+
+ # @return [Boolean] Whether the target is launchable.
+ #
+ def launchable_target_type?
+ case symbol_type
+ when :application, :command_line_tool
+ true
+ else
+ false
+ end
+ end
+
+ # Adds source files to the target.
+ #
+ # @param [Array<PBXFileReference>] file_references
+ # the files references of the source files that should be added
+ # to the target.
+ #
+ # @param [String] compiler_flags
+ # the compiler flags for the source files.
+ #
+ # @yield_param [PBXBuildFile] each created build file.
+ #
+ # @return [Array<PBXBuildFile>] the created build files.
+ #
+ def add_file_references(file_references, compiler_flags = {})
+ file_references.map do |file|
+ extension = File.extname(file.path).downcase
+ header_extensions = Constants::HEADER_FILES_EXTENSIONS
+ is_header_phase = header_extensions.include?(extension)
+ phase = is_header_phase ? headers_build_phase : source_build_phase
+
+ unless build_file = phase.build_file(file)
+ build_file = project.new(PBXBuildFile)
+ build_file.file_ref = file
+ phase.files << build_file
+ end
+
+ if compiler_flags && !compiler_flags.empty? && !is_header_phase
+ (build_file.settings ||= {}).merge!('COMPILER_FLAGS' => compiler_flags) do |_, old, new|
+ [old, new].compact.join(' ')
+ end
+ end
+
+ yield build_file if block_given?
+
+ build_file
+ end
+ end
+
+ # Adds resource files to the resources build phase of the target.
+ #
+ # @param [Array<PBXFileReference>] resource_file_references
+ # the files references of the resources to the target.
+ #
+ # @return [void]
+ #
+ def add_resources(resource_file_references)
+ resource_file_references.each do |file|
+ next if resources_build_phase.include?(file)
+ build_file = project.new(PBXBuildFile)
+ build_file.file_ref = file
+ resources_build_phase.files << build_file
+ end
+ end
+
+ # Adds on demand resources to the resources build phase of the target.
+ #
+ # @param {String => [Array<PBXFileReference>]} on_demand_resource_tag_files
+ # the files references of the on demand resources to add to the target keyed by the tag.
+ #
+ # @return [void]
+ #
+ def add_on_demand_resources(on_demand_resource_tag_files)
+ on_demand_resource_tag_files.each do |tag, file_refs|
+ file_refs.each do |file_ref|
+ if resources_build_phase.include?(file_ref)
+ existing_build_file = resources_build_phase.build_file(file_ref)
+ existing_build_file.settings ||= {}
+ existing_build_file.settings['ASSET_TAGS'] ||= []
+ existing_build_file.settings['ASSET_TAGS'] << tag
+ existing_build_file.settings['ASSET_TAGS'].uniq!
+ next
+ end
+ build_file = resources_build_phase.add_file_reference(file_ref, true)
+ build_file.settings = (build_file.settings ||= {}).merge('ASSET_TAGS' => [tag])
+ end
+ end
+ end
+
+ # Remove on demand resources from the resources build phase of the target.
+ #
+ # @param {String => [Array<PBXFileReference>]} on_demand_resource_tag_files
+ # the files references of the on demand resources to add to the target keyed by the tag.
+ #
+ # @return [void]
+ #
+ def remove_on_demand_resources(on_demand_resource_tag_files)
+ on_demand_resource_tag_files.each do |tag, file_refs|
+ file_refs.each do |file_ref|
+ build_file = resources_build_phase.build_file(file_ref)
+ next if build_file.nil?
+ asset_tags = build_file.settings['ASSET_TAGS']
+ asset_tags.delete(tag)
+ resources_build_phase.remove_file_reference(file_ref) if asset_tags.empty?
+ end
+ end
+ end
+
+ # Finds or creates the headers build phase of the target.
+ #
+ # @note A target should have only one headers build phase.
+ #
+ # @return [PBXHeadersBuildPhase] the headers build phase.
+ #
+ def headers_build_phase
+ find_or_create_build_phase_by_class(PBXHeadersBuildPhase)
+ end
+
+ # Finds or creates the source build phase of the target.
+ #
+ # @note A target should have only one source build phase.
+ #
+ # @return [PBXSourcesBuildPhase] the source build phase.
+ #
+ def source_build_phase
+ find_or_create_build_phase_by_class(PBXSourcesBuildPhase)
+ end
+
+ # Finds or creates the frameworks build phase of the target.
+ #
+ # @note A target should have only one frameworks build phase.
+ #
+ # @return [PBXFrameworksBuildPhase] the frameworks build phase.
+ #
+ def frameworks_build_phase
+ find_or_create_build_phase_by_class(PBXFrameworksBuildPhase)
+ end
+
+ # Finds or creates the resources build phase of the target.
+ #
+ # @note A target should have only one resources build phase.
+ #
+ # @return [PBXResourcesBuildPhase] the resources build phase.
+ #
+ def resources_build_phase
+ find_or_create_build_phase_by_class(PBXResourcesBuildPhase)
+ end
+
+ private
+
+ # @!group Internal Helpers
+ #--------------------------------------#
+
+ # Find or create a build phase by a given class
+ #
+ # @param [Class] phase_class the class of the build phase to find or create.
+ #
+ # @return [AbstractBuildPhase] the build phase whose class match the given phase_class.
+ #
+ def find_or_create_build_phase_by_class(phase_class)
+ @phases ||= {}
+ unless phase_class < AbstractBuildPhase
+ raise ArgumentError, "#{phase_class} must be a subclass of #{AbstractBuildPhase.class}"
+ end
+ @phases[phase_class] ||= build_phases.find { |bp| bp.class == phase_class } ||
+ project.new(phase_class).tap { |bp| build_phases << bp }
+ end
+
+ public
+
+ # @!group AbstractObject Hooks
+ #--------------------------------------#
+
+ # Sorts the to many attributes of the object according to the display
+ # name.
+ #
+ # Build phases are not sorted as they order is relevant.
+ #
+ def sort(_options = nil)
+ attributes_to_sort = to_many_attributes.reject { |attr| attr.name == :build_phases }
+ attributes_to_sort.each do |attrb|
+ list = attrb.get_value(self)
+ list.sort! do |x, y|
+ x.display_name <=> y.display_name
+ end
+ end
+ end
+
+ def to_hash_as(method = :to_hash)
+ hash_as = super
+ excluded_keys_for_serialization_when_empty.each do |key|
+ if !hash_as[key].nil? && hash_as[key].empty?
+ hash_as.delete(key)
+ end
+ end
+ hash_as
+ end
+
+ def to_ascii_plist
+ plist = super
+ excluded_keys_for_serialization_when_empty.each do |key|
+ if !plist.value[key].nil? && plist.value[key].empty?
+ plist.value.delete(key)
+ end
+ end
+ plist
+ end
+
+ # @return [Array<String>] array of keys to exclude from serialization when the value is empty
+ def excluded_keys_for_serialization_when_empty
+ %w(packageProductDependencies fileSystemSynchronizedGroups)
+ end
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # Represents a target that only consists in a aggregate of targets.
+ #
+ # @todo Apparently it can't have build rules.
+ #
+ class PBXAggregateTarget < AbstractTarget
+ # @!group Attributes
+
+ # @return [PBXBuildRule] the build phases of the target.
+ #
+ # @note Apparently only PBXCopyFilesBuildPhase and
+ # PBXShellScriptBuildPhase can appear multiple times in a
+ # target.
+ #
+ has_many :build_phases, [PBXCopyFilesBuildPhase, PBXShellScriptBuildPhase]
+ end
+
+ #-----------------------------------------------------------------------#
+
+ # Represents a legacy target which uses an external build tool.
+ #
+ # Apparently it can't have any build phase but the attribute can be
+ # present.
+ #
+ class PBXLegacyTarget < AbstractTarget
+ # @!group Attributes
+
+ # @return [String] e.g "Dir"
+ #
+ attribute :build_working_directory, String
+
+ # @return [String] e.g "$(ACTION)"
+ #
+ attribute :build_arguments_string, String
+
+ # @return [String] e.g "1"
+ #
+ attribute :pass_build_settings_in_environment, String
+
+ # @return [String] e.g "/usr/bin/make"
+ #
+ attribute :build_tool_path, String
+
+ # @return [PBXBuildRule] the build phases of the target.
+ #
+ # @note Apparently only PBXCopyFilesBuildPhase and
+ # PBXShellScriptBuildPhase can appear multiple times in a
+ # target.
+ #
+ has_many :build_phases, AbstractBuildPhase
+ end
+
+ #-----------------------------------------------------------------------#
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/reference_proxy.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/reference_proxy.rb
new file mode 100644
index 0000000..08a369a
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/reference_proxy.rb
@@ -0,0 +1,86 @@
+module Xcodeproj
+ class Project
+ module Object
+ # Apparently a proxy for a reference object which might belong another
+ # project contained in the same workspace of the project document.
+ #
+ # This class is used for referencing the products of another project.
+ #
+ class PBXReferenceProxy < AbstractObject
+ # @!group Attributes
+
+ # @return [String] the name of the reference.
+ #
+ attribute :name, String
+
+ # @return [String] the path of the referenced filed.
+ #
+ attribute :path, String
+
+ # @return [String] the file type of the referenced filed.
+ #
+ attribute :file_type, String
+
+ # @return [PBXContainerItemProxy] the proxy to the project that
+ # contains the object.
+ #
+ has_one :remote_ref, PBXContainerItemProxy
+
+ # @return [String] the source tree for the path of the reference.
+ #
+ # @example
+ # "BUILT_PRODUCTS_DIR"
+ #
+ attribute :source_tree, String
+
+ #---------------------------------------------------------------------#
+
+ public
+
+ # @!group Helpers
+
+ # Checks whether the reference is a proxy.
+ #
+ # @return [Bool] always true for this ISA.
+ #
+ def proxy?
+ true
+ end
+
+ #---------------------------------------------------------------------#
+
+ def ascii_plist_annotation
+ " #{name || path && File.basename(path)} "
+ end
+
+ # @return [String] A name suitable for displaying the object to the
+ # user.
+ #
+ def display_name
+ return name if name
+ return path if path
+ super
+ end
+
+ # @return [Array<PBXBuildFile>] the build files associated with the
+ # current reference proxy.
+ #
+ def build_files
+ referrers.grep(PBXBuildFile)
+ end
+
+ # In addition to removing the reference proxy, this will also remove any
+ # items related to this reference.
+ #
+ # @see AbstractObject#remove_from_project
+ #
+ # @return [void]
+ #
+ def remove_from_project
+ build_files.each(&:remove_from_project)
+ super
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/root_object.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/root_object.rb
new file mode 100644
index 0000000..b2d6d46
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/root_object.rb
@@ -0,0 +1,108 @@
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents the root object of a project document.
+ #
+ class PBXProject < AbstractObject
+ # @!group Attributes
+
+ # @return [ObjectList<AbstractTarget>] a list of all the targets in
+ # the project.
+ #
+ has_many :targets, AbstractTarget
+
+ # @return [Hash{String => String}] attributes the attributes of the
+ # target.
+ #
+ # @note The hash might contain the following keys:
+ #
+ # - `CLASSPREFIX`
+ # - `LastUpgradeCheck`
+ # - `ORGANIZATIONNAME`
+ #
+ attribute :attributes, Hash,
+ 'LastSwiftUpdateCheck' => Constants::LAST_SWIFT_UPGRADE_CHECK,
+ 'LastUpgradeCheck' => Constants::LAST_UPGRADE_CHECK
+
+ # @return [XCConfigurationList] the configuration list of the project.
+ #
+ has_one :build_configuration_list, XCConfigurationList
+
+ # @return [String] the compatibility version of the project.
+ #
+ attribute :compatibility_version, String, 'Xcode 3.2'
+
+ # @return [String] the development region of the project.
+ #
+ attribute :development_region, String, 'en'
+
+ # @return [String] whether the project has scanned for encodings.
+ #
+ attribute :has_scanned_for_encodings, String, '0'
+
+ # @return [Array<String>] the list of known regions.
+ #
+ attribute :known_regions, Array, %w(en Base)
+
+ # @return [PBXGroup] the main group of the project. The one displayed
+ # by Xcode in the Project Navigator.
+ #
+ has_one :main_group, PBXGroup
+
+ # @return [String] whether minimizes project reference proxies
+ #
+ attribute :minimized_project_reference_proxies, String, '0'
+
+ # @return [String] preferred project object version
+ #
+ attribute :preferred_project_object_version, String, Constants::LAST_KNOWN_OBJECT_VERSION.to_s
+
+ # @return [PBXGroup] the group containing the references to products of
+ # the project.
+ #
+ has_one :product_ref_group, PBXGroup
+
+ # @return [String] the directory of the project.
+ #
+ attribute :project_dir_path, String, ''
+
+ # @return [String] the root of the project.
+ #
+ attribute :project_root, String, ''
+
+ # @return [Array<XCRemoteSwiftPackageReference, XCLocalSwiftPackageReference>] the list of Swift package references.
+ #
+ has_many :package_references, [XCRemoteSwiftPackageReference, XCLocalSwiftPackageReference]
+
+ # @return [Array<ObjectDictionary>] any reference to other projects.
+ #
+ has_many_references_by_keys :project_references,
+ :project_ref => PBXFileReference,
+ :product_group => PBXGroup
+
+ def name
+ project.path.basename('.xcodeproj').to_s
+ end
+
+ def ascii_plist_annotation
+ ' Project object '
+ end
+
+ def to_hash_as(method = :to_hash)
+ hash_as = super
+ if !hash_as['packageReferences'].nil? && hash_as['packageReferences'].empty?
+ hash_as.delete('packageReferences') if !hash_as['packageReferences'].nil? && hash_as['packageReferences'].empty?
+ end
+ hash_as
+ end
+
+ def to_ascii_plist
+ plist = super
+ plist.value.delete('projectReferences') if plist.value['projectReferences'].empty?
+ plist.value.delete('packageReferences') if !plist.value['packageReferences'].nil? && plist.value['packageReferences'].empty?
+ plist
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_local_reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_local_reference.rb
new file mode 100644
index 0000000..aa5ae7f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_local_reference.rb
@@ -0,0 +1,34 @@
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a local Swift package reference.
+ #
+ class XCLocalSwiftPackageReference < AbstractObject
+ # @!group Attributes
+
+ # @return [String] the repository url this Swift package was installed from.
+ #
+ attribute :path, String
+
+ # @return [String] the repository path where the package is located relative
+ # to the Xcode project.
+ #
+ attribute :relative_path, String
+
+ # @!group AbstractObject Hooks
+ #--------------------------------------#
+
+ def ascii_plist_annotation
+ " #{isa} \"#{File.basename(display_name)}\" "
+ end
+
+ # @return [String] the path of the local Swift package reference.
+ #
+ def display_name
+ return relative_path if relative_path
+ super
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_product_dependency.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_product_dependency.rb
new file mode 100644
index 0000000..471227b
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_product_dependency.rb
@@ -0,0 +1,29 @@
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a Swift package product dependency.
+ #
+ class XCSwiftPackageProductDependency < AbstractObject
+ # @!group Attributes
+
+ # @return [XCRemoteSwiftPackageReference, XCLocalSwiftPackageReference] the Swift package reference.
+ #
+ has_one :package, [XCRemoteSwiftPackageReference, XCLocalSwiftPackageReference]
+
+ # @return [String] the product name of this Swift package.
+ #
+ attribute :product_name, String
+
+ # @!group AbstractObject Hooks
+ #--------------------------------------#
+
+ # @return [String] the name of the Swift package product dependency.
+ #
+ def display_name
+ return product_name if product_name
+ super
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_remote_reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_remote_reference.rb
new file mode 100644
index 0000000..5abdaab
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/swift_package_remote_reference.rb
@@ -0,0 +1,33 @@
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents a remote Swift package reference.
+ #
+ class XCRemoteSwiftPackageReference < AbstractObject
+ # @!group Attributes
+
+ # @return [String] the repository url this Swift package was installed from.
+ #
+ attribute :repositoryURL, String
+
+ # @return [Hash] the version requirements for this Swift package.
+ #
+ attribute :requirement, Hash
+
+ # @!group AbstractObject Hooks
+ #--------------------------------------#
+
+ def ascii_plist_annotation
+ " #{isa} \"#{File.basename(display_name, '.git')}\" "
+ end
+
+ # @return [String] the name of the remote Swift package reference.
+ #
+ def display_name
+ return repositoryURL if repositoryURL
+ super
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/target_dependency.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/target_dependency.rb
new file mode 100644
index 0000000..54b09fc
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object/target_dependency.rb
@@ -0,0 +1,97 @@
+module Xcodeproj
+ class Project
+ module Object
+ # Represents a dependency of a target on another one.
+ #
+ class PBXTargetDependency < AbstractObject
+ # @!group Attributes
+
+ # @return [PBXNativeTarget] the target that needs to be built to
+ # satisfy the dependency.
+ #
+ has_one :target, AbstractTarget
+
+ # @return [PBXContainerItemProxy] a proxy for the target that needs to
+ # be built.
+ #
+ # @note Apparently to support targets in other projects of the same
+ # workspace.
+ #
+ has_one :target_proxy, PBXContainerItemProxy
+
+ # @return [String] the name of the target.
+ #
+ # @note This seems only to be used when the target dependency is a
+ # target from a nested Xcode project.
+ #
+ attribute :name, String
+
+ # @return [String] the platform filter for this target dependency.
+ #
+ attribute :platform_filter, String
+
+ # @return [Array<String>] the platform filters for this target dependency.
+ #
+ attribute :platform_filters, Array
+
+ # @return [XCSwiftPackageProductDependency] the Swift Package product
+ # for this target dependency.
+ #
+ has_one :product_ref, XCSwiftPackageProductDependency
+
+ public
+
+ # @!group AbstractObject Hooks
+ #--------------------------------------#
+
+ # @return [String] The name of the dependency.
+ #
+ def display_name
+ return name if name
+ return target.name if target
+ return target_proxy.remote_info if target_proxy
+ return product_ref.product_name if product_ref
+ end
+
+ def ascii_plist_annotation
+ " #{isa} "
+ end
+
+ # @return [String] the uuid of the target if the dependency is a native
+ # target, the uuid of the target in the sub-project if the
+ # dependency is a target proxy, nil if the dependency is a Swift
+ # Package.
+ #
+ def native_target_uuid
+ return target.uuid if target
+ return target_proxy.remote_global_id_string if target_proxy
+ return nil if product_ref
+ raise "Expected target or target_proxy, from which to fetch a uuid for target '#{display_name}'." \
+ "Find and clear the PBXTargetDependency entry with uuid '#{@uuid}' in your .xcodeproj."
+ end
+
+ # @note This override is necessary because Xcode allows for circular
+ # target dependencies.
+ #
+ # @return [Hash<String => String>] Returns a cascade representation of
+ # the object without UUIDs.
+ #
+ def to_tree_hash
+ hash = {}
+ hash['displayName'] = display_name
+ hash['isa'] = isa
+ hash['targetProxy'] = target_proxy.to_tree_hash if target_proxy
+ hash
+ end
+
+ # @note This is a no-op, because the targets could theoretically depend
+ # on each other, leading to a stack level too deep error.
+ #
+ # @see AbstractObject#sort_recursively
+ #
+ def sort_recursively(_options = nil)
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_attributes.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_attributes.rb
new file mode 100644
index 0000000..4276721
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_attributes.rb
@@ -0,0 +1,522 @@
+module Xcodeproj
+ class Project
+ module Object
+ # This class represents an attribute of {AbstractObject} subclasses.
+ # Attributes are created by the {AbstractObject} DSL methods and allow to
+ # mirror the underlying attributes of the xcodeproj document model.
+ #
+ # Attributes provide support for runtime type checking. They also allow
+ # {AbstractObject} initialization and serialization to plist.
+ #
+ # @todo Add support for a list of required values so objects can be
+ # validated before serialization ?
+ #
+ class AbstractObjectAttribute
+ # @return [Symbol] the type of the attribute. It can be `:simple`,
+ # `:to_one`, `:to_many`.
+ #
+ attr_reader :type
+
+ # @return [Symbol] the name of the attribute.
+ #
+ attr_reader :name
+
+ # @return [Class] the class that owns the attribute.
+ #
+ attr_accessor :owner
+
+ # Creates a new attribute with the given type and name.
+ #
+ # Attributes are expected to be instantiated only by the
+ # {AbstractObject} DSL methods.
+ #
+ # @param [Symbol] type
+ # the type of the attribute.
+ #
+ # @param [Symbol] name
+ # the name of the attribute.
+ #
+ # @param [Class] owner
+ # the class that owns the attribute.
+ #
+ def initialize(type, name, owner)
+ @type = type
+ @name = name
+ @owner = owner
+ end
+
+ # @return [String] The name of the attribute in camel case.
+ #
+ # @example
+ # attribute.new(:simple, :project_root)
+ # attribute.plist_name #=> projectRoot
+ #
+ def plist_name
+ @plist_name ||= CaseConverter.convert_to_plist(name, :lower)
+ end
+
+ # @return [Array<Class>] the list of the classes accepted by the
+ # attribute.
+ #
+ attr_accessor :classes
+
+ # @return [{Symbol, Array<Class>}] the list of the classes accepted by
+ # each key for attributes which store a dictionary.
+ #
+ attr_accessor :classes_by_key
+
+ # @return [String, Array, Hash] the default value, if any, for simple
+ # attributes.
+ #
+ attr_accessor :default_value
+
+ # Convenience method that returns the value of this attribute for a
+ # given object.
+ #
+ # @param [AbstractObject] object
+ # the object for which the value of this attribute is requested.
+ #
+ # @return [String, Array, Hash, AbstractObject, ObjectList]
+ # the value.
+ #
+ def get_value(object)
+ object.send(name)
+ end
+
+ # Convenience method that sets the value of this attribute for a
+ # given object. It makes sense only for `:simple` or `:to_one`
+ # attributes.
+ #
+ # @raise It the type of this attribute is `:to_many`.
+ #
+ # @param [AbstractObject] object
+ # the object for which to set the value.
+ #
+ # @param [String, Hash, Array, AbstractObject] new_value
+ # the value to set for the attribute.
+ #
+ # @return [void]
+ #
+ def set_value(object, new_value)
+ if type == :to_many
+ raise '[Xcodeproj] Set value called for a to-many attribute'
+ end
+ object.send("#{name}=", new_value)
+ end
+
+ # Convenience method that sets the value of this attribute for a given
+ # object to the default (if any). It makes sense only for `:simple`
+ # attributes.
+ #
+ # @param [AbstractObject] object
+ # the object for which to set the default value.
+ #
+ # @note It is extremely important to duplicate the default values
+ # otherwise kittens cry!
+ #
+ # @return [void]
+ #
+ def set_default(object)
+ unless type == :simple
+ raise "[Xcodeproj] Set value called for a #{type} attribute"
+ end
+ set_value(object, default_value.dup) if default_value
+ end
+
+ # Checks that a given value is compatible with the attribute.
+ #
+ # This method powers the runtime type checking of the {AbstractObject}
+ # and is used its by synthesised methods.
+ #
+ # @raise If the class of the value is not compatible with the attribute.
+ #
+ # @return [void]
+ #
+ def validate_value(object)
+ return unless object
+ acceptable = classes.find { |klass| object.class == klass || object.class < klass }
+ if type == :simple
+ raise "[Xcodeproj] Type checking error: got `#{object.class}` " \
+ "for attribute: #{inspect}" unless acceptable
+ else
+ raise "[Xcodeproj] Type checking error: got `#{object.isa}` for " \
+ "attribute: #{inspect} - #{object.uuid} #{object.to_ascii_plist}" unless acceptable
+ end
+ end
+
+ # Checks that a given value is compatible with a key for attributes
+ # which store references by key.
+ #
+ # This method is used by the #{ObjectDictionary} class.
+ #
+ # @raise If the class of the value is not compatible with the given
+ # key.
+ #
+ def validate_value_for_key(object, key)
+ unless type == :references_by_keys
+ raise '[Xcodeproj] This method should be called only for ' \
+ 'attributes of type `references_by_keys`'
+ end
+
+ unless classes_by_key.keys.include?(key)
+ raise "[Xcodeproj] unsupported key `#{key}` " \
+ "(accepted `#{classes_by_key.keys}`) for attribute `#{inspect}`"
+ end
+
+ return unless object
+ classes = Array(classes_by_key[key])
+ acceptable = classes.find { |klass| object.class == klass || object.class < klass }
+ unless acceptable
+ raise "[Xcodeproj] Type checking error: got `#{object.isa}` " \
+ "for key `#{key}` (which accepts `#{classes}`) of " \
+ "attribute: `#{inspect}`"
+ end
+ end
+
+ # @return [String] A string suitable for debugging the object.
+ #
+ def inspect
+ if type == :simple
+ "Attribute `#{plist_name}` (type: `#{type}`, classes: " \
+ "`#{classes}`, owner class: `#{owner.isa}`)"
+ else
+ "Attribute `#{plist_name}` (type: `#{type}`, classes: " \
+ "`#{classes.map(&:isa)}`, owner class: `#{owner.isa}`)"
+ end
+ end
+ end
+
+ class AbstractObject
+ # The {AbstractObject} DSL methods allow to specify with fidelity the
+ # underlying model of the xcodeproj document format. {AbstractObject}
+ # subclasses should specify their attributes through the following
+ # methods:
+ #
+ # - `{AbstractObject.attribute}`
+ # - `{AbstractObject.has_one}`
+ # - `{AbstractObject.has_many}`
+ #
+ # @note The subclasses should not interfere with the methods
+ # synthesised by the DSL and should only implement helpers in top
+ # of them.
+ #
+ # @note Attributes are typed and are validated at runtime.
+ #
+ class << self
+ # @return [Array<AbstractObjectAttribute>] the attributes associated
+ # with the class.
+ #
+ # @note It includes the attributes defined in the superclass and the
+ # list is cleaned for duplicates. Subclasses should not duplicate
+ # an attribute of the superclass but for the method implementation
+ # they will duplicate them.
+ #
+ # @visibility private
+ #
+ def attributes
+ unless @full_attributes
+ attributes = @attributes || []
+ if superclass.respond_to?(:attributes)
+ super_attributes = superclass.attributes
+ else
+ super_attributes = []
+ end
+ # The uniqueness of the attributes is very important because the
+ # initialization from plist deletes the values from the
+ # dictionary.
+ @full_attributes = attributes.concat(super_attributes).uniq
+ end
+ @full_attributes
+ end
+
+ # @return [Array<AbstractObjectAttribute>] the simple attributes
+ # associated with with the class.
+ #
+ # @visibility private
+ #
+ def simple_attributes
+ @simple_attributes ||= attributes.select { |a| a.type == :simple }
+ end
+
+ # @return [Array<AbstractObjectAttribute>] the attributes
+ # representing a to one relationship associated with with the
+ # class.
+ #
+ # @visibility private
+ #
+ def to_one_attributes
+ @to_one_attributes ||= attributes.select { |a| a.type == :to_one }
+ end
+
+ # @return [Array<AbstractObjectAttribute>] the attributes
+ # representing a to many relationship associated with with the
+ # class.
+ #
+ # @visibility private
+ #
+ def to_many_attributes
+ @to_many_attributes ||= attributes.select { |a| a.type == :to_many }
+ end
+
+ # @visibility private
+ #
+ def references_by_keys_attributes
+ @references_by_keys_attributes ||= attributes.select { |a| a.type == :references_by_keys }
+ end
+
+ private
+
+ # Defines a new simple attribute and synthesises the corresponding
+ # methods.
+ #
+ # @note Simple attributes are directly stored in a hash. They can
+ # contain only a string, array of strings or a hash containing
+ # strings and thus they are not affected by reference counting.
+ # Clients can access the hash directly through the
+ # {AbstractObject#simple_attributes_hash} method.
+ #
+ # @param [Symbol] name
+ # the name of the attribute.
+ #
+ # @param [Class] klass
+ # the accepted {Class} for the values of the attribute.
+ #
+ # @param [String, Array<String>, Hash{String=>String}] default_value
+ # the default value for new objects.
+ #
+ # @example
+ # attribute :project_root
+ # #=> leads to the creation of the following methods
+ #
+ # def project_root
+ # @simple_attributes_hash[projectRoot]
+ # end
+ #
+ # def project_root=(value)
+ # attribute.validate_value(value)
+ # @simple_attributes_hash[projectRoot] = value
+ # end
+ #
+ # @macro [attach] attribute
+ # @!attribute [rw] $1
+ #
+ def attribute(name, klass, default_value = nil)
+ attrb = AbstractObjectAttribute.new(:simple, name, self)
+ attrb.classes = [klass]
+ attrb.default_value = default_value
+ add_attribute(attrb)
+
+ define_method(attrb.name) do
+ @simple_attributes_hash ||= {}
+ @simple_attributes_hash[attrb.plist_name]
+ end
+
+ define_method("#{attrb.name}=") do |value|
+ @simple_attributes_hash ||= {}
+ attrb.validate_value(value)
+
+ existing = @simple_attributes_hash[attrb.plist_name]
+ if existing.is_a?(Hash) && value.is_a?(Hash)
+ return value if existing.keys == value.keys && existing == value
+ elsif existing == value
+ return value
+ end
+ mark_project_as_dirty!
+ @simple_attributes_hash[attrb.plist_name] = value
+ end
+ end
+
+ # rubocop:disable Style/PredicateName
+
+ # Defines a new relationship to a single and synthesises the
+ # corresponding methods.
+ #
+ # @note The synthesised setter takes care of handling reference
+ # counting directly.
+ #
+ # @param [String] singular_name
+ # the name of the relationship.
+ #
+ # @param [Class, Array<Class>] isas
+ # the list of the classes corresponding to the accepted isas for
+ # this relationship.
+ #
+ # @macro [attach] has_one
+ # @!attribute [rw] $1
+ #
+ def has_one(singular_name, isas)
+ isas = [isas] unless isas.is_a?(Array)
+ attrb = AbstractObjectAttribute.new(:to_one, singular_name, self)
+ attrb.classes = isas
+ add_attribute(attrb)
+
+ attr_reader(attrb.name)
+ # 1.9.2 fix, see https://github.com/CocoaPods/Xcodeproj/issues/40.
+ public(attrb.name)
+
+ variable_name = :"@#{attrb.name}"
+ define_method("#{attrb.name}=") do |value|
+ attrb.validate_value(value)
+
+ previous_value = send(attrb.name)
+ return value if previous_value == value
+ mark_project_as_dirty!
+ previous_value.remove_referrer(self) if previous_value
+ instance_variable_set(variable_name, value)
+ value.add_referrer(self) if value
+ end
+ end
+
+ # Defines a new ordered relationship to many.
+ #
+ # @note This attribute only generates the reader method. Clients are
+ # not supposed to create {ObjectList} objects which are created
+ # by the methods synthesised by this attribute on demand.
+ # Clients, however can mutate the list according to its
+ # interface. The list is responsible to manage the reference
+ # counting for its values.
+ #
+ # @param [String] plural_name
+ # the name of the relationship.
+ #
+ # @param [Class, Array<Class>] isas
+ # the list of the classes corresponding to the accepted isas for
+ # this relationship.
+ #
+ # @macro [attach] has_many
+ # @!attribute [r] $1
+ #
+ def has_many(plural_name, isas)
+ isas = [isas] unless isas.is_a?(Array)
+
+ attrb = AbstractObjectAttribute.new(:to_many, plural_name, self)
+ attrb.classes = isas
+ add_attribute(attrb)
+
+ variable_name = :"@#{attrb.name}"
+ define_method(attrb.name) do
+ # Here we are in the context of the instance
+ list = instance_variable_get(variable_name)
+ unless list
+ list = ObjectList.new(attrb, self)
+ instance_variable_set(variable_name, list)
+ end
+ list
+ end
+ end
+
+ # Defines a new ordered relationship to many.
+ #
+ # @note This attribute only generates the reader method. Clients are
+ # not supposed to create {ObjectList} objects which are created
+ # by the methods synthesised by this attribute on demand.
+ # Clients, however can mutate the list according to its
+ # interface. The list is responsible to manage the reference
+ # counting for its values.
+ #
+ # @param [String] plural_name
+ # the name of the relationship.
+ #
+ # @param [{Symbol, Array<Class>}] classes_by_key
+ # the list of the classes corresponding to the accepted isas for
+ # this relationship.
+ #
+ # @macro [attach] has_many
+ # @!attribute [r] $1
+ #
+ def has_many_references_by_keys(plural_name, classes_by_key)
+ attrb = AbstractObjectAttribute.new(:references_by_keys, plural_name, self)
+ attrb.classes = classes_by_key.values
+ attrb.classes_by_key = classes_by_key
+ add_attribute(attrb)
+
+ variable_name = :"@#{attrb.name}"
+ define_method(attrb.name) do
+ # Here we are in the context of the instance
+ list = instance_variable_get(variable_name)
+ unless list
+ list = ObjectList.new(attrb, self)
+ instance_variable_set(variable_name, list)
+ end
+ list
+ end
+ end
+
+ # rubocop:enable Style/PredicateName
+
+ protected
+
+ # Adds an attribute to the list of attributes of the class.
+ #
+ # @note This method is intended to be invoked only by the
+ # {AbstractObject} meta programming methods
+ #
+ # @return [void]
+ #
+ def add_attribute(attribute)
+ unless attribute.classes
+ raise "[Xcodeproj] BUG - missing classes for #{attribute.inspect}"
+ end
+
+ unless attribute.classes.all? { |klass| klass.is_a?(Class) }
+ raise "[Xcodeproj] BUG - classes:#{attribute.classes} for #{attribute.inspect}"
+ end
+
+ @attributes ||= []
+ @attributes << attribute
+ end
+ end # AbstractObject << self
+
+ private
+
+ # @return [Hash] the simple attributes hash.
+ #
+ attr_reader :simple_attributes_hash
+
+ public
+
+ # @!group xcodeproj format attributes
+
+ # @return (see AbstractObject.attributes)
+ #
+ # @visibility private
+ #
+ def attributes
+ self.class.attributes
+ end
+
+ # @return (see AbstractObject.simple_attributes)
+ #
+ # @visibility private
+ #
+ def simple_attributes
+ self.class.simple_attributes
+ end
+
+ # @return (see AbstractObject.to_one_attributes)
+ #
+ # @visibility private
+ #
+ def to_one_attributes
+ self.class.to_one_attributes
+ end
+
+ # @return (see AbstractObject.to_many_attributes)
+ #
+ # @visibility private
+ #
+ def to_many_attributes
+ self.class.to_many_attributes
+ end
+
+ # @return (see AbstractObject.to_many_attributes)
+ #
+ # @visibility private
+ #
+ def references_by_keys_attributes
+ self.class.references_by_keys_attributes
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_dictionary.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_dictionary.rb
new file mode 100644
index 0000000..f664057
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_dictionary.rb
@@ -0,0 +1,210 @@
+module Xcodeproj
+ class Project
+ # This class represents relationships to other objects stored in a
+ # Dictionary.
+ #
+ # It works in conjunction with the {AbstractObject} class to ensure that
+ # the project is not serialized with unreachable objects by updating the
+ # with reference count on modifications.
+ #
+ # @note To provide full support as the other classes the dictionary should:
+ #
+ # Give the following attribute:
+ #
+ # has_many_references_by_keys :project_references, {
+ # :project_ref => PBXFileReference,
+ # :product_group => PBXGroup
+ # }
+ #
+ # This should be possible:
+ #
+ # #=> Note the API:
+ # root_object.project_references.project_ref = file
+ #
+ # #=> This should raise:
+ # root_object.project_references.product_group = file
+ #
+ # I.e. generate setters and getters from the specification hash.
+ #
+ # Also the interface is a dirty hybrid between the
+ # {AbstractObjectAttribute} and the {ObjectList}.
+ #
+ # @note Concerning the mutations methods it is safe to call only those
+ # which are overridden to inform objects reference count. Ideally all
+ # the hash methods should be covered, but this is not done yet.
+ # Moreover it is a moving target because the methods of array
+ # usually are implemented in C.
+ #
+ # @todo This class should use a {Hash} as a backing store instead of
+ # inheriting from it. This would prevent the usage of methods which
+ # don't notify the objects.
+ #
+ class ObjectDictionary < Hash
+ # @param [Object::AbstractObjectAttribute] attribute @see #attribute
+ # @param [Object] owner @see #owner
+ #
+ def initialize(attribute, owner)
+ @attribute = attribute
+ @owner = owner
+ end
+
+ # @return [Object::AbstractObjectAttribute] The attribute that generated
+ # the list.
+ #
+ attr_reader :attribute
+
+ # @return [Object] The object that owns the list.
+ #
+ attr_reader :owner
+
+ # @return [Array<Symbol>] The list of the allowed keys.
+ #
+ def allowed_keys
+ attribute.classes_by_key.keys
+ end
+
+ # @return [String] A string suitable for debugging.
+ #
+ def inspect
+ "<ObjectDictionary attribute:`#{@attribute.name}` " \
+ "owner:`#{@owner.display_name}` values:#{super.inspect}>"
+ end
+
+ # @!group Notification enabled methods
+ #------------------------------------------------------------------------#
+
+ # Associates an object to the given key and updates its references count.
+ #
+ # @param [String] key
+ # The key.
+ #
+ # @param [AbstractObject] object
+ # The object to add to the dictionary.
+ #
+ # @return [AbstractObject] The given object.
+ #
+ def []=(key, object)
+ key = normalize_key(key)
+ if object
+ perform_additions_operations(object, key)
+ else
+ perform_deletion_operations(self[key])
+ end
+ super(key, object)
+ end
+
+ # Removes the given key from the dictionary and informs the object that
+ # is not longer referenced by the owner.
+ #
+ # @param [String] key
+ # The key.
+ #
+ def delete(key)
+ key = normalize_key(key)
+ object = self[key]
+ perform_deletion_operations(object)
+ super
+ end
+
+ # @!group AbstractObject Methods
+ #-----------------------------------------------------------------------#
+
+ # @return [Hash<String => String>] The plist representation of the
+ # dictionary where the objects are replaced by their UUIDs.
+ #
+ def to_hash
+ result = {}
+ each do |key, obj|
+ if obj
+ plist_key = Object::CaseConverter.convert_to_plist(key, nil)
+ result[plist_key] = Nanaimo::String.new(obj.uuid, obj.ascii_plist_annotation)
+ end
+ end
+ result
+ end
+
+ def to_ascii_plist
+ to_hash
+ end
+
+ # @return [Hash<String => String>] Returns a cascade representation of
+ # the object without UUIDs.
+ #
+ def to_tree_hash
+ result = {}
+ each do |key, obj|
+ if obj
+ plist_key = Object::CaseConverter.convert_to_plist(key, nil)
+ result[plist_key] = obj.to_tree_hash
+ end
+ end
+ result
+ end
+
+ # Removes all the references to a given object.
+ #
+ def remove_reference(object)
+ each { |key, obj| self[key] = nil if obj == object }
+ end
+
+ # Informs the objects contained in the dictionary that another object is
+ # referencing them.
+ #
+ def add_referrer(referrer)
+ values.each { |obj| obj.add_referrer(referrer) }
+ end
+
+ # Informs the objects contained in the dictionary that another object
+ # stopped referencing them.
+ #
+ def remove_referrer(referrer)
+ values.each { |obj| obj.remove_referrer(referrer) }
+ end
+
+ private
+
+ # @!group Private helpers
+ #------------------------------------------------------------------------#
+
+ # @return [Symbol] Normalizes a key to a symbol converting the camel case
+ # format with underscores.
+ #
+ # @param [String, Symbol] key
+ # The key to normalize.
+ #
+ def normalize_key(key)
+ if key.is_a?(String)
+ key = Object::CaseConverter.convert_to_ruby(key)
+ end
+
+ unless allowed_keys.include?(key)
+ raise "[Xcodeproj] Unsupported key `#{key}` (allowed " \
+ "`#{allowed_keys}`) for `#{inspect}`"
+ end
+ key
+ end
+
+ # Informs an object that it was added to the dictionary. In practice it
+ # adds the owner of the list as referrer to the objects. It also
+ # validates the value.
+ #
+ # @return [void]
+ #
+ def perform_additions_operations(object, key)
+ owner.mark_project_as_dirty!
+ object.add_referrer(owner)
+ attribute.validate_value_for_key(object, key)
+ end
+
+ # Informs an object that it was removed from to the dictionary, so it can
+ # remove it from its referrers and take the appropriate actions.
+ #
+ # @return [void]
+ #
+ def perform_deletion_operations(objects)
+ owner.mark_project_as_dirty!
+ objects.remove_referrer(owner)
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_list.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_list.rb
new file mode 100644
index 0000000..e1df1b8
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/object_list.rb
@@ -0,0 +1,223 @@
+module Xcodeproj
+ class Project
+ # This class represents an ordered relationship to many objects.
+ #
+ # It works in conjunction with the {AbstractObject} class to ensure that
+ # the project is not serialized with unreachable objects by updating the
+ # with reference count on modifications.
+ #
+ # @note Concerning the mutations methods it is safe to call only those
+ # which are overridden to inform objects reference count. Ideally all
+ # the array methods should be covered, but this is not done yet.
+ # Moreover it is a moving target because the methods of array
+ # usually are implemented in C
+ #
+ # @todo Cover all the mutations methods of the {Array} class.
+ #
+ class ObjectList < Array
+ # {Xcodeproj} clients are not expected to create instances of
+ # {ObjectList}, it is always initialized empty and automatically by the
+ # synthesized methods generated by {AbstractObject.has_many}.
+ #
+ def initialize(attribute, owner)
+ @attribute = attribute
+ @owner = owner
+ end
+
+ # @return [Array<Class>] the attribute that generated the list.
+ #
+ attr_reader :attribute
+
+ # @return [Array<Class>] the object that owns the list.
+ #
+ attr_reader :owner
+
+ # @return [Array<String>]
+ # the UUIDs of all the objects referenced by this list.
+ #
+ def uuids
+ map(&:uuid)
+ end
+
+ # @return [Array<AbstractObject>]
+ # a new array generated with the objects contained in the list.
+ #
+ def objects
+ to_a
+ end
+
+ public
+
+ # @!group Notification enabled methods
+ #------------------------------------------------------------------------#
+
+ # TODO: the overridden methods are incomplete.
+
+ # Adds an array of objects to list and updates their references count.
+ #
+ # @param [Array<AbstractObject, ObjectDictionary>] objects
+ # an array of objects to add to the list.
+ #
+ # @return [void]
+ #
+ def +(other)
+ perform_additions_operations(other)
+ super
+ end
+
+ # Appends an object to list the and updates its references count.
+ #
+ # @param [AbstractObject, ObjectDictionary] object
+ # The object to add to the list.
+ #
+ # @return [void]
+ #
+ def <<(object)
+ perform_additions_operations(object)
+ super
+ end
+
+ # Adds an object to the given index of the list the and updates its
+ # references count.
+ #
+ # @param [AbstractObject, ObjectDictionary] object
+ # The object to add to the list.
+ #
+ # @return [void]
+ #
+ def insert(index, object)
+ perform_additions_operations(object)
+ super
+ end
+
+ # Prepends an object to the list and updates its references count.
+ #
+ # @param [AbstractObject, ObjectDictionary] object
+ # The object to add to the list.
+ #
+ # @return [void]
+ #
+ def unshift(object)
+ perform_additions_operations(object)
+ super
+ end
+
+ # Removes an object to list and updates its references count.
+ #
+ # @param [AbstractObject, ObjectDictionary] object
+ # the object to delete from the list.
+ #
+ # @return [AbstractObject, ObjectDictionary, Nil] the object if found.
+ #
+ def delete(object)
+ perform_deletion_operations(object)
+ super
+ end
+
+ # Removes the object at the given index from the list and updates its
+ # references count.
+ #
+ # @param [Fixnum] from
+ # The index of the object.
+ #
+ # @return [AbstractObject, ObjectDictionary, Nil] the object if found.
+ #
+ def delete_at(index)
+ object = at(index)
+ perform_deletion_operations(object)
+ super
+ end
+
+ # Removes all the objects contained in the list and updates their
+ # reference counts.
+ #
+ # @return [void]
+ #
+ def clear
+ objects.each do |object|
+ perform_deletion_operations(object)
+ end
+ super
+ end
+
+ # Moves the given object to the given index.
+ #
+ # @param [AbstractObject, ObjectDictionary] object
+ # The object to move.
+ #
+ # @param [Fixnum] to
+ # The new index for the object.
+ #
+ # @return [void]
+ #
+ def move(object, new_index)
+ return if index(object) == new_index
+ if obj = delete(object)
+ insert(new_index, obj)
+ else
+ raise "Attempt to move object `#{object}` not present in the list `#{inspect}`"
+ end
+ end
+
+ # Moves the object at the given index to the given position.
+ #
+ # @param [Fixnum] from
+ # The current index of the object.
+ #
+ # @param [Fixnum] to
+ # The new index for the object.
+ #
+ # @return [void]
+ #
+ def move_from(current_index, new_index)
+ return if current_index == new_index
+ if obj = delete_at(current_index)
+ insert(new_index, obj)
+ else
+ raise "Attempt to move object from index `#{current_index}` which is beyond bounds of the list `#{inspect}`"
+ end
+ end
+
+ def sort!
+ return super if owner.project.dirty?
+ previous = to_a
+ super
+ owner.mark_project_as_dirty! unless previous == to_a
+ self
+ end
+
+ private
+
+ # @!group Notification Methods
+ #------------------------------------------------------------------------#
+
+ # Informs an object that it was added to the list. In practice it adds
+ # the owner of the list as referrer to the objects. It also validates the
+ # value.
+ #
+ # @return [void]
+ #
+ def perform_additions_operations(objects)
+ objects = [objects] unless objects.is_a?(Array)
+ objects.each do |obj|
+ owner.mark_project_as_dirty!
+ obj.add_referrer(owner)
+ attribute.validate_value(obj) unless obj.is_a?(ObjectDictionary)
+ end
+ end
+
+ # Informs an object that it was removed from to the list, so it can
+ # remove its owner from its referrers and take the appropriate actions.
+ #
+ # @return [void]
+ #
+ def perform_deletion_operations(objects)
+ objects = [objects] unless objects.is_a?(Array)
+ objects.each do |obj|
+ owner.mark_project_as_dirty!
+ obj.remove_referrer(owner) unless obj.is_a?(ObjectDictionary)
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/project_helper.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/project_helper.rb
new file mode 100644
index 0000000..8a28417
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/project_helper.rb
@@ -0,0 +1,343 @@
+module Xcodeproj
+ class Project
+ module ProjectHelper
+ include Object
+
+ # @!group Targets
+
+ #-----------------------------------------------------------------------#
+
+ # Creates a new target and adds it to the project.
+ #
+ # The target is configured for the given platform and its file reference it
+ # is added to the {products_group}.
+ #
+ # The target is pre-populated with common build settings, and the
+ # appropriate Framework according to the platform is added to to its
+ # Frameworks phase.
+ #
+ # @param [Project] project
+ # the project to which the target should be added.
+ #
+ # @param [Symbol] type
+ # the type of target. Can be `:application`, `:dynamic_library`,
+ # `framework` or `:static_library`.
+ #
+ # @param [String] name
+ # the name of the target product.
+ #
+ # @param [Symbol] platform
+ # the platform of the target. Can be `:ios` or `:osx`.
+ #
+ # @param [String] deployment_target
+ # the deployment target for the platform.
+ #
+ # @param [PBXGroup] product_group
+ # the product group, where to add to a file reference of the
+ # created target.
+ #
+ # @param [Symbol] language
+ # the primary language of the target, can be `:objc` or `:swift`.
+ #
+ # @return [PBXNativeTarget] the target.
+ #
+ def self.new_target(project, type, name, platform, deployment_target, product_group, language, product_basename)
+ # Target
+ target = project.new(PBXNativeTarget)
+ project.targets << target
+ target.name = name
+ target.product_name = product_basename
+ target.product_type = Constants::PRODUCT_TYPE_UTI[type]
+ target.build_configuration_list = configuration_list(project, platform, deployment_target, type, language)
+
+ # Product
+ product = product_group.new_product_ref_for_target(target.product_name, type)
+ target.product_reference = product
+
+ # Build phases
+ build_phases_for_target_type(type).each { |phase| target.build_phases << project.new(phase) }
+
+ # Frameworks
+ unless type == :static_library
+ framework_name = (platform == :osx) ? 'Cocoa' : 'Foundation'
+ target.add_system_framework(framework_name)
+ end
+
+ target
+ end
+
+ # Creates a new resource bundles target and adds it to the project.
+ #
+ # The target is configured for the given platform and its file reference it
+ # is added to the {products_group}.
+ #
+ # The target is pre-populated with common build settings
+ #
+ # @param [Project] project
+ # the project to which the target should be added.
+ #
+ # @param [String] name
+ # the name of the resources bundle.
+ #
+ # @param [Symbol] platform
+ # the platform of the resources bundle. Can be `:ios` or `:osx`.
+ #
+ # @param [PBXGroup] product_group
+ # the product group, where to add to a file reference of the
+ # created target.
+ #
+ # @return [PBXNativeTarget] the target.
+ #
+ def self.new_resources_bundle(project, name, platform, product_group, product_basename)
+ # Target
+ target = project.new(PBXNativeTarget)
+ project.targets << target
+ target.name = name
+ target.product_name = product_basename
+ target.product_type = Constants::PRODUCT_TYPE_UTI[:bundle]
+
+ # Configuration List
+ cl = project.new(XCConfigurationList)
+ cl.default_configuration_is_visible = '0'
+ cl.default_configuration_name = 'Release'
+ release_conf = project.new(XCBuildConfiguration)
+ release_conf.name = 'Release'
+ release_conf.build_settings = common_build_settings(nil, platform, nil, target.product_type)
+ debug_conf = project.new(XCBuildConfiguration)
+ debug_conf.name = 'Debug'
+ debug_conf.build_settings = common_build_settings(nil, platform, nil, target.product_type)
+ cl.build_configurations << release_conf
+ cl.build_configurations << debug_conf
+ target.build_configuration_list = cl
+
+ # Product
+ product = product_group.new_bundle(target.product_name)
+ target.product_reference = product
+
+ # Build phases
+ build_phases_for_target_type(:bundle).each { |phase| target.build_phases << project.new(phase) }
+
+ target
+ end
+
+ # Creates a new aggregate target and adds it to the project.
+ #
+ # The target is configured for the given platform.
+ #
+ # @param [Project] project
+ # the project to which the target should be added.
+ #
+ # @param [String] name
+ # the name of the aggregate target.
+ #
+ # @param [Symbol] platform
+ # the platform of the aggregate target. Can be `:ios` or `:osx`.
+ #
+ # @param [String] deployment_target
+ # the deployment target for the platform.
+ #
+ # @return [PBXAggregateTarget] the target.
+ #
+ def self.new_aggregate_target(project, name, platform, deployment_target)
+ target = project.new(PBXAggregateTarget)
+ project.targets << target
+ target.name = name
+ target.build_configuration_list = configuration_list(project, platform, deployment_target)
+ target
+ end
+
+ # Creates a new legacy target and adds it to the project.
+ #
+ # The target is configured for the given platform.
+ #
+ # @param [Project] project
+ # the project to which the target should be added.
+ #
+ # @param [String] name
+ # the name of the aggregate target.
+ #
+ # @param [String] build_tool_path
+ # the build tool path to use for this target.
+ #
+ # @param [String] build_arguments_string
+ # the build arguments string to use for this target.
+ #
+ # @param [String] build_working_directory
+ # the build working directory to use for this target.
+ #
+ # @param [String] pass_build_settings_in_environment
+ # whether to pass build settings in the environment during execution of this target.
+ #
+ # @return [PBXLegacyTarget] the target.
+ #
+ def self.new_legacy_target(project, name, build_tool_path = '/usr/bin/make', build_arguments_string = '$(ACTION)',
+ build_working_directory = nil, pass_build_settings_in_environment = '1')
+ target = project.new(PBXLegacyTarget)
+ project.targets << target
+ target.name = name
+ target.build_configuration_list = configuration_list(project)
+ target.build_tool_path = build_tool_path
+ target.build_arguments_string = build_arguments_string
+ target.build_working_directory = build_working_directory
+ target.pass_build_settings_in_environment = pass_build_settings_in_environment
+ target
+ end
+
+ # @!group Private Helpers
+
+ #-----------------------------------------------------------------------#
+
+ # Returns a new configuration list, populated with release and debug
+ # configurations with common build settings for the given platform.
+ #
+ # @param [Project] project
+ # the project to which the configuration list should be added.
+ #
+ # @param [Symbol] platform
+ # the platform for the configuration list, can be `:ios` or `:osx`.
+ #
+ # @param [String] deployment_target
+ # the deployment target for the platform.
+ #
+ # @param [Symbol] target_product_type
+ # the product type of the target, can be any of `Constants::PRODUCT_TYPE_UTI.values`
+ # or `Constants::PRODUCT_TYPE_UTI.keys`.
+ #
+ # @param [Symbol] language
+ # the primary language of the target, can be `:objc` or `:swift`.
+ #
+ # @return [XCConfigurationList] the generated configuration list.
+ #
+ def self.configuration_list(project, platform = nil, deployment_target = nil, target_product_type = nil, language = nil)
+ cl = project.new(XCConfigurationList)
+ cl.default_configuration_is_visible = '0'
+ cl.default_configuration_name = 'Release'
+
+ release_conf = project.new(XCBuildConfiguration)
+ release_conf.name = 'Release'
+ release_conf.build_settings = common_build_settings(:release, platform, deployment_target, target_product_type, language)
+
+ debug_conf = project.new(XCBuildConfiguration)
+ debug_conf.name = 'Debug'
+ debug_conf.build_settings = common_build_settings(:debug, platform, deployment_target, target_product_type, language)
+
+ cl.build_configurations << release_conf
+ cl.build_configurations << debug_conf
+
+ existing_configurations = cl.build_configurations.map(&:name)
+ project.build_configurations.each do |configuration|
+ next if existing_configurations.include?(configuration.name)
+
+ new_config = project.new(XCBuildConfiguration)
+ new_config.name = configuration.name
+ new_config.build_settings = common_build_settings(configuration.type, platform, deployment_target, target_product_type, language)
+ cl.build_configurations << new_config
+ end
+
+ cl
+ end
+
+ # Returns the common build settings for a given platform and configuration
+ # name.
+ #
+ # @param [Symbol] type
+ # the type of the build configuration, can be `:release` or
+ # `:debug`.
+ #
+ # @param [Symbol] platform
+ # the platform for the build settings, can be `:ios` or `:osx`.
+ #
+ # @param [String] deployment_target
+ # the deployment target for the platform.
+ #
+ # @param [Symbol] target_product_type
+ # the product type of the target, can be any of
+ # `Constants::PRODUCT_TYPE_UTI.values`
+ # or `Constants::PRODUCT_TYPE_UTI.keys`. Default is :application.
+ #
+ # @param [Symbol] language
+ # the primary language of the target, can be `:objc` or `:swift`.
+ #
+ # @return [Hash] The common build settings
+ #
+ def self.common_build_settings(type, platform = nil, deployment_target = nil, target_product_type = nil, language = :objc)
+ target_product_type = (Constants::PRODUCT_TYPE_UTI.find { |_, v| v == target_product_type } || [target_product_type || :application])[0]
+ common_settings = Constants::COMMON_BUILD_SETTINGS
+
+ # Use intersecting settings for all key sets as base
+ settings = deep_dup(common_settings[:all])
+
+ # Match further common settings by key sets
+ keys = [type, platform, target_product_type, language].compact
+ key_combinations = (1..keys.length).flat_map { |n| keys.combination(n).to_a }
+ key_combinations.each do |key_combination|
+ settings.merge!(deep_dup(common_settings[key_combination] || {}))
+ end
+
+ if deployment_target
+ case platform
+ when :ios
+ settings['IPHONEOS_DEPLOYMENT_TARGET'] = deployment_target
+ settings['CLANG_ENABLE_OBJC_WEAK'] = 'NO' if deployment_target < '5'
+ when :osx
+ settings['MACOSX_DEPLOYMENT_TARGET'] = deployment_target
+ settings['CLANG_ENABLE_OBJC_WEAK'] = 'NO' if deployment_target < '10.7'
+ when :tvos
+ settings['TVOS_DEPLOYMENT_TARGET'] = deployment_target
+ when :visionos
+ settings['XROS_DEPLOYMENT_TARGET'] = deployment_target
+ when :watchos
+ settings['WATCHOS_DEPLOYMENT_TARGET'] = deployment_target
+ end
+ end
+
+ settings
+ end
+
+ # Creates a deep copy of the given object
+ #
+ # @param [Object] object
+ # the object to copy.
+ #
+ # @return [Object] The deep copy of the object.
+ #
+ def self.deep_dup(object)
+ case object
+ when Hash
+ new_hash = {}
+ object.each do |key, value|
+ new_hash[key] = deep_dup(value)
+ end
+ new_hash
+ when Array
+ object.map { |value| deep_dup(value) }
+ else
+ object.dup
+ end
+ end
+
+ # Returns the build phases, in order, that appear by default
+ # on a target of the given type.
+ #
+ # @param [Symbol] type
+ # the name of the target type.
+ #
+ # @return [Array<String>] The list of build phase class names for the target type.
+ #
+ def self.build_phases_for_target_type(type)
+ case type
+ when :static_library, :dynamic_library
+ %w(Headers Sources Frameworks)
+ when :framework
+ %w(Headers Sources Frameworks Resources)
+ when :command_line_tool
+ %w(Sources Frameworks)
+ else
+ %w(Sources Frameworks Resources)
+ end.map { |phase| "PBX#{phase}BuildPhase" }
+ end
+
+ #-----------------------------------------------------------------------#
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/uuid_generator.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/uuid_generator.rb
new file mode 100644
index 0000000..f47da43
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/project/uuid_generator.rb
@@ -0,0 +1,132 @@
+module Xcodeproj
+ class Project
+ class UUIDGenerator
+ require 'digest'
+
+ def initialize(projects)
+ @projects = Array(projects)
+ @paths_by_object = {}
+ end
+
+ def generate!
+ generate_all_paths_by_objects(@projects)
+
+ new_objects_by_project = Hash[@projects.map do |project|
+ [project, switch_uuids(project)]
+ end]
+ all_new_objects_by_project = new_objects_by_project.values.flat_map(&:values)
+ all_objects_by_uuid = @projects.map(&:objects_by_uuid).inject(:merge)
+ all_objects = @projects.flat_map(&:objects)
+ verify_no_duplicates!(all_objects, all_new_objects_by_project)
+ @projects.each { |project| fixup_uuid_references(project, all_objects_by_uuid) }
+ new_objects_by_project.each do |project, new_objects_by_uuid|
+ project.instance_variable_set(:@generated_uuids, project.instance_variable_get(:@available_uuids))
+ project.instance_variable_set(:@objects_by_uuid, new_objects_by_uuid)
+ end
+ end
+
+ private
+
+ UUID_ATTRIBUTES = [:remote_global_id_string, :container_portal, :target_proxy].freeze
+
+ def verify_no_duplicates!(all_objects, all_new_objects)
+ duplicates = all_objects - all_new_objects
+ UserInterface.warn "[Xcodeproj] Generated duplicate UUIDs:\n\n" <<
+ duplicates.map { |d| "#{d.isa} -- #{@paths_by_object[d]}" }.join("\n") unless duplicates.empty?
+ end
+
+ def fixup_uuid_references(target_project, all_objects_by_uuid)
+ fixup = ->(object, attr) do
+ if object.respond_to?(attr) && link = all_objects_by_uuid[object.send(attr)]
+ object.send(:"#{attr}=", link.uuid)
+ end
+ end
+ target_project.objects.each do |object|
+ UUID_ATTRIBUTES.each do |attr|
+ fixup[object, attr]
+ end
+ end
+
+ if (project_attributes = target_project.root_object.attributes) && project_attributes['TargetAttributes']
+ project_attributes['TargetAttributes'] = Hash[project_attributes['TargetAttributes'].map do |target_uuid, attributes|
+ if test_target_id = attributes['TestTargetID']
+ attributes = attributes.merge('TestTargetID' => all_objects_by_uuid[test_target_id].uuid)
+ end
+ if target_object = all_objects_by_uuid[target_uuid]
+ target_uuid = target_object.uuid
+ end
+ [target_uuid, attributes]
+ end]
+ end
+ end
+
+ def generate_all_paths_by_objects(projects)
+ projects.each { |project| generate_paths(project.root_object, project.path.basename.to_s) }
+ end
+
+ def generate_paths(object, path = '')
+ existing = @paths_by_object[object] || path
+ return existing if @paths_by_object.key?(object)
+ @paths_by_object[object] = path.size > existing.size ? path : existing
+
+ object.to_one_attributes.each do |attrb|
+ obj = attrb.get_value(object)
+ generate_paths(obj, path + '/' << attrb.plist_name) if obj
+ end
+
+ object.to_many_attributes.each do |attrb|
+ attrb.get_value(object).each do |o|
+ generate_paths(o, path + '/' << attrb.plist_name << "/#{path_component_for_object(o)}")
+ end
+ end
+
+ object.references_by_keys_attributes.each do |attrb|
+ attrb.get_value(object).each do |dictionary|
+ dictionary.each do |key, value|
+ generate_paths(value, path + '/' << attrb.plist_name << "/k:#{key}/#{path_component_for_object(value)}")
+ end
+ end
+ end
+ end
+
+ def switch_uuids(project)
+ project.mark_dirty!
+ project.objects.each_with_object({}) do |object, hash|
+ next unless path = @paths_by_object[object]
+ uuid = uuid_for_path(path)
+ object.instance_variable_set(:@uuid, uuid)
+ hash[uuid] = object
+ end
+ end
+
+ def uuid_for_path(path)
+ Digest::MD5.hexdigest(path).upcase
+ end
+
+ def path_component_for_object(object)
+ @path_component_for_object ||= Hash.new do |cache, key|
+ component = tree_hash_to_path(key.to_tree_hash)
+ component << key.hierarchy_path.to_s if key.respond_to?(:hierarchy_path)
+ cache[key] = component
+ end
+ @path_component_for_object[object]
+ end
+
+ def tree_hash_to_path(object, depth = 4)
+ return '|' if depth.zero?
+ case object
+ when Hash
+ object.sort.each_with_object('') do |(key, value), string|
+ string << key << ':' << tree_hash_to_path(value, depth - 1) << ','
+ end
+ when Array
+ object.map do |value|
+ tree_hash_to_path(value, depth - 1)
+ end.join(',')
+ else
+ object.to_s
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme.rb
new file mode 100644
index 0000000..e855ad1
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme.rb
@@ -0,0 +1,375 @@
+require 'rexml/document'
+
+require 'xcodeproj/scheme/build_action'
+require 'xcodeproj/scheme/test_action'
+require 'xcodeproj/scheme/launch_action'
+require 'xcodeproj/scheme/profile_action'
+require 'xcodeproj/scheme/analyze_action'
+require 'xcodeproj/scheme/archive_action'
+
+require 'xcodeproj/scheme/buildable_product_runnable'
+require 'xcodeproj/scheme/buildable_reference'
+require 'xcodeproj/scheme/location_scenario_reference'
+require 'xcodeproj/scheme/execution_action'
+require 'xcodeproj/scheme/macro_expansion'
+require 'xcodeproj/scheme/remote_runnable'
+require 'xcodeproj/scheme/send_email_action_content'
+require 'xcodeproj/scheme/shell_script_action_content'
+
+module Xcodeproj
+ # This class represents a Scheme document represented by a ".xcscheme" file
+ # usually stored in a xcuserdata or xcshareddata (for a shared scheme)
+ # folder.
+ #
+ class XCScheme
+ # @return [REXML::Document] the XML object that will be manipulated to save
+ # the scheme file after.
+ #
+ attr_reader :doc
+
+ # Create a XCScheme either from scratch or using an existing file
+ #
+ # @param [String] file_path
+ # The path of the existing .xcscheme file. If nil will create an empty scheme
+ #
+ def initialize(file_path = nil)
+ if file_path
+ @file_path = file_path
+ @doc = File.open(file_path, 'r') do |f|
+ REXML::Document.new(f)
+ end
+ @doc.context[:attribute_quote] = :quote
+
+ @scheme = @doc.elements['Scheme']
+ else
+ @doc = REXML::Document.new
+ @doc.context[:attribute_quote] = :quote
+ @doc << REXML::XMLDecl.new(REXML::XMLDecl::DEFAULT_VERSION, 'UTF-8')
+
+ @scheme = @doc.add_element 'Scheme'
+ @scheme.attributes['LastUpgradeVersion'] = Constants::LAST_UPGRADE_CHECK
+ @scheme.attributes['version'] = Xcodeproj::Constants::XCSCHEME_FORMAT_VERSION
+
+ self.build_action = BuildAction.new
+ self.test_action = TestAction.new
+ self.launch_action = LaunchAction.new
+ self.profile_action = ProfileAction.new
+ self.analyze_action = AnalyzeAction.new
+ self.archive_action = ArchiveAction.new
+ end
+ end
+
+ # Convenience method to quickly add app and test targets to a new scheme.
+ #
+ # It will add the runnable_target to the Build, Launch and Profile actions
+ # and the test_target to the Build and Test actions
+ #
+ # @param [Xcodeproj::Project::Object::PBXAbstractTarget] runnable_target
+ # The target to use for the 'Run', 'Profile' and 'Analyze' actions
+ #
+ # @param [Xcodeproj::Project::Object::PBXAbstractTarget] test_target
+ # The target to use for the 'Test' action
+ #
+ # @param [Boolean] launch_target
+ # Determines if the runnable_target is launchable.
+ #
+ def configure_with_targets(runnable_target, test_target, launch_target: false)
+ if runnable_target
+ add_build_target(runnable_target)
+ set_launch_target(runnable_target) if launch_target
+ end
+ if test_target
+ add_build_target(test_target, false) if test_target != runnable_target
+ add_test_target(test_target)
+ end
+ end
+
+ public
+
+ # @!group Access Action nodes
+
+ # @return [XCScheme::BuildAction]
+ # The Build Action associated with this scheme
+ #
+ def build_action
+ @build_action ||= BuildAction.new(@scheme.elements['BuildAction'])
+ end
+
+ # @param [XCScheme::BuildAction] action
+ # The Build Action to associate to this scheme
+ #
+ def build_action=(action)
+ @scheme.delete_element('BuildAction')
+ @scheme.add_element(action.xml_element)
+ @build_action = action
+ end
+
+ # @return [XCScheme::TestAction]
+ # The Test Action associated with this scheme
+ #
+ def test_action
+ @test_action ||= TestAction.new(@scheme.elements['TestAction'])
+ end
+
+ # @param [XCScheme::TestAction] action
+ # The Test Action to associate to this scheme
+ #
+ def test_action=(action)
+ @scheme.delete_element('TestAction')
+ @scheme.add_element(action.xml_element)
+ @test_action = action
+ end
+
+ # @return [XCScheme::LaunchAction]
+ # The Launch Action associated with this scheme
+ #
+ def launch_action
+ @launch_action ||= LaunchAction.new(@scheme.elements['LaunchAction'])
+ end
+
+ # @param [XCScheme::LaunchAction] action
+ # The Launch Action to associate to this scheme
+ #
+ def launch_action=(action)
+ @scheme.delete_element('LaunchAction')
+ @scheme.add_element(action.xml_element)
+ @launch_action = action
+ end
+
+ # @return [XCScheme::ProfileAction]
+ # The Profile Action associated with this scheme
+ #
+ def profile_action
+ @profile_action ||= ProfileAction.new(@scheme.elements['ProfileAction'])
+ end
+
+ # @param [XCScheme::ProfileAction] action
+ # The Profile Action to associate to this scheme
+ #
+ def profile_action=(action)
+ @scheme.delete_element('ProfileAction')
+ @scheme.add_element(action.xml_element)
+ @profile_action = action
+ end
+
+ # @return [XCScheme::AnalyzeAction]
+ # The Analyze Action associated with this scheme
+ #
+ def analyze_action
+ @analyze_action ||= AnalyzeAction.new(@scheme.elements['AnalyzeAction'])
+ end
+
+ # @param [XCScheme::AnalyzeAction] action
+ # The Analyze Action to associate to this scheme
+ #
+ def analyze_action=(action)
+ @scheme.delete_element('AnalyzeAction')
+ @scheme.add_element(action.xml_element)
+ @analyze_action = action
+ end
+
+ # @return [XCScheme::ArchiveAction]
+ # The Archive Action associated with this scheme
+ #
+ def archive_action
+ @archive_action ||= ArchiveAction.new(@scheme.elements['ArchiveAction'])
+ end
+
+ # @param [XCScheme::ArchiveAction] action
+ # The Archive Action to associate to this scheme
+ #
+ def archive_action=(action)
+ @scheme.delete_element('ArchiveAction')
+ @scheme.add_element(action.xml_element)
+ @archive_action = action
+ end
+
+ # @!group Target methods
+
+ # Add a target to the list of targets to build in the build action.
+ #
+ # @param [Xcodeproj::Project::Object::AbstractTarget] build_target
+ # A target used by scheme in the build step.
+ #
+ # @param [Bool] build_for_running
+ # Whether to build this target in the launch action. Often false for test targets.
+ #
+ def add_build_target(build_target, build_for_running = true)
+ entry = BuildAction::Entry.new(build_target)
+
+ entry.build_for_testing = true
+ entry.build_for_running = build_for_running
+ entry.build_for_profiling = build_for_running
+ entry.build_for_archiving = build_for_running
+ entry.build_for_analyzing = build_for_running
+
+ build_action.add_entry(entry)
+ end
+
+ # Add a target to the list of targets to build in the build action.
+ #
+ # @param [Xcodeproj::Project::Object::AbstractTarget] test_target
+ # A target used by scheme in the test step.
+ #
+ def add_test_target(test_target)
+ testable = TestAction::TestableReference.new(test_target)
+ test_action.add_testable(testable)
+ end
+
+ # Sets a runnable target to be the target of the launch action of the scheme.
+ #
+ # @param [Xcodeproj::Project::Object::AbstractTarget] build_target
+ # A target used by scheme in the launch step.
+ #
+ def set_launch_target(build_target)
+ launch_runnable = BuildableProductRunnable.new(build_target, 0)
+ launch_action.buildable_product_runnable = launch_runnable
+
+ profile_runnable = BuildableProductRunnable.new(build_target, 0)
+ profile_action.buildable_product_runnable = profile_runnable
+
+ macro_exp = MacroExpansion.new(build_target)
+ test_action.add_macro_expansion(macro_exp)
+ end
+
+ # @!group Class methods
+
+ #-------------------------------------------------------------------------#
+
+ # Share a User Scheme. Basically this method move the xcscheme file from
+ # the xcuserdata folder to xcshareddata folder.
+ #
+ # @param [String] project_path
+ # Path of the .xcodeproj folder.
+ #
+ # @param [String] scheme_name
+ # The name of scheme that will be shared.
+ #
+ # @param [String] user
+ # The user name that have the scheme.
+ #
+ def self.share_scheme(project_path, scheme_name, user = nil)
+ to_folder = shared_data_dir(project_path)
+ to_folder.mkpath
+ to = to_folder + "#{scheme_name}.xcscheme"
+ from = user_data_dir(project_path, user) + "#{scheme_name}.xcscheme"
+ FileUtils.mv(from, to)
+ end
+
+ # @return [Pathname]
+ #
+ def self.shared_data_dir(project_path)
+ project_path = Pathname.new(project_path)
+ project_path + 'xcshareddata/xcschemes'
+ end
+
+ # @return [Pathname]
+ #
+ def self.user_data_dir(project_path, user = nil)
+ project_path = Pathname.new(project_path)
+ user ||= ENV['USER']
+ project_path + "xcuserdata/#{user}.xcuserdatad/xcschemes"
+ end
+
+ public
+
+ # @!group Serialization
+
+ #-------------------------------------------------------------------------#
+
+ # Serializes the current state of the object to a String.
+ #
+ # @note The goal of the string representation is to match Xcode output as
+ # close as possible to aide comparison.
+ #
+ # @return [String] the XML string value of the current state of the object.
+ #
+ def to_s
+ formatter = XMLFormatter.new(2)
+ formatter.compact = false
+ out = ''
+ formatter.write(@doc, out)
+ out.gsub!("<?xml version='1.0' encoding='UTF-8'?>", '<?xml version="1.0" encoding="UTF-8"?>')
+ out << "\n"
+ out
+ end
+
+ # Serializes the current state of the object to a ".xcscheme" file.
+ #
+ # @param [String, Pathname] project_path
+ # The path where the ".xcscheme" file should be stored.
+ #
+ # @param [String] name
+ # The name of the scheme, to have ".xcscheme" appended.
+ #
+ # @param [Boolean] shared
+ # true => if the scheme must be a shared scheme (default value)
+ # false => if the scheme must be a user scheme
+ #
+ # @return [void]
+ #
+ # @example Saving a scheme
+ # scheme.save_as('path/to/Project.xcodeproj') #=> true
+ #
+ def save_as(project_path, name, shared = true)
+ scheme_folder_path = if shared
+ self.class.shared_data_dir(project_path)
+ else
+ self.class.user_data_dir(project_path)
+ end
+ scheme_folder_path.mkpath
+ scheme_path = scheme_folder_path + "#{name}.xcscheme"
+ @file_path = scheme_path
+ File.open(scheme_path, 'w') do |f|
+ f.write(to_s)
+ end
+ end
+
+ # Serializes the current state of the object to the original ".xcscheme"
+ # file this XCScheme was created from, overriding the original file.
+ #
+ # Requires that the XCScheme object was initialized using a file path.
+ #
+ def save!
+ raise Informative, 'This XCScheme object was not initialized ' \
+ 'using a file path. Use save_as instead.' unless @file_path
+ File.open(@file_path, 'w') do |f|
+ f.write(to_s)
+ end
+ end
+
+ #-------------------------------------------------------------------------#
+
+ # XML formatter which closely mimics the output generated by Xcode.
+ #
+ class XMLFormatter < REXML::Formatters::Pretty
+ def write_element(node, output)
+ @indentation = 3
+ output << ' ' * @level
+ output << "<#{node.expanded_name}"
+
+ @level += @indentation
+ node.context = node.parent.context # HACK: to ensure strings are properly quoted
+ node.attributes.each_attribute do |attr|
+ output << "\n"
+ output << ' ' * @level
+ output << attr.to_string.sub(/=/, ' = ')
+ end unless node.attributes.empty?
+
+ output << '>'
+
+ output << "\n"
+ node.children.each do |child|
+ next if child.is_a?(REXML::Text) && child.to_s.strip.length == 0
+ write(child, output)
+ output << "\n"
+ end
+ @level -= @indentation
+ output << ' ' * @level
+ output << "</#{node.expanded_name}>"
+ end
+ end
+
+ #-------------------------------------------------------------------------#
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/abstract_scheme_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/abstract_scheme_action.rb
new file mode 100644
index 0000000..0b59d63
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/abstract_scheme_action.rb
@@ -0,0 +1,100 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+require 'xcodeproj/scheme/environment_variables'
+require 'xcodeproj/scheme/command_line_arguments'
+
+module Xcodeproj
+ class XCScheme
+ # This abstract class aims to be the base class for every XxxAction class
+ # that have a #build_configuration attribute
+ #
+ class AbstractSchemeAction < XMLElementWrapper
+ # @return [String]
+ # The build configuration associated with this action
+ # (usually either 'Debug' or 'Release')
+ #
+ def build_configuration
+ @xml_element.attributes['buildConfiguration']
+ end
+
+ # @param [String] config_name
+ # The build configuration to associate with this action
+ # (usually either 'Debug' or 'Release')
+ #
+ def build_configuration=(config_name)
+ @xml_element.attributes['buildConfiguration'] = config_name
+ end
+
+ # @return [Array<ExecutionAction>]
+ # The list of actions to run before this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def pre_actions
+ pre_actions = @xml_element.elements['PreActions']
+ return nil unless pre_actions
+ pre_actions.get_elements('ExecutionAction').map do |entry_node|
+ ExecutionAction.new(entry_node)
+ end
+ end
+
+ # @param [Array<ExecutionAction>] pre_actions
+ # Set the list of actions to run before this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def pre_actions=(pre_actions)
+ @xml_element.delete_element('PreActions')
+ unless pre_actions.empty?
+ pre_actions_element = @xml_element.add_element('PreActions')
+ pre_actions.each do |entry_node|
+ pre_actions_element.add_element(entry_node.xml_element)
+ end
+ end
+ pre_actions
+ end
+
+ # @param [ExecutionAction] pre_action
+ # Add an action to the list of actions to run before this scheme action.
+ # It can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def add_pre_action(pre_action)
+ pre_actions = @xml_element.elements['PreActions'] || @xml_element.add_element('PreActions')
+ pre_actions.add_element(pre_action.xml_element)
+ end
+
+ # @return [Array<ExecutionAction>]
+ # The list of actions to run after this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def post_actions
+ post_actions = @xml_element.elements['PostActions']
+ return nil unless post_actions
+ post_actions.get_elements('ExecutionAction').map do |entry_node|
+ ExecutionAction.new(entry_node)
+ end
+ end
+
+ # @param [Array<ExecutionAction>] post_actions
+ # Set the list of actions to run after this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def post_actions=(post_actions)
+ @xml_element.delete_element('PostActions')
+ unless post_actions.empty?
+ post_actions_element = @xml_element.add_element('PostActions')
+ post_actions.each do |entry_node|
+ post_actions_element.add_element(entry_node.xml_element)
+ end
+ end
+ post_actions
+ end
+
+ # @param [ExecutionAction] post_action
+ # Add an action to the list of actions to run after this scheme action.
+ # It can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def add_post_action(post_action)
+ post_actions = @xml_element.elements['PostActions'] || @xml_element.add_element('PostActions')
+ post_actions.add_element(post_action.xml_element)
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/analyze_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/analyze_action.rb
new file mode 100644
index 0000000..e951980
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/analyze_action.rb
@@ -0,0 +1,19 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+ class XCScheme
+ # This class wraps the AnalyzeAction node of a .xcscheme XML file
+ #
+ class AnalyzeAction < AbstractSchemeAction
+ # @param [REXML::Element] node
+ # The 'AnalyzeAction' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'AnalyzeAction') do
+ self.build_configuration = 'Debug'
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/archive_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/archive_action.rb
new file mode 100644
index 0000000..d00581f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/archive_action.rb
@@ -0,0 +1,59 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+ class XCScheme
+ # This class wraps the ArchiveAction node of a .xcscheme XML file
+ #
+ class ArchiveAction < AbstractSchemeAction
+ # @param [REXML::Element] node
+ # The 'ArchiveAction' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'ArchiveAction') do
+ self.build_configuration = 'Release'
+ self.reveal_archive_in_organizer = true
+ end
+ end
+
+ # @return [Bool]
+ # Whether the Archive will be revealed in Xcode's Organizer
+ # after it's done building.
+ #
+ def reveal_archive_in_organizer?
+ string_to_bool(@xml_element.attributes['revealArchiveInOrganizer'])
+ end
+
+ # @param [Bool] flag
+ # Set whether the Archive will be revealed in Xcode's Organizer
+ # after it's done building.
+ #
+ def reveal_archive_in_organizer=(flag)
+ @xml_element.attributes['revealArchiveInOrganizer'] = bool_to_string(flag)
+ end
+
+ # @return [String]
+ # The custom name to give to the archive.
+ # If nil, the generated archive will have the same name as the one
+ # set in the associated target's Build Settings for the built product.
+ #
+ def custom_archive_name
+ @xml_element.attributes['customArchiveName']
+ end
+
+ # @param [String] name
+ # Set the custom name to use for the built archive
+ # If nil, the customization of the archive name will be removed and
+ # the generated archive will have the same name as the one set in the
+ # associated target's Build Settings for the build product.
+ #
+ def custom_archive_name=(name)
+ if name
+ @xml_element.attributes['customArchiveName'] = name
+ else
+ @xml_element.delete_attribute('customArchiveName')
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/build_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/build_action.rb
new file mode 100644
index 0000000..5b67213
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/build_action.rb
@@ -0,0 +1,298 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+
+module Xcodeproj
+ class XCScheme
+ # This class wraps the BuildAction node of a .xcscheme XML file
+ #
+ # Note: It's not a AbstractSchemeAction like the others because it is
+ # a special case of action (with no build_configuration, etc)
+ #
+ class BuildAction < XMLElementWrapper
+ # @param [REXML::Element] node
+ # The 'BuildAction' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'BuildAction') do
+ self.parallelize_buildables = true
+ self.build_implicit_dependencies = true
+ end
+ end
+
+ # @return [Bool]
+ # Whether or not to run post actions on build failure
+ #
+ def run_post_actions_on_failure?
+ string_to_bool(@xml_element.attributes['runPostActionsOnFailure'])
+ end
+
+ # @param [Bool] flag
+ # Set whether or not to run post actions on build failure
+ #
+ def run_post_actions_on_failure=(flag)
+ @xml_element.attributes['runPostActionsOnFailure'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether or not to build the various targets in parallel
+ #
+ def parallelize_buildables?
+ string_to_bool(@xml_element.attributes['parallelizeBuildables'])
+ end
+
+ # @param [Bool] flag
+ # Set whether or not to build the various targets in parallel
+ #
+ def parallelize_buildables=(flag)
+ @xml_element.attributes['parallelizeBuildables'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether or not to detect and build implicit dependencies for each target
+ #
+ def build_implicit_dependencies?
+ string_to_bool(@xml_element.attributes['buildImplicitDependencies'])
+ end
+
+ # @param [Bool] flag
+ # Whether or not to detect and build implicit dependencies for each target
+ #
+ def build_implicit_dependencies=(flag)
+ @xml_element.attributes['buildImplicitDependencies'] = bool_to_string(flag)
+ end
+
+ # @return [Array<ExecutionAction>]
+ # The list of actions to run before this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def pre_actions
+ pre_actions = @xml_element.elements['PreActions']
+ return nil unless pre_actions
+ pre_actions.get_elements('ExecutionAction').map do |entry_node|
+ ExecutionAction.new(entry_node)
+ end
+ end
+
+ # @param [Array<ExecutionAction>] pre_actions
+ # Set the list of actions to run before this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def pre_actions=(pre_actions)
+ @xml_element.delete_element('PreActions')
+ unless pre_actions.empty?
+ pre_actions_element = @xml_element.add_element('PreActions')
+ pre_actions.each do |entry_node|
+ pre_actions_element.add_element(entry_node.xml_element)
+ end
+ end
+ pre_actions
+ end
+
+ # @param [ExecutionAction] pre_action
+ # Add an action to the list of actions to run before this scheme action.
+ # It can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def add_pre_action(pre_action)
+ pre_actions = @xml_element.elements['PreActions'] || @xml_element.add_element('PreActions')
+ pre_actions.add_element(pre_action.xml_element)
+ end
+
+ # @return [Array<ExecutionAction>]
+ # The list of actions to run after this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def post_actions
+ post_actions = @xml_element.elements['PostActions']
+ return nil unless post_actions
+ post_actions.get_elements('ExecutionAction').map do |entry_node|
+ ExecutionAction.new(entry_node)
+ end
+ end
+
+ # @param [Array<ExecutionAction>] post_actions
+ # Set the list of actions to run after this scheme action.
+ # Each entry can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def post_actions=(post_actions)
+ @xml_element.delete_element('PostActions')
+ unless post_actions.empty?
+ post_actions_element = @xml_element.add_element('PostActions')
+ post_actions.each do |entry_node|
+ post_actions_element.add_element(entry_node.xml_element)
+ end
+ end
+ post_actions
+ end
+
+ # @param [ExecutionAction] post_action
+ # Add an action to the list of actions to run after this scheme action.
+ # It can be either a 'Run Script' or a 'Send Email' action.
+ #
+ def add_post_action(post_action)
+ post_actions = @xml_element.elements['PostActions'] || @xml_element.add_element('PostActions')
+ post_actions.add_element(post_action.xml_element)
+ end
+
+ # @return [Array<BuildAction::Entry>]
+ # The list of BuildActionEntry nodes associated with this Build Action.
+ # Each entry represent a target to build and tells for which action it's needed to be built.
+ #
+ def entries
+ entries = @xml_element.elements['BuildActionEntries']
+ return nil unless entries
+ entries.get_elements('BuildActionEntry').map do |entry_node|
+ BuildAction::Entry.new(entry_node)
+ end
+ end
+
+ # @param [Array<BuildAction::Entry>] entries
+ # Sets the list of BuildActionEntry nodes associated with this Build Action.
+ #
+ def entries=(entries)
+ @xml_element.delete_element('BuildActionEntries')
+ unless entries.empty?
+ entries_element = @xml_element.add_element('BuildActionEntries')
+ entries.each do |entry_node|
+ entries_element.add_element(entry_node.xml_element)
+ end
+ end
+ entries
+ end
+
+ # @param [BuildAction::Entry] entry
+ # The BuildActionEntry to add to the list of targets to build for the various actions
+ #
+ def add_entry(entry)
+ entries = @xml_element.elements['BuildActionEntries'] || @xml_element.add_element('BuildActionEntries')
+ entries.add_element(entry.xml_element)
+ end
+
+ #-------------------------------------------------------------------------#
+
+ class Entry < XMLElementWrapper
+ # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+ # Either the Xcode target to reference,
+ # or an existing XML 'BuildActionEntry' node element to reference,
+ # or nil to create an new, empty Entry with default values
+ #
+ def initialize(target_or_node = nil)
+ create_xml_element_with_fallback(target_or_node, 'BuildActionEntry') do
+ # Check target type to configure the default entry attributes accordingly
+ is_test_target = false
+ is_app_target = false
+ if target_or_node && target_or_node.is_a?(::Xcodeproj::Project::Object::PBXNativeTarget)
+ test_types = [Constants::PRODUCT_TYPE_UTI[:octest_bundle],
+ Constants::PRODUCT_TYPE_UTI[:unit_test_bundle],
+ Constants::PRODUCT_TYPE_UTI[:ui_test_bundle]]
+ app_types = [Constants::PRODUCT_TYPE_UTI[:application]]
+ is_test_target = test_types.include?(target_or_node.product_type)
+ is_app_target = app_types.include?(target_or_node.product_type)
+ end
+
+ self.build_for_testing = is_test_target
+ self.build_for_running = is_app_target
+ self.build_for_profiling = is_app_target
+ self.build_for_archiving = is_app_target
+ self.build_for_analyzing = true
+
+ add_buildable_reference BuildableReference.new(target_or_node) if target_or_node
+ end
+ end
+
+ # @return [Bool]
+ # Whether or not to build this target when building for Testing
+ #
+ def build_for_testing?
+ string_to_bool(@xml_element.attributes['buildForTesting'])
+ end
+
+ # @param [Bool]
+ # Set whether or not to build this target when building for Testing
+ #
+ def build_for_testing=(flag)
+ @xml_element.attributes['buildForTesting'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether or not to build this target when building for Running
+ #
+ def build_for_running?
+ string_to_bool(@xml_element.attributes['buildForRunning'])
+ end
+
+ # @param [Bool]
+ # Set whether or not to build this target when building for Running
+ #
+ def build_for_running=(flag)
+ @xml_element.attributes['buildForRunning'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether or not to build this target when building for Profiling
+ #
+ def build_for_profiling?
+ string_to_bool(@xml_element.attributes['buildForProfiling'])
+ end
+
+ # @param [Bool]
+ # Set whether or not to build this target when building for Profiling
+ #
+ def build_for_profiling=(flag)
+ @xml_element.attributes['buildForProfiling'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether or not to build this target when building for Archiving
+ #
+ def build_for_archiving?
+ string_to_bool(@xml_element.attributes['buildForArchiving'])
+ end
+
+ # @param [Bool]
+ # Set whether or not to build this target when building for Archiving
+ #
+ def build_for_archiving=(flag)
+ @xml_element.attributes['buildForArchiving'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether or not to build this target when building for Analyzing
+ #
+ def build_for_analyzing?
+ string_to_bool(@xml_element.attributes['buildForAnalyzing'])
+ end
+
+ # @param [Bool]
+ # Set whether or not to build this target when building for Analyzing
+ #
+ def build_for_analyzing=(flag)
+ @xml_element.attributes['buildForAnalyzing'] = bool_to_string(flag)
+ end
+
+ # @return [Array<BuildableReference>]
+ # The list of BuildableReferences this entry will build.
+ # (The list usually contains only one element)
+ #
+ def buildable_references
+ @xml_element.get_elements('BuildableReference').map do |node|
+ BuildableReference.new(node)
+ end
+ end
+
+ # @param [BuildableReference] ref
+ # The BuildableReference to add to the list of targets this entry will build
+ #
+ def add_buildable_reference(ref)
+ @xml_element.add_element(ref.xml_element)
+ end
+
+ # @param [BuildableReference] ref
+ # The BuildableReference to remove from the list of targets this entry will build
+ #
+ def remove_buildable_reference(ref)
+ @xml_element.delete_element(ref.xml_element)
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/buildable_product_runnable.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/buildable_product_runnable.rb
new file mode 100644
index 0000000..f4d350f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/buildable_product_runnable.rb
@@ -0,0 +1,55 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps the BuildableProductRunnable node of a .xcscheme XML file
+ #
+ # A BuildableProductRunnable is a product that is both buildable
+ # (it contains a BuildableReference) and runnable (it can be launched and debugged)
+ #
+ class BuildableProductRunnable < XMLElementWrapper
+ # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+ # Either the Xcode target to reference,
+ # or an existing XML 'BuildableProductRunnable' node element to reference
+ # or nil to create an new, empty BuildableProductRunnable
+ #
+ # @param [#to_s] runnable_debugging_mode
+ # The debugging mode (usually '0')
+ #
+ def initialize(target_or_node = nil, runnable_debugging_mode = nil)
+ create_xml_element_with_fallback(target_or_node, 'BuildableProductRunnable') do
+ self.buildable_reference = BuildableReference.new(target_or_node) if target_or_node
+ @xml_element.attributes['runnableDebuggingMode'] = runnable_debugging_mode.to_s if runnable_debugging_mode
+ end
+ end
+
+ # @return [String]
+ # The Runnable debugging mode (usually either empty or equal to '0')
+ #
+ def runnable_debugging_mode
+ @xml_element.attributes['runnableDebuggingMode']
+ end
+
+ # @param [String] value
+ # Set the runnable debugging mode of this buildable product runnable
+ #
+ def runnable_debugging_mode=(value)
+ @xml_element.attributes['runnableDebuggingMode'] = value.to_s
+ end
+
+ # @return [BuildableReference]
+ # The Buildable Reference this Buildable Product Runnable is gonna build and run
+ #
+ def buildable_reference
+ @buildable_reference ||= BuildableReference.new @xml_element.elements['BuildableReference']
+ end
+
+ # @param [BuildableReference] ref
+ # Set the Buildable Reference this Buildable Product Runnable is gonna build and run
+ #
+ def buildable_reference=(ref)
+ @xml_element.delete_element('BuildableReference')
+ @xml_element.add_element(ref.xml_element)
+ @buildable_reference = ref
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/buildable_reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/buildable_reference.rb
new file mode 100644
index 0000000..b75e26e
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/buildable_reference.rb
@@ -0,0 +1,129 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps the BuildableReference node of a .xcscheme XML file
+ #
+ # A BuildableReference is a reference to a buildable product (which is
+ # typically is synonymous for an Xcode target)
+ #
+ class BuildableReference < XMLElementWrapper
+ # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+ # Either the Xcode target to reference,
+ # or an existing XML 'BuildableReference' node element to reference
+ #
+ # @param [Xcodeproj::Project] the root project to reference from
+ # (when nil the project of the target is used)
+ #
+ def initialize(target_or_node, root_project = nil)
+ create_xml_element_with_fallback(target_or_node, 'BuildableReference') do
+ @xml_element.attributes['BuildableIdentifier'] = 'primary'
+ set_reference_target(target_or_node, true, root_project) if target_or_node
+ end
+ end
+
+ # @return [String]
+ # The name of the target this Buildable Reference points to
+ #
+ def target_name
+ @xml_element.attributes['BlueprintName']
+ end
+
+ # @return [String]
+ # The Unique Identifier of the target (target.uuid) this Buildable Reference points to.
+ #
+ # @note You can use this to `#find` the `Xcodeproj::Project::Object::AbstractTarget`
+ # instance in your Xcodeproj::Project object.
+ # e.g. `project.targets.find { |t| t.uuid == ref.target_uuid }`
+ #
+ def target_uuid
+ @xml_element.attributes['BlueprintIdentifier']
+ end
+
+ # @return [String]
+ # The string representing the container of that target.
+ # Typically in the form of 'container:xxxx.xcodeproj'
+ #
+ def target_referenced_container
+ @xml_element.attributes['ReferencedContainer']
+ end
+
+ # Set the BlueprintIdentifier (target.uuid), BlueprintName (target.name)
+ # and TerefencedContainer (URI pointing to target's projet) all at once
+ #
+ # @param [Xcodeproj::Project::Object::AbstractTarget] target
+ # The target this BuildableReference refers to.
+ #
+ # @param [Xcodeproj::Project] the root project to reference from
+ # (when nil the project of the target is used)
+ #
+ # @param [Bool] override_buildable_name
+ # If true, buildable_name will also be updated by computing a name from the target
+ #
+ def set_reference_target(target, override_buildable_name = false, root_project = nil)
+ # note, the order of assignment here is important, it determines the order of serialization in the xml
+ # this matches the order that Xcode generates
+ @xml_element.attributes['BlueprintIdentifier'] = target.uuid
+ self.buildable_name = construct_buildable_name(target) if override_buildable_name
+ @xml_element.attributes['BlueprintName'] = target.name
+ @xml_element.attributes['ReferencedContainer'] = construct_referenced_container_uri(target, root_project)
+ end
+
+ # @return [String]
+ # The name of the final product when building this Buildable Reference
+ #
+ def buildable_name
+ @xml_element.attributes['BuildableName']
+ end
+
+ # @param [String] value
+ # Set the name of the final product when building this Buildable Reference
+ #
+ def buildable_name=(value)
+ @xml_element.attributes['BuildableName'] = value
+ end
+
+ #-------------------------------------------------------------------------#
+
+ private
+
+ # @!group Private helpers
+
+ # @param [Xcodeproj::Project::Object::AbstractTarget] target
+ #
+ # @return [String] The buildable name of the scheme.
+ #
+ def construct_buildable_name(build_target)
+ case build_target.isa
+ when 'PBXNativeTarget'
+ File.basename(build_target.product_reference.path)
+ when 'PBXAggregateTarget'
+ build_target.name
+ else
+ raise ArgumentError, "Unsupported build target type #{build_target.isa}"
+ end
+ end
+
+ # @param [Xcodeproj::Project::Object::AbstractTarget] target
+ #
+ # @param [Xcodeproj::Project] the root project to reference from
+ # (when nil the project of the target is used)
+ #
+ # @return [String] A string in the format "container:[path to the project
+ # file relative to the project_dir_path, always ending with
+ # the actual project directory name]"
+ #
+ def construct_referenced_container_uri(target, root_project = nil)
+ target_project = target.project
+ root_project ||= target_project
+ root_project_dir_path = root_project.root_object.project_dir_path
+ path = if !root_project_dir_path.to_s.empty?
+ root_project.path + root_project_dir_path
+ else
+ root_project.project_dir
+ end
+ relative_path = target_project.path.relative_path_from(path).to_s
+ relative_path = target_project.path.basename if relative_path == '.'
+ "container:#{relative_path}"
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/command_line_arguments.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/command_line_arguments.rb
new file mode 100644
index 0000000..f5fd5d7
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/command_line_arguments.rb
@@ -0,0 +1,162 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+
+module Xcodeproj
+ class XCScheme
+ COMMAND_LINE_ARGS_NODE = 'CommandLineArguments'.freeze
+ COMMAND_LINE_ARG_NODE = 'CommandLineArgument'.freeze
+
+ # This class wraps the CommandLineArguments node of a .xcscheme XML file. This
+ # is just a container of CommandLineArgument objects. It can either appear on a
+ # LaunchAction or TestAction scheme group.
+ #
+ class CommandLineArguments < XMLElementWrapper
+ # @param [nil,REXML::Element,Array<CommandLineArgument>,Array<Hash{Symbol => String,Bool}>] node_or_arguments
+ # The 'CommandLineArguments' XML node, or list of command line arguments, that this object represents.
+ # - If nil, an empty 'CommandLineArguments' XML node will be created
+ # - If an REXML::Element, it must be named 'CommandLineArguments'
+ # - If an Array of objects or Hashes, they'll each be passed to {#assign_argument}
+ #
+ def initialize(node_or_arguments = nil)
+ create_xml_element_with_fallback(node_or_arguments, COMMAND_LINE_ARGS_NODE) do
+ @all_arguments = []
+ node_or_arguments.each { |var| assign_argument(var) } unless node_or_arguments.nil?
+ end
+ end
+
+ # @return [Array<CommandLineArgument>]
+ # The key value pairs currently set in @xml_element
+ #
+ def all_arguments
+ @all_arguments ||= @xml_element.get_elements(COMMAND_LINE_ARG_NODE).map { |argument| CommandLineArgument.new(argument) }
+ end
+
+ # Adds a given argument to the set of command line arguments, or replaces it if that key already exists
+ #
+ # @param [CommandLineArgument,Hash{Symbol => String,Bool}] argument
+ # The argument to add or update, backed by an CommandLineArgument node.
+ # - If an CommandLineArgument, the previous reference will still be valid
+ # - If a Hash, must conform to {CommandLineArgument#initialize} requirements
+ # @return [Array<CommandLineArgument>]
+ # The new set of command line arguments after addition
+ #
+ def assign_argument(argument)
+ command_line_arg = if argument.is_a?(CommandLineArgument)
+ argument
+ else
+ CommandLineArgument.new(argument)
+ end
+ all_arguments.each { |existing_var| remove_argument(existing_var) if existing_var.argument == command_line_arg.argument }
+ @xml_element.add_element(command_line_arg.xml_element)
+ @all_arguments << command_line_arg
+ end
+
+ # Removes a specified argument (by string or object) from the set of command line arguments
+ #
+ # @param [CommandLineArgument,String] argument
+ # The argument to remove
+ # @return [Array<CommandLineArgument>]
+ # The new set of command line arguments after removal
+ #
+ def remove_argument(argument)
+ command_line_arg = if argument.is_a?(CommandLineArgument)
+ argument
+ else
+ CommandLineArgument.new(argument)
+ end
+ raise "Unexpected parameter type: #{command_line_arg.class}" unless command_line_arg.is_a?(CommandLineArgument)
+ @xml_element.delete_element(command_line_arg.xml_element)
+ @all_arguments -= [command_line_arg]
+ end
+
+ # @param [String] key
+ # The key to lookup
+ # @return [CommandLineArgument] argument
+ # Returns the matching command line argument for a specified key
+ #
+ def [](argument)
+ all_arguments.find { |var| var.argument == argument }
+ end
+
+ # Assigns a value for a specified key
+ #
+ # @param [String] key
+ # The key to update in the command line arguments
+ # @param [String] value
+ # The value to lookup
+ # @return [CommandLineArgument] argument
+ # The newly updated command line argument
+ #
+ def []=(argument, enabled)
+ assign_argument(:argument => argument, :enabled => enabled)
+ self[argument]
+ end
+
+ # @return [Array<Hash{Symbol => String,Bool}>]
+ # The current command line arguments represented as an array
+ #
+ def to_a
+ all_arguments.map(&:to_h)
+ end
+ end
+
+ # This class wraps the CommandLineArgument node of a .xcscheme XML file.
+ # Environment arguments are accessible via the NSDictionary returned from
+ # [[NSProcessInfo processInfo] arguments] in your app code.
+ #
+ class CommandLineArgument < XMLElementWrapper
+ # @param [nil,REXML::Element,Hash{Symbol => String,Bool}] node_or_argument
+ # - If nil, it will create a default XML node to use
+ # - If a REXML::Element, should be a <CommandLineArgument> XML node to wrap
+ # - If a Hash, must contain keys :key and :value (Strings) and optionally :enabled (Boolean)
+ #
+ def initialize(node_or_argument)
+ create_xml_element_with_fallback(node_or_argument, COMMAND_LINE_ARG_NODE) do
+ raise "Must pass a Hash with 'argument' and 'enabled'!" unless node_or_argument.is_a?(Hash) &&
+ node_or_argument.key?(:argument) && node_or_argument.key?(:enabled)
+
+ @xml_element.attributes['argument'] = node_or_argument[:argument]
+ @xml_element.attributes['isEnabled'] = if node_or_argument.key?(:enabled)
+ bool_to_string(node_or_argument[:enabled])
+ else
+ bool_to_string(false)
+ end
+ end
+ end
+
+ # Returns the CommandLineArgument's key
+ # @return [String]
+ #
+ def argument
+ @xml_element.attributes['argument']
+ end
+
+ # Sets the CommandLineArgument's key
+ # @param [String] key
+ #
+ def argument=(argument)
+ @xml_element.attributes['argument'] = argument
+ end
+
+ # Returns the CommandLineArgument's enabled state
+ # @return [Bool]
+ #
+ def enabled
+ string_to_bool(@xml_element.attributes['isEnabled'])
+ end
+
+ # Sets the CommandLineArgument's enabled state
+ # @param [Bool] enabled
+ #
+ def enabled=(enabled)
+ @xml_element.attributes['isEnabled'] = bool_to_string(enabled)
+ end
+
+ # @return [Hash{:key => String, :value => String, :enabled => Bool}]
+ # The command line argument XML node with attributes converted to a representative Hash
+ #
+ def to_h
+ { :argument => argument, :enabled => enabled }
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/environment_variables.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/environment_variables.rb
new file mode 100644
index 0000000..7335df6
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/environment_variables.rb
@@ -0,0 +1,170 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+
+module Xcodeproj
+ class XCScheme
+ VARIABLES_NODE = 'EnvironmentVariables'
+ VARIABLE_NODE = 'EnvironmentVariable'
+
+ # This class wraps the EnvironmentVariables node of a .xcscheme XML file. This
+ # is just a container of EnvironmentVariable objects. It can either appear on a
+ # LaunchAction or TestAction scheme group.
+ #
+ class EnvironmentVariables < XMLElementWrapper
+ # @param [nil,REXML::Element,Array<EnvironmentVariable>,Array<Hash{Symbol => String,Bool}>] node_or_variables
+ # The 'EnvironmentVariables' XML node, or list of environment variables, that this object represents.
+ # - If nil, an empty 'EnvironmentVariables' XML node will be created
+ # - If an REXML::Element, it must be named 'EnvironmentVariables'
+ # - If an Array of objects or Hashes, they'll each be passed to {#assign_variable}
+ #
+ def initialize(node_or_variables = nil)
+ create_xml_element_with_fallback(node_or_variables, VARIABLES_NODE) do
+ @all_variables = []
+ node_or_variables.each { |var| assign_variable(var) } unless node_or_variables.nil?
+ end
+ end
+
+ # @return [Array<EnvironmentVariable>]
+ # The key value pairs currently set in @xml_element
+ #
+ def all_variables
+ @all_variables ||= @xml_element.get_elements(VARIABLE_NODE).map { |variable| EnvironmentVariable.new(variable) }
+ end
+
+ # Adds a given variable to the set of environment variables, or replaces it if that key already exists
+ #
+ # @param [EnvironmentVariable,Hash{Symbol => String,Bool}] variable
+ # The variable to add or update, backed by an EnvironmentVariable node.
+ # - If an EnvironmentVariable, the previous reference will still be valid
+ # - If a Hash, must conform to {EnvironmentVariable#initialize} requirements
+ # @return [Array<EnvironmentVariable>]
+ # The new set of environment variables after addition
+ #
+ def assign_variable(variable)
+ env_var = variable.is_a?(EnvironmentVariable) ? variable : EnvironmentVariable.new(variable)
+ all_variables.each { |existing_var| remove_variable(existing_var) if existing_var.key == env_var.key }
+ @xml_element.add_element(env_var.xml_element)
+ @all_variables << env_var
+ end
+
+ # Removes a specified variable (by string or object) from the set of environment variables
+ #
+ # @param [EnvironmentVariable,String] variable
+ # The variable to remove
+ # @return [Array<EnvironmentVariable>]
+ # The new set of environment variables after removal
+ #
+ def remove_variable(variable)
+ env_var = variable.is_a?(EnvironmentVariable) ? variable : all_variables.find { |var| var.key == variable }
+ raise "Unexpected parameter type: #{env_var.class}" unless env_var.is_a?(EnvironmentVariable)
+ @xml_element.delete_element(env_var.xml_element)
+ @all_variables -= [env_var]
+ end
+
+ # @param [String] key
+ # The key to lookup
+ # @return [EnvironmentVariable] variable
+ # Returns the matching environment variable for a specified key
+ #
+ def [](key)
+ all_variables.find { |var| var.key == key }
+ end
+
+ # Assigns a value for a specified key
+ #
+ # @param [String] key
+ # The key to update in the environment variables
+ # @param [String] value
+ # The value to lookup
+ # @return [EnvironmentVariable] variable
+ # The newly updated environment variable
+ #
+ def []=(key, value)
+ assign_variable(:key => key, :value => value)
+ self[key]
+ end
+
+ # @return [Array<Hash{Symbol => String,Bool}>]
+ # The current environment variables represented as an array
+ #
+ def to_a
+ all_variables.map(&:to_h)
+ end
+ end
+
+ # This class wraps the EnvironmentVariable node of a .xcscheme XML file.
+ # Environment variables are accessible via the NSDictionary returned from
+ # [[NSProcessInfo processInfo] environment] in your app code.
+ #
+ class EnvironmentVariable < XMLElementWrapper
+ # @param [nil,REXML::Element,Hash{Symbol => String,Bool}] node_or_variable
+ # - If nil, it will create a default XML node to use
+ # - If a REXML::Element, should be a <EnvironmentVariable> XML node to wrap
+ # - If a Hash, must contain keys :key and :value (Strings) and optionally :enabled (Boolean)
+ #
+ def initialize(node_or_variable)
+ create_xml_element_with_fallback(node_or_variable, VARIABLE_NODE) do
+ raise "Must pass a Hash with 'key' and 'value'!" unless node_or_variable.is_a?(Hash) &&
+ node_or_variable.key?(:key) && node_or_variable.key?(:value)
+
+ @xml_element.attributes['key'] = node_or_variable[:key]
+ @xml_element.attributes['value'] = node_or_variable[:value]
+
+ @xml_element.attributes['isEnabled'] = if node_or_variable.key?(:enabled)
+ bool_to_string(node_or_variable[:enabled])
+ else
+ bool_to_string(true)
+ end
+ end
+ end
+
+ # Returns the EnvironmentValue's key
+ # @return [String]
+ #
+ def key
+ @xml_element.attributes['key']
+ end
+
+ # Sets the EnvironmentValue's key
+ # @param [String] key
+ #
+ def key=(key)
+ @xml_element.attributes['key'] = key
+ end
+
+ # Returns the EnvironmentValue's value
+ # @return [String]
+ #
+ def value
+ @xml_element.attributes['value']
+ end
+
+ # Sets the EnvironmentValue's value
+ # @param [String] value
+ #
+ def value=(value)
+ @xml_element.attributes['value'] = value
+ end
+
+ # Returns the EnvironmentValue's enabled state
+ # @return [Bool]
+ #
+ def enabled
+ string_to_bool(@xml_element.attributes['isEnabled'])
+ end
+
+ # Sets the EnvironmentValue's enabled state
+ # @param [Bool] enabled
+ #
+ def enabled=(enabled)
+ @xml_element.attributes['isEnabled'] = bool_to_string(enabled)
+ end
+
+ # @return [Hash{:key => String, :value => String, :enabled => Bool}]
+ # The environment variable XML node with attributes converted to a representative Hash
+ #
+ def to_h
+ { :key => key, :value => value, :enabled => enabled }
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/execution_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/execution_action.rb
new file mode 100644
index 0000000..6a6e66c
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/execution_action.rb
@@ -0,0 +1,86 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps the ExecutionAction node of a .xcscheme XML file
+ #
+ class ExecutionAction < XMLElementWrapper
+ # @param [REXML::Element] node
+ # The 'ExecutionAction' XML node that this object will wrap.
+ # If nil, will create an empty one
+ #
+ # @param [Symbol] action_type
+ # One of `EXECUTION_ACTION_TYPE.keys`
+ #
+ def initialize(node = nil, action_type = nil)
+ create_xml_element_with_fallback(node, 'ExecutionAction') do
+ type = action_type || node.action_type
+ raise "[Xcodeproj] Invalid ActionType `#{type}`" unless Constants::EXECUTION_ACTION_TYPE.keys.include?(type)
+ @xml_element.attributes['ActionType'] = Constants::EXECUTION_ACTION_TYPE[type]
+ end
+ end
+
+ # @return [String]
+ # The ActionType of this ExecutionAction. One of two values:
+ #
+ # Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction,
+ # Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.SendEmailAction
+ #
+ def action_type
+ @xml_element.attributes['ActionType']
+ end
+
+ # @return [ShellScriptActionContent]
+ # If action_type is 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction'
+ # returns the contents of the shell script to run pre/post action.
+ #
+ # @return [SendEmailActionContent]
+ # If action_type is 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.SendEmailAction'
+ # returns the contents of the email to send pre/post action.
+ #
+ def action_content
+ case action_type
+ when Constants::EXECUTION_ACTION_TYPE[:shell_script]
+ ShellScriptActionContent.new(@xml_element.elements['ActionContent'])
+ when Constants::EXECUTION_ACTION_TYPE[:send_email]
+ SendEmailActionContent.new(@xml_element.elements['ActionContent'])
+ else
+ raise "[Xcodeproj] Invalid ActionType `#{action_type}`"
+ end
+ end
+
+ # @param [ShellScriptActionContent, SendEmailActionContent] value
+ # Set either the contents of the shell script to run pre/post action
+ # or the contents of the email to send pre/post action.
+ #
+ def action_content=(value)
+ raise "[Xcodeproj] Invalid ActionContent `#{value.class}` for " \
+ "ActionType `#{action_type}`" unless valid_action_content?(value)
+
+ @xml_element.delete_element('ActionContent')
+ @xml_element.add_element(value.xml_element)
+ end
+
+ #-------------------------------------------------------------------------#
+
+ private
+
+ # @!group Private helpers
+
+ # @return [Bool]
+ # True if value (ActionContent) is valid for current action_type
+ #
+ # @param [ShellScriptActionContent, SendEmailActionContent] value
+ # Checks if value matches the expected action_type if present.
+ #
+ def valid_action_content?(value)
+ case action_type
+ when Constants::EXECUTION_ACTION_TYPE[:shell_script]
+ value.is_a?(ShellScriptActionContent)
+ when Constants::EXECUTION_ACTION_TYPE[:send_email]
+ value.is_a?(SendEmailActionContent)
+ else
+ false
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/launch_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/launch_action.rb
new file mode 100644
index 0000000..27eecc0
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/launch_action.rb
@@ -0,0 +1,179 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+ class XCScheme
+ # This class wraps the LaunchAction node of a .xcscheme XML file
+ #
+ class LaunchAction < AbstractSchemeAction
+ # @param [REXML::Element] node
+ # The 'LaunchAction' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'LaunchAction') do
+ self.build_configuration = 'Debug'
+
+ # Add some attributes (that are not handled by this wrapper class yet but expected in the XML)
+ @xml_element.attributes['selectedDebuggerIdentifier'] = 'Xcode.DebuggerFoundation.Debugger.LLDB'
+ @xml_element.attributes['selectedLauncherIdentifier'] = 'Xcode.DebuggerFoundation.Launcher.LLDB'
+ @xml_element.attributes['launchStyle'] = '0'
+ @xml_element.attributes['useCustomWorkingDirectory'] = bool_to_string(false)
+ @xml_element.attributes['ignoresPersistentStateOnLaunch'] = bool_to_string(false)
+ @xml_element.attributes['debugDocumentVersioning'] = bool_to_string(true)
+ @xml_element.attributes['debugServiceExtension'] = 'internal'
+
+ # Setup default values for other (handled) attributes
+ self.allow_location_simulation = true
+ end
+ end
+
+ # @todo handle 'launchStyle' attribute
+ # @todo handle 'useCustomWorkingDirectory attribute
+ # @todo handle 'ignoresPersistentStateOnLaunch' attribute
+ # @todo handle 'debugDocumentVersioning' attribute
+ # @todo handle 'debugServiceExtension'
+
+ # @return [Bool]
+ # Whether or not to allow GPS location simulation when launching this target
+ #
+ def allow_location_simulation?
+ string_to_bool(@xml_element.attributes['allowLocationSimulation'])
+ end
+
+ # @param [Bool] flag
+ # Set whether or not to allow GPS location simulation when launching this target
+ #
+ def allow_location_simulation=(flag)
+ @xml_element.attributes['allowLocationSimulation'] = bool_to_string(flag)
+ end
+
+ # @return [LocationScenarioReference]
+ # The LocationScenarioReference to simulate a GPS location when executing the Launch Action
+ #
+ def location_scenario_reference?
+ LocationScenarioReference.new(@xml_element.elements['LocationScenarioReference'])
+ end
+
+ # @return [LocationScenarioReference]
+ # Set the LocationScenarioReference which simulates a GPS location when executing the Launch Action
+ #
+ def location_scenario_reference=(reference)
+ @xml_element.delete_element('LocationScenarioReference')
+ @xml_element.add_element(reference.xml_element) if reference
+ end
+
+ # @return [Bool]
+ # Whether this Build Action should disable detection of UI API misuse
+ # from background threads
+ #
+ def disable_main_thread_checker?
+ string_to_bool(@xml_element.attributes['disableMainThreadChecker'])
+ end
+
+ # @param [Bool] flag
+ # Set whether this Build Action should disable detection of UI API misuse
+ # from background threads
+ #
+ def disable_main_thread_checker=(flag)
+ @xml_element.attributes['disableMainThreadChecker'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether UI API misuse from background threads detection should pause execution.
+ # This flag is ignored when the thread checker disabled
+ # ([disable_main_thread_checker] flag).
+ #
+ def stop_on_every_main_thread_checker_issue?
+ string_to_bool(@xml_element.attributes['stopOnEveryMainThreadCheckerIssue'])
+ end
+
+ # @param [Bool] flag
+ # Set whether UI API misuse from background threads detection should pause execution.
+ # This flag is ignored when the thread checker disabled
+ # ([disable_main_thread_checker] flag).
+ #
+ def stop_on_every_main_thread_checker_issue=(flag)
+ @xml_element.attributes['stopOnEveryMainThreadCheckerIssue'] = bool_to_string(flag)
+ end
+
+ # @return [String]
+ # The launch automatically substyle
+ #
+ def launch_automatically_substyle
+ @xml_element.attributes['launchAutomaticallySubstyle']
+ end
+
+ # @param [String] flag
+ # Set the launch automatically substyle ('2' for extensions)
+ #
+ def launch_automatically_substyle=(value)
+ @xml_element.attributes['launchAutomaticallySubstyle'] = value.to_s
+ end
+
+ # @return [BuildableProductRunnable]
+ # The BuildReference to launch when executing the Launch Action
+ #
+ def buildable_product_runnable
+ BuildableProductRunnable.new(@xml_element.elements['BuildableProductRunnable'], 0)
+ end
+
+ # @param [BuildableProductRunnable] runnable
+ # Set the BuildableProductRunnable referencing the target to launch
+ #
+ def buildable_product_runnable=(runnable)
+ @xml_element.delete_element('BuildableProductRunnable')
+ @xml_element.add_element(runnable.xml_element) if runnable
+ end
+
+ # @return [EnvironmentVariables]
+ # Returns the EnvironmentVariables that will be defined at app launch
+ #
+ def environment_variables
+ EnvironmentVariables.new(@xml_element.elements[XCScheme::VARIABLES_NODE])
+ end
+
+ # @param [EnvironmentVariables,nil] env_vars
+ # Sets the EnvironmentVariables that will be defined at app launch
+ #
+ def environment_variables=(env_vars)
+ @xml_element.delete_element(XCScheme::VARIABLES_NODE)
+ @xml_element.add_element(env_vars.xml_element) if env_vars
+ env_vars
+ end
+
+ # @todo handle 'AdditionalOptions' tag
+
+ # @return [CommandLineArguments]
+ # Returns the CommandLineArguments that will be passed at app launch
+ #
+ def command_line_arguments
+ CommandLineArguments.new(@xml_element.elements[XCScheme::COMMAND_LINE_ARGS_NODE])
+ end
+
+ # @return [CommandLineArguments] arguments
+ # Sets the CommandLineArguments that will be passed at app launch
+ #
+ def command_line_arguments=(arguments)
+ @xml_element.delete_element(XCScheme::COMMAND_LINE_ARGS_NODE)
+ @xml_element.add_element(arguments.xml_element) if arguments
+ arguments
+ end
+
+ # @return [Array<MacroExpansion>]
+ # The list of MacroExpansion bound with this LaunchAction
+ #
+ def macro_expansions
+ @xml_element.get_elements('MacroExpansion').map do |node|
+ MacroExpansion.new(node)
+ end
+ end
+
+ # @param [MacroExpansion] macro_expansion
+ # Add a MacroExpansion to this LaunchAction
+ #
+ def add_macro_expansion(macro_expansion)
+ @xml_element.add_element(macro_expansion.xml_element)
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/location_scenario_reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/location_scenario_reference.rb
new file mode 100644
index 0000000..e58f241
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/location_scenario_reference.rb
@@ -0,0 +1,49 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps the LocationScenarioReference node of a .xcscheme XML file
+ #
+ # A LocationScenarioReference is a reference to a simulated GPS location associated
+ # with a scheme's launch action
+ #
+ class LocationScenarioReference < XMLElementWrapper
+ # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+ # Either the Xcode target to reference,
+ # or an existing XML 'LocationScenarioReference' node element to reference
+ #
+ def initialize(target_or_node)
+ create_xml_element_with_fallback(target_or_node, 'LocationScenarioReference') do
+ self.identifier = ''
+ self.reference_type = '0'
+ end
+ end
+
+ # @return [String]
+ # The identifier of a built-in location scenario reference, or a path to a GPX file
+ #
+ def identifier
+ @xml_element.attributes['identifier']
+ end
+
+ # @param [String] value
+ # Set the identifier for the location scenario reference
+ #
+ def identifier=(value)
+ @xml_element.attributes['identifier'] = value
+ end
+
+ # @return [String]
+ # The reference type is 0 when using a custom GPX file, or 1 when using a built-in location reference
+ #
+ def reference_type
+ @xml_element.attributes['referenceType']
+ end
+
+ # @param [String] value
+ # Set the reference type for the location scenario reference
+ #
+ def reference_type=(value)
+ @xml_element.attributes['referenceType'] = value
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/macro_expansion.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/macro_expansion.rb
new file mode 100644
index 0000000..66b099a
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/macro_expansion.rb
@@ -0,0 +1,34 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps the MacroExpansion node of a .xcscheme XML file
+ #
+ class MacroExpansion < XMLElementWrapper
+ # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+ # Either the Xcode target to reference,
+ # or an existing XML 'MacroExpansion' node element
+ # or nil to create an empty MacroExpansion object
+ #
+ def initialize(target_or_node = nil)
+ create_xml_element_with_fallback(target_or_node, 'MacroExpansion') do
+ self.buildable_reference = BuildableReference.new(target_or_node) if target_or_node
+ end
+ end
+
+ # @return [BuildableReference]
+ # The BuildableReference this MacroExpansion refers to
+ #
+ def buildable_reference
+ @buildable_reference ||= BuildableReference.new @xml_element.elements['BuildableReference']
+ end
+
+ # @param [BuildableReference] ref
+ # Set the BuildableReference this MacroExpansion refers to
+ #
+ def buildable_reference=(ref)
+ @xml_element.delete_element('BuildableReference')
+ @xml_element.add_element(ref.xml_element)
+ @buildable_reference = ref
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/profile_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/profile_action.rb
new file mode 100644
index 0000000..041a810
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/profile_action.rb
@@ -0,0 +1,57 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+ class XCScheme
+ # This class wraps the ProfileAction node of a .xcscheme XML file
+ #
+ class ProfileAction < AbstractSchemeAction
+ # @param [REXML::Element] node
+ # The 'ProfileAction' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'ProfileAction') do
+ # Setup default values for other (handled) attributes
+ self.build_configuration = 'Release'
+ self.should_use_launch_scheme_args_env = true
+
+ # Add some attributes (that are not handled by this wrapper class yet but expected in the XML)
+ @xml_element.attributes['savedToolIdentifier'] = ''
+ @xml_element.attributes['useCustomWorkingDirectory'] = bool_to_string(false)
+ @xml_element.attributes['debugDocumentVersioning'] = bool_to_string(true)
+ end
+ end
+
+ # @return [Bool]
+ # Whether this Profile Action should use the same arguments and environment variables
+ # as the Launch Action.
+ #
+ def should_use_launch_scheme_args_env?
+ string_to_bool(@xml_element.attributes['shouldUseLaunchSchemeArgsEnv'])
+ end
+
+ # @param [Bool] flag
+ # Set Whether this Profile Action should use the same arguments and environment variables
+ # as the Launch Action.
+ #
+ def should_use_launch_scheme_args_env=(flag)
+ @xml_element.attributes['shouldUseLaunchSchemeArgsEnv'] = bool_to_string(flag)
+ end
+
+ # @return [BuildableProductRunnable]
+ # The BuildableProductRunnable to launch when launching the Profile action
+ #
+ def buildable_product_runnable
+ BuildableProductRunnable.new @xml_element.elements['BuildableProductRunnable'], 0
+ end
+
+ # @param [BuildableProductRunnable] runnable
+ # Set the BuildableProductRunnable referencing the target to launch when profiling
+ #
+ def buildable_product_runnable=(runnable)
+ @xml_element.delete_element('BuildableProductRunnable')
+ @xml_element.add_element(runnable.xml_element) if runnable
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/remote_runnable.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/remote_runnable.rb
new file mode 100644
index 0000000..c51c547
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/remote_runnable.rb
@@ -0,0 +1,92 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps the RemoteRunnable node of a .xcscheme XML file
+ #
+ # A RemoteRunnable is a product that is both buildable
+ # (it contains a BuildableReference) and
+ # runnable remotely (it can be launched and debugged on a remote device, i.e. an Apple Watch)
+ #
+ class RemoteRunnable < XMLElementWrapper
+ # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+ # Either the Xcode target to reference,
+ # or an existing XML 'RemoteRunnable' node element to reference
+ # or nil to create an new, empty RemoteRunnable
+ #
+ # @param [#to_s] runnable_debugging_mode
+ # The debugging mode (usually '2')
+ #
+ # @param [#to_s] bundle_identifier
+ # The bundle identifier (usually 'com.apple.Carousel')
+ #
+ # @param [#to_s] remote_path
+ # The remote path (not required, unknown usage)
+ #
+ def initialize(target_or_node = nil, runnable_debugging_mode = nil, bundle_identifier = nil, remote_path = nil)
+ create_xml_element_with_fallback(target_or_node, 'RemoteRunnable') do
+ self.buildable_reference = BuildableReference.new(target_or_node) if target_or_node
+ @xml_element.attributes['runnableDebuggingMode'] = runnable_debugging_mode.to_s if runnable_debugging_mode
+ @xml_element.attributes['BundleIdentifier'] = bundle_identifier.to_s if bundle_identifier
+ @xml_element.attributes['RemotePath'] = remote_path.to_s if remote_path
+ end
+ end
+
+ # @return [String]
+ # The runnable debugging mode (usually '2')
+ #
+ def runnable_debugging_mode
+ @xml_element.attributes['runnableDebuggingMode']
+ end
+
+ # @param [String] value
+ # Set the runnable debugging mode
+ #
+ def runnable_debugging_mode=(value)
+ @xml_element.attributes['runnableDebuggingMode'] = value.to_s
+ end
+
+ # @return [String]
+ # The runnable bundle identifier (usually 'com.apple.Carousel')
+ #
+ def bundle_identifier
+ @xml_element.attributes['BundleIdentifier']
+ end
+
+ # @param [String] value
+ # Set the runnable bundle identifier
+ #
+ def bundle_identifier=(value)
+ @xml_element.attributes['BundleIdentifier'] = value.to_s
+ end
+
+ # @return [String]
+ # The runnable remote path (not required, unknown usage)
+ #
+ def remote_path
+ @xml_element.attributes['RemotePath']
+ end
+
+ # @param [String] value
+ # Set the runnable remote path
+ #
+ def remote_path=(value)
+ @xml_element.attributes['RemotePath'] = value.to_s
+ end
+
+ # @return [BuildableReference]
+ # The buildable reference this remote runnable is gonna build and run
+ #
+ def buildable_reference
+ @buildable_reference ||= BuildableReference.new @xml_element.elements['BuildableReference']
+ end
+
+ # @param [BuildableReference] ref
+ # Set the buildable reference this remote runnable is gonna build and run
+ #
+ def buildable_reference=(ref)
+ @xml_element.delete_element('BuildableReference')
+ @xml_element.add_element(ref.xml_element)
+ @buildable_reference = ref
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/send_email_action_content.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/send_email_action_content.rb
new file mode 100644
index 0000000..24ee2fe
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/send_email_action_content.rb
@@ -0,0 +1,84 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps a 'ActionContent' node of type
+ # 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.SendEmailAction' of a .xcscheme XML file
+ #
+ class SendEmailActionContent < XMLElementWrapper
+ # @param [REXML::Element] node
+ # The 'ActionContent' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'ActionContent') do
+ self.title = 'Send Email'
+ # For some reason this is not visible in Xcode's UI and it's always set to 'NO'
+ # couldn't find much documentation on it so it might be safer to keep it read only
+ @xml_element.attributes['attachLogToEmail'] = 'NO'
+ end
+ end
+
+ # @return [Bool]
+ # Whether or not this action should attach log to email
+ #
+ def attach_log_to_email?
+ string_to_bool(@xml_element.attributes['attachLogToEmail'])
+ end
+
+ # @return [String]
+ # The title of this ActionContent
+ #
+ def title
+ @xml_element.attributes['title']
+ end
+
+ # @param [String] value
+ # Set the title of this ActionContent
+ #
+ def title=(value)
+ @xml_element.attributes['title'] = value
+ end
+
+ # @return [String]
+ # The email recipient of this ActionContent
+ #
+ def email_recipient
+ @xml_element.attributes['emailRecipient']
+ end
+
+ # @param [String] value
+ # Set the email recipient of this ActionContent
+ #
+ def email_recipient=(value)
+ @xml_element.attributes['emailRecipient'] = value
+ end
+
+ # @return [String]
+ # The email subject of this ActionContent
+ #
+ def email_subject
+ @xml_element.attributes['emailSubject']
+ end
+
+ # @param [String] value
+ # Set the email subject of this ActionContent
+ #
+ def email_subject=(value)
+ @xml_element.attributes['emailSubject'] = value
+ end
+
+ # @return [String]
+ # The email body of this ActionContent
+ #
+ def email_body
+ @xml_element.attributes['emailBody']
+ end
+
+ # @param [String] value
+ # Set the email body of this ActionContent
+ #
+ def email_body=(value)
+ @xml_element.attributes['emailBody'] = value
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/shell_script_action_content.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/shell_script_action_content.rb
new file mode 100644
index 0000000..75b3bb6
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/shell_script_action_content.rb
@@ -0,0 +1,77 @@
+module Xcodeproj
+ class XCScheme
+ # This class wraps a 'ActionContent' node of type
+ # 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction' of a .xcscheme XML file
+ #
+ class ShellScriptActionContent < XMLElementWrapper
+ # @param [REXML::Element] node
+ # The 'ActionContent' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'ActionContent') do
+ self.title = 'Run Script'
+ end
+ end
+
+ # @return [String]
+ # The title of this ActionContent
+ #
+ def title
+ @xml_element.attributes['title']
+ end
+
+ # @param [String] value
+ # Set the title of this ActionContent
+ #
+ def title=(value)
+ @xml_element.attributes['title'] = value
+ end
+
+ # @return [String]
+ # The contents of the shell script represented by this ActionContent
+ #
+ def script_text
+ @xml_element.attributes['scriptText']
+ end
+
+ # @param [String] value
+ # Set the contents of the shell script represented by this ActionContent
+ #
+ def script_text=(value)
+ @xml_element.attributes['scriptText'] = value
+ end
+
+ # @return [String]
+ # The preferred shell to invoke with this ActionContent
+ #
+ def shell_to_invoke
+ @xml_element.attributes['shellToInvoke']
+ end
+
+ # @param [String] value
+ # Set the preferred shell to invoke with this ActionContent
+ #
+ def shell_to_invoke=(value)
+ @xml_element.attributes['shellToInvoke'] = value
+ end
+
+ # @return [BuildableReference]
+ # The BuildableReference (Xcode target) associated with this ActionContent
+ #
+ def buildable_reference
+ BuildableReference.new(@xml_element.elements['EnvironmentBuildable'].elements['BuildableReference'])
+ end
+
+ # @param [BuildableReference] ref
+ # Set the BuildableReference (Xcode target) associated with this ActionContent
+ #
+ def buildable_reference=(ref)
+ @xml_element.delete_element('EnvironmentBuildable')
+
+ env_buildable = @xml_element.add_element('EnvironmentBuildable')
+ env_buildable.add_element(ref.xml_element)
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/test_action.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/test_action.rb
new file mode 100644
index 0000000..5043d01
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/test_action.rb
@@ -0,0 +1,394 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+ class XCScheme
+ # This class wraps the TestAction node of a .xcscheme XML file
+ #
+ class TestAction < AbstractSchemeAction
+ # @param [REXML::Element] node
+ # The 'TestAction' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'TestAction') do
+ self.build_configuration = 'Debug'
+ @xml_element.attributes['selectedDebuggerIdentifier'] = 'Xcode.DebuggerFoundation.Debugger.LLDB'
+ @xml_element.attributes['selectedLauncherIdentifier'] = 'Xcode.DebuggerFoundation.Launcher.LLDB'
+ self.should_use_launch_scheme_args_env = true
+ @xml_element.add_element('Testables')
+ end
+ end
+
+ # @return [Bool]
+ # Whether this Test Action should use the same arguments and environment variables
+ # as the Launch Action.
+ #
+ def should_use_launch_scheme_args_env?
+ string_to_bool(@xml_element.attributes['shouldUseLaunchSchemeArgsEnv'])
+ end
+
+ # @param [Bool] flag
+ # Set whether this Test Action should use the same arguments and environment variables
+ # as the Launch Action.
+ #
+ def should_use_launch_scheme_args_env=(flag)
+ @xml_element.attributes['shouldUseLaunchSchemeArgsEnv'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether this Test Action should disable detection of UI API misuse
+ # from background threads
+ #
+ def disable_main_thread_checker?
+ string_to_bool(@xml_element.attributes['disableMainThreadChecker'])
+ end
+
+ # @param [Bool] flag
+ # Set whether this Test Action should disable detection of UI API misuse
+ # from background threads
+ #
+ def disable_main_thread_checker=(flag)
+ @xml_element.attributes['disableMainThreadChecker'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether Clang Code Coverage is enabled ('Gather coverage data' turned ON)
+ #
+ def code_coverage_enabled?
+ string_to_bool(@xml_element.attributes['codeCoverageEnabled'])
+ end
+
+ # @param [Bool] flag
+ # Set whether Clang Code Coverage is enabled ('Gather coverage data' turned ON)
+ #
+ def code_coverage_enabled=(flag)
+ @xml_element.attributes['codeCoverageEnabled'] = bool_to_string(flag)
+ end
+
+ # @return [Array<TestableReference>]
+ # The list of TestableReference (test bundles) associated with this Test Action
+ #
+ def testables
+ return [] unless @xml_element.elements['Testables']
+
+ @xml_element.elements['Testables'].get_elements('TestableReference').map do |node|
+ TestableReference.new(node)
+ end
+ end
+
+ # @param [Array<TestableReference>] testables
+ # Sets the list of TestableReference (test bundles) associated with this Test Action
+ #
+ def testables=(testables)
+ @xml_element.delete_element('Testables')
+ testables_element = @xml_element.add_element('Testables')
+ testables.each do |testable|
+ testables_element.add_element(testable.xml_element)
+ end
+ testables
+ end
+
+ # @param [TestableReference] testable
+ # Add a TestableReference (test bundle) to this Test Action
+ #
+ def add_testable(testable)
+ testables = @xml_element.elements['Testables'] || @xml_element.add_element('Testables')
+ testables.add_element(testable.xml_element)
+ end
+
+ # @return [Array<MacroExpansion>]
+ # The list of MacroExpansion bound with this TestAction
+ #
+ def macro_expansions
+ @xml_element.get_elements('MacroExpansion').map do |node|
+ MacroExpansion.new(node)
+ end
+ end
+
+ # @param [MacroExpansion] macro_expansion
+ # Add a MacroExpansion to this TestAction
+ #
+ def add_macro_expansion(macro_expansion)
+ if testables = @xml_element.elements['Testables']
+ @xml_element.insert_before(testables, macro_expansion.xml_element)
+ else
+ @xml_element.add_element(macro_expansion.xml_element)
+ end
+ end
+
+ # @return [EnvironmentVariables]
+ # Returns the EnvironmentVariables that will be defined at test launch
+ #
+ def environment_variables
+ EnvironmentVariables.new(@xml_element.elements[XCScheme::VARIABLES_NODE])
+ end
+
+ # @param [EnvironmentVariables,nil] env_vars
+ # Sets the EnvironmentVariables that will be defined at test launch
+ # @return [EnvironmentVariables]
+ #
+ def environment_variables=(env_vars)
+ @xml_element.delete_element(XCScheme::VARIABLES_NODE)
+ @xml_element.add_element(env_vars.xml_element) if env_vars
+ env_vars
+ end
+
+ # @todo handle 'AdditionalOptions' tag
+
+ # @return [CommandLineArguments]
+ # Returns the CommandLineArguments that will be passed at app launch
+ #
+ def command_line_arguments
+ CommandLineArguments.new(@xml_element.elements[XCScheme::COMMAND_LINE_ARGS_NODE])
+ end
+
+ # @return [CommandLineArguments] arguments
+ # Sets the CommandLineArguments that will be passed at app launch
+ #
+ def command_line_arguments=(arguments)
+ @xml_element.delete_element(XCScheme::COMMAND_LINE_ARGS_NODE)
+ @xml_element.add_element(arguments.xml_element) if arguments
+ arguments
+ end
+
+ # @return [Array<BuildableReference>]
+ # The list of BuildableReference (code coverage targets) associated with this Test Action
+ #
+ def code_coverage_targets
+ return [] unless @xml_element.elements['CodeCoverageTargets']
+
+ @xml_element.elements['CodeCoverageTargets'].get_elements('BuildableReference').map do |node|
+ BuildableReference.new(node)
+ end
+ end
+
+ # @param [Array<BuildableReference>] buildable_references
+ # Sets the list of BuildableReference (code coverage targets) associated with this Test Action
+ #
+ def code_coverage_targets=(buildable_references)
+ @xml_element.attributes['onlyGenerateCoverageForSpecifiedTargets'] = bool_to_string(true)
+
+ @xml_element.delete_element('CodeCoverageTargets')
+ coverage_targets_element = @xml_element.add_element('CodeCoverageTargets')
+ buildable_references.each do |reference|
+ coverage_targets_element.add_element(reference.xml_element)
+ end
+
+ code_coverage_targets
+ end
+
+ # @param [BuildableReference] buildable_reference
+ # Add a BuildableReference (code coverage target) to this Test Action
+ #
+ def add_code_coverage_target(buildable_reference)
+ @xml_element.attributes['onlyGenerateCoverageForSpecifiedTargets'] = bool_to_string(true)
+
+ coverage_targets_element = @xml_element.elements['CodeCoverageTargets'] || @xml_element.add_element('CodeCoverageTargets')
+ coverage_targets_element.add_element(buildable_reference.xml_element)
+
+ code_coverage_targets
+ end
+
+ #-------------------------------------------------------------------------#
+
+ class TestableReference < XMLElementWrapper
+ # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+ # Either the Xcode target to reference,
+ # or an existing XML 'TestableReference' node element to reference,
+ # or nil to create an new, empty TestableReference
+ #
+ # @param [Xcodeproj::Project] the root project to reference from
+ # (when nil the project of the target is used)
+ #
+ def initialize(target_or_node = nil, root_project = nil)
+ create_xml_element_with_fallback(target_or_node, 'TestableReference') do
+ self.skipped = false
+ add_buildable_reference BuildableReference.new(target_or_node, root_project) unless target_or_node.nil?
+ end
+ end
+
+ # @return [Bool]
+ # Whether or not this TestableReference (test bundle) should be skipped or not
+ #
+ def skipped?
+ string_to_bool(@xml_element.attributes['skipped'])
+ end
+
+ # @param [Bool] flag
+ # Set whether or not this TestableReference (test bundle) should be skipped or not
+ #
+ def skipped=(flag)
+ @xml_element.attributes['skipped'] = bool_to_string(flag)
+ end
+
+ # @return [Bool]
+ # Whether or not this TestableReference (test bundle) should be run in parallel or not
+ #
+ def parallelizable?
+ string_to_bool(@xml_element.attributes['parallelizable'])
+ end
+
+ # @param [Bool] flag
+ # Set whether or not this TestableReference (test bundle) should be run in parallel or not
+ #
+ def parallelizable=(flag)
+ @xml_element.attributes['parallelizable'] = bool_to_string(flag)
+ end
+
+ # @return [String]
+ # The execution order for this TestableReference (test bundle)
+ #
+ def test_execution_ordering
+ @xml_element.attributes['testExecutionOrdering']
+ end
+
+ # @param [String] order
+ # Set the execution order for this TestableReference (test bundle)
+ #
+ def test_execution_ordering=(order)
+ @xml_element.attributes['testExecutionOrdering'] = order
+ end
+
+ # @return [Bool]
+ # Whether or not this TestableReference (test bundle) should be run in randomized order.
+ #
+ def randomized?
+ test_execution_ordering == 'random'
+ end
+
+ # @return [Array<BuildableReference>]
+ # The list of BuildableReferences this action will build.
+ # (The list usually contains only one element)
+ #
+ def buildable_references
+ @xml_element.get_elements('BuildableReference').map do |node|
+ BuildableReference.new(node)
+ end
+ end
+
+ # @param [BuildableReference] ref
+ # The BuildableReference to add to the list of targets this action will build
+ #
+ def add_buildable_reference(ref)
+ @xml_element.add_element(ref.xml_element)
+ end
+
+ # @param [BuildableReference] ref
+ # The BuildableReference to remove from the list of targets this entry will build
+ #
+ def remove_buildable_reference(ref)
+ @xml_element.delete_element(ref.xml_element)
+ end
+
+ # @return [Array<Test>]
+ # The list of SkippedTest this action will skip.
+ #
+ def skipped_tests
+ return [] if @xml_element.elements['SkippedTests'].nil?
+ @xml_element.elements['SkippedTests'].get_elements('Test').map do |node|
+ Test.new(node)
+ end
+ end
+
+ # @param [Array<Test>] tests
+ # Set the list of SkippedTest this action will skip.
+ #
+ def skipped_tests=(tests)
+ @xml_element.delete_element('SkippedTests')
+ if tests.nil?
+ return
+ end
+ entries = @xml_element.add_element('SkippedTests')
+ tests.each do |skipped|
+ entries.add_element(skipped.xml_element)
+ end
+ end
+
+ # @param [Test] skipped_test
+ # The SkippedTest to add to the list of tests this action will skip
+ #
+ def add_skipped_test(skipped_test)
+ entries = @xml_element.elements['SkippedTests'] || @xml_element.add_element('SkippedTests')
+ entries.add_element(skipped_test.xml_element)
+ end
+
+ # @return [Bool]
+ # Whether or not this TestableReference (test bundle) should use a whitelist or not
+ #
+ def use_test_selection_whitelist?
+ string_to_bool(@xml_element.attributes['useTestSelectionWhitelist'])
+ end
+
+ # @param [Bool] flag
+ # Set whether or not this TestableReference (test bundle) should use a whitelist or not
+ #
+ def use_test_selection_whitelist=(flag)
+ @xml_element.attributes['useTestSelectionWhitelist'] = bool_to_string(flag)
+ end
+
+ # @return [Array<Test>]
+ # The list of SelectedTest this action will run.
+ #
+ def selected_tests
+ return [] if @xml_element.elements['SelectedTests'].nil?
+ @xml_element.elements['SelectedTests'].get_elements('Test').map do |node|
+ Test.new(node)
+ end
+ end
+
+ # @param [Array<Test>] tests
+ # Set the list of SelectedTest this action will run.
+ #
+ def selected_tests=(tests)
+ @xml_element.delete_element('SelectedTests')
+ return if tests.nil?
+ entries = @xml_element.add_element('SelectedTests')
+ tests.each do |selected|
+ entries.add_element(selected.xml_element)
+ end
+ end
+
+ # @param [Test] selected_test
+ # The SelectedTest to add to the list of tests this action will run.
+ #
+ def add_selected_test(selected_test)
+ entries = @xml_element.elements['SelectedTests'] || @xml_element.add_element('SelectedTests')
+ entries.add_element(selected_test.xml_element)
+ end
+
+ class Test < XMLElementWrapper
+ # @param [REXML::Element] node
+ # The 'Test' XML node that this object will wrap.
+ # If nil, will create a default XML node to use.
+ #
+ def initialize(node = nil)
+ create_xml_element_with_fallback(node, 'Test') do
+ self.identifier = node.attributes['Identifier'] unless node.nil?
+ end
+ end
+
+ # @return [String]
+ # Skipped test class name
+ #
+ def identifier
+ @xml_element.attributes['Identifier']
+ end
+
+ # @param [String] value
+ # Set the name of the skipped test class name
+ #
+ def identifier=(value)
+ @xml_element.attributes['Identifier'] = value
+ end
+ end
+
+ # Aliased to`Test` for compatibility
+ # @todo Remove in Xcodeproj 2
+ #
+ SkippedTest = Test
+
+ # @todo handle 'AdditionalOptions' tag
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/xml_element_wrapper.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/xml_element_wrapper.rb
new file mode 100644
index 0000000..ceb7420
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/scheme/xml_element_wrapper.rb
@@ -0,0 +1,82 @@
+module Xcodeproj
+ class XCScheme
+ # Abstract base class used for other XCScheme classes wrapping an XML element
+ #
+ class XMLElementWrapper
+ # @return [REXML::Element]
+ # The XML node wrapped and manipulated by this XMLElementWrapper object
+ #
+ attr_reader :xml_element
+
+ # @return [String]
+ # The XML representation of the node this XMLElementWrapper wraps,
+ # formatted in the same way that Xcode would.
+ def to_s
+ formatter = XMLFormatter.new(2)
+ formatter.compact = false
+ out = ''
+ formatter.write(@xml_element, out)
+ out.gsub!("<?xml version='1.0' encoding='UTF-8'?>", '')
+ out << "\n"
+ out
+ end
+
+ private
+
+ # This is a method intended to be used to facilitate the implementation of the initializers.
+ #
+ # - Create the @xml_element attribute based on the node passed as parameter, only if
+ # that parameter is of type REXML::Element and its name matches the tag_name given.
+ # - Otherwise, create a brand new REXML::Element with the proper tag name and
+ # execute the block given as a fallback to let the caller the chance to configure it
+ #
+ # @param [REXML::Element, *] node
+ # The node this XMLElementWrapper is expected to wrap
+ # or any other object (typically an AbstractTarget instance, or nil) the initializer might expect
+ #
+ # @param [String] tag_name
+ # The expected name for the node, which will also be the name used to create the new node
+ # if that `node` parameter is not a REXML::Element itself.
+ #
+ # @yield a parameter-less block if the `node` parameter is not actually a REXML::Element
+ #
+ # @raise Informative
+ # If the `node` parameter is a REXML::Element instance but the node's name
+ # doesn't match the one provided by the `tag_name` parameter.
+ #
+ def create_xml_element_with_fallback(node, tag_name)
+ if node && node.is_a?(REXML::Element)
+ raise Informative, 'Wrong XML tag name' unless node.name == tag_name
+ @xml_element = node
+ else
+ @xml_element = REXML::Element.new(tag_name)
+ yield if block_given?
+ end
+ end
+
+ # @param [Bool]
+ # The boolean we want to represent as a string
+ #
+ # @return [String]
+ # The string representaiton of that boolean used in the XML ('YES' or 'NO')
+ #
+ def bool_to_string(flag)
+ flag ? 'YES' : 'NO'
+ end
+
+ # @param [String]
+ # The string representaiton of a boolean used in the XML ('YES' or 'NO')
+ #
+ # @return [Bool]
+ # The boolean interpretation of that string
+ #
+ # @raise Informative
+ # If the string is not representing a boolean (i.e. is neither 'YES' nor 'NO')
+ #
+ def string_to_bool(str)
+ raise Informative, 'Invalid tag value. Expected YES or NO.' unless %w(YES NO).include?(str)
+ str == 'YES'
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/user_interface.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/user_interface.rb
new file mode 100644
index 0000000..9737c52
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/user_interface.rb
@@ -0,0 +1,22 @@
+module Xcodeproj
+ # Manages the UI output so clients can customize it.
+ #
+ module UserInterface
+ # Prints a message to standard output.
+ #
+ # @return [void]
+ #
+ def self.puts(message)
+ STDOUT.puts message
+ end
+
+ # Prints a message to standard error.
+ #
+ # @return [void]
+ #
+ def self.warn(message)
+ STDERR.puts message
+ end
+ end
+ UI = UserInterface
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace.rb
new file mode 100644
index 0000000..40afbd0
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace.rb
@@ -0,0 +1,277 @@
+require 'fileutils'
+require 'rexml/document'
+require 'xcodeproj/workspace/file_reference'
+require 'xcodeproj/workspace/group_reference'
+
+module Xcodeproj
+ # Provides support for generating, reading and serializing Xcode Workspace
+ # documents.
+ #
+ class Workspace
+ # @return [REXML::Document] the parsed XML model for the workspace contents
+ attr_reader :document
+
+ # @return [Hash<String => String>] a mapping from scheme name to project full path
+ # containing the scheme
+ attr_reader :schemes
+
+ # @return [Array<FileReference>] the paths of the projects contained in the
+ # workspace.
+ #
+ def file_references
+ return [] unless @document
+ @document.get_elements('/Workspace//FileRef').map do |node|
+ FileReference.from_node(node)
+ end
+ end
+
+ # @return [Array<GroupReference>] the groups contained in the workspace
+ #
+ def group_references
+ return [] unless @document
+ @document.get_elements('/Workspace//Group').map do |node|
+ GroupReference.from_node(node)
+ end
+ end
+
+ # @param [REXML::Document] document @see document
+ # @param [Array<FileReference>] file_references additional projects to add
+ #
+ # @note The document parameter is passed to the << operator if it is not a
+ # valid REXML::Document. It is optional, but may also be passed as nil
+ #
+ def initialize(document, *file_references)
+ @schemes = {}
+ if document.nil?
+ @document = REXML::Document.new(root_xml(''))
+ elsif document.is_a?(REXML::Document)
+ @document = document
+ else
+ @document = REXML::Document.new(root_xml(''))
+ self << document
+ end
+ file_references.each { |ref| self << ref }
+ end
+
+ #-------------------------------------------------------------------------#
+
+ # Returns a workspace generated by reading the contents of the given path.
+ #
+ # @param [String] path
+ # the path of the `xcworkspace` file.
+ #
+ # @return [Workspace] the generated workspace.
+ #
+ def self.new_from_xcworkspace(path)
+ from_s(File.read(File.join(path, 'contents.xcworkspacedata')),
+ File.expand_path(path))
+ rescue Errno::ENOENT
+ new(nil)
+ end
+
+ #-------------------------------------------------------------------------#
+
+ # Returns a workspace generated by reading the contents of the given
+ # XML representation.
+ #
+ # @param [String] xml
+ # the XML representation of the workspace.
+ #
+ # @return [Workspace] the generated workspace.
+ #
+ def self.from_s(xml, workspace_path = '')
+ document = REXML::Document.new(xml)
+ instance = new(document)
+ instance.load_schemes(workspace_path)
+ instance
+ end
+
+ # Adds a new path to the list of the of projects contained in the
+ # workspace.
+ # @param [String, Xcodeproj::Workspace::FileReference] path_or_reference
+ # A string or Xcode::Workspace::FileReference containing a path to an Xcode project
+ #
+ # @raise [ArgumentError] Raised if the input is neither a String nor a FileReference
+ #
+ # @return [void]
+ #
+ def <<(path_or_reference)
+ return unless @document && @document.respond_to?(:root)
+
+ case path_or_reference
+ when String
+ project_file_reference = Xcodeproj::Workspace::FileReference.new(path_or_reference)
+ when Xcodeproj::Workspace::FileReference
+ project_file_reference = path_or_reference
+ projpath = nil
+ else
+ raise ArgumentError, "Input to the << operator must be a file path or FileReference, got #{path_or_reference.inspect}"
+ end
+ unless file_references.any? { |ref| project_file_reference.eql? ref }
+ @document.root.add_element(project_file_reference.to_node)
+ end
+ load_schemes_from_project File.expand_path(projpath || project_file_reference.path)
+ end
+
+ #-------------------------------------------------------------------------#
+
+ # Adds a new group container to the workspace
+ # workspace.
+ #
+ # @param [String] name The name of the group
+ #
+ # @yield [Xcodeproj::Workspace::GroupReference, REXML::Element]
+ # Yields the GroupReference and underlying XML element for mutation
+ #
+ # @return [Xcodeproj::Workspace::GroupReference] The added group reference
+ #
+ def add_group(name)
+ return nil unless @document
+ group = Xcodeproj::Workspace::GroupReference.new(name)
+ elem = @document.root.add_element(group.to_node)
+ yield group, elem if block_given?
+ group
+ end
+
+ # Checks if the workspace contains the project with the given file
+ # reference.
+ #
+ # @param [FileReference] file_reference
+ # The file_reference to the project.
+ #
+ # @return [Boolean] whether the project is contained in the workspace.
+ #
+ def include?(file_reference)
+ file_references.include?(file_reference)
+ end
+
+ # @return [String] the XML representation of the workspace.
+ #
+ def to_s
+ contents = ''
+ stack = []
+ @document.root.each_recursive do |elem|
+ until stack.empty?
+ last = stack.last
+ break if last == elem.parent
+ contents += xcworkspace_element_end_xml(stack.length, last)
+ stack.pop
+ end
+
+ stack << elem
+ contents += xcworkspace_element_start_xml(stack.length, elem)
+ end
+
+ until stack.empty?
+ contents += xcworkspace_element_end_xml(stack.length, stack.last)
+ stack.pop
+ end
+
+ root_xml(contents)
+ end
+
+ # Saves the workspace at the given `xcworkspace` path.
+ #
+ # @param [String] path
+ # the path where to save the project.
+ #
+ # @return [void]
+ #
+ def save_as(path)
+ FileUtils.mkdir_p(path)
+ File.open(File.join(path, 'contents.xcworkspacedata'), 'w') do |out|
+ out << to_s
+ end
+ end
+
+ #-------------------------------------------------------------------------#
+
+ # Load all schemes from all projects in workspace or in the workspace container itself
+ #
+ # @param [String] workspace_dir_path
+ # path of workspaces dir
+ #
+ # @return [void]
+ #
+ def load_schemes(workspace_dir_path)
+ # Normalizes path to directory of workspace needed for file_reference.absolute_path
+ workspaces_dir = workspace_dir_path
+ if File.extname(workspace_dir_path) == '.xcworkspace'
+ workspaces_dir = File.expand_path('..', workspaces_dir)
+ end
+
+ file_references.each do |file_reference|
+ project_full_path = file_reference.absolute_path(workspaces_dir)
+ load_schemes_from_project(project_full_path)
+ end
+
+ # Load schemes that are in the workspace container.
+ workspace_abs_path = File.absolute_path(workspace_dir_path)
+ Dir[File.join(workspace_dir_path, 'xcshareddata', 'xcschemes', '*.xcscheme')].each do |scheme|
+ scheme_name = File.basename(scheme, '.xcscheme')
+ @schemes[scheme_name] = workspace_abs_path
+ end
+ end
+
+ private
+
+ # Load all schemes from project
+ #
+ # @param [String] project_full_path
+ # project full path
+ #
+ # @return [void]
+ #
+ def load_schemes_from_project(project_full_path)
+ schemes = Xcodeproj::Project.schemes project_full_path
+ schemes.each do |scheme_name|
+ @schemes[scheme_name] = project_full_path
+ end
+ end
+
+ # @return [String] The template of the workspace XML as formated by Xcode.
+ #
+ # @param [String] contents The XML contents of the workspace.
+ #
+ def root_xml(contents)
+ <<-DOC
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+ version = "1.0">
+#{contents.rstrip}
+</Workspace>
+DOC
+ end
+
+ #
+ # @param [Integer] depth The depth of the element in the tree
+ # @param [REXML::Document::Element] elem The XML element to format.
+ #
+ # @return [String] The Xcode-specific XML formatting of an element start
+ #
+ def xcworkspace_element_start_xml(depth, elem)
+ attributes = case elem.name
+ when 'Group'
+ %w(location name)
+ when 'FileRef'
+ %w(location)
+ end
+ contents = "<#{elem.name}"
+ indent = ' ' * depth
+ attributes.each { |name| contents += "\n #{name} = \"#{elem.attribute(name)}\"" }
+ contents.split("\n").map { |line| "#{indent}#{line}" }.join("\n") + ">\n"
+ end
+
+ #
+ # @param [Integer] depth The depth of the element in the tree
+ # @param [REXML::Document::Element] elem The XML element to format.
+ #
+ # @return [String] The Xcode-specific XML formatting of an element end
+ #
+ def xcworkspace_element_end_xml(depth, elem)
+ "#{' ' * depth}</#{elem.name}>\n"
+ end
+
+ #-------------------------------------------------------------------------#
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/file_reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/file_reference.rb
new file mode 100644
index 0000000..1691a63
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/file_reference.rb
@@ -0,0 +1,79 @@
+require 'xcodeproj/workspace/reference'
+
+module Xcodeproj
+ class Workspace
+ # Describes a file reference of a Workspace.
+ #
+ class FileReference < Reference
+ # @return [String] the path to the project
+ #
+ attr_reader :path
+
+ # @param [#to_s] path @see path
+ # @param [#to_s] type @see type
+ #
+ def initialize(path, type = 'group')
+ @path = Pathname.new(path.to_s).cleanpath.to_s
+ @type = type.to_s
+ end
+
+ # @return [Bool] Wether a file reference is equal to another.
+ #
+ def ==(other)
+ path == other.path && type == other.type
+ end
+ alias_method :eql?, :==
+
+ # @return [Fixnum] A hash identical for equals objects.
+ #
+ def hash
+ [path, type].hash
+ end
+
+ # Returns a file reference given XML representation.
+ #
+ # @param [REXML::Element] xml_node
+ # the XML representation.
+ #
+ # @return [FileReference] The new file reference instance.
+ #
+ def self.from_node(xml_node)
+ type, path = xml_node.attribute('location').value.split(':', 2)
+ if type == 'group'
+ path = prepend_parent_path(xml_node, path)
+ end
+ new(path, type)
+ end
+
+ # @return [REXML::Element] the XML representation of the file reference.
+ #
+ def to_node
+ REXML::Element.new('FileRef').tap do |element|
+ element.add_attribute('location', "#{type}:#{path}")
+ end
+ end
+
+ # Returns the absolute path of a file reference given the path of the
+ # directory containing workspace.
+ #
+ # @param [#to_s] workspace_dir_path
+ # The Path of the directory containing the workspace.
+ #
+ # @return [String] The absolute path to the project.
+ #
+ def absolute_path(workspace_dir_path)
+ workspace_dir_path = workspace_dir_path.to_s
+ case type
+ when 'group', 'container', 'self'
+ File.expand_path(File.join(workspace_dir_path, path))
+ when 'absolute'
+ File.expand_path(path)
+ when 'developer'
+ raise "Developer workspace file reference type is not yet supported (#{path})"
+ else
+ raise "Unsupported workspace file reference type `#{type}`"
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/group_reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/group_reference.rb
new file mode 100644
index 0000000..ec73dbf
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/group_reference.rb
@@ -0,0 +1,67 @@
+require 'xcodeproj/workspace/reference'
+
+module Xcodeproj
+ class Workspace
+ # Describes a group reference of a Workspace.
+ #
+ class GroupReference < Reference
+ # @return [String] the name of the group
+ #
+ attr_reader :name
+
+ # @return [String] the location of the group on disk
+ #
+ attr_reader :location
+
+ # @param [#to_s] name @see name
+ # @param [#to_s] type @see type
+ # @param [#to_s] location @see location
+ #
+ def initialize(name, type = 'container', location = '')
+ @name = name.to_s
+ @type = type.to_s
+ @location = location.to_s
+ end
+
+ # @return [Bool] Whether a group reference is equal to another.
+ #
+ def ==(other)
+ name == other.name && type == other.type && location == other.location
+ end
+ alias_method :eql?, :==
+
+ # @return [Fixnum] A hash identical for equals objects.
+ #
+ def hash
+ [name, type, location].hash
+ end
+
+ # Returns a group reference given XML representation.
+ #
+ # @param [REXML::Element] xml_node
+ # the XML representation.
+ #
+ # @return [GroupReference] The new group reference instance.
+ #
+ def self.from_node(xml_node)
+ location_array = xml_node.attribute('location').value.split(':', 2)
+ type = location_array.first
+ location = location_array[1] || ''
+ if type == 'group'
+ location = prepend_parent_path(xml_node, location)
+ end
+ name = xml_node.attribute('name').value
+ new(name, type, location)
+ end
+
+ # @return [REXML::Element] the XML representation of the group reference.
+ #
+ def to_node
+ REXML::Element.new('Group').tap do |element|
+ element.add_attribute('location', "#{type}:#{location}")
+ element.add_attribute('name', "#{name}")
+ end
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/reference.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/reference.rb
new file mode 100644
index 0000000..599052b
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/workspace/reference.rb
@@ -0,0 +1,40 @@
+module Xcodeproj
+ class Workspace
+ # Describes a file/group reference of a Workspace.
+ #
+ class Reference
+ # @return [String] the type of reference to the project
+ #
+ # This can be of the following values:
+ # - absolute
+ # - group
+ # - container
+ # - developer (unsupported)
+ #
+ attr_reader :type
+
+ # Returns the relative path to the parent group reference (if one exists)
+ # prepended to the passed in path.
+ #
+ # @param [REXML::Element] xml_node
+ # the XML representation.
+ #
+ # @param [String] path
+ # the path that will be prepended to.
+ #
+ # @return [String] the extended path including the parent node's path.
+ #
+ def self.prepend_parent_path(xml_node, path)
+ if !xml_node.parent.nil? && (xml_node.parent.name == 'Group')
+ group = GroupReference.from_node(xml_node.parent)
+ if !group.location.nil? && !group.location.empty?
+ path = '' if path.nil?
+ path = File.join(group.location, path)
+ end
+ end
+
+ path
+ end
+ end
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/xcodebuild_helper.rb b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/xcodebuild_helper.rb
new file mode 100644
index 0000000..03a9aff
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/gems/xcodeproj-1.27.0/lib/xcodeproj/xcodebuild_helper.rb
@@ -0,0 +1,117 @@
+module Xcodeproj
+ # Helper class which returns information from xcodebuild.
+ #
+ class XcodebuildHelper
+ def initialize
+ @needs_to_parse_sdks = true
+ end
+
+ # @return [String] The version of the last iOS sdk.
+ #
+ def last_ios_sdk
+ parse_sdks_if_needed
+ versions_by_sdk[:ios].sort.last
+ end
+
+ # @return [String] The version of the last OS X sdk.
+ #
+ def last_osx_sdk
+ parse_sdks_if_needed
+ versions_by_sdk[:osx].sort.last
+ end
+
+ # @return [String] The version of the last tvOS sdk.
+ #
+ def last_tvos_sdk
+ parse_sdks_if_needed
+ versions_by_sdk[:tvos].sort.last
+ end
+
+ # @return [String] The version of the last visionOS sdk.
+ #
+ def last_visionos_sdk
+ parse_sdks_if_needed
+ versions_by_sdk[:visionos].sort.last
+ end
+
+ # @return [String] The version of the last watchOS sdk.
+ #
+ def last_watchos_sdk
+ parse_sdks_if_needed
+ versions_by_sdk[:watchos].sort.last
+ end
+
+ private
+
+ # !@group Private Helpers
+
+ #-------------------------------------------------------------------------#
+
+ # @return [Hash] The versions of the sdks grouped by name (`:ios`, or `:osx`).
+ #
+ attr_accessor :versions_by_sdk
+
+ # @return [void] Parses the SDKs returned by xcodebuild and stores the
+ # information in the `needs_to_parse_sdks` hash.
+ #
+ def parse_sdks_if_needed
+ if @needs_to_parse_sdks
+ @versions_by_sdk = {}
+ @versions_by_sdk[:osx] = []
+ @versions_by_sdk[:ios] = []
+ @versions_by_sdk[:tvos] = []
+ @versions_by_sdk[:visionos] = []
+ @versions_by_sdk[:watchos] = []
+ if xcodebuild_available?
+ sdks = parse_sdks_information(xcodebuild_sdks)
+ sdks.each do |(name, version)|
+ case
+ when name == 'macosx' then @versions_by_sdk[:osx] << version
+ when name == 'iphoneos' then @versions_by_sdk[:ios] << version
+ when name == 'appletvos' then @versions_by_sdk[:tvos] << version
+ when name == 'xros' then @versions_by_sdk[:visionos] << version
+ when name == 'watchos' then @versions_by_sdk[:watchos] << version
+ end
+ end
+ end
+ end
+ end
+
+ # @return [Bool] Whether xcodebuild is available.
+ #
+ def xcodebuild_available?
+ if @xcodebuild_available.nil?
+ `which xcodebuild 2>/dev/null`
+ @xcodebuild_available = $?.exitstatus.zero?
+ end
+ @xcodebuild_available
+ end
+
+ # @return [Array<Array<String>>] An array of tuples where the first element
+ # is the name of the SDK and the second is the version.
+ #
+ def parse_sdks_information(output)
+ output.scan(/-sdk (macosx|iphoneos|watchos|appletvos|xros)(.+\w)/)
+ end
+
+ # @return [String] The sdk information reported by xcodebuild.
+ #
+ def xcodebuild_sdks
+ `xcodebuild -showsdks 2>/dev/null`
+ end
+
+ #-------------------------------------------------------------------------#
+
+ # @!group Singleton
+
+ # @return [XcodebuildHelper] the current xcodebuild instance creating one
+ # if needed, which caches the information from the xcodebuild
+ # command line tool.
+ #
+ def self.instance
+ @instance ||= new
+ end
+
+ #-------------------------------------------------------------------------#
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/CFPropertyList-3.0.7.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/CFPropertyList-3.0.7.gemspec
new file mode 100644
index 0000000..26a48fa
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/CFPropertyList-3.0.7.gemspec
@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+# stub: CFPropertyList 3.0.7 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "CFPropertyList".freeze
+ s.version = "3.0.7"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Christian Kruse".freeze]
+ s.date = "2024-02-15"
+ s.description = "This is a module to read, write and manipulate both binary and XML property lists as defined by apple.".freeze
+ s.email = "cjk@defunct.ch".freeze
+ s.extra_rdoc_files = ["README.rdoc".freeze]
+ s.files = ["README.rdoc".freeze]
+ s.homepage = "https://github.com/ckruse/CFPropertyList".freeze
+ s.licenses = ["MIT".freeze]
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "Read, write and manipulate both binary and XML property lists as defined by apple".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+
+ if s.respond_to? :specification_version then
+ s.specification_version = 4
+
+ if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+ s.add_runtime_dependency(%q<rexml>.freeze, [">= 0"])
+ s.add_runtime_dependency(%q<nkf>.freeze, [">= 0"])
+ s.add_runtime_dependency(%q<base64>.freeze, [">= 0"])
+ s.add_development_dependency(%q<libxml-ruby>.freeze, [">= 0"])
+ s.add_development_dependency(%q<minitest>.freeze, [">= 0"])
+ s.add_development_dependency(%q<nokogiri>.freeze, [">= 0"])
+ s.add_development_dependency(%q<rake>.freeze, [">= 0.7.0"])
+ else
+ s.add_dependency(%q<rexml>.freeze, [">= 0"])
+ s.add_dependency(%q<nkf>.freeze, [">= 0"])
+ s.add_dependency(%q<base64>.freeze, [">= 0"])
+ s.add_dependency(%q<libxml-ruby>.freeze, [">= 0"])
+ s.add_dependency(%q<minitest>.freeze, [">= 0"])
+ s.add_dependency(%q<nokogiri>.freeze, [">= 0"])
+ s.add_dependency(%q<rake>.freeze, [">= 0.7.0"])
+ end
+ else
+ s.add_dependency(%q<rexml>.freeze, [">= 0"])
+ s.add_dependency(%q<nkf>.freeze, [">= 0"])
+ s.add_dependency(%q<base64>.freeze, [">= 0"])
+ s.add_dependency(%q<libxml-ruby>.freeze, [">= 0"])
+ s.add_dependency(%q<minitest>.freeze, [">= 0"])
+ s.add_dependency(%q<nokogiri>.freeze, [">= 0"])
+ s.add_dependency(%q<rake>.freeze, [">= 0.7.0"])
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/atomos-0.1.3.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/atomos-0.1.3.gemspec
new file mode 100644
index 0000000..1d17732
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/atomos-0.1.3.gemspec
@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+# stub: atomos 0.1.3 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "atomos".freeze
+ s.version = "0.1.3"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Samuel Giddins".freeze]
+ s.bindir = "exe".freeze
+ s.date = "2018-08-07"
+ s.email = ["segiddins@segiddins.me".freeze]
+ s.homepage = "https://github.com/segiddins/atomos".freeze
+ s.licenses = ["MIT".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.0".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "A simple gem to atomically write files".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+
+ if s.respond_to? :specification_version then
+ s.specification_version = 4
+
+ if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+ s.add_development_dependency(%q<bundler>.freeze, ["~> 1.16"])
+ s.add_development_dependency(%q<rake>.freeze, ["~> 10.0"])
+ s.add_development_dependency(%q<rspec>.freeze, ["~> 3.0"])
+ s.add_development_dependency(%q<rubocop>.freeze, [">= 0"])
+ else
+ s.add_dependency(%q<bundler>.freeze, ["~> 1.16"])
+ s.add_dependency(%q<rake>.freeze, ["~> 10.0"])
+ s.add_dependency(%q<rspec>.freeze, ["~> 3.0"])
+ s.add_dependency(%q<rubocop>.freeze, [">= 0"])
+ end
+ else
+ s.add_dependency(%q<bundler>.freeze, ["~> 1.16"])
+ s.add_dependency(%q<rake>.freeze, ["~> 10.0"])
+ s.add_dependency(%q<rspec>.freeze, ["~> 3.0"])
+ s.add_dependency(%q<rubocop>.freeze, [">= 0"])
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/base64-0.3.0.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/base64-0.3.0.gemspec
new file mode 100644
index 0000000..d9c817f
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/base64-0.3.0.gemspec
@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+# stub: base64 0.3.0 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "base64".freeze
+ s.version = "0.3.0"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.metadata = { "changelog_uri" => "https://github.com/ruby/base64/releases", "homepage_uri" => "https://github.com/ruby/base64", "source_code_uri" => "https://github.com/ruby/base64" } if s.respond_to? :metadata=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Yusuke Endoh".freeze]
+ s.bindir = "exe".freeze
+ s.date = "1980-01-02"
+ s.description = "Support for encoding and decoding binary data using a Base64 representation.".freeze
+ s.email = ["mame@ruby-lang.org".freeze]
+ s.homepage = "https://github.com/ruby/base64".freeze
+ s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.4".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "Support for encoding and decoding binary data using a Base64 representation.".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/claide-1.1.0.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/claide-1.1.0.gemspec
new file mode 100644
index 0000000..51f3f33
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/claide-1.1.0.gemspec
@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+# stub: claide 1.1.0 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "claide".freeze
+ s.version = "1.1.0"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Eloy Duran".freeze, "Fabio Pelosin".freeze]
+ s.date = "2022-01-12"
+ s.email = ["eloy.de.enige@gmail.com".freeze, "fabiopelosin@gmail.com".freeze]
+ s.homepage = "https://github.com/CocoaPods/CLAide".freeze
+ s.licenses = ["MIT".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.3.0".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "A small command-line interface framework.".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/colored2-3.1.2.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/colored2-3.1.2.gemspec
new file mode 100644
index 0000000..4c7fa86
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/colored2-3.1.2.gemspec
@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+# stub: colored2 3.1.2 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "colored2".freeze
+ s.version = "3.1.2"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6".freeze) if s.respond_to? :required_rubygems_version=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Chris Wanstrath".freeze, "Konstantin Gredeskoul".freeze]
+ s.date = "2017-02-14"
+ s.description = "This is a heavily modified fork of http://github.com/defunkt/colored gem, with many\nsensible pull requests combined. Since the authors of the original gem no longer support it,\nthis might, perhaps, be considered a good alternative.\n\nSimple gem that adds various color methods to String class, and can be used as follows:\n\n require 'colored2'\n\n puts 'this is red'.red\n puts 'this is red with a yellow background'.red.on.yellow\n puts 'this is red with and italic'.red.italic\n puts 'this is green bold'.green.bold << ' and regular'.green\n puts 'this is really bold blue on white but reversed'.bold.blue.on.white.reversed\n puts 'this is regular, but '.red! << 'this is red '.yellow! << ' and yellow.'.no_color!\n puts ('this is regular, but '.red! do\n 'this is red '.yellow! do\n ' and yellow.'.no_color!\n end\n end)\n\n".freeze
+ s.email = "kigster@gmail.com".freeze
+ s.homepage = "http://github.com/kigster/colored2".freeze
+ s.licenses = ["MIT".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.0.0".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "Add even more color to your life.".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+
+ if s.respond_to? :specification_version then
+ s.specification_version = 4
+
+ if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+ s.add_development_dependency(%q<rake>.freeze, ["~> 10.0"])
+ s.add_development_dependency(%q<rspec>.freeze, ["~> 3.4"])
+ s.add_development_dependency(%q<codeclimate-test-reporter>.freeze, [">= 0"])
+ else
+ s.add_dependency(%q<rake>.freeze, ["~> 10.0"])
+ s.add_dependency(%q<rspec>.freeze, ["~> 3.4"])
+ s.add_dependency(%q<codeclimate-test-reporter>.freeze, [">= 0"])
+ end
+ else
+ s.add_dependency(%q<rake>.freeze, ["~> 10.0"])
+ s.add_dependency(%q<rspec>.freeze, ["~> 3.4"])
+ s.add_dependency(%q<codeclimate-test-reporter>.freeze, [">= 0"])
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/nanaimo-0.4.0.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/nanaimo-0.4.0.gemspec
new file mode 100644
index 0000000..949c52e
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/nanaimo-0.4.0.gemspec
@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+# stub: nanaimo 0.4.0 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "nanaimo".freeze
+ s.version = "0.4.0"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Danielle Tomlinson".freeze, "Samuel Giddins".freeze]
+ s.bindir = "exe".freeze
+ s.date = "2024-10-03"
+ s.email = ["dan@tomlinson.io".freeze, "segiddins@segiddins.me".freeze]
+ s.homepage = "https://github.com/CocoaPods/Nanaimo".freeze
+ s.licenses = ["MIT".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.3.0".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "A library for (de)serialization of ASCII Plists.".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+
+ if s.respond_to? :specification_version then
+ s.specification_version = 4
+
+ if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+ s.add_development_dependency(%q<bundler>.freeze, ["~> 2.3"])
+ s.add_development_dependency(%q<rake>.freeze, ["~> 12.3"])
+ s.add_development_dependency(%q<rspec>.freeze, ["~> 3.0"])
+ else
+ s.add_dependency(%q<bundler>.freeze, ["~> 2.3"])
+ s.add_dependency(%q<rake>.freeze, ["~> 12.3"])
+ s.add_dependency(%q<rspec>.freeze, ["~> 3.0"])
+ end
+ else
+ s.add_dependency(%q<bundler>.freeze, ["~> 2.3"])
+ s.add_dependency(%q<rake>.freeze, ["~> 12.3"])
+ s.add_dependency(%q<rspec>.freeze, ["~> 3.0"])
+ end
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/nkf-0.2.0.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/nkf-0.2.0.gemspec
new file mode 100644
index 0000000..807da37
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/nkf-0.2.0.gemspec
@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+# stub: nkf 0.2.0 ruby lib
+# stub: ext/nkf/extconf.rb
+
+Gem::Specification.new do |s|
+ s.name = "nkf".freeze
+ s.version = "0.2.0"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.metadata = { "homepage_uri" => "https://github.com/ruby/nkf", "source_code_uri" => "https://github.com/ruby/nkf" } if s.respond_to? :metadata=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["NARUSE Yui".freeze, "Charles Oliver Nutter".freeze]
+ s.bindir = "exe".freeze
+ s.date = "2024-01-22"
+ s.description = "Ruby extension for Network Kanji Filter".freeze
+ s.email = ["naruse@airemix.jp".freeze, "headius@headius.com".freeze]
+ s.extensions = ["ext/nkf/extconf.rb".freeze]
+ s.files = ["ext/nkf/extconf.rb".freeze]
+ s.homepage = "https://github.com/ruby/nkf".freeze
+ s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.3.0".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "Ruby extension for Network Kanji Filter".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/rexml-3.4.4.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/rexml-3.4.4.gemspec
new file mode 100644
index 0000000..ff8e2f6
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/rexml-3.4.4.gemspec
@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+# stub: rexml 3.4.4 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "rexml".freeze
+ s.version = "3.4.4"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.metadata = { "changelog_uri" => "https://github.com/ruby/rexml/releases/tag/v3.4.4" } if s.respond_to? :metadata=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Kouhei Sutou".freeze]
+ s.date = "1980-01-02"
+ s.description = "An XML toolkit for Ruby".freeze
+ s.email = ["kou@cozmixng.org".freeze]
+ s.extra_rdoc_files = ["LICENSE.txt".freeze, "NEWS.md".freeze, "README.md".freeze, "doc/rexml/context.rdoc".freeze, "doc/rexml/tasks/rdoc/child.rdoc".freeze, "doc/rexml/tasks/rdoc/document.rdoc".freeze, "doc/rexml/tasks/rdoc/element.rdoc".freeze, "doc/rexml/tasks/rdoc/node.rdoc".freeze, "doc/rexml/tasks/rdoc/parent.rdoc".freeze, "doc/rexml/tasks/tocs/child_toc.rdoc".freeze, "doc/rexml/tasks/tocs/document_toc.rdoc".freeze, "doc/rexml/tasks/tocs/element_toc.rdoc".freeze, "doc/rexml/tasks/tocs/master_toc.rdoc".freeze, "doc/rexml/tasks/tocs/node_toc.rdoc".freeze, "doc/rexml/tasks/tocs/parent_toc.rdoc".freeze, "doc/rexml/tutorial.rdoc".freeze]
+ s.files = ["LICENSE.txt".freeze, "NEWS.md".freeze, "README.md".freeze, "doc/rexml/context.rdoc".freeze, "doc/rexml/tasks/rdoc/child.rdoc".freeze, "doc/rexml/tasks/rdoc/document.rdoc".freeze, "doc/rexml/tasks/rdoc/element.rdoc".freeze, "doc/rexml/tasks/rdoc/node.rdoc".freeze, "doc/rexml/tasks/rdoc/parent.rdoc".freeze, "doc/rexml/tasks/tocs/child_toc.rdoc".freeze, "doc/rexml/tasks/tocs/document_toc.rdoc".freeze, "doc/rexml/tasks/tocs/element_toc.rdoc".freeze, "doc/rexml/tasks/tocs/master_toc.rdoc".freeze, "doc/rexml/tasks/tocs/node_toc.rdoc".freeze, "doc/rexml/tasks/tocs/parent_toc.rdoc".freeze, "doc/rexml/tutorial.rdoc".freeze]
+ s.homepage = "https://github.com/ruby/rexml".freeze
+ s.licenses = ["BSD-2-Clause".freeze]
+ s.rdoc_options = ["--main".freeze, "README.md".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.5.0".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "An XML toolkit for Ruby".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+end
diff --git a/ios/vendor/bundle/ruby/2.6.0/specifications/xcodeproj-1.27.0.gemspec b/ios/vendor/bundle/ruby/2.6.0/specifications/xcodeproj-1.27.0.gemspec
new file mode 100644
index 0000000..5e79d1b
--- /dev/null
+++ b/ios/vendor/bundle/ruby/2.6.0/specifications/xcodeproj-1.27.0.gemspec
@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+# stub: xcodeproj 1.27.0 ruby lib
+
+Gem::Specification.new do |s|
+ s.name = "xcodeproj".freeze
+ s.version = "1.27.0"
+
+ s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+ s.require_paths = ["lib".freeze]
+ s.authors = ["Eloy Duran".freeze]
+ s.date = "2024-10-31"
+ s.description = "Xcodeproj lets you create and modify Xcode projects from Ruby. Script boring management tasks or build Xcode-friendly libraries. Also includes support for Xcode workspaces (.xcworkspace) and configuration files (.xcconfig).".freeze
+ s.email = "eloy.de.enige@gmail.com".freeze
+ s.executables = ["xcodeproj".freeze]
+ s.files = ["bin/xcodeproj".freeze]
+ s.homepage = "https://github.com/cocoapods/xcodeproj".freeze
+ s.licenses = ["MIT".freeze]
+ s.required_ruby_version = Gem::Requirement.new(">= 2.0.0".freeze)
+ s.rubygems_version = "3.0.3.1".freeze
+ s.summary = "Create and modify Xcode projects from Ruby.".freeze
+
+ s.installed_by_version = "3.0.3.1" if s.respond_to? :installed_by_version
+
+ if s.respond_to? :specification_version then
+ s.specification_version = 3
+
+ if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+ s.add_runtime_dependency(%q<atomos>.freeze, ["~> 0.1.3"])
+ s.add_runtime_dependency(%q<CFPropertyList>.freeze, [">= 2.3.3", "< 4.0"])
+ s.add_runtime_dependency(%q<claide>.freeze, [">= 1.0.2", "< 2.0"])
+ s.add_runtime_dependency(%q<colored2>.freeze, ["~> 3.1"])
+ s.add_runtime_dependency(%q<nanaimo>.freeze, ["~> 0.4.0"])
+ s.add_runtime_dependency(%q<rexml>.freeze, [">= 3.3.6", "< 4.0"])
+ else
+ s.add_dependency(%q<atomos>.freeze, ["~> 0.1.3"])
+ s.add_dependency(%q<CFPropertyList>.freeze, [">= 2.3.3", "< 4.0"])
+ s.add_dependency(%q<claide>.freeze, [">= 1.0.2", "< 2.0"])
+ s.add_dependency(%q<colored2>.freeze, ["~> 3.1"])
+ s.add_dependency(%q<nanaimo>.freeze, ["~> 0.4.0"])
+ s.add_dependency(%q<rexml>.freeze, [">= 3.3.6", "< 4.0"])
+ end
+ else
+ s.add_dependency(%q<atomos>.freeze, ["~> 0.1.3"])
+ s.add_dependency(%q<CFPropertyList>.freeze, [">= 2.3.3", "< 4.0"])
+ s.add_dependency(%q<claide>.freeze, [">= 1.0.2", "< 2.0"])
+ s.add_dependency(%q<colored2>.freeze, ["~> 3.1"])
+ s.add_dependency(%q<nanaimo>.freeze, ["~> 0.4.0"])
+ s.add_dependency(%q<rexml>.freeze, [">= 3.3.6", "< 4.0"])
+ end
+end
diff --git a/package-lock.json b/package-lock.json
index f5c0497..1c929c7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -83,7 +83,8 @@
"@types/react-native": "^0.72.8",
"babel-plugin-transform-remove-console": "^6.9.4",
"react-native-svg-transformer": "^1.5.0",
- "typescript": "^5.3.3"
+ "typescript": "^5.3.3",
+ "xcode": "^3.0.1"
}
},
"node_modules/@0no-co/graphql.web": {
diff --git a/package.json b/package.json
index fcf5d9f..b0c2782 100644
--- a/package.json
+++ b/package.json
@@ -83,7 +83,8 @@
"@types/react-native": "^0.72.8",
"babel-plugin-transform-remove-console": "^6.9.4",
"react-native-svg-transformer": "^1.5.0",
- "typescript": "^5.3.3"
+ "typescript": "^5.3.3",
+ "xcode": "^3.0.1"
},
"private": true
}
diff --git a/src/components/player/KSPlayer.tsx b/src/components/player/KSPlayer.tsx
new file mode 100644
index 0000000..625ce2a
--- /dev/null
+++ b/src/components/player/KSPlayer.tsx
@@ -0,0 +1,137 @@
+import React, { useRef, useImperativeHandle, forwardRef, useEffect, useState } from 'react';
+import { View, requireNativeComponent, UIManager, findNodeHandle, NativeModules } from 'react-native';
+
+export interface KSPlayerSource {
+ uri: string;
+ headers?: Record<string, string>;
+}
+
+interface KSPlayerViewProps {
+ source?: KSPlayerSource;
+ paused?: boolean;
+ volume?: number;
+ audioTrack?: number;
+ textTrack?: number;
+ onLoad?: (data: any) => void;
+ onProgress?: (data: any) => void;
+ onBuffering?: (data: any) => void;
+ onEnd?: () => void;
+ onError?: (error: any) => void;
+ onBufferingProgress?: (data: any) => void;
+ style?: any;
+}
+
+const KSPlayerViewManager = requireNativeComponent<KSPlayerViewProps>('KSPlayerView');
+const KSPlayerModule = NativeModules.KSPlayerModule;
+
+export interface KSPlayerRef {
+ seek: (time: number) => void;
+ setSource: (source: KSPlayerSource) => void;
+ setPaused: (paused: boolean) => void;
+ setVolume: (volume: number) => void;
+ setAudioTrack: (trackId: number) => void;
+ setTextTrack: (trackId: number) => void;
+}
+
+export interface KSPlayerProps {
+ source?: KSPlayerSource;
+ paused?: boolean;
+ volume?: number;
+ audioTrack?: number;
+ textTrack?: number;
+ onLoad?: (data: any) => void;
+ onProgress?: (data: any) => void;
+ onBuffering?: (data: any) => void;
+ onEnd?: () => void;
+ onError?: (error: any) => void;
+ onBufferingProgress?: (data: any) => void;
+ style?: any;
+}
+
+const KSPlayer = forwardRef<KSPlayerRef, KSPlayerProps>((props, ref) => {
+ const nativeRef = useRef<any>(null);
+ const [key, setKey] = useState(0); // Force re-render when source changes
+
+ useImperativeHandle(ref, () => ({
+ seek: (time: number) => {
+ if (nativeRef.current) {
+ const node = findNodeHandle(nativeRef.current);
+ // @ts-ignore legacy UIManager commands path for Paper
+ const commandId = UIManager.getViewManagerConfig('KSPlayerView').Commands.seek;
+ UIManager.dispatchViewManagerCommand(node, commandId, [time]);
+ }
+ },
+ setSource: (source: KSPlayerSource) => {
+ if (nativeRef.current) {
+ const node = findNodeHandle(nativeRef.current);
+ // @ts-ignore legacy UIManager commands path for Paper
+ const commandId = UIManager.getViewManagerConfig('KSPlayerView').Commands.setSource;
+ UIManager.dispatchViewManagerCommand(node, commandId, [source]);
+ }
+ },
+ setPaused: (paused: boolean) => {
+ if (nativeRef.current) {
+ const node = findNodeHandle(nativeRef.current);
+ // @ts-ignore legacy UIManager commands path for Paper
+ const commandId = UIManager.getViewManagerConfig('KSPlayerView').Commands.setPaused;
+ UIManager.dispatchViewManagerCommand(node, commandId, [paused]);
+ }
+ },
+ setVolume: (volume: number) => {
+ if (nativeRef.current) {
+ const node = findNodeHandle(nativeRef.current);
+ // @ts-ignore legacy UIManager commands path for Paper
+ const commandId = UIManager.getViewManagerConfig('KSPlayerView').Commands.setVolume;
+ UIManager.dispatchViewManagerCommand(node, commandId, [volume]);
+ }
+ },
+ setAudioTrack: (trackId: number) => {
+ if (nativeRef.current) {
+ const node = findNodeHandle(nativeRef.current);
+ // @ts-ignore legacy UIManager commands path for Paper
+ const commandId = UIManager.getViewManagerConfig('KSPlayerView').Commands.setAudioTrack;
+ UIManager.dispatchViewManagerCommand(node, commandId, [trackId]);
+ }
+ },
+ setTextTrack: (trackId: number) => {
+ if (nativeRef.current) {
+ const node = findNodeHandle(nativeRef.current);
+ // @ts-ignore legacy UIManager commands path for Paper
+ const commandId = UIManager.getViewManagerConfig('KSPlayerView').Commands.setTextTrack;
+ UIManager.dispatchViewManagerCommand(node, commandId, [trackId]);
+ }
+ },
+ }));
+
+ // No need for event listeners - events are handled through props
+
+ // Force re-render when source changes to ensure proper reloading
+ useEffect(() => {
+ if (props.source) {
+ setKey(prev => prev + 1);
+ }
+ }, [props.source?.uri]);
+
+ return (
+ <KSPlayerViewManager
+ key={key}
+ ref={nativeRef}
+ source={props.source}
+ paused={props.paused}
+ volume={props.volume}
+ audioTrack={props.audioTrack}
+ textTrack={props.textTrack}
+ onLoad={props.onLoad}
+ onProgress={props.onProgress}
+ onBuffering={props.onBuffering}
+ onEnd={props.onEnd}
+ onError={props.onError}
+ onBufferingProgress={props.onBufferingProgress}
+ style={props.style}
+ />
+ );
+});
+
+KSPlayer.displayName = 'KSPlayer';
+
+export default KSPlayer;
diff --git a/src/components/player/VideoPlayer.tsx b/src/components/player/VideoPlayer.tsx
index 123adaa..08043e9 100644
--- a/src/components/player/VideoPlayer.tsx
+++ b/src/components/player/VideoPlayer.tsx
@@ -1,7 +1,6 @@
import React, { useState, useRef, useEffect, useMemo, useCallback } from 'react';
import { View, TouchableOpacity, Dimensions, Animated, ActivityIndicator, Platform, NativeModules, StatusBar, Text, Image, StyleSheet, Modal, AppState } from 'react-native';
import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import { VLCPlayer } from 'react-native-vlc-media-player';
import { useNavigation, useRoute, RouteProp, useFocusEffect } from '@react-navigation/native';
import { RootStackParamList, RootStackNavigationProp } from '../../navigation/AppNavigator';
import { PinchGestureHandler, PanGestureHandler, TapGestureHandler, State, PinchGestureHandlerGestureEvent, PanGestureHandlerGestureEvent, TapGestureHandlerGestureEvent } from 'react-native-gesture-handler';
@@ -14,6 +13,7 @@ import { MaterialIcons } from '@expo/vector-icons';
import { LinearGradient } from 'expo-linear-gradient';
import Slider from '@react-native-community/slider';
import AndroidVideoPlayer from './AndroidVideoPlayer';
+import KSPlayer, { KSPlayerRef, KSPlayerSource } from './KSPlayer';
import { useTraktAutosync } from '../../hooks/useTraktAutosync';
import { useTraktAutosyncSettings } from '../../hooks/useTraktAutosyncSettings';
import { useMetadata } from '../../hooks/useMetadata';
@@ -51,20 +51,16 @@ const VideoPlayer: React.FC = () => {
// Detect if stream is MKV format
const isMkvFile = isMkvStream(uri, headers);
- // Use AndroidVideoPlayer for:
- // - Android devices
- // - Non-MKV files on iOS (unless forceVlc is set)
- // Use VideoPlayer (VLC) for:
- // - MKV files on iOS (unless forceVlc is set)
- const shouldUseAndroidPlayer = Platform.OS === 'android' ||
- (Platform.OS === 'ios' && !isMkvFile && !forceVlc);
+ // Use AndroidVideoPlayer for Android devices
+ // Use KSPlayer for iOS devices
+ const shouldUseAndroidPlayer = Platform.OS === 'android';
safeDebugLog("Player selection logic", {
platform: Platform.OS,
isMkvFile,
- forceVlc,
shouldUseAndroidPlayer
});
+
if (shouldUseAndroidPlayer) {
return <AndroidVideoPlayer />;
}
@@ -132,7 +128,7 @@ const VideoPlayer: React.FC = () => {
const [resizeMode, setResizeMode] = useState<ResizeModeType>('stretch');
const [buffered, setBuffered] = useState(0);
const [seekPosition, setSeekPosition] = useState<number | null>(null);
- const vlcRef = useRef<any>(null);
+ const ksPlayerRef = useRef<KSPlayerRef>(null);
const [showAudioModal, setShowAudioModal] = useState(false);
const [showSubtitleModal, setShowSubtitleModal] = useState(false);
const [initialPosition, setInitialPosition] = useState<number | null>(null);
@@ -784,51 +780,27 @@ const VideoPlayer: React.FC = () => {
const seekToTime = (rawSeconds: number) => {
// Clamp to just before the end to avoid triggering onEnd.
const timeInSeconds = Math.max(0, Math.min(rawSeconds, duration > 0 ? duration - END_EPSILON : rawSeconds));
- if (vlcRef.current && duration > 0 && !isSeeking.current) {
+ if (ksPlayerRef.current && duration > 0 && !isSeeking.current) {
if (DEBUG_MODE) {
if (__DEV__) logger.log(`[VideoPlayer] Seeking to ${timeInSeconds.toFixed(2)}s out of ${duration.toFixed(2)}s`);
}
isSeeking.current = true;
- // For Android, use direct seeking on VLC player ref instead of seek prop
- if (Platform.OS === 'android' && vlcRef.current.seek) {
- // Calculate position as fraction
- const position = timeInSeconds / duration;
- vlcRef.current.seek(position);
- // Clear seek state after Android seek
- setTimeout(() => {
- if (isMounted.current) {
- isSeeking.current = false;
- if (DEBUG_MODE) {
- logger.log(`[VideoPlayer] Android seek completed to ${timeInSeconds.toFixed(2)}s`);
- }
- }
- }, 500);
- } else {
- // iOS (and other platforms) – prefer direct seek on the ref to avoid re-mounts caused by the `seek` prop
- const position = timeInSeconds / duration; // VLC expects a 0-1 fraction
- if (vlcRef.current && typeof vlcRef.current.seek === 'function') {
- vlcRef.current.seek(position);
- } else {
- // Fallback to legacy behaviour only if direct seek is unavailable
- setSeekPosition(position);
- }
+ // KSPlayer uses direct time seeking
+ ksPlayerRef.current.seek(timeInSeconds);
- setTimeout(() => {
- if (isMounted.current) {
- // Reset temporary seek state
- setSeekPosition(null);
- isSeeking.current = false;
- if (DEBUG_MODE) {
- logger.log(`[VideoPlayer] iOS seek completed to ${timeInSeconds.toFixed(2)}s`);
- }
+ setTimeout(() => {
+ if (isMounted.current) {
+ isSeeking.current = false;
+ if (DEBUG_MODE) {
+ logger.log(`[VideoPlayer] KSPlayer seek completed to ${timeInSeconds.toFixed(2)}s`);
}
- }, 500);
- }
+ }
+ }, 500);
} else {
if (DEBUG_MODE) {
- logger.error(`[VideoPlayer] Seek failed: vlcRef=${!!vlcRef.current}, duration=${duration}, seeking=${isSeeking.current}`);
+ logger.error(`[VideoPlayer] Seek failed: ksPlayerRef=${!!ksPlayerRef.current}, duration=${duration}, seeking=${isSeeking.current}`);
}
}
};
@@ -882,13 +854,14 @@ const VideoPlayer: React.FC = () => {
const handleProgress = (event: any) => {
if (isDragging || isSeeking.current) return;
- const currentTimeInSeconds = event.currentTime / 1000;
+ // KSPlayer returns times in seconds directly
+ const currentTimeInSeconds = event.currentTime;
// Only update if there's a significant change to avoid unnecessary updates
if (Math.abs(currentTimeInSeconds - currentTime) > 0.5) {
safeSetState(() => setCurrentTime(currentTimeInSeconds));
- // Removed progressAnim animation - no longer needed with React Native Community Slider
- const bufferedTime = event.bufferTime / 1000 || currentTimeInSeconds;
+ // KSPlayer returns bufferTime in seconds
+ const bufferedTime = event.bufferTime || currentTimeInSeconds;
safeSetState(() => setBuffered(bufferedTime));
}
@@ -954,8 +927,9 @@ const VideoPlayer: React.FC = () => {
logger.error('[VideoPlayer] onLoad called with null/undefined data');
return;
}
- const videoDuration = data.duration / 1000;
- if (data.duration > 0) {
+ // KSPlayer returns duration in seconds directly
+ const videoDuration = data.duration;
+ if (videoDuration > 0) {
setDuration(videoDuration);
// Store the actual duration for future reference and update existing progress
@@ -969,13 +943,14 @@ const VideoPlayer: React.FC = () => {
}
}
}
- // Set aspect ratio with null check for videoSize
- if (data.videoSize && data.videoSize.width && data.videoSize.height) {
- setVideoAspectRatio(data.videoSize.width / data.videoSize.height);
+
+ // Set aspect ratio from naturalSize (KSPlayer format)
+ if (data.naturalSize && data.naturalSize.width && data.naturalSize.height) {
+ setVideoAspectRatio(data.naturalSize.width / data.naturalSize.height);
} else {
- // Fallback to 16:9 aspect ratio if videoSize is not available
+ // Fallback to 16:9 aspect ratio if naturalSize is not available
setVideoAspectRatio(16 / 9);
- logger.warn('[VideoPlayer] videoSize not available, using default 16:9 aspect ratio');
+ logger.warn('[VideoPlayer] naturalSize not available, using default 16:9 aspect ratio');
}
if (data.audioTracks && data.audioTracks.length > 0) {
@@ -2551,31 +2526,22 @@ const VideoPlayer: React.FC = () => {
onLongPress={resetZoom}
delayLongPress={300}
>
- <VLCPlayer
- ref={vlcRef}
+ <KSPlayer
+ ref={ksPlayerRef}
style={[styles.video, customVideoStyles, { transform: [{ scale: zoomScale }] }]}
- source={(() => {
- // Use route headers for VLC streams
- const sourceWithHeaders = headers && Object.keys(headers).length > 0 ? {
- uri: currentStreamUrl,
- headers: headers
- } : { uri: currentStreamUrl };
-
- return sourceWithHeaders;
- })()}
+ source={{
+ uri: currentStreamUrl,
+ headers: headers && Object.keys(headers).length > 0 ? headers : undefined
+ }}
paused={paused}
+ volume={volume / 100}
+ audioTrack={selectedAudioTrack}
+ textTrack={useCustomSubtitles ? -1 : selectedTextTrack}
onProgress={handleProgress}
onLoad={onLoad}
onEnd={onEnd}
onError={handleError}
onBuffering={onBuffering}
- onPlaying={onPlaying}
- onPaused={onPaused}
- resizeMode={resizeMode as any}
- audioTrack={selectedAudioTrack ?? undefined}
- textTrack={useCustomSubtitles ? -1 : (selectedTextTrack >= 0 ? selectedTextTrack : -1)}
- autoAspectRatio
- volume={volume / 100}
/>
</TouchableOpacity>
</View>
@@ -2596,7 +2562,7 @@ const VideoPlayer: React.FC = () => {
currentTime={currentTime}
duration={duration}
zoomScale={zoomScale}
- vlcAudioTracks={vlcAudioTracks}
+ vlcAudioTracks={[]} // TODO: Update with KSPlayer tracks
selectedAudioTrack={selectedAudioTrack}
availableStreams={availableStreams}
togglePlayback={togglePlayback}