everypolitician-daff 1.3.26

data/lib/lib/coopy/ndjson.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Ndjson 
+    
+    def initialize(tab)
+      @tab = tab
+      @view = tab.get_cell_view
+      @header_row = 0
+    end
+    
+    protected
+    
+    attr_accessor :tab
+    attr_accessor :view
+    attr_accessor :columns
+    attr_accessor :header_row
+    
+    public
+    
+    def render_row(r)
+      row = {}
+      begin
+        _g1 = 0
+        _g = @tab.get_width
+        while(_g1 < _g) 
+          c = _g1
+          _g1+=1
+          key = @view.to_s(@tab.get_cell(c,@header_row))
+          key = "@:@" if c == 0 && @header_row == 1
+          begin
+            value = @tab.get_cell(c,r)
+            begin
+              value1 = value
+              row[key] = value1
+            end
+          end
+        end
+      end
+      ::Haxe::Format::JsonPrinter._print(row,nil,nil)
+    end
+    
+    def render 
+      txt = ""
+      offset = 0
+      return txt if @tab.get_height == 0
+      return txt if @tab.get_width == 0
+      offset = 1 if @tab.get_cell(0,0) == "@:@"
+      @header_row = offset
+      begin
+        _g1 = @header_row + 1
+        _g = @tab.get_height
+        while(_g1 < _g) 
+          r = _g1
+          _g1+=1
+          txt += self.render_row(r)
+          txt += "\n"
+        end
+      end
+      txt
+    end
+    
+    def add_row(r,txt)
+      json = ::Haxe::Format::JsonParser.new(txt).parse_rec
+      @columns = {} if @columns == nil
+      w = @tab.get_width
+      h = @tab.get_height
+      resize = false
+      begin
+        _g = 0
+        _g1 = Reflect.fields(json)
+        while(_g < _g1.length) 
+          name = _g1[_g]
+          _g+=1
+          if !@columns.include?(name) 
+            @columns[name] = w
+            w+=1
+            resize = true
+          end
+        end
+      end
+      if r >= h 
+        h = r + 1
+        resize = true
+      end
+      @tab.resize(w,h) if resize
+      begin
+        _g2 = 0
+        _g11 = Reflect.fields(json)
+        while(_g2 < _g11.length) 
+          name1 = _g11[_g2]
+          _g2+=1
+          v = Reflect.field(json,name1)
+          c = @columns[name1]
+          @tab.set_cell(c,r,v)
+        end
+      end
+    end
+    
+    def add_header_row(r)
+      names = ::Rb::RubyIterator.new(@columns.keys)
+      _it = names
+      while(_it.has_next) do
+        n = _it._next
+        @tab.set_cell(@columns[n],r,@view.to_datum(n))
+      end
+    end
+    
+    def parse(txt)
+      @columns = nil
+      rows = txt.split("\n")
+      h = rows.length
+      if h == 0 
+        @tab.clear
+        return
+      end
+      h-=1 if rows[h - 1] == ""
+      begin
+        _g = 0
+        while(_g < h) 
+          i = _g
+          _g+=1
+          at = h - i - 1
+          self.add_row(at + 1,rows[at])
+        end
+      end
+      self.add_header_row(0)
+    end
+    
+  haxe_me ["coopy", "Ndjson"]
+  end
+
+end

data/lib/lib/coopy/nested_cell_builder.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class NestedCellBuilder 
+    
+    def initialize
+    end
+    
+    protected
+    
+    attr_accessor :view
+    
+    public
+    
+    def need_separator 
+      false
+    end
+    
+    def set_separator(separator)
+    end
+    
+    def set_conflict_separator(separator)
+    end
+    
+    def set_view(view)
+      @view = view
+    end
+    
+    def update(local,remote)
+      h = @view.make_hash
+      @view.hash_set(h,"before",local)
+      @view.hash_set(h,"after",remote)
+      h
+    end
+    
+    def conflict(parent,local,remote)
+      h = @view.make_hash
+      @view.hash_set(h,"before",parent)
+      @view.hash_set(h,"ours",local)
+      @view.hash_set(h,"theirs",remote)
+      h
+    end
+    
+    def marker(label)
+      @view.to_datum(label)
+    end
+    
+    protected
+    
+    def neg_to_null(x)
+      return nil if x < 0
+      x
+    end
+    
+    public
+    
+    def links(unit,row_like)
+      h = @view.make_hash
+      if unit.p >= -1 
+        @view.hash_set(h,"before",self.neg_to_null(unit.p))
+        @view.hash_set(h,"ours",self.neg_to_null(unit.l))
+        @view.hash_set(h,"theirs",self.neg_to_null(unit.r))
+        return h
+      end
+      @view.hash_set(h,"before",self.neg_to_null(unit.l))
+      @view.hash_set(h,"after",self.neg_to_null(unit.r))
+      h
+    end
+    
+  haxe_me ["coopy", "NestedCellBuilder"]
+  end
+
+end

data/lib/lib/coopy/ordering.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Ordering 
+    
+    def initialize
+      @order = Array.new
+      @ignore_parent = false
+    end
+    
+    protected
+    
+    attr_accessor :order
+    attr_accessor :ignore_parent
+    
+    public
+    
+    def add(l,r,p = -2)
+      p = -2 if @ignore_parent
+      @order.push(::Coopy::Unit.new(l,r,p))
+    end
+    
+    def get_list 
+      @order
+    end
+    
+    def set_list(lst)
+      @order = lst
+    end
+    
+    def to_s 
+      txt = ""
+      begin
+        _g1 = 0
+        _g = @order.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          txt += ", " if i > 0
+          txt += @order[i].to_s
+        end
+      end
+      txt
+    end
+    
+    def ignore_parent 
+      @ignore_parent = true
+    end
+    
+  haxe_me ["coopy", "Ordering"]
+  end
+
+end

data/lib/lib/coopy/property_change.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class PropertyChange 
+    
+    def initialize
+    end
+    
+    attr_accessor :prev_name
+    attr_accessor :name
+    attr_accessor :val
+  haxe_me ["coopy", "PropertyChange"]
+  end
+
+end

data/lib/lib/coopy/row.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Row 
+    def getRowString(c) puts "Abstract Row.getRowString called" end
+    def isPreamble() puts "Abstract Row.isPreamble called" end
+  haxe_me ["coopy", "Row"]
+  end
+
+end

data/lib/lib/coopy/row_change.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class RowChange 
+    
+    def initialize
+    end
+    
+    attr_accessor :cond
+    attr_accessor :val
+    attr_accessor :conflicting_val
+    attr_accessor :conflicting_parent_val
+    attr_accessor :conflicted
+    attr_accessor :is_key
+    attr_accessor :action
+    
+    protected
+    
+    def show_map(m)
+      return "{}" if m == nil
+      txt = ""
+      _it = ::Rb::RubyIterator.new(m.keys)
+      while(_it.has_next) do
+        k = _it._next
+        txt += ", " if txt != ""
+        v = m[k]
+        txt += _hx_str(k) + "=" + _hx_str(v.to_s)
+      end
+      "{ " + _hx_str(txt) + " }"
+    end
+    
+    public
+    
+    def to_s 
+      _hx_str(@action) + " " + _hx_str(self.show_map(@cond)) + " : " + _hx_str(self.show_map(@val))
+    end
+    
+  haxe_me ["coopy", "RowChange"]
+  end
+
+end

data/lib/lib/coopy/row_stream.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class RowStream 
+    def fetchColumns() puts "Abstract RowStream.fetchColumns called" end
+    def fetchRow() puts "Abstract RowStream.fetchRow called" end
+  haxe_me ["coopy", "RowStream"]
+  end
+
+end

data/lib/lib/coopy/simple_meta.rb

@@ -0,0 +1,314 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class SimpleMeta 
+    
+    def initialize(t,has_properties = true,may_be_nested = false)
+      @t = t
+      self.row_change
+      self.col_change
+      @has_properties = has_properties
+      @may_be_nested = may_be_nested
+      @metadata = nil
+      @keys = nil
+      @row_active = false
+      @row_change_cache = nil
+    end
+    
+    protected
+    
+    attr_accessor :t
+    attr_accessor :name2row
+    attr_accessor :name2col
+    attr_accessor :has_properties
+    attr_accessor :metadata
+    attr_accessor :keys
+    attr_accessor :row_active
+    attr_accessor :row_change_cache
+    attr_accessor :may_be_nested
+    
+    public
+    
+    def store_row_changes(changes)
+      @row_change_cache = changes
+      @row_active = true
+    end
+    
+    protected
+    
+    def row_change 
+      @name2row = nil
+    end
+    
+    def col_change 
+      @name2col = nil
+    end
+    
+    def col(key)
+      return -1 if @t.get_height < 1
+      if @name2col == nil 
+        @name2col = {}
+        w = @t.get_width
+        begin
+          _g = 0
+          while(_g < w) 
+            c = _g
+            _g+=1
+            begin
+              key1 = @t.get_cell(c,0)
+              @name2col[key1] = c
+            end
+          end
+        end
+      end
+      return -1 if !@name2col.include?(key)
+      @name2col[key]
+    end
+    
+    def row(key)
+      return -1 if @t.get_width < 1
+      if @name2row == nil 
+        @name2row = {}
+        h = @t.get_height
+        begin
+          _g = 1
+          while(_g < h) 
+            r = _g
+            _g+=1
+            begin
+              key1 = @t.get_cell(0,r)
+              @name2row[key1] = r
+            end
+          end
+        end
+      end
+      return -1 if !@name2row.include?(key)
+      @name2row[key]
+    end
+    
+    public
+    
+    def alter_columns(columns)
+      target = {}
+      wfate = 0
+      if @has_properties 
+        target["@"] = wfate
+        wfate+=1
+      end
+      begin
+        _g1 = 0
+        _g = columns.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          col = columns[i]
+          target[col.prev_name] = wfate if col.prev_name != nil
+          wfate+=1 if col.name != nil
+        end
+      end
+      fate = Array.new
+      begin
+        _g11 = 0
+        _g2 = @t.get_width
+        while(_g11 < _g2) 
+          i1 = _g11
+          _g11+=1
+          targeti = -1
+          name = @t.get_cell(i1,0)
+          targeti = target[name] if target.include?(name)
+          fate.push(targeti)
+        end
+      end
+      @t.insert_or_delete_columns(fate,wfate)
+      start = nil
+      if @has_properties 
+        start = 1
+      else 
+        start = 0
+      end
+      at = start
+      begin
+        _g12 = 0
+        _g3 = columns.length
+        while(_g12 < _g3) 
+          i2 = _g12
+          _g12+=1
+          col1 = columns[i2]
+          if col1.name != nil 
+            @t.set_cell(at,0,col1.name) if col1.name != col1.prev_name
+          end
+          at+=1 if col1.name != nil
+        end
+      end
+      return true if !@has_properties
+      self.col_change
+      at = start
+      begin
+        _g13 = 0
+        _g4 = columns.length
+        while(_g13 < _g4) 
+          i3 = _g13
+          _g13+=1
+          col2 = columns[i3]
+          if col2.name != nil 
+            _g21 = 0
+            _g31 = col2.props
+            while(_g21 < _g31.length) 
+              prop = _g31[_g21]
+              _g21+=1
+              self.set_cell(col2.name,prop.name,prop.val)
+            end
+          end
+          at+=1 if col2.name != nil
+        end
+      end
+      true
+    end
+    
+    protected
+    
+    def set_cell(c,r,val)
+      ri = self.row(r)
+      return false if ri == -1
+      ci = self.col(c)
+      return false if ci == -1
+      @t.set_cell(ci,ri,val)
+      true
+    end
+    
+    public
+    
+    def add_meta_data(column,property,val)
+      if @metadata == nil 
+        @metadata = {}
+        @keys = {}
+      end
+      if !@metadata.include?(column) 
+        value = {}
+        @metadata[column] = value
+      end
+      props = @metadata[column]
+      begin
+        value1 = val
+        begin
+          value2 = value1
+          props[property] = value2
+        end
+      end
+      @keys[property] = true
+    end
+    
+    def as_table 
+      return @t if @has_properties && @metadata == nil
+      return nil if @metadata == nil
+      w = @t.get_width
+      props = Array.new
+      _it = ::Rb::RubyIterator.new(@keys.keys)
+      while(_it.has_next) do
+        k = _it._next
+        props.push(k)
+      end
+      props.sort!{|a,b| Reflect.compare(a,b)}
+      mt = ::Coopy::SimpleTable.new(w + 1,props.length + 1)
+      mt.set_cell(0,0,"@")
+      begin
+        _g = 0
+        while(_g < w) 
+          x = _g
+          _g+=1
+          name = @t.get_cell(x,0)
+          mt.set_cell(1 + x,0,name)
+          next if !@metadata.include?(name)
+          vals = @metadata[name]
+          begin
+            _g2 = 0
+            _g1 = props.length
+            while(_g2 < _g1) 
+              i = _g2
+              _g2+=1
+              mt.set_cell(1 + x,i + 1,vals[props[i]]) if vals.include?(props[i])
+            end
+          end
+        end
+      end
+      begin
+        _g11 = 0
+        _g3 = props.length
+        while(_g11 < _g3) 
+          y = _g11
+          _g11+=1
+          mt.set_cell(0,y + 1,props[y])
+        end
+      end
+      mt
+    end
+    
+    def clone_meta(table = nil)
+      result = ::Coopy::SimpleMeta.new(table)
+      if @metadata != nil 
+        result.keys = {}
+        _it = ::Rb::RubyIterator.new(@keys.keys)
+        while(_it.has_next) do
+          k = _it._next
+          result.keys[k] = true
+        end
+        result.metadata = {}
+        _it2 = ::Rb::RubyIterator.new(@metadata.keys)
+        while(_it2.has_next) do
+          k1 = _it2._next
+          next if !@metadata.include?(k1)
+          vals = @metadata[k1]
+          nvals = {}
+          _it3 = ::Rb::RubyIterator.new(vals.keys)
+          while(_it3.has_next) do
+            p = _it3._next
+            value = vals[p]
+            begin
+              value1 = value
+              nvals[p] = value1
+            end
+          end
+          result.metadata[k1] = nvals
+        end
+      end
+      result
+    end
+    
+    def use_for_column_changes 
+      true
+    end
+    
+    def use_for_row_changes 
+      @row_active
+    end
+    
+    def change_row(rc)
+      @row_change_cache.push(rc)
+      false
+    end
+    
+    def apply_flags(flags)
+      false
+    end
+    
+    def get_row_stream 
+      ::Coopy::TableStream.new(@t)
+    end
+    
+    def is_nested 
+      @may_be_nested
+    end
+    
+    def is_sql 
+      false
+    end
+    
+    def get_name 
+      nil
+    end
+    
+  haxe_me ["coopy", "SimpleMeta"]
+  end
+
+end