everypolitician-daff 1.3.26

data/lib/lib/coopy/sqlite_helper.rb

@@ -0,0 +1,316 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class SqliteHelper 
+    
+    def initialize
+    end
+    
+    def get_table_names(db)
+      q = "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+      return nil if !db._begin(q,nil,["name"])
+      names = Array.new
+      while(db.read) 
+        names.push(db.get(0))
+      end
+      db._end
+      names
+    end
+    
+    def count_rows(db,name)
+      q = "SELECT COUNT(*) AS ct FROM " + _hx_str(db.get_quoted_table_name(name))
+      return -1 if !db._begin(q,nil,["ct"])
+      ct = -1
+      while(db.read) 
+        ct = db.get(0)
+      end
+      db._end
+      ct
+    end
+    
+    def get_row_ids(db,name)
+      result = Array.new
+      q = "SELECT ROWID AS r FROM " + _hx_str(db.get_quoted_table_name(name)) + " ORDER BY ROWID"
+      return nil if !db._begin(q,nil,["r"])
+      while(db.read) 
+        c = db.get(0)
+        result.push(c)
+      end
+      db._end
+      result
+    end
+    
+    def update(db,name,conds,vals)
+      q = "UPDATE " + _hx_str(db.get_quoted_table_name(name)) + " SET "
+      lst = Array.new
+      _it = ::Rb::RubyIterator.new(vals.keys)
+      while(_it.has_next) do
+        k = _it._next
+        q += ", " if lst.length > 0
+        q += db.get_quoted_column_name(k)
+        q += " = ?"
+        lst.push(vals[k])
+      end
+      val_len = lst.length
+      q += " WHERE "
+      _it2 = ::Rb::RubyIterator.new(conds.keys)
+      while(_it2.has_next) do
+        k1 = _it2._next
+        q += " and " if lst.length > val_len
+        q += db.get_quoted_column_name(k1)
+        q += " IS ?"
+        lst.push(conds[k1])
+      end
+      if !db._begin(q,lst,[]) 
+        puts "Problem with database update"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    def _delete(db,name,conds)
+      q = "DELETE FROM " + _hx_str(db.get_quoted_table_name(name)) + " WHERE "
+      lst = Array.new
+      _it = ::Rb::RubyIterator.new(conds.keys)
+      while(_it.has_next) do
+        k = _it._next
+        q += " and " if lst.length > 0
+        q += db.get_quoted_column_name(k)
+        q += " = ?"
+        lst.push(conds[k])
+      end
+      if !db._begin(q,lst,[]) 
+        puts "Problem with database delete"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    def insert(db,name,vals)
+      q = "INSERT INTO " + _hx_str(db.get_quoted_table_name(name)) + " ("
+      lst = Array.new
+      _it = ::Rb::RubyIterator.new(vals.keys)
+      while(_it.has_next) do
+        k = _it._next
+        q += "," if lst.length > 0
+        q += db.get_quoted_column_name(k)
+        lst.push(vals[k])
+      end
+      q += ") VALUES("
+      need_comma = false
+      _it2 = ::Rb::RubyIterator.new(vals.keys)
+      while(_it2.has_next) do
+        k1 = _it2._next
+        q += "," if need_comma
+        q += "?"
+        need_comma = true
+      end
+      q += ")"
+      if !db._begin(q,lst,[]) 
+        puts "Problem with database insert"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    def attach(db,tag,resource_name)
+      tag_present = false
+      tag_correct = false
+      result = Array.new
+      q = "PRAGMA database_list"
+      return false if !db._begin(q,nil,["seq","name","file"])
+      while(db.read) 
+        name = db.get(1)
+        if name == tag 
+          tag_present = true
+          file = db.get(2)
+          tag_correct = true if file == resource_name
+        end
+      end
+      db._end
+      if tag_present 
+        return true if tag_correct
+        if !db._begin("DETACH `" + _hx_str(tag) + "`",nil,[]) 
+          puts "Failed to detach " + _hx_str(tag)
+          return false
+        end
+        db._end
+      end
+      if !db._begin("ATTACH ? AS `" + _hx_str(tag) + "`",[resource_name],[]) 
+        puts "Failed to attach " + _hx_str(resource_name) + " as " + _hx_str(tag)
+        return false
+      end
+      db._end
+      true
+    end
+    
+    protected
+    
+    def column_list_sql(x)
+      x.join(",")
+    end
+    
+    def fetch_schema(db,name)
+      tname = db.get_quoted_table_name(name)
+      query = "select sql from sqlite_master where name = '" + _hx_str(tname) + "'"
+      if !db._begin(query,nil,["sql"]) 
+        puts "Cannot find schema for table " + _hx_str(tname)
+        return nil
+      end
+      sql = ""
+      sql = db.get(0) if db.read
+      db._end
+      sql
+    end
+    
+    def split_schema(db,name,sql)
+      preamble = ""
+      parts = Array.new
+      double_quote = false
+      single_quote = false
+      token = ""
+      nesting = 0
+      begin
+        _g1 = 0
+        _g = sql.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          ch = sql[i]
+          if double_quote || single_quote 
+            if double_quote 
+              double_quote = false if ch == "\""
+            end
+            if single_quote 
+              single_quote = false if ch == "'"
+            end
+            token += ch
+            next
+          end
+          brk = false
+          if ch == "(" 
+            nesting+=1
+            brk = true if nesting == 1
+          elsif ch == ")" 
+            nesting-=1
+            brk = true if nesting == 0
+          end
+          if ch == "," 
+            brk = true
+            if nesting == 1 
+            end
+          end
+          if brk 
+            token = token[1,token.length] if token[0] == " "
+            if preamble == "" 
+              preamble = token
+            else 
+              parts.push(token)
+            end
+            token = ""
+          else 
+            token += ch
+          end
+        end
+      end
+      cols = db.get_columns(name)
+      name2part = {}
+      name2col = {}
+      begin
+        _g11 = 0
+        _g2 = cols.length
+        while(_g11 < _g2) 
+          i1 = _g11
+          _g11+=1
+          col = cols[i1]
+          name2part[col.name] = parts[i1]
+          name2col[col.name] = cols[i1]
+        end
+      end
+      { preamble: preamble, parts: parts, name2part: name2part, columns: cols, name2column: name2col}
+    end
+    
+    def exec(db,query)
+      if !db._begin(query) 
+        puts "database problem"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    public
+    
+    def alter_columns(db,name,columns)
+      not_blank = lambda {|x|
+        return false if x == nil || x == "" || x == "null"
+        true
+      }
+      sql = self.fetch_schema(db,name)
+      schema = self.split_schema(db,name,sql)
+      parts = schema[:parts]
+      nparts = Array.new
+      new_column_list = Array.new
+      ins_column_list = Array.new
+      sel_column_list = Array.new
+      meta = schema[:columns]
+      begin
+        _g1 = 0
+        _g = columns.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          c = columns[i]
+          if c.name != nil 
+            if c.prev_name != nil 
+              sel_column_list.push(c.prev_name)
+              ins_column_list.push(c.name)
+            end
+            orig_type = ""
+            orig_primary = false
+            if schema[:name2column].include?(c.name) 
+              m = schema[:name2column][c.name]
+              orig_type = m.type_value
+              orig_primary = m.primary
+            end
+            next_type = orig_type
+            next_primary = orig_primary
+            if c.props != nil 
+              _g2 = 0
+              _g3 = c.props
+              while(_g2 < _g3.length) 
+                p = _g3[_g2]
+                _g2+=1
+                next_type = p.val if p.name == "type"
+                next_primary = "" + _hx_str(p.val.to_s) == "primary" if p.name == "key"
+              end
+            end
+            part = "" + _hx_str(c.name)
+            part += " " + _hx_str(next_type) if not_blank.call(next_type)
+            part += " PRIMARY KEY" if next_primary
+            nparts.push(part)
+            new_column_list.push(c.name)
+          end
+        end
+      end
+      return false if !self.exec(db,"BEGIN TRANSACTION")
+      c1 = self.column_list_sql(ins_column_list)
+      tname = db.get_quoted_table_name(name)
+      return false if !self.exec(db,"CREATE TEMPORARY TABLE __coopy_backup(" + _hx_str(c1) + ")")
+      return false if !self.exec(db,"INSERT INTO __coopy_backup (" + _hx_str(c1) + ") SELECT " + _hx_str(c1) + " FROM " + _hx_str(tname))
+      return false if !self.exec(db,"DROP TABLE " + _hx_str(tname))
+      return false if !self.exec(db,_hx_str(schema[:preamble]) + "(" + _hx_str(nparts.join(", ")) + ")")
+      return false if !self.exec(db,"INSERT INTO " + _hx_str(tname) + " (" + _hx_str(c1) + ") SELECT " + _hx_str(c1) + " FROM __coopy_backup")
+      return false if !self.exec(db,"DROP TABLE __coopy_backup")
+      return false if !self.exec(db,"COMMIT")
+      true
+    end
+    
+  haxe_me ["coopy", "SqliteHelper"]
+  end
+
+end

data/lib/lib/coopy/table.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Table 
+    def getCell(x,y) puts "Abstract Table.getCell called" end
+    def setCell(x,y,c) puts "Abstract Table.setCell called" end
+    def getCellView() puts "Abstract Table.getCellView called" end
+    def isResizable() puts "Abstract Table.isResizable called" end
+    def resize(w,h) puts "Abstract Table.resize called" end
+    def clear() puts "Abstract Table.clear called" end
+    def insertOrDeleteRows(fate,hfate) puts "Abstract Table.insertOrDeleteRows called" end
+    def insertOrDeleteColumns(fate,wfate) puts "Abstract Table.insertOrDeleteColumns called" end
+    def trimBlank() puts "Abstract Table.trimBlank called" end
+    def get_width() puts "Abstract Table.get_width called" end
+    def get_height() puts "Abstract Table.get_height called" end
+    def getData() puts "Abstract Table.getData called" end
+    def clone() puts "Abstract Table.clone called" end
+    def create() puts "Abstract Table.create called" end
+    def getMeta() puts "Abstract Table.getMeta called" end
+  haxe_me ["coopy", "Table"]
+  end
+
+end

data/lib/lib/coopy/table_comparison_state.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class TableComparisonState 
+    
+    def initialize
+      self.reset
+    end
+    
+    attr_accessor :p
+    attr_accessor :a
+    attr_accessor :b
+    attr_accessor :completed
+    attr_accessor :run_to_completion
+    attr_accessor :is_equal
+    attr_accessor :is_equal_known
+    attr_accessor :has_same_columns
+    attr_accessor :has_same_columns_known
+    attr_accessor :compare_flags
+    attr_accessor :p_meta
+    attr_accessor :a_meta
+    attr_accessor :b_meta
+    attr_accessor :alignment
+    attr_accessor :children
+    attr_accessor :child_order
+    
+    def reset 
+      @completed = false
+      @run_to_completion = true
+      @is_equal_known = false
+      @is_equal = false
+      @has_same_columns = false
+      @has_same_columns_known = false
+      @compare_flags = nil
+      @alignment = nil
+      @children = nil
+      @child_order = nil
+    end
+    
+    def get_meta 
+      @p_meta = @p.get_meta if @p != nil && @p_meta == nil
+      @a_meta = @a.get_meta if @a != nil && @a_meta == nil
+      @b_meta = @b.get_meta if @b != nil && @b_meta == nil
+    end
+    
+  haxe_me ["coopy", "TableComparisonState"]
+  end
+
+end

data/lib/lib/coopy/table_diff.rb

@@ -0,0 +1,1185 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class TableDiff 
+    
+    def initialize(align,flags)
+      @align = align
+      @flags = flags
+      @builder = nil
+      @preserve_columns = false
+    end
+    
+    protected
+    
+    attr_accessor :align
+    attr_accessor :flags
+    attr_accessor :builder
+    attr_accessor :row_map
+    attr_accessor :col_map
+    attr_accessor :has_parent
+    attr_accessor :a
+    attr_accessor :b
+    attr_accessor :p
+    attr_accessor :rp_header
+    attr_accessor :ra_header
+    attr_accessor :rb_header
+    attr_accessor :is_index_p
+    attr_accessor :is_index_a
+    attr_accessor :is_index_b
+    attr_accessor :order
+    attr_accessor :row_units
+    attr_accessor :column_units
+    attr_accessor :show_rc_numbers
+    attr_accessor :row_moves
+    attr_accessor :col_moves
+    attr_accessor :active_row
+    attr_accessor :active_column
+    attr_accessor :allow_insert
+    attr_accessor :allow_delete
+    attr_accessor :allow_update
+    attr_accessor :v
+    attr_accessor :sep
+    attr_accessor :conflict_sep
+    attr_accessor :schema
+    attr_accessor :have_schema
+    attr_accessor :top_line_done
+    attr_accessor :have_addition
+    attr_accessor :act
+    attr_accessor :publish
+    attr_accessor :diff_found
+    attr_accessor :schema_diff_found
+    attr_accessor :preserve_columns
+    attr_accessor :row_deletes
+    attr_accessor :row_inserts
+    attr_accessor :row_updates
+    attr_accessor :row_reorders
+    attr_accessor :col_deletes
+    attr_accessor :col_inserts
+    attr_accessor :col_updates
+    attr_accessor :col_renames
+    attr_accessor :col_reorders
+    attr_accessor :column_units_updated
+    attr_accessor :nested
+    attr_accessor :nesting_present
+    
+    public
+    
+    def set_cell_builder(builder)
+      @builder = builder
+    end
+    
+    protected
+    
+    def get_separator(t,t2,root)
+      sep = root
+      w = t.get_width
+      h = t.get_height
+      view = t.get_cell_view
+      begin
+        _g = 0
+        while(_g < h) 
+          y = _g
+          _g+=1
+          begin
+            _g1 = 0
+            while(_g1 < w) 
+              x = _g1
+              _g1+=1
+              txt = view.to_s(t.get_cell(x,y))
+              next if txt == nil
+              while((txt.index(sep,nil || 0) || -1) >= 0) 
+                sep = "-" + _hx_str(sep)
+              end
+            end
+          end
+        end
+      end
+      if t2 != nil 
+        w = t2.get_width
+        h = t2.get_height
+        begin
+          _g2 = 0
+          while(_g2 < h) 
+            y1 = _g2
+            _g2+=1
+            begin
+              _g11 = 0
+              while(_g11 < w) 
+                x1 = _g11
+                _g11+=1
+                txt1 = view.to_s(t2.get_cell(x1,y1))
+                next if txt1 == nil
+                while((txt1.index(sep,nil || 0) || -1) >= 0) 
+                  sep = "-" + _hx_str(sep)
+                end
+              end
+            end
+          end
+        end
+      end
+      sep
+    end
+    
+    def quote_for_diff(v,d)
+      _nil = "NULL"
+      return _nil if v.equals(d,nil)
+      str = v.to_s(d)
+      score = 0
+      begin
+        _g1 = 0
+        _g = str.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          break if (str[score].ord rescue nil) != 95
+          score+=1
+        end
+      end
+      str = "_" + _hx_str(str) if str[score..-1] == _nil
+      str
+    end
+    
+    def is_reordered(m,ct)
+      reordered = false
+      l = -1
+      r = -1
+      begin
+        _g = 0
+        while(_g < ct) 
+          i = _g
+          _g+=1
+          unit = m[i]
+          next if unit == nil
+          if unit.l >= 0 
+            if unit.l < l 
+              reordered = true
+              break
+            end
+            l = unit.l
+          end
+          if unit.r >= 0 
+            if unit.r < r 
+              reordered = true
+              break
+            end
+            r = unit.r
+          end
+        end
+      end
+      reordered
+    end
+    
+    def spread_context(units,del,active)
+      if del > 0 && active != nil 
+        mark = -del - 1
+        skips = 0
+        begin
+          _g1 = 0
+          _g = units.length
+          while(_g1 < _g) 
+            i = _g1
+            _g1+=1
+            if active[i] == -3 
+              skips+=1
+              next
+            end
+            if active[i] == 0 || active[i] == 3 
+              if i - mark <= del + skips 
+                active[i] = 2
+              elsif i - mark == del + 1 + skips 
+                active[i] = 3
+              end
+            elsif active[i] == 1 
+              mark = i
+              skips = 0
+            end
+          end
+        end
+        mark = units.length + del + 1
+        skips = 0
+        begin
+          _g11 = 0
+          _g2 = units.length
+          while(_g11 < _g2) 
+            j = _g11
+            _g11+=1
+            i1 = units.length - 1 - j
+            if active[i1] == -3 
+              skips+=1
+              next
+            end
+            if active[i1] == 0 || active[i1] == 3 
+              if mark - i1 <= del + skips 
+                active[i1] = 2
+              elsif mark - i1 == del + 1 + skips 
+                active[i1] = 3
+              end
+            elsif active[i1] == 1 
+              mark = i1
+              skips = 0
+            end
+          end
+        end
+      end
+    end
+    
+    def set_ignore(ignore,idx_ignore,tab,r_header)
+      v = tab.get_cell_view
+      if tab.get_height >= r_header 
+        _g1 = 0
+        _g = tab.get_width
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          name = v.to_s(tab.get_cell(i,r_header))
+          next if !ignore.include?(name)
+          idx_ignore[i] = true
+        end
+      end
+    end
+    
+    def count_active(active)
+      ct = 0
+      showed_dummy = false
+      begin
+        _g1 = 0
+        _g = active.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          publish = active[i] > 0
+          dummy = active[i] == 3
+          next if dummy && showed_dummy
+          next if !publish
+          showed_dummy = dummy
+          ct+=1
+        end
+      end
+      ct
+    end
+    
+    def reset 
+      @has_parent = false
+      @rp_header = @ra_header = @rb_header = 0
+      @is_index_p = {}
+      @is_index_a = {}
+      @is_index_b = {}
+      @row_map = {}
+      @col_map = {}
+      @show_rc_numbers = false
+      @row_moves = nil
+      @col_moves = nil
+      @allow_insert = @allow_delete = @allow_update = true
+      @sep = ""
+      @conflict_sep = ""
+      @top_line_done = false
+      @diff_found = false
+      @schema_diff_found = false
+      @row_deletes = 0
+      @row_inserts = 0
+      @row_updates = 0
+      @row_reorders = 0
+      @col_deletes = 0
+      @col_inserts = 0
+      @col_updates = 0
+      @col_renames = 0
+      @col_reorders = 0
+      @column_units_updated = {}
+    end
+    
+    def setup_tables 
+      @order = @align.to_order
+      @row_units = @order.get_list
+      @has_parent = @align.reference != nil
+      if @has_parent 
+        @p = @align.get_source
+        @a = @align.reference.get_target
+        @b = @align.get_target
+        @rp_header = @align.reference.meta.get_source_header
+        @ra_header = @align.reference.meta.get_target_header
+        @rb_header = @align.meta.get_target_header
+        if @align.get_index_columns != nil 
+          _g = 0
+          _g1 = @align.get_index_columns
+          while(_g < _g1.length) 
+            p2b = _g1[_g]
+            _g+=1
+            @is_index_p[p2b.l] = true if p2b.l >= 0
+            @is_index_b[p2b.r] = true if p2b.r >= 0
+          end
+        end
+        if @align.reference.get_index_columns != nil 
+          _g2 = 0
+          _g11 = @align.reference.get_index_columns
+          while(_g2 < _g11.length) 
+            p2a = _g11[_g2]
+            _g2+=1
+            @is_index_p[p2a.l] = true if p2a.l >= 0
+            @is_index_a[p2a.r] = true if p2a.r >= 0
+          end
+        end
+      else 
+        @a = @align.get_source
+        @b = @align.get_target
+        @p = @a
+        @ra_header = @align.meta.get_source_header
+        @rp_header = @ra_header
+        @rb_header = @align.meta.get_target_header
+        if @align.get_index_columns != nil 
+          _g3 = 0
+          _g12 = @align.get_index_columns
+          while(_g3 < _g12.length) 
+            a2b = _g12[_g3]
+            _g3+=1
+            @is_index_a[a2b.l] = true if a2b.l >= 0
+            @is_index_b[a2b.r] = true if a2b.r >= 0
+          end
+        end
+      end
+      @allow_insert = @flags.allow_insert
+      @allow_delete = @flags.allow_delete
+      @allow_update = @flags.allow_update
+      common = @a
+      common = @b if common == nil
+      common = @p if common == nil
+      @v = common.get_cell_view
+      @builder.set_view(@v)
+      @nested = false
+      meta = common.get_meta
+      @nested = meta.is_nested if meta != nil
+      @nesting_present = false
+    end
+    
+    def scan_activity 
+      @active_row = Array.new
+      @active_column = nil
+      if !@flags.show_unchanged 
+        _g1 = 0
+        _g = @row_units.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          @active_row[@row_units.length - 1 - i] = 0
+        end
+      end
+      if !@flags.show_unchanged_columns 
+        @active_column = Array.new
+        begin
+          _g11 = 0
+          _g2 = @column_units.length
+          while(_g11 < _g2) 
+            i1 = _g11
+            _g11+=1
+            v = 0
+            unit = @column_units[i1]
+            v = 1 if unit.l >= 0 && @is_index_a[unit.l]
+            v = 1 if unit.r >= 0 && @is_index_b[unit.r]
+            v = 1 if unit.p >= 0 && @is_index_p[unit.p]
+            @active_column[i1] = v
+          end
+        end
+      end
+    end
+    
+    def setup_columns 
+      column_order = @align.meta.to_order
+      @column_units = column_order.get_list
+      ignore = @flags.get_ignored_columns
+      if ignore != nil 
+        p_ignore = {}
+        a_ignore = {}
+        b_ignore = {}
+        self.set_ignore(ignore,p_ignore,@p,@rp_header)
+        self.set_ignore(ignore,a_ignore,@a,@ra_header)
+        self.set_ignore(ignore,b_ignore,@b,@rb_header)
+        ncolumn_units = Array.new
+        begin
+          _g1 = 0
+          _g = @column_units.length
+          while(_g1 < _g) 
+            j = _g1
+            _g1+=1
+            cunit = @column_units[j]
+            next if p_ignore.include?(cunit.p) || a_ignore.include?(cunit.l) || b_ignore.include?(cunit.r)
+            ncolumn_units.push(cunit)
+          end
+        end
+        @column_units = ncolumn_units
+      end
+    end
+    
+    def setup_moves 
+      if @flags.ordered 
+        @row_moves = {}
+        moves = ::Coopy::Mover.move_units(@row_units)
+        begin
+          _g1 = 0
+          _g = moves.length
+          while(_g1 < _g) 
+            i = _g1
+            _g1+=1
+            begin
+              @row_moves[moves[i]] = i
+              i
+            end
+          end
+        end
+        @col_moves = {}
+        moves = ::Coopy::Mover.move_units(@column_units)
+        begin
+          _g11 = 0
+          _g2 = moves.length
+          while(_g11 < _g2) 
+            i1 = _g11
+            _g11+=1
+            begin
+              @col_moves[moves[i1]] = i1
+              i1
+            end
+          end
+        end
+      end
+    end
+    
+    def scan_schema 
+      @schema = Array.new
+      @have_schema = false
+      begin
+        _g1 = 0
+        _g = @column_units.length
+        while(_g1 < _g) 
+          j = _g1
+          _g1+=1
+          cunit = @column_units[j]
+          reordered = false
+          if @flags.ordered 
+            reordered = true if @col_moves.include?(j)
+            @show_rc_numbers = true if reordered
+          end
+          act = ""
+          if cunit.r >= 0 && cunit.lp == -1 
+            @have_schema = true
+            act = "+++"
+            if @active_column != nil 
+              @active_column[j] = 1 if @allow_update
+            end
+            @col_inserts+=1 if @allow_update
+          end
+          if cunit.r < 0 && cunit.lp >= 0 
+            @have_schema = true
+            act = "---"
+            if @active_column != nil 
+              @active_column[j] = 1 if @allow_update
+            end
+            @col_deletes+=1 if @allow_update
+          end
+          if cunit.r >= 0 && cunit.lp >= 0 
+            if @p.get_height >= @rp_header && @b.get_height >= @rb_header 
+              pp = @p.get_cell(cunit.lp,@rp_header)
+              bb = @b.get_cell(cunit.r,@rb_header)
+              if !self.is_equal(@v,pp,bb) 
+                @have_schema = true
+                act = "("
+                act += @v.to_s(pp)
+                act += ")"
+                if @active_column != nil 
+                  @active_column[j] = 1
+                  @col_renames+=1
+                end
+              end
+            end
+          end
+          if reordered 
+            act = ":" + _hx_str(act)
+            @have_schema = true
+            @active_column = nil if @active_column != nil
+            @col_reorders+=1
+          end
+          @schema.push(act)
+        end
+      end
+    end
+    
+    def check_rc_numbers(w,h)
+      if !@show_rc_numbers 
+        if @flags.always_show_order 
+          @show_rc_numbers = true
+        elsif @flags.ordered 
+          @show_rc_numbers = self.is_reordered(@row_map,h)
+          @show_rc_numbers = self.is_reordered(@col_map,w) if !@show_rc_numbers
+        end
+      end
+    end
+    
+    def add_rc_numbers(output)
+      admin_w = 1
+      if @show_rc_numbers && !@flags.never_show_order 
+        admin_w+=1
+        target = Array.new
+        begin
+          _g1 = 0
+          _g = output.get_width
+          while(_g1 < _g) 
+            i = _g1
+            _g1+=1
+            target.push(i + 1)
+          end
+        end
+        output.insert_or_delete_columns(target,output.get_width + 1)
+        begin
+          _g11 = 0
+          _g2 = output.get_height
+          while(_g11 < _g2) 
+            i1 = _g11
+            _g11+=1
+            unit = @row_map[i1]
+            if unit == nil 
+              output.set_cell(0,i1,"")
+              next
+            end
+            output.set_cell(0,i1,@builder.links(unit,true))
+          end
+        end
+        target = Array.new
+        begin
+          _g12 = 0
+          _g3 = output.get_height
+          while(_g12 < _g3) 
+            i2 = _g12
+            _g12+=1
+            target.push(i2 + 1)
+          end
+        end
+        output.insert_or_delete_rows(target,output.get_height + 1)
+        begin
+          _g13 = 1
+          _g4 = output.get_width
+          while(_g13 < _g4) 
+            i3 = _g13
+            _g13+=1
+            unit1 = @col_map[i3 - 1]
+            if unit1 == nil 
+              output.set_cell(i3,0,"")
+              next
+            end
+            output.set_cell(i3,0,@builder.links(unit1,false))
+          end
+        end
+        output.set_cell(0,0,@builder.marker("@:@"))
+      end
+      admin_w
+    end
+    
+    def elide_columns(output,admin_w)
+      if @active_column != nil 
+        all_active = true
+        begin
+          _g1 = 0
+          _g = @active_column.length
+          while(_g1 < _g) 
+            i = _g1
+            _g1+=1
+            if @active_column[i] == 0 
+              all_active = false
+              break
+            end
+          end
+        end
+        if !all_active 
+          fate = Array.new
+          begin
+            _g2 = 0
+            while(_g2 < admin_w) 
+              i1 = _g2
+              _g2+=1
+              fate.push(i1)
+            end
+          end
+          at = admin_w
+          ct = 0
+          dots = Array.new
+          begin
+            _g11 = 0
+            _g3 = @active_column.length
+            while(_g11 < _g3) 
+              i2 = _g11
+              _g11+=1
+              off = @active_column[i2] == 0
+              if off 
+                ct = ct + 1
+              else 
+                ct = 0
+              end
+              if off && ct > 1 
+                fate.push(-1)
+              else 
+                dots.push(at) if off
+                fate.push(at)
+                at+=1
+              end
+            end
+          end
+          output.insert_or_delete_columns(fate,at)
+          begin
+            _g4 = 0
+            while(_g4 < dots.length) 
+              d = dots[_g4]
+              _g4+=1
+              begin
+                _g21 = 0
+                _g12 = output.get_height
+                while(_g21 < _g12) 
+                  j = _g21
+                  _g21+=1
+                  output.set_cell(d,j,@builder.marker("..."))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    def add_schema(output)
+      if @have_schema 
+        at = output.get_height
+        output.resize(@column_units.length + 1,at + 1)
+        output.set_cell(0,at,@builder.marker("!"))
+        begin
+          _g1 = 0
+          _g = @column_units.length
+          while(_g1 < _g) 
+            j = _g1
+            _g1+=1
+            output.set_cell(j + 1,at,@v.to_datum(@schema[j]))
+          end
+        end
+        @schema_diff_found = true
+      end
+    end
+    
+    def add_header(output)
+      if @flags.always_show_header 
+        at = output.get_height
+        output.resize(@column_units.length + 1,at + 1)
+        output.set_cell(0,at,@builder.marker("@@"))
+        begin
+          _g1 = 0
+          _g = @column_units.length
+          while(_g1 < _g) 
+            j = _g1
+            _g1+=1
+            cunit = @column_units[j]
+            if cunit.r >= 0 
+              output.set_cell(j + 1,at,@b.get_cell(cunit.r,@rb_header)) if @b.get_height != 0
+            elsif cunit.l >= 0 
+              output.set_cell(j + 1,at,@a.get_cell(cunit.l,@ra_header)) if @a.get_height != 0
+            elsif cunit.lp >= 0 
+              output.set_cell(j + 1,at,@p.get_cell(cunit.lp,@rp_header)) if @p.get_height != 0
+            end
+            @col_map[j + 1] = cunit
+          end
+        end
+        @top_line_done = true
+      end
+    end
+    
+    def check_meta(t,meta)
+      return false if meta.get_width != t.get_width + 1
+      return false if meta.get_width == 0 || meta.get_height == 0
+      true
+    end
+    
+    def get_meta_table(t)
+      return nil if t == nil
+      meta = t.get_meta
+      return nil if meta == nil
+      meta.as_table
+    end
+    
+    def add_meta(output)
+      a_meta = nil
+      b_meta = nil
+      p_meta = nil
+      a_meta = self.get_meta_table(@a)
+      b_meta = self.get_meta_table(@b)
+      p_meta = self.get_meta_table(@p)
+      return false if a_meta == nil || b_meta == nil || p_meta == nil
+      return false if !self.check_meta(@a,a_meta)
+      return false if !self.check_meta(@b,b_meta)
+      return false if !self.check_meta(@p,p_meta)
+      return false if !@flags.show_meta
+      meta_diff = ::Coopy::SimpleTable.new(0,0)
+      meta_flags = ::Coopy::CompareFlags.new
+      meta_flags.add_primary_key("@@")
+      meta_flags.add_primary_key("@")
+      meta_flags.unchanged_column_context = 65536
+      meta_flags.unchanged_context = 0
+      meta_align = ::Coopy::Coopy.compare_tables3(((a_meta == p_meta) ? nil : p_meta),a_meta,b_meta,meta_flags).align
+      td = ::Coopy::TableDiff.new(meta_align,meta_flags)
+      td.preserve_columns = true
+      td.hilite(meta_diff)
+      if td.has_difference 
+        h = output.get_height
+        dh = meta_diff.get_height
+        offset = nil
+        if td.has_schema_difference 
+          offset = 2
+        else 
+          offset = 1
+        end
+        output.resize(output.get_width,h + dh - offset)
+        v = meta_diff.get_cell_view
+        begin
+          _g = offset
+          while(_g < dh) 
+            y = _g
+            _g+=1
+            begin
+              _g2 = 1
+              _g1 = meta_diff.get_width
+              while(_g2 < _g1) 
+                x = _g2
+                _g2+=1
+                c = meta_diff.get_cell(x,y)
+                c = "@" + _hx_str(v.to_s(c)) + "@" + _hx_str(v.to_s(meta_diff.get_cell(0,y))) if x == 1
+                output.set_cell(x - 1,h + y - offset,c)
+              end
+            end
+          end
+        end
+        if @active_column != nil 
+          if td.active_column.length == meta_diff.get_width 
+            _g11 = 1
+            _g3 = meta_diff.get_width
+            while(_g11 < _g3) 
+              i = _g11
+              _g11+=1
+              @active_column[i - 1] = 1 if td.active_column[i] >= 0
+            end
+          end
+        end
+      end
+      false
+    end
+    
+    def refine_activity 
+      self.spread_context(@row_units,@flags.unchanged_context,@active_row)
+      self.spread_context(@column_units,@flags.unchanged_column_context,@active_column)
+      if @active_column != nil 
+        _g1 = 0
+        _g = @column_units.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          @active_column[i] = 0 if @active_column[i] == 3
+        end
+      end
+    end
+    
+    def normalize_string(v,str)
+      return str if str == nil
+      return str if !(@flags.ignore_whitespace || @flags.ignore_case)
+      txt = v.to_s(str)
+      txt = txt.strip if @flags.ignore_whitespace
+      txt = txt.downcase if @flags.ignore_case
+      txt
+    end
+    
+    def is_equal(v,aa,bb)
+      return self.normalize_string(v,aa) == self.normalize_string(v,bb) if @flags.ignore_whitespace || @flags.ignore_case
+      v.equals(aa,bb)
+    end
+    
+    def check_nesting(v,have_ll,ll,have_rr,rr,have_pp,pp,x,y)
+      all_tables = true
+      all_tables = all_tables && v.is_table(ll) if have_ll
+      all_tables = all_tables && v.is_table(rr) if have_rr
+      all_tables = all_tables && v.is_table(pp) if have_pp
+      return [ll,rr,pp] if !all_tables
+      ll_table = nil
+      rr_table = nil
+      pp_table = nil
+      ll_table = v.get_table(ll) if have_ll
+      rr_table = v.get_table(rr) if have_rr
+      pp_table = v.get_table(pp) if have_pp
+      compare = false
+      comp = ::Coopy::TableComparisonState.new
+      comp.a = ll_table
+      comp.b = rr_table
+      comp.p = pp_table
+      comp.compare_flags = @flags
+      comp.get_meta
+      key = nil
+      key = comp.a_meta.get_name if comp.a_meta != nil
+      key = comp.b_meta.get_name if key == nil && comp.b_meta != nil
+      key = _hx_str(x) + "_" + _hx_str(y) if key == nil
+      if @align.comp != nil 
+        if @align.comp.children == nil 
+          @align.comp.children = {}
+          @align.comp.child_order = Array.new
+          compare = true
+        else 
+          compare = !@align.comp.children.include?(key)
+        end
+      end
+      if compare 
+        @nesting_present = true
+        @align.comp.children[key] = comp
+        @align.comp.child_order.push(key)
+        ct = ::Coopy::CompareTable.new(comp)
+        ct.align
+      else 
+        comp = @align.comp.children[key]
+      end
+      ll_out = nil
+      rr_out = nil
+      pp_out = nil
+      if comp.alignment.is_marked_as_identical || have_ll && !have_rr || have_rr && !have_ll 
+        ll_out = "[" + _hx_str(key) + "]"
+        rr_out = ll_out
+        pp_out = ll_out
+      else 
+        ll_out = "[a." + _hx_str(key) + "]" if ll != nil
+        rr_out = "[b." + _hx_str(key) + "]" if rr != nil
+        pp_out = "[p." + _hx_str(key) + "]" if pp != nil
+      end
+      [ll_out,rr_out,pp_out]
+    end
+    
+    def scan_row(unit,output,at,i,out)
+      row_update = false
+      begin
+        _g1 = 0
+        _g = @column_units.length
+        while(_g1 < _g) 
+          j = _g1
+          _g1+=1
+          cunit = @column_units[j]
+          pp = nil
+          ll = nil
+          rr = nil
+          dd = nil
+          dd_to = nil
+          have_dd_to = false
+          dd_to_alt = nil
+          have_dd_to_alt = false
+          have_pp = false
+          have_ll = false
+          have_rr = false
+          if cunit.p >= 0 && unit.p >= 0 
+            pp = @p.get_cell(cunit.p,unit.p)
+            have_pp = true
+          end
+          if cunit.l >= 0 && unit.l >= 0 
+            ll = @a.get_cell(cunit.l,unit.l)
+            have_ll = true
+          end
+          if cunit.r >= 0 && unit.r >= 0 
+            rr = @b.get_cell(cunit.r,unit.r)
+            have_rr = true
+            if (((have_pp) ? cunit.p : cunit.l)) < 0 
+              if rr != nil 
+                if @v.to_s(rr) != "" 
+                  @have_addition = true if @flags.allow_update
+                end
+              end
+            end
+          end
+          if @nested 
+            ndiff = self.check_nesting(@v,have_ll,ll,have_rr,rr,have_pp,pp,i,j)
+            ll = ndiff[0]
+            rr = ndiff[1]
+            pp = ndiff[2]
+          end
+          if have_pp 
+            if !have_rr 
+              dd = pp
+            elsif self.is_equal(@v,pp,rr) 
+              dd = ll
+            else 
+              dd = pp
+              dd_to = rr
+              have_dd_to = true
+              if !self.is_equal(@v,pp,ll) 
+                if !self.is_equal(@v,pp,rr) 
+                  dd_to_alt = ll
+                  have_dd_to_alt = true
+                end
+              end
+            end
+          elsif have_ll 
+            if !have_rr 
+              dd = ll
+            elsif self.is_equal(@v,ll,rr) 
+              dd = ll
+            else 
+              dd = ll
+              dd_to = rr
+              have_dd_to = true
+            end
+          else 
+            dd = rr
+          end
+          cell = dd
+          if have_dd_to && @allow_update 
+            if !row_update 
+              @row_updates+=1 if out == 0
+              row_update = true
+            end
+            @active_column[j] = 1 if @active_column != nil
+            if @sep == "" 
+              if @builder.need_separator 
+                @sep = self.get_separator(@a,@b,"->")
+                @builder.set_separator(@sep)
+              else 
+                @sep = "->"
+              end
+            end
+            is_conflict = false
+            if have_dd_to_alt 
+              is_conflict = true if !self.is_equal(@v,dd_to,dd_to_alt)
+            end
+            if !is_conflict 
+              cell = @builder.update(dd,dd_to)
+              @act = @sep if @sep.length > @act.length
+            else 
+              if @conflict_sep == "" 
+                if @builder.need_separator 
+                  @conflict_sep = _hx_str(self.get_separator(@p,@a,"!")) + _hx_str(@sep)
+                  @builder.set_conflict_separator(@conflict_sep)
+                else 
+                  @conflict_sep = "!->"
+                end
+              end
+              cell = @builder.conflict(dd,dd_to_alt,dd_to)
+              @act = @conflict_sep
+            end
+            if !@column_units_updated.include?(j) 
+              @column_units_updated[j] = true
+              @col_updates+=1
+            end
+          end
+          @act = "+" if @act == "" && @have_addition
+          if @act == "+++" 
+            if have_rr 
+              @active_column[j] = 1 if @active_column != nil
+            end
+          end
+          if @publish 
+            output.set_cell(j + 1,at,cell) if @active_column == nil || @active_column[j] > 0
+          end
+        end
+      end
+      if @publish 
+        output.set_cell(0,at,@builder.marker(@act))
+        @row_map[at] = unit
+      end
+      if @act != "" 
+        @diff_found = true
+        if !@publish 
+          @active_row[i] = 1 if @active_row != nil
+        end
+      end
+    end
+    
+    public
+    
+    def hilite(output)
+      output = ::Coopy::Coopy.tablify(output)
+      self.hilite_single(output)
+    end
+    
+    protected
+    
+    def hilite_single(output)
+      return false if !output.is_resizable
+      if @builder == nil 
+        if @flags.allow_nested_cells 
+          @builder = ::Coopy::NestedCellBuilder.new
+        else 
+          @builder = ::Coopy::FlatCellBuilder.new(@flags)
+        end
+      end
+      output.resize(0,0)
+      output.clear
+      self.reset
+      self.setup_tables
+      self.setup_columns
+      self.setup_moves
+      self.scan_activity
+      self.scan_schema
+      self.add_schema(output)
+      self.add_header(output)
+      self.add_meta(output)
+      outer_reps_needed = nil
+      if @flags.show_unchanged && @flags.show_unchanged_columns 
+        outer_reps_needed = 1
+      else 
+        outer_reps_needed = 2
+      end
+      output_height = output.get_height
+      output_height_init = output.get_height
+      begin
+        _g = 0
+        while(_g < outer_reps_needed) 
+          out = _g
+          _g+=1
+          if out == 1 
+            self.refine_activity
+            rows = self.count_active(@active_row) + output_height_init
+            rows-=1 if @top_line_done
+            output_height = output_height_init
+            output.resize(@column_units.length + 1,rows) if rows > output.get_height
+          end
+          showed_dummy = false
+          l = -1
+          r = -1
+          begin
+            _g2 = 0
+            _g1 = @row_units.length
+            while(_g2 < _g1) 
+              i = _g2
+              _g2+=1
+              unit = @row_units[i]
+              reordered = false
+              if @flags.ordered 
+                reordered = true if @row_moves.include?(i)
+                @show_rc_numbers = true if reordered
+              end
+              next if unit.r < 0 && unit.l < 0
+              next if unit.r == 0 && unit.lp <= 0 && @top_line_done
+              @publish = @flags.show_unchanged
+              dummy = false
+              if out == 1 
+                value = @active_row[i]
+                @publish = value != nil && value > 0
+                dummy = value != nil && value == 3
+                next if dummy && showed_dummy
+                next if !@publish
+              end
+              showed_dummy = false if !dummy
+              at = output_height
+              if @publish 
+                output_height+=1
+                output.resize(@column_units.length + 1,output_height) if output.get_height < output_height
+              end
+              if dummy 
+                begin
+                  _g4 = 0
+                  _g3 = @column_units.length + 1
+                  while(_g4 < _g3) 
+                    j = _g4
+                    _g4+=1
+                    output.set_cell(j,at,@v.to_datum("..."))
+                  end
+                end
+                showed_dummy = true
+                next
+              end
+              @have_addition = false
+              skip = false
+              @act = ""
+              if reordered 
+                @act = ":"
+                @row_reorders+=1 if out == 0
+              end
+              if unit.p < 0 && unit.l < 0 && unit.r >= 0 
+                skip = true if !@allow_insert
+                @act = "+++"
+                @row_inserts+=1 if out == 0 && !skip
+              end
+              if (unit.p >= 0 || !@has_parent) && unit.l >= 0 && unit.r < 0 
+                skip = true if !@allow_delete
+                @act = "---"
+                @row_deletes+=1 if out == 0 && !skip
+              end
+              if skip 
+                if !@publish 
+                  @active_row[i] = -3 if @active_row != nil
+                end
+                next
+              end
+              self.scan_row(unit,output,at,i,out)
+            end
+          end
+        end
+      end
+      self.check_rc_numbers(output.get_width,output.get_height)
+      admin_w = self.add_rc_numbers(output)
+      self.elide_columns(output,admin_w) if !@preserve_columns
+      true
+    end
+    
+    public
+    
+    def hilite_with_nesting(output)
+      base = output.add("base")
+      result = self.hilite_single(base)
+      return false if !result
+      return true if @align.comp == nil
+      order = @align.comp.child_order
+      return true if order == nil
+      output.alignment = @align
+      begin
+        _g = 0
+        while(_g < order.length) 
+          name = order[_g]
+          _g+=1
+          child = @align.comp.children[name]
+          alignment = child.alignment
+          if alignment.is_marked_as_identical 
+            @align.comp.children[name] = nil
+            next
+          end
+          td = ::Coopy::TableDiff.new(alignment,@flags)
+          child_output = output.add(name)
+          result = result && td.hilite_single(child_output)
+        end
+      end
+      result
+    end
+    
+    def has_difference 
+      @diff_found
+    end
+    
+    def has_schema_difference 
+      @schema_diff_found
+    end
+    
+    def is_nested 
+      @nesting_present
+    end
+    
+    def get_comparison_state 
+      return nil if @align == nil
+      @align.comp
+    end
+    
+    def get_summary 
+      ds = ::Coopy::DiffSummary.new
+      ds.row_deletes = @row_deletes
+      ds.row_inserts = @row_inserts
+      ds.row_updates = @row_updates
+      ds.row_reorders = @row_reorders
+      ds.col_deletes = @col_deletes
+      ds.col_inserts = @col_inserts
+      ds.col_updates = @col_updates
+      ds.col_renames = @col_renames
+      ds.col_reorders = @col_reorders
+      ds.row_count_initial_with_header = @align.get_source.get_height
+      ds.row_count_final_with_header = @align.get_target.get_height
+      ds.row_count_initial = @align.get_source.get_height - @align.get_source_header - 1
+      ds.row_count_final = @align.get_target.get_height - @align.get_target_header - 1
+      ds.col_count_initial = @align.get_source.get_width
+      ds.col_count_final = @align.get_target.get_width
+      ds
+    end
+    
+  haxe_me ["coopy", "TableDiff"]
+  end
+
+end