everypolitician-daff 1.3.26

data/lib/lib/coopy/json_tables.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class JsonTables 
+    
+    def initialize(json,flags)
+      @db = json
+      names = Reflect.field(json,"names")
+      allowed = nil
+      count = names.length
+      if flags != nil && flags.tables != nil 
+        allowed = {}
+        begin
+          _g = 0
+          _g1 = flags.tables
+          while(_g < _g1.length) 
+            name = _g1[_g]
+            _g+=1
+            allowed[name] = true
+          end
+        end
+        count = 0
+        begin
+          _g2 = 0
+          while(_g2 < names.length) 
+            name1 = names[_g2]
+            _g2+=1
+            count+=1 if allowed.include?(name1)
+          end
+        end
+      end
+      @t = ::Coopy::SimpleTable.new(2,count + 1)
+      @t.set_cell(0,0,"name")
+      @t.set_cell(1,0,"table")
+      v = @t.get_cell_view
+      at = 1
+      begin
+        _g3 = 0
+        while(_g3 < names.length) 
+          name2 = names[_g3]
+          _g3+=1
+          if allowed != nil 
+            next if !allowed.include?(name2)
+          end
+          @t.set_cell(0,at,name2)
+          tab = Reflect.field(@db,"tables")
+          tab = Reflect.field(tab,name2)
+          @t.set_cell(1,at,v.wrap_table(::Coopy::JsonTable.new(tab,name2)))
+          at+=1
+        end
+      end
+    end
+    
+    protected
+    
+    attr_accessor :db
+    attr_accessor :t
+    attr_accessor :flags
+    
+    public
+    
+    def height() get_height end
+    def height=(__v) @height = __v end
+    def width() get_width end
+    def width=(__v) @width = __v end
+    
+    def get_cell(x,y)
+      @t.get_cell(x,y)
+    end
+    
+    def set_cell(x,y,c)
+    end
+    
+    def get_cell_view 
+      @t.get_cell_view
+    end
+    
+    def is_resizable 
+      false
+    end
+    
+    def resize(w,h)
+      false
+    end
+    
+    def clear 
+    end
+    
+    def insert_or_delete_rows(fate,hfate)
+      false
+    end
+    
+    def insert_or_delete_columns(fate,wfate)
+      false
+    end
+    
+    def trim_blank 
+      false
+    end
+    
+    def get_width 
+      @t.get_width
+    end
+    
+    def get_height 
+      @t.get_height
+    end
+    
+    def get_data 
+      nil
+    end
+    
+    def clone 
+      nil
+    end
+    
+    def get_meta 
+      ::Coopy::SimpleMeta.new(self,true,true)
+    end
+    
+    def create 
+      nil
+    end
+    
+  haxe_me ["coopy", "JsonTables"]
+  end
+
+end

data/lib/lib/coopy/merger.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Merger 
+    
+    def initialize(parent,local,remote,flags)
+      @parent = parent
+      @local = local
+      @remote = remote
+      @flags = flags
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :parent
+    attr_accessor :local
+    attr_accessor :remote
+    attr_accessor :flags
+    attr_accessor :order
+    attr_accessor :units
+    attr_accessor :column_order
+    attr_accessor :column_units
+    attr_accessor :row_mix_local
+    attr_accessor :row_mix_remote
+    attr_accessor :column_mix_local
+    attr_accessor :column_mix_remote
+    attr_accessor :conflicts
+    attr_accessor :conflict_infos
+    
+    def shuffle_dimension(dim_units,len,fate,cl,cr)
+      at = 0
+      begin
+        _g = 0
+        while(_g < dim_units.length) 
+          cunit = dim_units[_g]
+          _g+=1
+          if cunit.p < 0 
+            if cunit.l < 0 
+              if cunit.r >= 0 
+                begin
+                  cr[cunit.r] = at
+                  at
+                end
+                at+=1
+              end
+            else 
+              begin
+                cl[cunit.l] = at
+                at
+              end
+              at+=1
+            end
+          elsif cunit.l >= 0 
+            if cunit.r < 0 
+            else 
+              begin
+                cl[cunit.l] = at
+                at
+              end
+              at+=1
+            end
+          end
+        end
+      end
+      begin
+        _g1 = 0
+        while(_g1 < len) 
+          x = _g1
+          _g1+=1
+          idx = cl[x]
+          if idx == nil 
+            fate.push(-1)
+          else 
+            fate.push(idx)
+          end
+        end
+      end
+      at
+    end
+    
+    def shuffle_columns 
+      @column_mix_local = {}
+      @column_mix_remote = {}
+      fate = Array.new
+      wfate = self.shuffle_dimension(@column_units,@local.get_width,fate,@column_mix_local,@column_mix_remote)
+      @local.insert_or_delete_columns(fate,wfate)
+    end
+    
+    def shuffle_rows 
+      @row_mix_local = {}
+      @row_mix_remote = {}
+      fate = Array.new
+      hfate = self.shuffle_dimension(@units,@local.get_height,fate,@row_mix_local,@row_mix_remote)
+      @local.insert_or_delete_rows(fate,hfate)
+    end
+    
+    public
+    
+    def apply 
+      @conflicts = 0
+      @conflict_infos = Array.new
+      ct = ::Coopy::Coopy.compare_tables3(@parent,@local,@remote)
+      align = ct.align
+      @order = align.to_order
+      @units = @order.get_list
+      @column_order = align.meta.to_order
+      @column_units = @column_order.get_list
+      allow_insert = @flags.allow_insert
+      allow_delete = @flags.allow_delete
+      allow_update = @flags.allow_update
+      view = @parent.get_cell_view
+      begin
+        _g = 0
+        _g1 = @units
+        while(_g < _g1.length) 
+          row = _g1[_g]
+          _g+=1
+          if row.l >= 0 && row.r >= 0 && row.p >= 0 
+            _g2 = 0
+            _g3 = @column_units
+            while(_g2 < _g3.length) 
+              col = _g3[_g2]
+              _g2+=1
+              if col.l >= 0 && col.r >= 0 && col.p >= 0 
+                pcell = @parent.get_cell(col.p,row.p)
+                rcell = @remote.get_cell(col.r,row.r)
+                if !view.equals(pcell,rcell) 
+                  lcell = @local.get_cell(col.l,row.l)
+                  if view.equals(pcell,lcell) 
+                    @local.set_cell(col.l,row.l,rcell)
+                  else 
+                    @local.set_cell(col.l,row.l,::Coopy::Merger.make_conflicted_cell(view,pcell,lcell,rcell))
+                    @conflicts+=1
+                    self.add_conflict_info(row.l,col.l,view,pcell,lcell,rcell)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      self.shuffle_columns
+      self.shuffle_rows
+      _it = ::Rb::RubyIterator.new(@column_mix_remote.keys)
+      while(_it.has_next) do
+        x = _it._next
+        x2 = @column_mix_remote[x]
+        begin
+          _g4 = 0
+          _g11 = @units
+          while(_g4 < _g11.length) 
+            unit = _g11[_g4]
+            _g4+=1
+            if unit.l >= 0 && unit.r >= 0 
+              @local.set_cell(x2,@row_mix_local[unit.l],@remote.get_cell(x,unit.r))
+            elsif unit.p < 0 && unit.r >= 0 
+              @local.set_cell(x2,@row_mix_remote[unit.r],@remote.get_cell(x,unit.r))
+            end
+          end
+        end
+      end
+      _it2 = ::Rb::RubyIterator.new(@row_mix_remote.keys)
+      while(_it2.has_next) do
+        y = _it2._next
+        y2 = @row_mix_remote[y]
+        begin
+          _g5 = 0
+          _g12 = @column_units
+          while(_g5 < _g12.length) 
+            unit1 = _g12[_g5]
+            _g5+=1
+            @local.set_cell(@column_mix_local[unit1.l],y2,@remote.get_cell(unit1.r,y)) if unit1.l >= 0 && unit1.r >= 0
+          end
+        end
+      end
+      @conflicts
+    end
+    
+    def get_conflict_infos 
+      @conflict_infos
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def add_conflict_info(row,col,view,pcell,lcell,rcell)
+      @conflict_infos.push(::Coopy::ConflictInfo.new(row,col,view.to_s(pcell),view.to_s(lcell),view.to_s(rcell)))
+    end
+    
+    def Merger.make_conflicted_cell(view,pcell,lcell,rcell)
+      view.to_datum("((( " + _hx_str(view.to_s(pcell)) + " ))) " + _hx_str(view.to_s(lcell)) + " /// " + _hx_str(view.to_s(rcell)))
+    end
+    
+  haxe_me ["coopy", "Merger"]
+  end
+
+end

data/lib/lib/coopy/meta.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Meta 
+    def alterColumns(columns) puts "Abstract Meta.alterColumns called" end
+    def changeRow(rc) puts "Abstract Meta.changeRow called" end
+    def applyFlags(flags) puts "Abstract Meta.applyFlags called" end
+    def asTable() puts "Abstract Meta.asTable called" end
+    def cloneMeta(table = nil) puts "Abstract Meta.cloneMeta called" end
+    def useForColumnChanges() puts "Abstract Meta.useForColumnChanges called" end
+    def useForRowChanges() puts "Abstract Meta.useForRowChanges called" end
+    def getRowStream() puts "Abstract Meta.getRowStream called" end
+    def isNested() puts "Abstract Meta.isNested called" end
+    def isSql() puts "Abstract Meta.isSql called" end
+    def getName() puts "Abstract Meta.getName called" end
+  haxe_me ["coopy", "Meta"]
+  end
+
+end

data/lib/lib/coopy/mover.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Mover 
+    
+    def Mover.move_units(units)
+      isrc = Array.new
+      idest = Array.new
+      len = units.length
+      ltop = -1
+      rtop = -1
+      in_src = {}
+      in_dest = {}
+      begin
+        _g = 0
+        while(_g < len) 
+          i = _g
+          _g+=1
+          unit = units[i]
+          if unit.l >= 0 && unit.r >= 0 
+            ltop = unit.l if ltop < unit.l
+            rtop = unit.r if rtop < unit.r
+            begin
+              in_src[unit.l] = i
+              i
+            end
+            begin
+              in_dest[unit.r] = i
+              i
+            end
+          end
+        end
+      end
+      v = nil
+      begin
+        _g1 = 0
+        _g2 = ltop + 1
+        while(_g1 < _g2) 
+          i1 = _g1
+          _g1+=1
+          v = in_src[i1]
+          isrc.push(v) if v != nil
+        end
+      end
+      begin
+        _g11 = 0
+        _g3 = rtop + 1
+        while(_g11 < _g3) 
+          i2 = _g11
+          _g11+=1
+          v = in_dest[i2]
+          idest.push(v) if v != nil
+        end
+      end
+      ::Coopy::Mover.move_without_extras(isrc,idest)
+    end
+    
+    def Mover.move(isrc,idest)
+      len = isrc.length
+      len2 = idest.length
+      in_src = {}
+      in_dest = {}
+      begin
+        _g = 0
+        while(_g < len) 
+          i = _g
+          _g+=1
+          begin
+            in_src[isrc[i]] = i
+            i
+          end
+        end
+      end
+      begin
+        _g1 = 0
+        while(_g1 < len2) 
+          i1 = _g1
+          _g1+=1
+          begin
+            in_dest[idest[i1]] = i1
+            i1
+          end
+        end
+      end
+      src = Array.new
+      dest = Array.new
+      v = nil
+      begin
+        _g2 = 0
+        while(_g2 < len) 
+          i2 = _g2
+          _g2+=1
+          v = isrc[i2]
+          src.push(v) if in_dest.include?(v)
+        end
+      end
+      begin
+        _g3 = 0
+        while(_g3 < len2) 
+          i3 = _g3
+          _g3+=1
+          v = idest[i3]
+          dest.push(v) if in_src.include?(v)
+        end
+      end
+      ::Coopy::Mover.move_without_extras(src,dest)
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def Mover.move_without_extras(src,dest)
+      return nil if src.length != dest.length
+      return [] if src.length <= 1
+      len = src.length
+      in_src = {}
+      blk_len = {}
+      blk_src_loc = {}
+      blk_dest_loc = {}
+      begin
+        _g = 0
+        while(_g < len) 
+          i = _g
+          _g+=1
+          begin
+            in_src[src[i]] = i
+            i
+          end
+        end
+      end
+      ct = 0
+      in_cursor = -2
+      out_cursor = 0
+      _next = nil
+      blk = -1
+      v = nil
+      while(out_cursor < len) 
+        v = dest[out_cursor]
+        _next = in_src[v]
+        if _next != in_cursor + 1 
+          blk = v
+          ct = 1
+          blk_src_loc[blk] = _next
+          blk_dest_loc[blk] = out_cursor
+        else 
+          ct+=1
+        end
+        blk_len[blk] = ct
+        in_cursor = _next
+        out_cursor+=1
+      end
+      blks = Array.new
+      _it = ::Rb::RubyIterator.new(blk_len.keys)
+      while(_it.has_next) do
+        k = _it._next
+        blks.push(k)
+      end
+      blks.sort! {|a,b|
+        diff = blk_len[b] - blk_len[a]
+        diff = a - b if diff == 0
+        diff
+      }
+      moved = Array.new
+      while(blks.length > 0) 
+        blk1 = blks.shift
+        blen = blks.length
+        ref_src_loc = blk_src_loc[blk1]
+        ref_dest_loc = blk_dest_loc[blk1]
+        i1 = blen - 1
+        while(i1 >= 0) 
+          blki = blks[i1]
+          blki_src_loc = blk_src_loc[blki]
+          to_left_src = blki_src_loc < ref_src_loc
+          to_left_dest = blk_dest_loc[blki] < ref_dest_loc
+          if to_left_src != to_left_dest 
+            ct1 = blk_len[blki]
+            begin
+              _g1 = 0
+              while(_g1 < ct1) 
+                j = _g1
+                _g1+=1
+                moved.push(src[blki_src_loc])
+                blki_src_loc+=1
+              end
+            end
+            blks.slice!(i1,1)
+          end
+          i1-=1
+        end
+      end
+      moved
+    end
+    
+  haxe_me ["coopy", "Mover"]
+  end
+
+end