rho-tau-extensions 6.2.0 → 7.1.17

data/libs/fcm-push-18/ext/iphone/impl/readme.txt

@@ -0,0 +1,7 @@
+contains files with module API Implementation.
+
+Developer should create it - after first generation this folder is empty and this folder do not changed with next generation processes !!!.
+
+Developer should make at least <ModuleName>FactorySingleton.m with acees to <ModuleName>Factory interface!
+All other files include base_impl can be removed from project if it wants by developer.
+Default stub generated code placed in stub_impl folder - you can just copy all files from /generated/stub_impl to this folder and implement unemplemented methods.

data/libs/fcm-push-18/ext/platform/iphone/impl/readme.txt

@@ -0,0 +1,7 @@
+contains files with module API Implementation.
+
+Developer should create it - after first generation this folder is empty and this folder do not changed with next generation processes !!!.
+
+Developer should make at least <ModuleName>FactorySingleton.m with acees to <ModuleName>Factory interface!
+All other files include base_impl can be removed from project if it wants by developer.
+Default stub generated code placed in stub_impl folder - you can just copy all files from /generated/stub_impl to this folder and implement unemplemented methods.

data/libs/nodejs/ext/platform/android/jxCore/jx.h

@@ -11,7 +11,23 @@ extern "C" {
 
 typedef void (*JX_CALLBACK)(JXValue *result, int argc);
 
-// Call method below only once per app. to initialize JXcore
+// Creates a thread to run a restartable instance of the JXcore engine
+// Input arg 'start' is the function to run on the new thread.
+JXCORE_EXTERN(bool)
+JX_CreateRIThread(void (*start)(void *arg));
+
+// Join the thread created by JX_CreateRIThread. Make sure to call
+// this method only after JX_StopEngine has been called on the
+// thread to join.
+JXCORE_EXTERN(bool)
+JX_JoinRIThread();
+
+// If the script has called 'process.exit(exitcode)', it returns
+// the exitcode, otherwise returns '0'.
+JXCORE_EXTERN(int)
+JX_ProcessExitResult();
+
+// Call method below only once per app. to initialize JXcore.
 JXCORE_EXTERN(void)
 JX_InitializeOnce(const char *home_folder);
 

data/libs/nodejs/ext/platform/iphone/jxCore/jx.h

@@ -11,7 +11,23 @@ extern "C" {
 
 typedef void (*JX_CALLBACK)(JXValue *result, int argc);
 
-// Call method below only once per app. to initialize JXcore
+// Creates a thread to run a restartable instance of the JXcore engine
+// Input arg 'start' is the function to run on the new thread.
+JXCORE_EXTERN(bool)
+JX_CreateRIThread(void (*start)(void *arg));
+
+// Join the thread created by JX_CreateRIThread. Make sure to call
+// this method only after JX_StopEngine has been called on the
+// thread to join.
+JXCORE_EXTERN(bool)
+JX_JoinRIThread();
+
+// If the script has called 'process.exit(exitcode)', it returns
+// the exitcode, otherwise returns '0'.
+JXCORE_EXTERN(int)
+JX_ProcessExitResult();
+
+// Call method below only once per app. to initialize JXcore.
 JXCORE_EXTERN(void)
 JX_InitializeOnce(const char *home_folder);
 

data/libs/rexml-edge/rexml/attlistdecl.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: false
+#vim:ts=2 sw=2 noexpandtab:
+require 'rexml/child'
+require 'rexml/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

data/libs/rexml-edge/rexml/attribute.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: false
+require "rexml/namespace"
+require 'rexml/text'
+
+module REXML
+  # Defines an Element Attribute; IE, a attribute=value pair, as in:
+  # <element attribute="value"/>.  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
+    # The normalized value of this attribute.  That is, the attribute with
+    # entities intact.
+    attr_writer :normalized
+    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   # -> "elns"
+    #  a = Attribute.new( "x", "y" )
+    #  a.prefix                                   # -> ""
+    def prefix
+      pf = super
+      if pf == ""
+        pf = @element.prefix if @element
+      end
+      pf
+    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
+    def namespace arg=nil
+      arg = prefix if arg.nil?
+      @element.namespace arg
+    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
+      if @element and @element.context and @element.context[:attribute_quote] == :quote
+        %Q^#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"^
+      else
+        "#@expanded_name='#{to_s().gsub(/'/, '&apos;')}'"
+      end
+    end
+
+    def doctype
+      if @element
+        doc = @element.document
+        doc.doctype if doc
+      end
+    end
+
+    # Returns the attribute value, with entities replaced
+    def to_s
+      return @normalized if @normalized
+
+      @normalized = Text::normalize( @unnormalized, doctype )
+      @unnormalized = nil
+      @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 )
+      @normalized = nil
+      @unnormalized
+    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, doctype )
+      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
+      path = @element.xpath
+      path += "/@#{self.expanded_name}"
+      return path
+    end
+  end
+end
+#vim:ts=2 sw=2 noexpandtab:

data/libs/rexml-edge/rexml/cdata.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: false
+require "rexml/text"
+
+module REXML
+  class CData < Text
+    START = '<![CDATA['
+    STOP = ']]>'
+    ILLEGAL = /(\]\]>)/
+
+    #   Constructor.  CData is data between <![CDATA[ ... ]]>
+    #
+    # _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 )     #->  <![CDATA[ Some text ]]>
+    def write( output=$stdout, indent=-1, transitive=false, ie_hack=false )
+      Kernel.warn( "#{self.class.name}.write is deprecated" )
+      indent( output, indent )
+      output << START
+      output << @string
+      output << STOP
+    end
+  end
+end