coopy 0.6.4

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/sqlite_diff

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'coopy'
+Coopy.diff(ARGV)

data/bin/sqlite_patch

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'coopy'
+Coopy.patch(ARGV)

data/bin/sqlite_rediff

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'coopy'
+Coopy.rediff(ARGV)

data/lib/coopy.rb

@@ -0,0 +1,178 @@
+require 'optparse'
+
+class Coopy
+
+  class Flavor
+    attr_accessor :key
+    attr_accessor :banner
+    attr_accessor :min_length
+
+    def sql_subject?
+      [:diff,:patch].include? key
+    end
+
+    def sql_object?
+      key == :diff
+    end
+
+    def can_choose_format?
+      key != :patch
+    end
+
+    def can_set_output?
+      key != :patch
+    end
+
+    def default_format
+      (key==:patch) ? :apply : :csv
+    end
+  end
+
+  class OpenStruct
+    attr_accessor :format
+    attr_accessor :output
+  end
+
+  def self.parse(flavor,args)
+    options = OpenStruct.new
+    options.format = flavor.default_format
+    options.output = nil
+    OptionParser.new do |opts|
+      begin
+        opts.banner = flavor.banner
+        opts.separator ""
+        opts.separator "Specific options"
+        if flavor.can_choose_format?
+          opts.on("-f","--format [FORMAT]", [:csv, :html, :tdiff, :apply, :stats],
+                  "select format (csv,html,tdiff,apply,stats)") do |fmt|
+            options.format = fmt
+          end
+        end
+        if flavor.can_set_output?
+          opts.on("-o", "--output [FILENAME]",
+                  "direct output to a file") do |fname|
+            options.output = fname
+          end
+        end
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+        opts.parse!(args)
+        return options
+      rescue
+        puts "#{$!} (--help for help)"
+        exit 1
+      end
+    end
+  end
+
+  def self.core(flavor,argv)
+    options = self.parse(flavor,argv)
+
+    if argv.length < flavor.min_length
+      self.parse(flavor,["--help"])
+      exit(1)
+    end
+
+    if flavor.sql_subject?
+      db = SQLite3::Database.new(argv[0])
+      sql = SqliteSqlWrapper.new(db)
+    end
+
+    if flavor.sql_object?
+      name1 = nil
+      name2 = nil
+      case argv.length
+      when 2
+        name0 = sql.get_table_names[0]
+        db.execute("ATTACH ? AS `__peer_ - _`",argv[1])
+        name1 = "main.#{name0}"
+        name2 = "__peer_ - _.#{name0}"
+      when 3
+        name1 = argv[1]
+        name2 = argv[2]
+      when 4
+        name1 = "main.#{argv[1]}"
+        db.execute("ATTACH ? AS __peer__",argv[2])
+        name2 = "__peer__.#{argv[3]}"
+      end
+      cmp = SqlCompare.new(sql,name1,name2)
+    else
+      cmp = DiffParser.new(argv[flavor.min_length-1])
+    end
+
+    patches = DiffOutputGroup.new
+    # patches << DiffOutputRaw.new
+    case options.format
+    when :html
+      patches << DiffRenderHtml.new
+    when :tdiff
+      patches << DiffOutputTdiff.new
+    when :csv
+      patches << DiffRenderCsv.new
+    when :apply
+      patches << DiffApplySql.new(sql,name1)
+    when :raw
+      patches << DiffOutputRaw.new
+    when :stats
+      patches << DiffOutputStats.new
+    else
+      patches << DiffRenderCsv.new
+    end
+
+    cmp.set_output(patches)
+    
+    cmp.apply
+    result = patches.to_string
+    if result != ""
+      if options.output.nil?
+        print result
+      else
+        File.open(options.output,"w") do |f|
+          f << result
+        end
+      end
+    end
+    0
+  end
+
+  def self.diff(argv)
+    flavor = Flavor.new
+    flavor.key = :diff
+    flavor.banner = "Usage: sqlite_diff [options] ver1.sqlite ver2.sqlite"
+    flavor.min_length = 2
+    self.core(flavor,argv)
+  end
+
+  def self.patch(argv)
+    flavor = Flavor.new
+    flavor.key = :patch
+    flavor.banner = "Usage: sqlite_patch [options] db.sqlite patch.csv"
+    flavor.min_length = 2
+    self.core(flavor,argv)
+  end
+
+  def self.rediff(argv)
+    flavor = Flavor.new
+    flavor.key = :rediff
+    flavor.banner = "Usage: sqlite_rediff [options] patch.csv"
+    flavor.min_length = 1
+    self.core(flavor,argv)
+  end
+end
+
+require 'coopy/diff_output_raw'
+require 'coopy/diff_output_tdiff'
+require 'coopy/diff_render_html'
+require 'coopy/diff_render_csv'
+require 'coopy/diff_output_action'
+require 'coopy/diff_output_group'
+require 'coopy/diff_output_stats'
+require 'coopy/diff_apply_sql'
+require 'coopy/diff_parser'
+
+require 'coopy/sqlite_sql_wrapper'
+require 'coopy/sql_compare'
+require 'sqlite3'
+

data/lib/coopy/dbi_sql_wrapper.rb

@@ -0,0 +1,89 @@
+require 'sql_wrapper'
+require 'dbi'
+
+class Coopy::DbiSqlWrapper < SqlWrapper
+  def initialize(db)
+    @db = db
+    @t = nil
+    @qt = nil
+  end
+
+  def complete_table(tbl)
+    return tbl unless tbl.nil?
+    return @t unless @t.nil?
+    @t = @db.tables[0]
+    @t
+  end
+
+  def quote_table(tbl)
+    return @db.quote(tbl) unless tbl.nil?
+    return @qt unless @qt.nil?
+    @t = @db.tables[0]
+    @qt = @db.quote(@t)
+    @qt
+  end
+
+  def insert(tbl,cols,vals)
+    tbl = quote_table(tbl)
+    template = cols.map{|x| '?'}.join(",")
+    template = "INSERT INTO #{tbl} VALUES(#{template})"
+    stmt = @db.prepare(template)
+    stmt.execute(*vals)
+    stmt.finish
+  end
+
+  def delete(tbl,cols,vals)
+    tbl = quote_table(tbl)
+    template = cols.map{|c| @db.quote(c) + ' = ?'}.join(" AND ")
+    template = "DELETE FROM #{tbl} WHERE #{template}"
+    stmt = @db.prepare(template)
+    stmt.execute(*vals)
+    stmt.finish
+  end
+  
+  def update(tbl,set_cols,set_vals,cond_cols,cond_vals)
+    tbl = quote_table(tbl)
+    conds = cond_cols.map{|c| @db.quote(c) + ' = ?'}.join(" AND ")
+    sets = set_cols.map{|c| @db.quote(c) + ' = ?'}.join(", ")
+    template = "UPDATE #{@qt} SET #{sets} WHERE #{conds}"
+    v = set_vals + cond_vals
+    stmt = @db.prepare(template)
+    stmt.execute(*v)
+    stmt.finish
+  end
+
+  def transaction(&block)
+    @db["AutoCommit"]=false
+    begin
+      block.call
+      @db.commit
+    rescue Exception => e
+      @db.rollback
+      raise e
+    end
+  end
+
+  def columns(tbl)
+    tbl = complete_table(tbl)
+    @db.columns(tbl)
+  end
+
+  def column_names(tbl)
+    columns(tbl).map{|c| c[:name]}
+  end
+
+  def enhash(cols,vals)
+    Hash[*cols.map{|c| c.to_sym}.zip(vals).flatten]
+  end
+
+  def fetch(sql,names)
+    @db.select_all(sql) do |row|
+      yield row
+    end
+  end
+
+  def primary_key(tbl)
+    # don't seem to have this information? oy.
+    [column_names(tbl)[0]]
+  end
+end

data/lib/coopy/diff_apply_sql.rb

@@ -0,0 +1,35 @@
+require 'coopy/diff_output_action'
+require 'coopy/sql_wrapper'
+
+# for now, assume no schema changes, and a single table
+class Coopy::DiffApplySql < DiffOutputAction
+  def initialize(db, name = nil)
+    @name = name
+    @db = db
+  end
+
+  def row_insert(rc)
+    cols = rc.active_columns
+    @db.insert(@name,
+               cols.map{|c| c[:title]},
+               cols.map{|c| rc.value_at(c)})
+  end
+
+  def row_delete(rc)
+    cols = rc.active_columns
+    @db.delete(@name,
+               cols.map{|c| c[:title]},
+               cols.map{|c| rc.value_at(c)})
+  end
+
+  def row_update(rc)
+    cols = rc.active_columns
+    touched_cols = cols.select{|c| !rc.new_value_at(c).nil?}
+    @db.update(@name,
+               touched_cols.map{|c| c[:title]},
+               touched_cols.map{|c| rc.new_value_at(c)},
+               cols.map{|c| c[:title]},
+               cols.map{|c| rc.value_at(c)})
+  end
+end
+

data/lib/coopy/diff_columns.rb

@@ -0,0 +1,33 @@
+class DiffColumns
+  attr_accessor :change_row
+  attr_accessor :title_row
+
+  # general
+  attr_accessor :column_name   # *after* any column changes
+  attr_accessor :column_offset # *after* any column changes
+  attr_accessor :column_by_name
+  attr_accessor :column_by_offset
+
+  def update(prefix=1)
+    return if @title_row.nil?
+    @column_name = {}
+    @column_offset = {}
+    @column_by_name = {}
+    @column_by_offset = []
+    offset = -prefix
+    @title_row.each_with_index do |title,idx|
+      @column_name[idx] = title
+      if offset>=0
+        # assuming no column changes for the moment
+        @column_offset[idx] = offset
+        @column_by_name[title] = {
+          :title => title,
+          :in_offset => offset,
+          :diff_offset => idx
+        }
+        @column_by_offset << @column_by_name[title]
+      end
+      offset = offset+1
+    end
+  end
+end

data/lib/coopy/diff_output.rb

@@ -0,0 +1,21 @@
+require 'coopy/diff_columns'
+require 'coopy/row_change'
+
+class DiffOutput
+  def begin_diff
+  end
+
+  def end_diff
+  end
+
+  def apply_row(rc)
+  end
+
+  def to_string
+    ""
+  end
+
+  def want_context
+    true
+  end
+end

data/lib/coopy/diff_output_action.rb

@@ -0,0 +1,34 @@
+require 'coopy/diff_output'
+
+class DiffOutputAction < DiffOutput
+  def row_insert(rc)
+  end
+
+  def row_delete(rc)
+  end
+
+  def row_update(rc)
+  end
+
+  def row_skip(rc)
+  end
+
+  def row_context(rc)
+  end
+
+  def apply_row(rc)
+    mode = rc.row_mode
+    case mode
+    when "+++"
+      row_insert(rc)
+    when "---"
+      row_delete(rc)
+    when "->"
+      row_update(rc)
+    when "..."
+      row_skip(rc)
+    when ""
+      row_context(rc)
+    end
+  end
+end

data/lib/coopy/diff_output_group.rb

@@ -0,0 +1,40 @@
+require 'coopy/diff_columns'
+require 'coopy/row_change'
+
+class DiffOutputGroup
+  def initialize(*sinks)
+    @sinks = sinks
+  end
+
+  def <<(x)
+    @sinks = [] if @sinks.nil?
+    @sinks << x
+  end
+
+  def begin_diff
+    @sinks.each { |s| s.begin_diff }
+  end
+
+  def end_diff
+    @sinks.each { |s| s.end_diff }
+  end
+
+  def apply_row(rc)
+    @sinks.each { |s| s.apply_row(rc) }
+  end
+
+  def to_string
+    @sinks.each do |s|
+      result = s.to_string
+      return result if result!=""
+    end
+    ""
+  end
+
+  def want_context
+    return @want_context0 unless @want_context0.nil?
+    @want_context0 = false
+    @want_context0 = @sinks.each { |s| @want_context0 ||= s.want_context }
+    @want_context0
+  end
+end