wirispluginengine 3.62.0.1322

data/lib/src-generic/StringBuf.rb

@@ -0,0 +1,41 @@
+require 'stringio'
+
+module Wiris
+  class StringBuf
+    @sb
+
+    def sb
+      @sb
+    end
+    
+    def initialize()
+      @sb = StringIO.new('',"a+") # Append mode 
+    end
+
+    def add(o)
+      @sb << o
+    end
+
+    def addChar(c)
+      @sb << c.chr
+    end
+    
+    # public void addSub(String s, int pos, int len){
+    #   sb.append(s, pos, len+pos);
+    # }
+    
+    def toString()
+      return @sb.string
+    end
+
+    def to_s()
+      return @sb.string
+    end
+    # /**
+    #  * Not for haxe! Only for C#
+    #  * **/
+    # public int length(){
+    #   return sb.length();
+    # }
+  end
+end

data/lib/src-generic/StringTools.rb

@@ -0,0 +1,46 @@
+require 'cgi'
+module Wiris
+    class StringTools
+        def self.replace(text, target, replacement)
+            text = text.gsub(target, replacement)
+            return text
+        end
+
+        def self.startsWith(s, start)
+            return s.start_with?(start)
+        end
+
+        def self.endsWith(s, ends)
+            return s.end_with?(ends)
+        end
+
+        def self.urlEncode(s) #TODO Implement unsupoortedEncodingException? 
+            return CGI::escape(s)
+        end
+
+        def self.trim(s)
+            return s.strip
+        end
+
+        def self.hex(n, digits)
+            hex = n.to_s(16)
+            while hex.length() < digits
+                hex = "0" + hex
+            end
+            return hex
+        end
+
+    #     
+    #     public static byte[] string2Bytes(String str) {
+    #         try {
+    #             return str.getBytes("iso-8859-1");
+    #         } catch (UnsupportedEncodingException ex) {
+    #             throw new Error(ex);
+    #         }
+    #     }
+
+        def self.compare(s1,s2)
+            return s1<=>s2
+        end
+    end
+end

data/lib/src-generic/Timer.rb

@@ -0,0 +1,7 @@
+module Wiris
+	class Timer
+		def self.stamp()
+			return Time.now.to_f
+		end
+	end
+end

data/lib/src-generic/Type.rb

@@ -0,0 +1,19 @@
+module Wiris
+  class Type
+    def self.resolveClass(name)
+      name = name.to_s
+      name = name.split(".").last
+      return Object.const_get("Wiris::" + name)
+      rescue Exception => exc
+        return nil
+    end
+
+    def self.getClass(o)
+      return o.class.name
+    end
+
+    def self.createInstance(cls, args)
+      return cls.new()
+    end
+  end
+end

data/lib/src-generic/TypeTools.rb

@@ -0,0 +1,32 @@
+module Wiris
+	class TypeTools
+
+		def self.floatToString(float)
+			return float.to_s
+		end
+
+		def self.isFloating(str)
+			Float(str) rescue false
+		end
+
+		def self.isInteger(str)
+			Integer(str) rescue false
+		end
+
+		def self.isIdentifierPart(int)
+			return (int.chr.match(/^[[:alpha:]]$/) ? true : false) || (int.chr.match(/^[[:digit:]]$/) ? true : false) || int.chr == '_'
+		end
+
+		def self.isIdentifierStart(int)
+			return (int.chr.match(/^[[:alpha:]]$/) ? true : false) || int.chr == '_'
+		end
+
+		def self.isArray(o)
+			return o.instance_of? Array
+		end
+
+		def self.isHash(o)
+			return o.instance_of? Hash
+		end
+	end
+end

data/lib/src-generic/Unserializer.rb

@@ -0,0 +1,73 @@
+module Wiris
+  class Unserializer
+    def buf
+      @buf
+    end
+
+    def pos
+      @pos
+    end
+
+    def initialize(s)
+      @buf = s
+      @pos = 0
+    end
+
+    def self.run(s)
+      return Unserializer.new(s).unserialize()
+    end
+
+    def unserialize()
+      c = Std.charCodeAt(buf, @pos)
+      @pos += 1
+      case c
+      when 0x61 # 'a' for Array
+        a = Array.new()
+        while(true)
+          t = Std.charCodeAt(buf, @pos)
+          if (t == 0x68) # 'h'
+            @pos += 1
+            break
+          end
+          if (t == 0x75) # 'u'
+            @pos += 1
+            n = readDigits()
+            a._(a.length()-(n-1), nil)
+          else
+            a.push(unserialize())
+          end
+        end
+        return a
+      when 0x69 # 'i' for integer
+        return readDigits()
+      when 0x7a # 'z'
+        return 0
+      when 0x6e #n
+        return nil
+      else
+        raise Exception,'Object class not implemented: " ' + Std.fromCharCode(c) + "."
+      end
+    end
+
+    def readDigits()
+      n = 0
+      c = Std.charCodeAt(buf,@pos)
+      minus = false
+      if c == 0x2d # '-'
+        minus = true
+        @pos += 1
+        c = Std.charCodeAt(buf,@pos)
+      end
+      while (c>=0x30 && c<=0x39)
+        n = n*10 + (c-0x30)
+        @pos += 1
+        if (@pos >= buf.length())
+          break
+        end
+        c= Std.charCodeAt(buf,@pos)
+      end
+      ret = (minus ? -n : n)
+      return ret
+    end
+  end
+end

data/lib/src-generic/Utf8.rb

@@ -0,0 +1,27 @@
+module Wiris
+	class Utf8
+		def self.toBytes(str)
+			return str.force_encoding("UTF-8").bytes.to_a
+		end
+
+		def self.fromBytes(bytes)
+			return bytes.pack("C*")
+		end
+
+		def self.charCodeAt(s, index)
+			return s.codepoints.to_a[index]
+		end
+
+		def self.uchr(code)
+			return code.chr(Encoding::UTF_8)
+		end
+
+		def self.getLength(s)
+			return s.length
+		end
+
+		def self.charAt(s, i)
+			return s[i]
+		end
+	end
+end

data/lib/src-generic/Xml.rb

@@ -0,0 +1,199 @@
+require "rexml/document"
+module Wiris
+	class Xml
+		include REXML
+		include Comparable
+	  @node
+	  @nodeName
+	  @nodeType
+	  Element = :element
+	  PCData = :text
+	  CData = :text
+
+	  	def node=(node)
+			@node=node
+		end
+		def node
+			@node
+		end
+
+		def nodeName=(nodeName)
+			@nodeName=nodeName
+		end
+		def nodeName
+			@nodeName
+		end
+
+		def nodeType=(nodeType)
+			@nodeType=nodeType
+		end
+		def nodeType
+			@nodeType
+		end
+
+		def initialize(node)
+			@node =node
+			@nodeType = node.node_type
+			if node.class == REXML::CData
+				@nodeType = :text
+			end
+			if (@nodeType == :text)
+				@nodeName = :text
+			elsif (@nodeType == :text)
+				@nodeName = :text
+			else
+				@nodeName = node.name
+			end
+
+		end
+		def self.parse(xml)
+			return Xml.new REXML::Document.new xml
+		end
+
+		def iterator()
+			return XmlIterator.new(@node.each)
+		end
+
+		def elements()
+			childElements = Array.new
+			node = nil
+			if (self.firstChild() != nil)
+				node = self.firstChild().node
+			end
+
+			while (!node.nil?)
+				if (node.node_type == :element)
+					childElements.push(node)
+				end
+			node = node.next_sibling
+			end
+			# return XmlIterator.new(childElements.each)
+			return XmlIterator.new childElements.each
+		end
+
+	    def attributes()
+	        atts = Array.new;
+	        if @node.attributes.nil?
+	             return Iterator.new
+	        end
+
+	        @node.attributes.each_attribute { |attr|
+				atts.push(attr.expanded_name)
+			}
+
+	        return Iterator.new atts.each
+	    end
+
+	    def get(attributeName)
+	        return @node.attributes[attributeName]
+	    end
+
+	    def remove(attributeName)
+	    	if !@node.attributes[attributeName].nil?
+	    		@node.attributes.delete attributeName
+	    	end
+	    end
+
+	    def set(attributeName, attributeValue)
+	        newAtrribute = REXML::Attribute.new(attributeName, attributeValue);
+	        @node.attributes.add(newAtrribute)
+	    end
+
+	    def parent_()
+	    	if @node.parent.nil?
+	    		return nil
+	    	end
+	    	return Xml.new @node.parent
+	    end
+
+		def firstChild()
+			if defined?(@node.each_child).nil? || @node.each_child.count == 0
+				return nil
+			end
+
+			return Xml.new @node.each_child.next
+		end
+
+		def firstElement()
+			@node.each_recursive {|e|
+	 				if e.class == REXML::Element
+	 					return Xml.new e
+	 				end
+			}
+			return nil
+		end
+
+		def addChild(x)
+			@node << x.node
+		end
+
+		def insertChild(x, pos)
+			if pos < 0
+			end
+			# On ruby first index starts at 1.
+			# Check if node has childs, if not insert node directly.
+			if @node.elements[1].nil?
+				xmlparsed.firstChild.addChild(x)
+			else
+				@node.insert_before(@node.elements[1], x.node)
+			end
+		end
+		def removeChild(x)
+			remove = @node == x.node.parent
+			if remove
+				x.node.remove
+			end
+		end
+
+		def self.createDocument()
+			return Xml.new REXML::Document.new
+		end
+
+		def createElement_(name)
+			elementNode = REXML::Element.new name
+			return Xml.new elementNode
+		end
+
+		def createPCData_(text)
+			textNode = Text.new text
+			return Xml.new textNode
+		end
+
+		def getNodeValue_()
+			if (@node.node_type == :text || @node.node_type == :node)
+				return @node.value
+			else
+				return @node.text
+			end
+		end
+
+		def createCData_(text)
+			elem = REXML::CData.new(text)
+			return Xml.new elem
+		end
+
+		def toString()
+			return @node.to_s
+		end
+	end
+
+
+	class XmlIterator < Enumerator
+		def initialize(enum)
+			super(enum)
+		end
+		alias enumeratornext next
+		def next
+		    Xml.new self.enumeratornext
+		end
+
+		def hasNext()
+		    begin
+		        self.peek
+		        return true
+		    rescue StopIteration
+		        return false
+			end
+		end
+	end
+end