wirispluginengine 3.62.0.1322

data/lib/src-generic/Bytes.rb

@@ -0,0 +1,50 @@
+# This class encapsulates the data structure of an array of bytes. Depending
+# on the platform the actual byte array ca be a String, an array of integers,
+# or the best choice everywhere.
+# It is encouraged to use this structure specially for input/output 
+# operations where large byte arrays have to be handled.
+
+module Wiris
+  class Bytes
+    def bytes=(bytes)
+      @bytes=bytes
+    end
+    def bytes
+      @bytes
+    end
+
+    def initialize(bytes)
+      @bytes = bytes
+    end
+
+
+    def self.ofString(s)
+      return Bytes.new(s.force_encoding("ISO-8859-1").bytes.to_a)
+    end
+
+    def self.ofData(data)
+      return Bytes.new(data)
+    end
+
+    def getData()
+      return @bytes
+    end
+
+    def get(index)
+      return @bytes[index]
+    end
+
+    def self.alloc(int)
+      return []
+    end
+
+    def length()
+      return @bytes.length
+    end
+
+    def toString()
+      return @bytes.pack('c*').force_encoding("ISO-8859-1")
+    end
+
+  end
+end

data/lib/src-generic/BytesInput.rb

@@ -0,0 +1,38 @@
+module Wiris
+	class BytesInput
+		def binary()
+			@binary
+		end
+
+		def initialize(bs)
+			@binary = bs.getData().to_enum
+		end
+
+		def readBytes(b, pos, len)
+			return @binary[pos..len]
+		end
+
+		def readByte()
+			byt = @binary.next
+			if byt.nil?
+				return false
+			else
+				return byt
+			end
+		end
+		def readInt32()
+			c1 = readByte
+			c2 = readByte
+			c3 = readByte
+			c4 = readByte
+			return (c1 << 8 | c2) << 16 | (c3 << 8 | c4)
+		end
+
+		def readBytes(bytes, pos, len)
+			for i in 0..len-1
+				bytes[i]=readByte
+			end
+		end
+
+	end
+end

data/lib/src-generic/EReg.rb

@@ -0,0 +1,56 @@
+module Wiris
+	class EReg
+		def regex=(regex)
+			@regex=regex
+		end
+		def regex
+			@regex
+		end
+
+		def match=(match)
+			@match=match
+		end
+		def match
+			@match
+		end
+
+		def initialize(pattern, opts=nil)
+			flags = 0
+			if not opts.nil?
+				for i in 0..opts.length
+					case opts[i]
+					when "i"
+						flags += Regexp::IGNORECASE
+					when "s"
+						flags +=  Regexp::MULTILINE
+					when "m"
+						flags +=  Regexp::MULTILINE
+					end
+				end
+			end
+			@regex = Regexp.new(pattern, flags)
+		end
+
+		def match(str)
+			@match = @regex.match(str)
+			if (@match.nil?)
+				return false
+			else
+				return true
+			end
+		end
+
+		def replace(str, by)
+			@match = @regex.match(str)
+			if @match.nil?
+				return str
+			else
+				return str.gsub(@match.regexp, by)
+			end
+		end
+
+		def matched(n)
+			return @match[n]
+		end
+	end
+end

data/lib/src-generic/File.rb

@@ -0,0 +1,36 @@
+module Wiris
+  class File < ::File
+    def self.saveContent(file, str)
+      out = write(file, true);
+      out.write(str)
+      out.close
+    end
+
+    def self.saveBytes(file, b)
+      File.open(file, 'wb' ) do |output|
+        b.bytes.each do  | byte |
+           output.print byte.chr
+        end
+      end
+    end
+
+    def self.getBytes(file)
+        return Bytes.new(IO.binread(file).unpack("C*"))
+    end
+
+    def self.getContent(file)
+        return File.read(file)
+    end
+
+    def self.write(str, binary) 
+      if (!binary)
+         raise Exception,"Only binary files allowed!"
+       end
+       return File.open(str, 'wb')
+    end
+
+    def self.saveContent(file, str)
+      IO.binwrite(file, str.force_encoding("UTF-8"))
+    end
+  end
+end

data/lib/src-generic/FileLock.rb

@@ -0,0 +1,27 @@
+module Wiris
+    class FileLock
+
+        TIMEOUT= 5000
+        WAIT = 100
+
+        def file
+            @file
+        end
+
+        def initialize(file)
+            @file = file
+        end
+
+        def self.getLock(filename, remaining = 0)
+            # Time in milliseconds
+            starwait = (Time.now.to_f*1000).to_i
+            file = File.new(filename + ".lock", "w+")
+            return FileLock.new(file)
+        end
+
+        def release()
+            file.close
+            File.delete(file)
+        end
+    end
+end

data/lib/src-generic/FileSystem.rb

@@ -0,0 +1,37 @@
+module Wiris
+	class FileSystem
+		def self.readDirectory(folder)
+			return Dir::entries(folder) - ['.'] - ['..']
+		end
+
+		def self.createDirectory(folder)
+			Dir.mkdir(folder)
+		end
+
+		def self.exists(folder)
+			File.exists?(folder)
+		end
+
+		def self.fullPath(path)
+			if !exists(path)
+				return nil
+			end
+			return File::realpath(path)
+		end
+		def self.rename (path, newpath)
+			File::rename(path, newpath)
+			raise Exception, "Unable to rename \""+path+"\" to \""+newpath+"\"."
+		end
+		def self.isDirectory(path)
+			return File.directory?(path)
+		end
+		def self.deleteDirectory(folder)
+			if (Dir.entries(folder) == ['.', '..'])
+				return Dir.delete(folder)
+			end
+		end
+		def self.deleteFile(file)
+			return File.delete(file)
+		end
+	end
+end

data/lib/src-generic/Hash.rb

@@ -0,0 +1,43 @@
+module Wiris
+	class Hash < Hash
+		def javaHashtable=(javaHashtable)
+			@javaHashtable=javaHashtable
+		end
+
+		def javaHashtable
+			@javaHashtable
+		end
+		# private:javaHashtable=
+
+		def initialize(hs=nil)
+			if (hs.nil?)
+				super()
+			end
+			@javaHashtable = hs
+		end
+
+		def get(key)
+			return self[key]
+		end
+		def set(key, value)
+			self[key] = value
+		end
+		alias originalkeysmethod keys
+
+		def keys()
+			return Iterator.new(self.originalkeysmethod().to_enum)
+		end
+
+		def getJavaHashtable()
+			return @javaHashtable
+		end
+
+		def exists(key)
+			self.has_key?(key)
+		end
+
+		def remove(key)
+			self.delete(key)
+		end
+	end
+end

data/lib/src-generic/Http.rb

@@ -0,0 +1,107 @@
+require "net/http"
+require "uri"
+
+module Wiris
+  class Http
+    #
+    #  The server myURL.
+    #
+    #
+    @url
+    @postData
+    @headers
+    @params
+    @connection
+    @@PROXY=nil
+
+
+    def self.PROXY=(proxy)
+      @@PROXY = proxy
+    end
+
+    def self.PROXY
+      @@PROXY
+    end
+
+    def initialize(url)
+      @url = url
+      @headers = Hash.new()
+      @params = Hash.new()
+    end
+
+    def request(post)
+  #     try{
+      serializedParams = formEncode(@params)
+      uri = URI.parse(@url)
+
+      unless @@PROXY.nil?
+        @connection = @@PROXY.start(uri.host, uri.port)
+      else
+        @connection = Net::HTTP.new(uri.host, uri.port)
+      end
+
+      if !post
+        uri.query = serializedParams
+        request = Net::HTTP::Get.new(uri.request_uri)
+      else
+        request = Net::HTTP::Post.new(uri.request_uri)
+        # request.set_form_data(@params)
+        request.body = @postData != nil ? @postData : serializedParams
+
+      end
+
+      keys = @headers.keys()
+      
+      while keys.hasNext()
+        key = keys.next()
+        request.add_field(key, @headers.get(key))
+      end
+
+      response = @connection.request(request)
+
+      onData(response.body)
+    end
+
+     def formEncode(params)
+      i = params.keys()
+      sb = StringBuf.new()
+      first = true;
+      while (i.hasNext())
+         if(!first)
+           sb.add("&");
+         else
+           first = false;
+         end
+        key = i.next();
+        sb.add(StringTools.urlEncode(key));
+        sb.add("=");
+        sb.add(StringTools.urlEncode(params.get(key)));
+      end
+      return sb.toString();
+    end
+
+
+    def setHeader(header, value)
+      @headers.set(header,value)
+    end
+
+  #
+  #  Sets a parameter to be sent in the request. Multiple parameters can be set 
+  #  by making multiple setParameter calls.
+  #
+    def setParameter(param, value)
+      @params.set(param,value);
+    end
+
+   def setPostData(data)
+      @postData = data;
+   end
+
+   def onData(data)
+   end
+
+   def onError(msg)
+   end
+
+  end
+end

data/lib/src-generic/HttpRequest.rb

@@ -0,0 +1,25 @@
+module Wiris
+	class HttpRequest
+		attr_accessor  :params
+
+		def initialize(params)
+			@params = params;
+		end
+
+		def getParameter(key)
+			if (self.params[key].nil?)
+				return nil
+			end
+			return self.params[key]
+		end
+
+		def getContextURL()
+			return nil
+		end
+
+		def getParameterNames
+			return params.keys
+		end
+	end
+end
+

data/lib/src-generic/HttpResponse.rb

@@ -0,0 +1,71 @@
+module Wiris
+	class HttpResponse
+		def actionController
+			@actionController
+		end
+
+		def actionController=(actionController)
+			@actionController=actionController
+		end
+		def res
+			@res
+		end
+		def headers=(headers)
+			@headers = headers
+		end
+
+		def headers
+			@headers
+		end
+
+		def out=(out)
+			@out=out
+		end
+
+		def out
+			@out
+		end
+
+		def writing
+			@writing
+		end
+
+		def writing=(writing)
+			@writing=writing
+		end
+
+		def writeString(s)
+			@writing = true
+			@out = @out + s
+		end
+
+		def writeBinary(data)
+			writeString(data.toString())
+		end
+
+		def initialize(actionController)
+			@closed=false
+			@actionController = actionController
+			@writing=false
+			@out = ""
+			@res = actionController.response
+			@headers = Hash.new()
+		end
+
+		def setHeader(name, value)
+			@headers.set(name, value)
+			@res.headers[name] = value
+		end
+
+		def getHeader(name)
+			return @headers.get(name)
+		end
+
+		def close
+			@res.close
+			if @writing
+				actionController.render :text => @out
+			end
+		end
+	end
+end