everypolitician-daff 1.3.26

data/lib/lib/haxe/format/json_printer.rb

@@ -0,0 +1,240 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Format
+  class JsonPrinter 
+    
+    def initialize(replacer,space)
+      @replacer = replacer
+      @indent = space
+      @pretty = space != nil
+      @nind = 0
+      @buf = StringBuf.new
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :buf
+    attr_accessor :replacer
+    attr_accessor :indent
+    attr_accessor :pretty
+    attr_accessor :nind
+    
+    def write(k,v)
+      v = (@replacer).call(k,v) if @replacer != nil
+      begin
+        _g = Type._typeof(v)
+        case(_g.index)
+        when 8
+          @buf.b += "\"???\"".to_s
+        when 4
+          self.fields_string(v,Reflect.fields(v))
+        when 1
+          v1 = v
+          @buf.b += v1.to_s
+        when 2
+          v2 = nil
+          if lambda{|_this_| f = v
+          _r = f.to_f.finite?}.call(self) 
+            v2 = v
+          else 
+            v2 = "null"
+          end
+          @buf.b += v2.to_s
+        when 5
+          @buf.b += "\"<fun>\"".to_s
+        when 6
+          c = _g.params[0]
+          if c == String 
+            self.quote(v)
+          elsif c == Array 
+            v3 = v
+            @buf.b += [91].pack("U")
+            len = v3.length
+            last = len - 1
+            begin
+              _g1 = 0
+              while(_g1 < len) 
+                i = _g1
+                _g1+=1
+                if i > 0 
+                  @buf.b += [44].pack("U")
+                else 
+                  @nind+=1
+                end
+                @buf.b += [10].pack("U") if @pretty
+                if @pretty 
+                  v4 = nil
+                  begin
+                    c1 = @indent
+                    l = @nind * @indent.length
+                    if c1.length == 0 || "".length >= l 
+                      v4 = ""
+                    else 
+                      v4 = str_pad("",((l - "".length) / c1.length).ceil * c1.length + "".length,c1,__php__.call("STR_PAD_LEFT"))
+                    end
+                  end
+                  @buf.b += v4.to_s
+                end
+                self.write(i,v3[i])
+                if i == last 
+                  @nind-=1
+                  @buf.b += [10].pack("U") if @pretty
+                  if @pretty 
+                    v5 = nil
+                    begin
+                      c2 = @indent
+                      l1 = @nind * @indent.length
+                      if c2.length == 0 || "".length >= l1 
+                        v5 = ""
+                      else 
+                        v5 = str_pad("",((l1 - "".length) / c2.length).ceil * c2.length + "".length,c2,__php__.call("STR_PAD_LEFT"))
+                      end
+                    end
+                    @buf.b += v5.to_s
+                  end
+                end
+              end
+            end
+            @buf.b += [93].pack("U")
+          elsif c == ::Haxe::Ds::StringMap 
+            v6 = v
+            o = { }
+            _it2 = ::Rb::RubyIterator.new(v6.keys)
+            while(_it2.has_next) do
+              k1 = _it2._next
+              value = v6[k1]
+              o[k1] = value
+            end
+            self.fields_string(o,Reflect.fields(o))
+          elsif c == Date 
+            v7 = v
+            self.quote(HxOverrides.date_str(v7))
+          else 
+            self.fields_string(v,Reflect.fields(v))
+          end
+        when 7
+          i1 = nil
+          begin
+            e = v
+            i1 = e.index
+          end
+          begin
+            v8 = i1
+            @buf.b += v8.to_s
+          end
+        when 3
+          v9 = v
+          @buf.b += v9.to_s
+        when 0
+          @buf.b += "null".to_s
+        end
+      end
+    end
+    
+    def fields_string(v,fields)
+      @buf.b += [123].pack("U")
+      len = fields.length
+      last = len - 1
+      first = true
+      begin
+        _g = 0
+        while(_g < len) 
+          i = _g
+          _g+=1
+          f = fields[i]
+          value = Reflect.field(v,f)
+          next if Reflect.is_function(value)
+          if first 
+            @nind+=1
+            first = false
+          else 
+            @buf.b += [44].pack("U")
+          end
+          @buf.b += [10].pack("U") if @pretty
+          if @pretty 
+            v1 = nil
+            begin
+              c = @indent
+              l = @nind * @indent.length
+              if c.length == 0 || "".length >= l 
+                v1 = ""
+              else 
+                v1 = str_pad("",((l - "".length) / c.length).ceil * c.length + "".length,c,__php__.call("STR_PAD_LEFT"))
+              end
+            end
+            @buf.b += v1.to_s
+          end
+          self.quote(f)
+          @buf.b += [58].pack("U")
+          @buf.b += [32].pack("U") if @pretty
+          self.write(f,value)
+          if i == last 
+            @nind-=1
+            @buf.b += [10].pack("U") if @pretty
+            if @pretty 
+              v2 = nil
+              begin
+                c1 = @indent
+                l1 = @nind * @indent.length
+                if c1.length == 0 || "".length >= l1 
+                  v2 = ""
+                else 
+                  v2 = str_pad("",((l1 - "".length) / c1.length).ceil * c1.length + "".length,c1,__php__.call("STR_PAD_LEFT"))
+                end
+              end
+              @buf.b += v2.to_s
+            end
+          end
+        end
+      end
+      @buf.b += [125].pack("U")
+    end
+    
+    def quote(s)
+      @buf.b += [34].pack("U")
+      i = 0
+      while(true) 
+        c = nil
+        begin
+          index = i
+          i+=1
+          c = (s[index] || 0).ord
+        end
+        break if c == 0
+        case(c)
+        when 34
+          @buf.b += "\\\"".to_s
+        when 92
+          @buf.b += "\\\\".to_s
+        when 10
+          @buf.b += "\\n".to_s
+        when 13
+          @buf.b += "\\r".to_s
+        when 9
+          @buf.b += "\\t".to_s
+        when 8
+          @buf.b += "\\b".to_s
+        when 12
+          @buf.b += "\\f".to_s
+        else
+          @buf.b += [c].pack("U")
+        end
+      end
+      @buf.b += [34].pack("U")
+    end
+    
+    public
+    
+    def JsonPrinter._print(o,replacer = nil,space = nil)
+      printer = ::Haxe::Format::JsonPrinter.new(replacer,space)
+      printer.write("",o)
+      printer.buf.b
+    end
+    
+  haxe_me ["haxe", "format", "JsonPrinter"]
+  end
+
+end
+end

data/lib/lib/haxe/imap.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+  class IMap 
+    def get(k) puts "Abstract IMap.get called" end
+  haxe_me ["haxe", "IMap"]
+  end
+
+end

data/lib/lib/haxe/io/bytes.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Bytes 
+    
+    def initialize(length,b)
+      @length = length
+      @b = b
+    end
+    
+    attr_accessor :length
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :b
+    
+    public
+    
+    def get_string(pos,len)
+      raise hx_raise(::Haxe::Io::Error.outside_bounds) if pos < 0 || len < 0 || pos + len > @length
+      @b.byteslice(pos,len)
+    end
+    
+    def Bytes.of_string(s)
+      ::Haxe::Io::Bytes.new(s.bytesize,s)
+    end
+    
+  haxe_me ["haxe", "io", "Bytes"]
+  end
+
+end
+end

data/lib/lib/haxe/io/eof.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Eof 
+    
+    protected
+    
+    def to_s 
+      "Eof"
+    end
+    
+  haxe_me ["haxe", "io", "Eof"]
+  end
+
+end
+end

data/lib/lib/haxe/io/error.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Error
+    ISENUM__ = true
+    attr_accessor :tag
+    attr_accessor :index
+    attr_accessor :params
+    def initialize(t,index,p = nil ) @tag = t; @index = index; @params = p; end
+    
+    def Error.blocked() Error.new("Blocked",0) end
+    def Error.custom(e)  Error.new("Custom",3,[e]) end
+    def Error.outside_bounds() Error.new("OutsideBounds",2) end
+    def Error.overflow() Error.new("Overflow",1) end
+    CONSTRUCTS__ = ["Blocked","Overflow","OutsideBounds","Custom"]
+    def ==(a) (!a.nil?) && (a.respond_to? 'ISENUM__') && a.tag === @tag && a.index === @index && a.params == @params end
+  end
+
+end
+end

data/lib/lib/haxe/io/output.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Output 
+    
+    def write_byte(c)
+      raise hx_raise("Not implemented")
+    end
+    
+    def write_bytes(s,pos,len)
+      k = len
+      b = s.b
+      raise hx_raise(::Haxe::Io::Error.outside_bounds) if pos < 0 || len < 0 || pos + len > s.length
+      while(k > 0) 
+        self.write_byte(b[pos])
+        pos+=1
+        k-=1
+      end
+      len
+    end
+    
+    def write_full_bytes(s,pos,len)
+      while(len > 0) 
+        k = self.write_bytes(s,pos,len)
+        pos += k
+        len -= k
+      end
+    end
+    
+    def write_string(s)
+      b = ::Haxe::Io::Bytes.of_string(s)
+      self.write_full_bytes(b,0,b.length)
+    end
+    
+  haxe_me ["haxe", "io", "Output"]
+  end
+
+end
+end

data/lib/lib/hx_overrides.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class HxOverrides 
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def HxOverrides.date_str(date)
+      m = date.get_month + 1
+      d = date.get_date
+      h = date.get_hours
+      mi = date.get_minutes
+      s = date.get_seconds
+      _hx_str(date.get_full_year) + "-" + _hx_str((((m < 10) ? "0" + _hx_str(m) : "" + _hx_str(m)))) + "-" + _hx_str((((d < 10) ? "0" + _hx_str(d) : "" + _hx_str(d)))) + " " + _hx_str((((h < 10) ? "0" + _hx_str(h) : "" + _hx_str(h)))) + ":" + _hx_str((((mi < 10) ? "0" + _hx_str(mi) : "" + _hx_str(mi)))) + ":" + _hx_str((((s < 10) ? "0" + _hx_str(s) : "" + _hx_str(s))))
+    end
+    
+  haxe_me ["HxOverrides"]
+  end
+

data/lib/lib/hx_sys.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class HxSys 
+    
+    def HxSys.args 
+      ARGV
+    end
+    
+    def HxSys.get_env(s)
+      getenv(s)
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def HxSys.escape_argument(arg)
+      ok = true
+      begin
+        _g1 = 0
+        _g = arg.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          _g2 = (arg[i].ord rescue nil)
+          case(_g2)
+          when 32,34
+            ok = false
+          when 0,13,10
+            arg = arg[0,i]
+          end if _g2 != nil
+        end
+      end
+      return arg if ok
+      "\"" + _hx_str(arg.split("\"").join("\\\"")) + "\""
+    end
+    
+    public
+    
+    def HxSys.command(cmd,args = nil)
+      if args != nil 
+        cmd = HxSys.escape_argument(cmd)
+        begin
+          _g = 0
+          while(_g < args.length) 
+            a = args[_g]
+            _g+=1
+            cmd += " " + _hx_str(HxSys.escape_argument(a))
+          end
+        end
+      end
+      result = nil
+      if system(cmd) 
+        result = 0
+      else 
+        result = 1
+      end
+      result
+    end
+    
+    def HxSys.exit(code)
+      Kernel.exit(code)
+    end
+    
+    def HxSys.stdout 
+      ::Sys::Io::FileOutput.new(STDOUT)
+    end
+    
+    def HxSys.stderr 
+      ::Sys::Io::FileOutput.new(STDERR)
+    end
+    
+  haxe_me ["Sys"]
+  end
+