daff 1.3.2 → 1.3.6

data/lib/lib/coopy/compare_flags.rb

@@ -25,6 +25,7 @@ module Coopy
       @parent = nil
       @count_like_a_spreadsheet = true
       @ignore_whitespace = false
+      @ignore_case = false
     end
     
     attr_accessor :ordered
@@ -42,11 +43,13 @@ module Coopy
     attr_accessor :allow_nested_cells
     attr_accessor :warnings
     attr_accessor :diff_strategy
+    attr_accessor :padding_strategy
     attr_accessor :show_meta
     attr_accessor :show_unchanged_meta
     attr_accessor :parent
     attr_accessor :count_like_a_spreadsheet
     attr_accessor :ignore_whitespace
+    attr_accessor :ignore_case
     
     def filter(act,allow)
       if @acts == nil 

data/lib/lib/coopy/compare_table.rb

@@ -36,6 +36,8 @@ module Coopy
       end
       alignment = ::Coopy::Alignment.new
       self.align_core(alignment)
+      alignment.comp = @comp
+      @comp.alignment = alignment
       alignment
     end
     
@@ -59,7 +61,11 @@ module Coopy
           tab2 = @comp.b
           tab3 = @comp.a
         end
-        sc = ::Coopy::SqlCompare.new(tab1.get_database,tab1,tab2,tab3,align)
+        db = nil
+        db = tab1.get_database if tab1 != nil
+        db = tab2.get_database if db == nil && tab2 != nil
+        db = tab3.get_database if db == nil && tab3 != nil
+        sc = ::Coopy::SqlCompare.new(db,tab1,tab2,tab3,align)
         sc.apply
         align.meta.reference = align.reference.meta if @comp.p != nil
         return
@@ -588,6 +594,22 @@ module Coopy
       p = @comp.p
       a = @comp.a
       b = @comp.b
+      @comp.get_meta
+      nested = false
+      if @comp.p_meta != nil 
+        nested = true if @comp.p_meta.is_nested
+      end
+      if @comp.a_meta != nil 
+        nested = true if @comp.a_meta.is_nested
+      end
+      if @comp.b_meta != nil 
+        nested = true if @comp.b_meta.is_nested
+      end
+      if nested 
+        @comp.is_equal = false
+        @comp.is_equal_known = true
+        return true
+      end
       eq = self.is_equal2(a,b)
       eq = self.is_equal2(p,a) if eq && p != nil
       @comp.is_equal = eq
@@ -640,7 +662,21 @@ module Coopy
     
     def use_sql 
       return false if @comp.compare_flags == nil
-      @comp.compare_flags.diff_strategy == "sql"
+      @comp.get_meta
+      sql = true
+      if @comp.p_meta != nil 
+        sql = false if !@comp.p_meta.is_sql
+      end
+      if @comp.a_meta != nil 
+        sql = false if !@comp.a_meta.is_sql
+      end
+      if @comp.b_meta != nil 
+        sql = false if !@comp.b_meta.is_sql
+      end
+      sql = false if @comp.p != nil && @comp.p_meta == nil
+      sql = false if @comp.a != nil && @comp.a_meta == nil
+      sql = false if @comp.b != nil && @comp.b_meta == nil
+      sql
     end
     
   haxe_me ["coopy", "CompareTable"]

data/lib/lib/coopy/coopy.rb

@@ -87,10 +87,13 @@ module Coopy
       @extern_preference = true
     end
     
-    def render_table(name,t)
+    def get_renderer 
       renderer = ::Coopy::DiffRender.new
       renderer.use_pretty_arrows(@pretty)
-      renderer.render(t)
+      renderer
+    end
+    
+    def apply_renderer(name,renderer)
       renderer.complete_html if !@fragment
       if @format_preference == "www" 
         @io.send_to_browser(renderer.html)
@@ -101,24 +104,88 @@ module Coopy
       true
     end
     
-    def save_table(name,t)
+    def render_table(name,t)
+      renderer = self.get_renderer
+      renderer.render(t)
+      self.apply_renderer(name,renderer)
+    end
+    
+    def render_tables(name,t)
+      renderer = self.get_renderer
+      renderer.render_tables(t)
+      self.apply_renderer(name,renderer)
+    end
+    
+    def save_table(name,t,render = nil)
+      txt = self.encode_table(name,t,render)
+      self.save_text(name,txt)
+    end
+    
+    def encode_table(name,t,render = nil)
       self.set_format(@output_format) if @output_format != "copy"
       txt = ""
       self.check_format(name)
       @format_preference = "csv" if @format_preference == "sqlite" && !@extern_preference
-      if @format_preference == "csv" 
-        csv = ::Coopy::Csv.new(@delim_preference)
-        txt = csv.render_table(t)
-      elsif @format_preference == "ndjson" 
-        txt = ::Coopy::Ndjson.new(t).render
-      elsif @format_preference == "html" || @format_preference == "www" 
-        return self.render_table(name,t)
-      elsif @format_preference == "sqlite" 
-        @io.write_stderr("! Cannot yet output to sqlite, aborting\n")
-        return false
+      if render == nil 
+        if @format_preference == "csv" 
+          csv = ::Coopy::Csv.new(@delim_preference)
+          txt = csv.render_table(t)
+        elsif @format_preference == "ndjson" 
+          txt = ::Coopy::Ndjson.new(t).render
+        elsif @format_preference == "html" || @format_preference == "www" 
+          self.render_table(name,t)
+        elsif @format_preference == "sqlite" 
+          @io.write_stderr("! Cannot yet output to sqlite, aborting\n")
+          return ""
+        else 
+          value = ::Coopy::Coopy.jsonify(t)
+          txt = ::Haxe::Format::JsonPrinter._print(value,nil,"  ")
+        end
       else 
-        value = ::Coopy::Coopy.jsonify(t)
-        txt = ::Haxe::Format::JsonPrinter._print(value,nil,"  ")
+        txt = render.render(t)
+      end
+      txt
+    end
+    
+    def save_tables(name,os,use_color)
+      self.set_format(@output_format) if @output_format != "copy"
+      txt = ""
+      self.check_format(name)
+      render = nil
+      render = ::Coopy::TerminalDiffRender.new(@flags) if use_color
+      order = os.get_order
+      return self.save_table(name,os.one,render) if order.length == 1
+      return self.render_tables(name,os) if @format_preference == "html" || @format_preference == "www"
+      need_blank = false
+      if order.length == 0 || os.has_ins_del 
+        txt += self.encode_table(name,os.one,render)
+        need_blank = true
+      end
+      if order.length > 1 
+        _g1 = 1
+        _g = order.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          t = os.get(order[i])
+          if t != nil 
+            txt += "\n" if need_blank
+            need_blank = true
+            txt += _hx_str(order[i]) + "\n"
+            line = ""
+            begin
+              _g3 = 0
+              _g2 = order[i].length
+              while(_g3 < _g2) 
+                i1 = _g3
+                _g3+=1
+                line += "="
+              end
+            end
+            txt += _hx_str(line) + "\n"
+            txt += self.encode_table(name,os.get(order[i]),render)
+          end
+        end
       end
       self.save_text(name,txt)
     end
@@ -132,6 +199,69 @@ module Coopy
       true
     end
     
+    def json_to_tables(json)
+      tables = Reflect.field(json,"tables")
+      return self.json_to_table(json) if tables == nil
+      ::Coopy::JsonTables.new(json,@flags)
+    end
+    
+    def json_to_table(json)
+      output = nil
+      begin
+        _g = 0
+        _g1 = Reflect.fields(json)
+        while(_g < _g1.length) 
+          name = _g1[_g]
+          _g+=1
+          t = Reflect.field(json,name)
+          columns = Reflect.field(t,"columns")
+          next if columns == nil
+          rows = Reflect.field(t,"rows")
+          next if rows == nil
+          output = ::Coopy::SimpleTable.new(columns.length,rows.length)
+          has_hash = false
+          has_hash_known = false
+          begin
+            _g3 = 0
+            _g2 = rows.length
+            while(_g3 < _g2) 
+              i = _g3
+              _g3+=1
+              row = rows[i]
+              if !has_hash_known 
+                has_hash = true if Reflect.fields(row).length == columns.length
+                has_hash_known = true
+              end
+              if !has_hash 
+                lst = row
+                begin
+                  _g5 = 0
+                  _g4 = columns.length
+                  while(_g5 < _g4) 
+                    j = _g5
+                    _g5+=1
+                    val = lst[j]
+                    output.set_cell(j,i,::Coopy::Coopy.cell_for(val))
+                  end
+                end
+              else 
+                _g51 = 0
+                _g41 = columns.length
+                while(_g51 < _g41) 
+                  j1 = _g51
+                  _g51+=1
+                  val1 = Reflect.field(row,columns[j1])
+                  output.set_cell(j1,i,::Coopy::Coopy.cell_for(val1))
+                end
+              end
+            end
+          end
+        end
+      end
+      output.trim_blank if output != nil
+      output
+    end
+    
     def load_table(name)
       ext = self.check_format(name)
       if ext == "sqlite" 
@@ -140,25 +270,7 @@ module Coopy
           @io.write_stderr("! Cannot open database, aborting\n")
           return nil
         end
-        helper = ::Coopy::SqliteHelper.new
-        name1 = ""
-        if @flags == nil || @flags.tables == nil || @flags.tables.length == 0 
-          names = helper.get_table_names(sql)
-          if names == nil 
-            @io.write_stderr("! Cannot find database tables, aborting\n")
-            return nil
-          end
-          if names.length == 0 
-            @io.write_stderr("! No tables in database, aborting\n")
-            return nil
-          end
-          name1 = names[0]
-        else 
-          name1 = @flags.tables[0]
-          @io.write_stderr("! Cannot compare more than one table yet\n") if @flags.tables.length > 1
-        end
-        tab = ::Coopy::SqlTable.new(sql,::Coopy::SqlTableName.new(name1),helper)
-        @strategy = "sql"
+        tab = ::Coopy::SqlTables.new(sql,@flags)
         return tab
       end
       txt = @io.get_content(name)
@@ -171,7 +283,7 @@ module Coopy
       begin
         json = ::Haxe::Format::JsonParser.new(txt).parse_rec
         @format_preference = "json"
-        t1 = ::Coopy::Coopy.json_to_table(json)
+        t1 = self.json_to_tables(json)
         raise hx_raise("JSON failed") if t1 == nil
         return t1
       rescue => e
@@ -504,6 +616,16 @@ module Coopy
               @flags.ignore_whitespace = true
               args.slice!(i,1)
               break
+            elsif tag == "-i" || tag == "--ignore-case" 
+              more = true
+              @flags.ignore_case = true
+              args.slice!(i,1)
+              break
+            elsif tag == "--padding" 
+              more = true
+              @flags.padding_strategy = args[i + 1]
+              args.slice!(i,2)
+              break
             end
           end
         end
@@ -570,9 +692,11 @@ module Coopy
         io.write_stderr("     --no-color:    make sure terminal colors are not used\n")
         io.write_stderr("     --ordered:     assume row order is meaningful (default for CSV)\n")
         io.write_stderr("     --output-format [csv|tsv|ssv|json|copy|html]: set format for output\n")
+        io.write_stderr("     --padding [dense|sparse|smart]: set padding method for aligning columns\n")
         io.write_stderr("     --table NAME:  compare the named table, used with SQL sources\n")
         io.write_stderr("     --unordered:   assume row order is meaningless (default for json formats)\n")
         io.write_stderr("     -w / --ignore-whitespace: ignore changes in leading/trailing whitespace\n")
+        io.write_stderr("     -i / --ignore-case: ignore differences in case\n")
         io.write_stderr("\n")
         io.write_stderr("  daff render [--output OUTPUT.html] [--css CSS.css] [--fragment] [--plain] diff.csv\n")
         io.write_stderr("     --css CSS.css: generate a suitable css file to go with the html\n")
@@ -650,19 +774,15 @@ module Coopy
         align = ct1.align
         td = ::Coopy::TableDiff.new(align,@flags)
         o = ::Coopy::SimpleTable.new(0,0)
-        td.hilite(o)
+        os = ::Coopy::Tables.new(o)
+        td.hilite_with_nesting(os)
         use_color = color
         if !(color || no_color) 
           if output == "-" && @output_format == "copy" 
             use_color = io.is_tty if io.is_tty_known
           end
         end
-        if use_color 
-          render = ::Coopy::TerminalDiffRender.new
-          tool.save_text(output,render.render(o))
-        else 
-          tool.save_table(output,o)
-        end
+        tool.save_tables(output,os,use_color)
       elsif cmd1 == "patch" 
         patcher = ::Coopy::HighlightPatch.new(a,b)
         patcher.apply
@@ -691,7 +811,7 @@ module Coopy
     class << self
     attr_accessor :version
     end
-    @version = "1.3.2"
+    @version = "1.3.6"
     
     def Coopy.diff_as_html(local,remote,flags = nil)
       o = ::Coopy::Coopy.diff(local,remote,flags)
@@ -701,33 +821,36 @@ module Coopy
     
     def Coopy.diff_as_ansi(local,remote,flags = nil)
       o = ::Coopy::Coopy.diff(local,remote,flags)
-      render = ::Coopy::TerminalDiffRender.new
+      render = ::Coopy::TerminalDiffRender.new(flags)
       render.render(o)
     end
     
     def Coopy.diff(local,remote,flags = nil)
       comp = ::Coopy::TableComparisonState.new
-      comp.a = local
-      comp.b = remote
+      comp.a = ::Coopy::Coopy.tablify(local)
+      comp.b = ::Coopy::Coopy.tablify(remote)
       flags = ::Coopy::CompareFlags.new if flags == nil
       comp.compare_flags = flags
       ct = ::Coopy::CompareTable.new(comp)
       align = ct.align
       td = ::Coopy::TableDiff.new(align,flags)
-      o = ::Coopy::SimpleTable.new(0,0)
+      o = nil
+      o = comp.a.create if comp.a != nil
+      o = comp.b.create if o == nil && comp.b != nil
+      o = ::Coopy::SimpleTable.new(0,0) if o == nil
       td.hilite(o)
       o
     end
     
     def Coopy.patch(local,patch,flags = nil)
-      patcher = ::Coopy::HighlightPatch.new(local,patch)
+      patcher = ::Coopy::HighlightPatch.new(::Coopy::Coopy.tablify(local),::Coopy::Coopy.tablify(patch))
       patcher.apply
     end
     
     def Coopy.compare_tables(local,remote,flags = nil)
       comp = ::Coopy::TableComparisonState.new
-      comp.a = local
-      comp.b = remote
+      comp.a = ::Coopy::Coopy.tablify(local)
+      comp.b = ::Coopy::Coopy.tablify(remote)
       comp.compare_flags = flags
       ct = ::Coopy::CompareTable.new(comp)
       ct
@@ -735,9 +858,9 @@ module Coopy
     
     def Coopy.compare_tables3(parent,local,remote,flags = nil)
       comp = ::Coopy::TableComparisonState.new
-      comp.p = parent
-      comp.a = local
-      comp.b = remote
+      comp.p = ::Coopy::Coopy.tablify(parent)
+      comp.a = ::Coopy::Coopy.tablify(local)
+      comp.b = ::Coopy::Coopy.tablify(remote)
       comp.compare_flags = flags
       ct = ::Coopy::CompareTable.new(comp)
       ct
@@ -756,6 +879,9 @@ module Coopy
       csv = ::Coopy::Csv.new
       tm = ::Coopy::TableModifier.new(nil)
       sc = ::Coopy::SqlCompare.new(nil,nil,nil,nil)
+      sq = ::Coopy::SqliteHelper.new
+      sm = ::Coopy::SimpleMeta.new(nil)
+      ct = ::Coopy::CombinedTable.new(nil)
       0
     end
     
@@ -763,63 +889,6 @@ module Coopy
       x
     end
     
-    def Coopy.json_to_table(json)
-      output = nil
-      begin
-        _g = 0
-        _g1 = Reflect.fields(json)
-        while(_g < _g1.length) 
-          name = _g1[_g]
-          _g+=1
-          t = Reflect.field(json,name)
-          columns = Reflect.field(t,"columns")
-          next if columns == nil
-          rows = Reflect.field(t,"rows")
-          next if rows == nil
-          output = ::Coopy::SimpleTable.new(columns.length,rows.length)
-          has_hash = false
-          has_hash_known = false
-          begin
-            _g3 = 0
-            _g2 = rows.length
-            while(_g3 < _g2) 
-              i = _g3
-              _g3+=1
-              row = rows[i]
-              if !has_hash_known 
-                has_hash = true if Reflect.fields(row).length == columns.length
-                has_hash_known = true
-              end
-              if !has_hash 
-                lst = row
-                begin
-                  _g5 = 0
-                  _g4 = columns.length
-                  while(_g5 < _g4) 
-                    j = _g5
-                    _g5+=1
-                    val = lst[j]
-                    output.set_cell(j,i,::Coopy::Coopy.cell_for(val))
-                  end
-                end
-              else 
-                _g51 = 0
-                _g41 = columns.length
-                while(_g51 < _g41) 
-                  j1 = _g51
-                  _g51+=1
-                  val1 = Reflect.field(row,columns[j1])
-                  output.set_cell(j1,i,::Coopy::Coopy.cell_for(val1))
-                end
-              end
-            end
-          end
-        end
-      end
-      output.trim_blank if output != nil
-      output
-    end
-    
     public
     
     def Coopy.main 
@@ -885,6 +954,15 @@ module Coopy
       workbook
     end
     
+    public
+    
+    def Coopy.tablify(data)
+      return data if data == nil
+      return data if data.respond_to? :get_cell_view
+      require 'ruby_table_view' unless defined?(RubyTableView)
+      ::RubyTableView.new(data)
+    end
+    
   haxe_me ["coopy", "Coopy"]
   end