daff 1.3.2 → 1.3.6

data/lib/lib/coopy/sql_table.rb

@@ -210,6 +210,10 @@ module Coopy
       nil
     end
     
+    def create 
+      nil
+    end
+    
     def get_meta 
       self
     end
@@ -242,7 +246,7 @@ module Coopy
       mt = ::Coopy::SimpleTable.new(w + 1,pct)
       mt.set_cell(0,0,"@")
       mt.set_cell(0,1,"type")
-      mt.set_cell(0,2,"pkey")
+      mt.set_cell(0,2,"key")
       begin
         _g = 0
         while(_g < w) 
@@ -251,7 +255,7 @@ module Coopy
           i = x + 1
           mt.set_cell(i,0,@column_names[x])
           mt.set_cell(i,1,@columns[x].type_value)
-          mt.set_cell(i,2,((@columns[x].primary) ? 1 : 0))
+          mt.set_cell(i,2,((@columns[x].primary) ? "primary" : ""))
         end
       end
       mt
@@ -283,6 +287,14 @@ module Coopy
       self
     end
     
+    def is_nested 
+      false
+    end
+    
+    def is_sql 
+      true
+    end
+    
     def fetch_row 
       if @db.read 
         row = {}
@@ -313,6 +325,10 @@ module Coopy
       @column_names
     end
     
+    def get_name 
+      @name.to_s
+    end
+    
   haxe_me ["coopy", "SqlTable"]
   end
 

data/lib/lib/coopy/sql_tables.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class SqlTables 
+    
+    def initialize(db,flags)
+      @db = db
+      helper = @db.get_helper
+      names = helper.get_table_names(db)
+      allowed = nil
+      count = names.length
+      if 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)
+          @t.set_cell(1,at,v.wrap_table(::Coopy::SqlTable.new(db,::Coopy::SqlTableName.new(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 create 
+      nil
+    end
+    
+    def get_meta 
+      ::Coopy::SimpleMeta.new(self,true,true)
+    end
+    
+  haxe_me ["coopy", "SqlTables"]
+  end
+
+end

data/lib/lib/coopy/sqlite_helper.rb

@@ -118,6 +118,28 @@ module Coopy
     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
@@ -264,7 +286,7 @@ module Coopy
                 p = _g3[_g2]
                 _g2+=1
                 next_type = p.val if p.name == "type"
-                next_primary = "" + _hx_str(p.val.to_s) == "1" if p.name == "pkey"
+                next_primary = "" + _hx_str(p.val.to_s) == "primary" if p.name == "key"
               end
             end
             part = "" + _hx_str(c.name)

data/lib/lib/coopy/table.rb

@@ -16,6 +16,7 @@ module Coopy
     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

data/lib/lib/coopy/table_comparison_state.rb

@@ -18,6 +18,12 @@ module Coopy
     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
@@ -27,6 +33,15 @@ module Coopy
       @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"]

data/lib/lib/coopy/table_diff.rb

@@ -51,6 +51,8 @@ module Coopy
     attr_accessor :diff_found
     attr_accessor :schema_diff_found
     attr_accessor :preserve_columns
+    attr_accessor :nested
+    attr_accessor :nesting_present
     
     public
     
@@ -319,8 +321,15 @@ module Coopy
       @allow_insert = @flags.allow_insert
       @allow_delete = @flags.allow_delete
       @allow_update = @flags.allow_update
-      @v = @a.get_cell_view
+      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 
@@ -448,7 +457,7 @@ module Coopy
             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 !@v.equals(pp,bb) 
+              if !self.is_equal(@v,pp,bb) 
                 @have_schema = true
                 act = "("
                 act += @v.to_s(pp)
@@ -658,6 +667,7 @@ module Coopy
     end
     
     def get_meta_table(t)
+      return nil if t == nil
       meta = t.get_meta
       return nil if meta == nil
       meta.as_table
@@ -743,13 +753,76 @@ module Coopy
       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 lambda{|_this_| s = v.to_s(aa)
-      _r = s.strip}.call(self) == lambda{|_this_| s1 = v.to_s(bb)
-      _r2 = s1.strip}.call(self) if @flags.ignore_whitespace
+      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)
       begin
         _g1 = 0
@@ -788,6 +861,12 @@ module Coopy
               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
@@ -986,6 +1065,33 @@ module Coopy
       true
     end
     
+    def hilite_with_nesting(output)
+      base = output.add("base")
+      result = self.hilite(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(child_output)
+        end
+      end
+      result
+    end
+    
     def has_difference 
       @diff_found
     end
@@ -994,6 +1100,10 @@ module Coopy
       @schema_diff_found
     end
     
+    def is_nested 
+      @nesting_present
+    end
+    
   haxe_me ["coopy", "TableDiff"]
   end
 

data/lib/lib/coopy/tables.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Tables 
+    
+    def initialize(template)
+      @template = template
+      @tables = {}
+      @table_order = Array.new
+    end
+    
+    protected
+    
+    attr_accessor :template
+    attr_accessor :tables
+    attr_accessor :table_order
+    
+    public
+    
+    attr_accessor :alignment
+    
+    def add(name)
+      t = @template.clone
+      @tables[name] = t
+      @table_order.push(name)
+      t
+    end
+    
+    def get_order 
+      @table_order
+    end
+    
+    def get(name)
+      @tables[name]
+    end
+    
+    def one 
+      @tables[@table_order[0]]
+    end
+    
+    def has_ins_del 
+      return false if @alignment == nil
+      return true if @alignment.has_addition
+      return true if @alignment.has_removal
+      false
+    end
+    
+  haxe_me ["coopy", "Tables"]
+  end
+
+end