daff 1.1.2

data/bin/daff.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'daff'
+Daff::Coopy.main

data/lib/daff.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# Translation requires Ruby >= 1.9.3
+ruby_major, ruby_minor, ruby_patch = RUBY_VERSION.split('.').map{|x| x.to_i}
+if ruby_major<1 || (ruby_major==1 && (ruby_minor<9 || (ruby_minor==9 && ruby_patch<3)))
+  $stderr.puts "Your current Ruby version is: #{RUBY_VERSION}. Haxe/Ruby generates code for version 1.9.3 or later."
+  Kernel.exit 1
+end
+
+require 'date'
+require_relative 'lib/hx_overrides'
+require_relative 'lib/lambda'
+require_relative 'lib/list'
+require_relative 'lib/imap'
+require_relative 'lib/reflect'
+require_relative 'lib/string_buf'
+require_relative 'lib/sys'
+require_relative 'lib/value_type'
+require_relative 'lib/type'
+require_relative 'lib/coopy/alignment'
+require_relative 'lib/coopy/bag'
+require_relative 'lib/coopy/cell_info'
+require_relative 'lib/coopy/change'
+require_relative 'lib/coopy/change_type'
+require_relative 'lib/coopy/compare'
+require_relative 'lib/coopy/compare_flags'
+require_relative 'lib/coopy/compare_table'
+require_relative 'lib/coopy/coopy'
+require_relative 'lib/coopy/cross_match'
+require_relative 'lib/coopy/csv'
+require_relative 'lib/coopy/diff_render'
+require_relative 'lib/coopy/row'
+require_relative 'lib/coopy/highlight_patch'
+require_relative 'lib/coopy/highlight_patch_unit'
+require_relative 'lib/coopy/index'
+require_relative 'lib/coopy/index_item'
+require_relative 'lib/coopy/index_pair'
+require_relative 'lib/coopy/mover'
+require_relative 'lib/coopy/ordering'
+require_relative 'lib/coopy/report'
+require_relative 'lib/coopy/simple_cell'
+require_relative 'lib/coopy/table'
+require_relative 'lib/coopy/simple_table'
+require_relative 'lib/coopy/view'
+require_relative 'lib/coopy/simple_view'
+require_relative 'lib/coopy/sparse_sheet'
+require_relative 'lib/coopy/table_comparison_state'
+require_relative 'lib/coopy/table_diff'
+require_relative 'lib/coopy/table_io'
+require_relative 'lib/coopy/table_modifier'
+require_relative 'lib/coopy/table_text'
+require_relative 'lib/coopy/unit'
+require_relative 'lib/coopy/viewed_datum'
+require_relative 'lib/coopy/viterbi'
+require_relative 'lib/coopy/workspace'
+require_relative 'lib/haxe/log'
+require_relative 'lib/haxe/ds/int_map'
+require_relative 'lib/haxe/ds/string_map'
+require_relative 'lib/haxe/format/json_parser'
+require_relative 'lib/haxe/format/json_printer'
+require_relative 'lib/haxe/io/bytes'
+require_relative 'lib/haxe/io/output'
+require_relative 'lib/haxe/io/eof'
+require_relative 'lib/haxe/io/error'
+require_relative 'lib/rb/boot'
+require_relative 'lib/rb/ruby_iterator'
+require_relative 'lib/sys/io/file_handle'
+require_relative 'lib/sys/io/file'
+require_relative 'lib/sys/io/file_output'
+
+
+def _hx_ushr(x,ct) (((x<0) ? (x + 0x100000000) : x) >> ct) end
+def _hx_str(x) (x.nil? ? 'null' : x.to_s) end
+def _hx_add(x,y) (((x.is_a? String)||(y.is_a? String)) ? (_hx_str(x)+_hx_str(y)) : (x+y)) end
+def _hx_ord(s) return 0 if s.nil?; s.ord end
+$hx_exception_classes = {}
+def hx_exception_class(c)
+  $hx_exception_classes[c.name] ||= Class.new(RuntimeError) do
+    Object.const_set((c.name.split(/::/).old_access(-1)||'') + 'HaxeException',self)
+    def initialize(target) @target = target; end
+    def method_missing(name, *args, &block)
+      @target.send(name, *args, &block)
+    end
+  end
+end
+def hx_exception(x)
+  hx_exception_class(x.class).new(x)
+end
+
+
+Daff = Coopy
+if __FILE__ == $0
+	Coopy::Coopy.main
+end

data/lib/lib/coopy/alignment.rb

@@ -0,0 +1,409 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Alignment 
+    
+    def initialize
+      @map_a2b = {}
+      @map_b2a = {}
+      @ha = @hb = 0
+      @map_count = 0
+      @reference = nil
+      @meta = nil
+      @order_cache_has_reference = false
+      @ia = 0
+      @ib = 0
+    end
+    
+    protected
+    
+    attr_accessor :map_a2b
+    attr_accessor :map_b2a
+    attr_accessor :ha
+    attr_accessor :hb
+    attr_accessor :ta
+    attr_accessor :tb
+    attr_accessor :ia
+    attr_accessor :ib
+    attr_accessor :map_count
+    attr_accessor :order_cache
+    attr_accessor :order_cache_has_reference
+    attr_accessor :index_columns
+    
+    public
+    
+    attr_accessor :reference
+    attr_accessor :meta
+    
+    def range(ha,hb)
+      @ha = ha
+      @hb = hb
+    end
+    
+    def tables(ta,tb)
+      @ta = ta
+      @tb = tb
+    end
+    
+    def headers(ia,ib)
+      @ia = ia
+      @ib = ib
+    end
+    
+    def set_rowlike(flag)
+    end
+    
+    def link(a,b)
+      @map_a2b[a] = b
+      @map_b2a[b] = a
+      @map_count+=1
+    end
+    
+    def add_index_columns(unit)
+      @index_columns = Array.new if @index_columns == nil
+      @index_columns.push(unit)
+    end
+    
+    def get_index_columns 
+      return @index_columns
+    end
+    
+    def a2b(a)
+      return @map_a2b[a]
+    end
+    
+    def b2a(b)
+      return @map_b2a[b]
+    end
+    
+    def count 
+      return @map_count
+    end
+    
+    def to_s 
+      return "" + "not implemented yet"
+    end
+    
+    def to_order_pruned(rowlike)
+      return self.to_order_cached(true,rowlike)
+    end
+    
+    def to_order 
+      return self.to_order_cached(false,false)
+    end
+    
+    def get_source 
+      return @ta
+    end
+    
+    def get_target 
+      return @tb
+    end
+    
+    def get_source_header 
+      return @ia
+    end
+    
+    def get_target_header 
+      return @ib
+    end
+    
+    protected
+    
+    def to_order_cached(prune,rowlike)
+      if @order_cache != nil 
+        if @reference != nil 
+          @order_cache = nil if !@order_cache_has_reference
+        end
+      end
+      @order_cache = self.to_order3(prune,rowlike) if @order_cache == nil
+      @order_cache_has_reference = true if @reference != nil
+      return @order_cache
+    end
+    
+    def prune_order(o,ref,rowlike)
+      tl = ref.tb
+      tr = @tb
+      if rowlike 
+        return if tl.get_width != tr.get_width
+      elsif tl.get_height != tr.get_height 
+        return
+      end
+      units = o.get_list
+      left_units = Array.new
+      left_locs = Array.new
+      right_units = Array.new
+      right_locs = Array.new
+      eliminate = Array.new
+      ct = 0
+      begin
+        _g1 = 0
+        _g = units.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          unit = units[i]
+          if unit.l < 0 && unit.r >= 0 
+            right_units.push(unit)
+            right_locs.push(i)
+            ct+=1
+          elsif unit.r < 0 && unit.l >= 0 
+            left_units.push(unit)
+            left_locs.push(i)
+            ct+=1
+          elsif ct > 0 
+            left_units.slice!(0,left_units.length)
+            right_units.slice!(0,right_units.length)
+            left_locs.slice!(0,left_locs.length)
+            right_locs.slice!(0,right_locs.length)
+            ct = 0
+          end
+          while(left_locs.length > 0 && right_locs.length > 0) 
+            l = left_units[0].l
+            r = right_units[0].r
+            view = tl.get_cell_view
+            match = true
+            if rowlike 
+              w = tl.get_width
+              begin
+                _g2 = 0
+                while(_g2 < w) 
+                  j = _g2
+                  _g2+=1
+                  if !view.equals(tl.get_cell(j,l),tr.get_cell(j,r)) 
+                    match = false
+                    break
+                  end
+                end
+              end
+            else 
+              h = tl.get_height
+              begin
+                _g21 = 0
+                while(_g21 < h) 
+                  j1 = _g21
+                  _g21+=1
+                  if !view.equals(tl.get_cell(l,j1),tr.get_cell(r,j1)) 
+                    match = false
+                    break
+                  end
+                end
+              end
+            end
+            if match 
+              eliminate.push(left_locs[0])
+              eliminate.push(right_locs[0])
+            end
+            left_units.shift
+            right_units.shift
+            left_locs.shift
+            right_locs.shift
+            ct -= 2
+          end
+        end
+      end
+      if eliminate.length > 0 
+        eliminate.sort {|a,b|
+          return a - b
+        }
+        del = 0
+        begin
+          _g3 = 0
+          while(_g3 < eliminate.length) 
+            e = eliminate[_g3]
+            _g3+=1
+            begin
+              _this = o.get_list
+              _this.slice!(e - del,1)
+            end
+            del+=1
+          end
+        end
+      end
+    end
+    
+    def to_order3(prune,rowlike)
+      ref = @reference
+      if ref == nil 
+        ref = ::Coopy::Alignment.new
+        ref.range(@ha,@ha)
+        ref.tables(@ta,@ta)
+        begin
+          _g1 = 0
+          _g = @ha
+          while(_g1 < _g) 
+            i = _g1
+            _g1+=1
+            ref.link(i,i)
+          end
+        end
+      end
+      order = ::Coopy::Ordering.new
+      order.ignore_parent if @reference == nil
+      xp = 0
+      xl = 0
+      xr = 0
+      hp = @ha
+      hl = ref.hb
+      hr = @hb
+      vp = {}
+      vl = {}
+      vr = {}
+      begin
+        _g2 = 0
+        while(_g2 < hp) 
+          i1 = _g2
+          _g2+=1
+          vp[i1] = i1
+        end
+      end
+      begin
+        _g3 = 0
+        while(_g3 < hl) 
+          i2 = _g3
+          _g3+=1
+          vl[i2] = i2
+        end
+      end
+      begin
+        _g4 = 0
+        while(_g4 < hr) 
+          i3 = _g4
+          _g4+=1
+          vr[i3] = i3
+        end
+      end
+      ct_vp = hp
+      ct_vl = hl
+      ct_vr = hr
+      prev = -1
+      ct = 0
+      max_ct = (hp + hl + hr) * 10
+      while(ct_vp > 0 || ct_vl > 0 || ct_vr > 0) 
+        ct+=1
+        if ct > max_ct 
+          ::Haxe::Log._trace.call("Ordering took too long, something went wrong",{ file_name: "Alignment.hx", line_number: 241, class_name: "coopy.Alignment", method_name: "toOrder3"})
+          break
+        end
+        xp = 0 if xp >= hp
+        xl = 0 if xl >= hl
+        xr = 0 if xr >= hr
+        if xp < hp && ct_vp > 0 
+          if self.a2b(xp) == nil && ref.a2b(xp) == nil 
+            if vp.include?(xp) 
+              order.add(-1,-1,xp)
+              prev = xp
+              vp.delete(xp)
+              ct_vp-=1
+            end
+            xp+=1
+            next
+          end
+        end
+        zl = nil
+        zr = nil
+        if xl < hl && ct_vl > 0 
+          zl = ref.b2a(xl)
+          if zl == nil 
+            if vl.include?(xl) 
+              order.add(xl,-1,-1)
+              vl.delete(xl)
+              ct_vl-=1
+            end
+            xl+=1
+            next
+          end
+        end
+        if xr < hr && ct_vr > 0 
+          zr = self.b2a(xr)
+          if zr == nil 
+            if vr.include?(xr) 
+              order.add(-1,xr,-1)
+              vr.delete(xr)
+              ct_vr-=1
+            end
+            xr+=1
+            next
+          end
+        end
+        if zl != nil 
+          if self.a2b(zl) == nil 
+            if vl.include?(xl) 
+              order.add(xl,-1,zl)
+              prev = zl
+              vp.delete(zl)
+              ct_vp-=1
+              vl.delete(xl)
+              ct_vl-=1
+              xp = zl + 1
+            end
+            xl+=1
+            next
+          end
+        end
+        if zr != nil 
+          if ref.a2b(zr) == nil 
+            if vr.include?(xr) 
+              order.add(-1,xr,zr)
+              prev = zr
+              vp.delete(zr)
+              ct_vp-=1
+              vr.delete(xr)
+              ct_vr-=1
+              xp = zr + 1
+            end
+            xr+=1
+            next
+          end
+        end
+        if zl != nil && zr != nil && self.a2b(zl) != nil && ref.a2b(zr) != nil 
+          if zl == prev + 1 || zr != prev + 1 
+            if vr.include?(xr) 
+              order.add(ref.a2b(zr),xr,zr)
+              prev = zr
+              vp.delete(zr)
+              ct_vp-=1
+              begin
+                key = ref.a2b(zr)
+                vl.delete(key)
+              end
+              ct_vl-=1
+              vr.delete(xr)
+              ct_vr-=1
+              xp = zr + 1
+              xl = ref.a2b(zr) + 1
+            end
+            xr+=1
+            next
+          else 
+            if vl.include?(xl) 
+              order.add(xl,self.a2b(zl),zl)
+              prev = zl
+              vp.delete(zl)
+              ct_vp-=1
+              vl.delete(xl)
+              ct_vl-=1
+              begin
+                key1 = self.a2b(zl)
+                vr.delete(key1)
+              end
+              ct_vr-=1
+              xp = zl + 1
+              xr = self.a2b(zl) + 1
+            end
+            xl+=1
+            next
+          end
+        end
+        xp+=1
+        xl+=1
+        xr+=1
+      end
+      self.prune_order(order,ref,rowlike) if prune
+      return order
+    end
+    
+  end
+
+end