koke-mydiff 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 / 2008-05-13
+
+* First public ALPHA release
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/mydiff
+lib/mydiff/change.rb
+lib/mydiff/cli.rb
+lib/mydiff.rb
+test/helper.rb
+test/test_mydiff.rb

data/README.txt

@@ -0,0 +1,51 @@
+= MyDiff MySQL diff library
+
+http://github.com/koke/mydiff
+
+== DESCRIPTION:
+
+MySQL diff library
+
+*WARNING* Although this code is public, it's not complete yet.
+
+== FEATURES/PROBLEMS:
+
+* FIXME
+
+== SYNOPSIS:
+
+  mydiff -o mydiff -n mydiff_new
+
+== REQUIREMENTS:
+
+* mysql
+* highline
+
+== INSTALL:
+
+* sudo gem install mydiff
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rubygems'
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "rake/testtask"
+require 'hoe'
+require './lib/mydiff.rb'
+
+Hoe.new('mydiff', MyDiff::VERSION) do |p|
+  p.author = 'Jorge Bernal'
+  p.email = 'jbernal@warp.es'
+  p.summary = 'MySQL diff library'
+  p.description = p.paragraphs_of('README.txt', 2..2).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 1).first
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.extra_deps << ['mysql','>= 2.7']
+  p.extra_deps << ['highline', '>= 1.4.0']
+  p.remote_rdoc_dir = ''
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/mydiff.rb"
+end
+
+desc "Run coverage tests"
+task :coverage do
+  system("rm -fr coverage")
+  system("rcov test/test_*.rb")
+  system("open coverage/index.html")
+end

data/bin/mydiff

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+if File.directory?("lib")
+  $: << "lib"
+end
+
+require "rubygems"
+require "mydiff"
+require "optparse"
+
+
+$DEBUG = false
+
+config = {
+  :host => "localhost",
+  :user => "root",
+  :password => nil
+}
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename(__FILE__)} [options] -o OLDDB -n NEWDB"
+
+  opts.on("-d", "--debug", "Show debug messages") do |v|
+    $DEBUG = v
+  end
+  
+  opts.on("-o", "--olddb OLDDB", "Database to apply changes") do |o|
+    config[:olddb] = o
+  end
+
+  opts.on("-n", "--newdb NEWDB", "Database to read changes") do |n|
+    config[:newdb] = n
+  end
+  
+  opts.on("-h", "--host name", "MySQL host to connect (default #{config[:host]})") do |o|
+    config[:host] = o
+  end
+  
+  opts.on("-u", "--user name", "MySQL username (default #{config[:user]})") do |o|
+    config[:user] = o
+  end
+  
+  opts.on("-p", "--password passwd", "MySQL password") do |o|
+    config[:password] = o
+  end
+  
+end
+
+opts.parse!
+
+unless config[:newdb] and config[:olddb]
+  puts opts.help
+  exit 1
+end
+
+md = MyDiff.new(config)
+md.cli.main_menu
+
+# popt = config[:password].nil? ? "" : "-p#{config[:password]}"
+# system "mysql -h #{config[:host]} -u #{config[:user]} #{popt} #{md.newdb} < new.sql"
+# system "mysql -h #{config[:host]} -u #{config[:user]} #{popt} #{md.olddb} < old.sql"

data/lib/mydiff.rb

@@ -0,0 +1,230 @@
+$:.unshift File.dirname(__FILE__) 
+ 
+require "mysql"
+require "mydiff/cli"
+require "mydiff/change"
+
+# MyDiff helps you to apply changes from one MySQL database to another
+#
+# It has some helper methods to 
+#
+# Example
+#
+#  md = MyDiff.new(:host => "localhost", :user => "root", :newdb => "mydiff_new", :olddb => "mydiff_old") # => <MyDiff>
+#  md.newdb           #=> "mydiff_new"
+#  md.olddb           #=> "mydiff_old"
+#  md.new_tables      #=> ["new_table1", "new_table2"]
+#  md.dropped_tables  #=> ["old_table"]
+class MyDiff
+  VERSION = '0.0.1'
+  
+  # Name of the database with changes
+  attr_accessor :newdb
+  # Name of the current database. Changes will be applied here
+  attr_accessor :olddb
+  # Command Line Interface. See MyDiff::CLI
+  attr_accessor :cli
+  attr_accessor :my #:nodoc:
+  
+  # Creates a new MyDiff instance
+  #
+  # Config options
+  # - <tt>:host</tt> - MySQL host
+  # - <tt>:user</tt> - MySQL user
+  # - <tt>:password</tt> - MySQL password
+  # - <tt>:newdb</tt> - Name of the database with the changes to apply
+  # - <tt>:olddb</tt> - Name of the database to apply the changes
+  #
+  # Returns MyDiff
+  def initialize(config)
+    @my = Mysql::new(config[:host], config[:user], config[:password])
+    @newdb = config[:newdb]
+    @olddb = config[:olddb]
+    @cli = CLI.new(self)
+    @fields = {}
+  end
+  
+  # Recreates the new database
+  # 
+  # *WARNING*: This method drops and recreates the +newdb+ database, you may lose data!
+  def prepare!
+    begin
+      @my.query("DROP DATABASE #{@newdb}")
+    rescue
+    end
+
+    @my.query("CREATE DATABASE #{@newdb}")
+  end
+    
+  # Returns an array with table names for the database given in +db+
+  def list_tables(db)
+    @my.select_db(db)
+    @my.list_tables
+  end
+  
+  # Returns an array with table names present on +newdb+ but not on +olddb+
+  def new_tables
+    ntables = list_tables(@newdb)
+    otables = list_tables(@olddb)
+    
+    ntables.select {|t| not otables.include?(t) }
+  end
+  
+  # Returns an array with table names present on +olddb+ but not on +newdb+
+  def dropped_tables
+    ntables = list_tables(@newdb)
+    otables = list_tables(@olddb)
+    
+    otables.select {|t| not ntables.include?(t) }
+  end
+  
+  # Returns an array with table names present on +newdb+ and +olddb+ which 
+  # are different in content
+  def changed_tables
+    ntables = list_tables(@newdb)
+    otables = list_tables(@olddb)
+    
+    ntables.select {|t| otables.include?(t) and table_changed?(t) }
+  end
+  
+  # Returns an array with rows present in +newdb+ but not in +olddb+, using the +table+ given
+  def new_rows(table)
+    fields = fields_from(table)
+    pkey, fields = extract_pkey_from(fields)
+    my.select_db(@newdb)
+    
+    query = "SELECT "
+    query << pkey.collect do |f|
+      "n.#{f["Field"]} #{f["Field"]}"
+    end.join(",")
+    query << ","
+    query << fields.collect do |f|
+      "n.#{f["Field"]} n_#{f["Field"]}"
+    end.join(",")
+    
+    query << " FROM #{@newdb}.#{table} AS n LEFT JOIN #{@olddb}.#{table} AS o ON "
+    query << pkey.collect do |f|
+      "n.#{f["Field"]} = o.#{f["Field"]}"
+    end.join(" AND ")
+    query << " WHERE "
+    query << pkey.collect do |f|
+      "o.#{f["Field"]} IS NULL"
+    end.join(" AND ")
+    
+    result = my.query(query)
+    new_rows = []
+    while row = result.fetch_hash
+      new_rows << row
+    end
+    new_rows
+  end
+
+  def deleted_rows(table)
+    fields = fields_from(table)
+    pkey, fields = extract_pkey_from(fields)
+    my.select_db(@olddb)
+    
+    query = "SELECT "
+    query << pkey.collect do |f|
+      "o.#{f["Field"]} #{f["Field"]}"
+    end.join(",")
+    query << ","
+    query << fields.collect do |f|
+      "o.#{f["Field"]} o_#{f["Field"]}"
+    end.join(",")
+    
+    query << " FROM #{@olddb}.#{table} AS o LEFT JOIN #{@newdb}.#{table} AS n ON "
+    query << pkey.collect do |f|
+      "n.#{f["Field"]} = o.#{f["Field"]}"
+    end.join(" AND ")
+    query << " WHERE "
+    query << pkey.collect do |f|
+      "n.#{f["Field"]} IS NULL"
+    end.join(" AND ")
+    
+    result = my.query(query)
+    deleted_rows = []
+    while row = result.fetch_hash
+      deleted_rows << row
+    end
+    deleted_rows
+  end
+
+  def changed_rows(table)
+    fields = fields_from(table)
+    pkey, fields = extract_pkey_from(fields)
+    my.select_db(@olddb)
+    
+    query = "SELECT "
+    query << pkey.collect do |f|
+      "o.#{f["Field"]} #{f["Field"]}"
+    end.join(",")
+    query << ","
+    query << fields.collect do |f|
+      "o.#{f["Field"]} o_#{f["Field"]}, n.#{f["Field"]} n_#{f["Field"]}"
+    end.join(",")
+    
+    query << " FROM #{@olddb}.#{table} AS o INNER JOIN #{@newdb}.#{table} AS n ON "
+    query << pkey.collect do |f|
+      "n.#{f["Field"]} = o.#{f["Field"]}"
+    end.join(" AND ")    
+    
+    result = my.query(query)
+    changed_rows = []
+    while row = result.fetch_hash
+      changed_rows << row
+    end
+    changed_rows.select do |row|
+      fields.inject(true) do |s,f|
+        s and row["o_#{f["Field"]}"] == row["n_#{f["Field"]}"]
+      end
+    end
+  end
+  
+  def fields_from(table)
+    return @fields[table] if @fields[table]
+    @my.select_db(@newdb)
+    res = @my.query("DESCRIBE #{table}")
+    fields = []
+    while (field = res.fetch_hash)
+      fields << field
+    end
+    
+    @fields[table] ||= fields
+  end  
+  
+  def count_rows(db, table)
+    @my.select_db(db)
+    res = @my.query("SELECT COUNT(*) FROM #{table}")
+    res.fetch_row[0]
+  end
+  
+  def extract_pkey_from(fields)
+    fields.partition {|f| f["Key"] == "PRI" }    
+  end
+  
+  def pkey_of(table)
+    fields_from(table).select {|f| f["Key"] == "PRI"}.map {|f| f["Field"]}
+  end
+
+  def data_fields_of(table)
+    fields_from(table).select {|f| f["Key"] != "PRI"}.map {|f| f["Field"]}
+  end
+  
+  def checksum_table(db, table)
+    @my.select_db(db)
+    @my.query("CHECKSUM TABLE #{table}").fetch_row[1]
+  end
+  
+  def table_changed?(table)
+    checksum_table(@olddb, table) != checksum_table(@newdb, table)
+  end
+  
+  def select_new
+    @my.select_db(@newdb)
+  end
+  
+  def select_old
+    @my.select_db(@olddb)
+  end  
+end

data/lib/mydiff/change.rb

@@ -0,0 +1,105 @@
+require "yaml"
+
+class MyDiff
+  # Represents one change to apply to the database
+  class Change
+    # Can be one of <tt>:new</tt>, <tt>:drop</tt>, <tt>:overwrite</tt> or <tt>:patch</tt>
+    attr_accessor :type
+    attr_accessor :chunks
+    
+    # Create a new change for a specific table
+    #
+    # +parent+:: the MyDiff parent class
+    # +type+:: one of <tt>:new</tt>, <tt>:drop</tt>, <tt>:overwrite</tt> or <tt>:patch</tt>
+    # +table+:: the table to change
+    def initialize(parent, type, table)
+      @md = parent
+      @type = type
+      @table = table
+      @chunks = {}
+    end
+    
+    # Adds a chunk to apply in the change. 
+    #
+    # +type+:: can be either <tt>:new</tt>, <tt>:delete</tt> or <tt>:change</tt>
+    # +pkey+:: should be a hash containing primary key fields
+    # +fields+:: should be a hash containint the fields not belonging to primary key (only for +type+ = <tt>:new</tt> or <tt>:change</tt>)
+    def add_chunk(type, pkey, fields = {})
+      raise ArgumentError, "Chunks can be added only if type is :patch" unless @type.eql?(:patch)
+      @chunks[pkey.to_yaml] = { :type => type, :pkey => pkey, :fields => fields}
+    end
+    
+    def delete_chunk(pkey)
+      @chunks.delete(pkey.to_yaml)
+    end
+    
+    def get_chunk(pkey)
+      @chunks[pkey.to_yaml]
+    end
+    
+    def has_chunk?(pkey)
+      @chunks.has_key?(pkey.to_yaml)
+    end
+    
+    def apply!
+      if @type.eql?(:new)
+        puts "** Creating #{@table}"
+        @md.select_old
+        @md.my.query("CREATE TABLE #{@table} LIKE #{@md.newdb}.#{@table}")
+        @md.my.query("INSERT INTO #{@table} SELECT * FROM #{@md.newdb}.#{@table}")
+      elsif @type.eql?(:drop)
+        puts "** Dropping table #{@table}"
+        @md.select_old
+        @md.my.query("DROP TABLE #{@table}")
+      elsif @type.eql?(:overwrite)
+        raise NotImplementedError, "Type :overwrite is not yet in use"
+      elsif @type.eql?(:patch)
+        printf "** Updating table #{@table}"
+        @chunks.each_pair do |pkey, data|
+          printf "."
+          @md.select_old
+          if data[:type].eql?(:new)
+            field_list = []
+            data_list = []
+            data[:pkey].each_pair do |k,v|
+              field_list << k
+              data_list << "'" + @md.my.escape_string(v) + "'"
+            end
+            data[:fields].each_pair do |k,v|
+              field_list << k
+              data_list << "'" + @md.my.escape_string(v) + "'"
+            end
+            
+            puts("INSERT INTO #{@table} (#{field_list.join(',')}) VALUES(#{data_list.join(',')})") if $DEBUG
+            @md.my.query("INSERT INTO #{@table} (#{field_list.join(',')}) VALUES(#{data_list.join(',')})")
+          elsif data[:type].eql?(:change)
+            changes_list = []
+            pkey_list = []
+            data[:pkey].each_pair do |k,v|
+              pkey_list << "#{k} = '" + @md.my.escape_string(v) + "'"
+            end
+            data[:fields].each_pair do |k,v|
+              changes_list << "#{k} = '" + @md.my.escape_string(v) + "'"
+            end
+            
+            puts("UPDATE #{@table} SET #{changes_list.join(',')} WHERE #{pkey_list.join(' AND ')}") if $DEBUG
+            @md.my.query("UPDATE #{@table} SET #{changes_list.join(',')} WHERE #{pkey_list.join(' AND ')}")
+          elsif data[:type].eql?(:delete)
+            pkey_list = []
+            data[:pkey].each_pair do |k,v|
+              pkey_list << "#{k} = '" + @md.my.escape_string(v) + "'"
+            end
+            puts("DELETE FROM #{@table} WHERE #{pkey_list.join(' AND ')}") if $DEBUG
+            @md.my.query("DELETE FROM #{@table} WHERE #{pkey_list.join(' AND ')}")
+          else
+            raise NotImplementedError, "Invalid chunk type: #{data[:type]}"
+          end
+        end
+        
+        puts
+      else
+        raise NotImplementedError, "Invalid type #{@type.to_s}"
+      end
+    end
+  end
+end

data/lib/mydiff/cli.rb

@@ -0,0 +1,204 @@
+require "highline"
+
+class MyDiff
+  class CLI < HighLine
+    def initialize(parent)
+      @md = parent
+      @tables = []
+      @md.new_tables.each {|t| @tables << {:status => :new, :table => t}}
+      @md.dropped_tables.each {|t| @tables << {:status => :drop, :table => t}}
+      @md.changed_tables.each {|t| @tables << {:status => :change, :table => t}}
+      
+      @tables.sort! {|t1,t2| t1[:table] <=> t2[:table]}
+      @changes = {}
+      super()
+    end
+    
+    def main_menu
+      continue = true
+      begin
+        while continue
+          choose do |menu|
+            menu.prompt = "What now?"
+          
+            menu.choice("Status") { status }
+            menu.choice("Accept") { accept }
+            menu.choice("Reject") { reject }
+            menu.choice("Patch")  { patch  }
+            menu.choice("Apply")  { apply! }
+            menu.choice("Quit")   { continue = false }
+          end
+        end
+      rescue Interrupt
+      end
+    end
+    
+    def status(type = :all)
+      type = [type] unless type.is_a?(Array)
+      @tables.each_with_index do |table, count|
+        if type.include?(:all) or type.include?(table[:status])
+          render_row(count, table[:table], table[:status])
+        end
+      end
+    end
+    
+    def accept
+      submenu do |table|
+        change = @changes[table[:table]]
+        if change #and change.type.eql?(:patch)
+          @changes.delete(table[:table])
+        end
+        @changes[table[:table]] = Change.new(@md, :add, table[:table])
+      end
+    end
+
+    def reject
+      submenu do |table|
+        change = @changes[table[:table]]
+        if change #and change.type.eql?(:patch)
+          @changes.delete(table[:table])
+        end
+      end
+    end
+    
+    def patch
+      submenu([:change, :new]) do |table|
+        continue = true
+        while continue
+          rows = []
+          @md.deleted_rows(table[:table]).each {|r| rows << {:status => :delete, :row => r}}
+          @md.changed_rows(table[:table]).each {|r| rows << {:status => :change, :row => r}}
+          @md.new_rows(table[:table]).each {|r| rows << {:status => :new, :row => r}}
+          rows.each_with_index do |row, count|
+            status = row[:status]
+            row = row[:row]
+            pkey = {}
+            @md.pkey_of(table[:table]).each do |f|
+              pkey[f] = row[f]
+            end
+            ndata = @md.data_fields_of(table[:table]).map do |f|
+              row["n_#{f}"]
+            end
+            odata = @md.data_fields_of(table[:table]).map do |f|
+              row["o_#{f}"]
+            end
+            
+            begin
+              if @changes[table[:table]].has_chunk?(pkey)
+                status = "*"
+              else
+                status = " "
+              end
+            rescue
+              status = " "
+            end
+            say ""
+            say "%2d. [%s] (%s) %s" % [count, status, pkey.values.join("||"), odata.join("||")]
+            puts "    [%s] (%s) %s" % [status, pkey.values.join("||"), ndata.join("||")]            
+            
+          end
+          
+          opt = ask "Which one?"
+          if opt.empty? or opt.downcase.eql?("q")
+            continue = false
+          else
+            if opt =~ /(\d+)-(\d+)/
+              opts = ($1..$2).to_a
+            elsif opt =~ /(\d+)/
+              opts = [$1]
+            end
+            opts.each do |opt|
+              row = rows[opt.to_i]
+              if row.nil? or not opt =~ /[0-9+]/
+                say "Wrong answer!"
+                next
+              end
+              change = @changes[table[:table]]
+              if (change and not change.type.eql?(:patch)) or not change
+                @changes.delete(table[:table])
+                change = Change.new(@md, :patch, table[:table])
+              end
+
+              pkey = {}
+              @md.pkey_of(table[:table]).each do |f|
+                pkey[f] = row[:row][f]
+              end
+              if change.has_chunk?(pkey)
+                change.delete_chunk(pkey)
+              else
+                data = {}
+                @md.data_fields_of(table[:table]).each do |f|
+                  data[f] = row[:row]["n_#{f}"]
+                end
+                change.add_chunk(row[:status], pkey, data)
+              end
+
+              @changes[table[:table]] = change
+              if change.chunks.empty?
+                @changes.delete(table[:table])
+              end              
+            end
+          end
+        end
+      end      
+    end
+    
+    def apply!
+      @changes.each_value do |change|
+        change.apply!
+      end
+    end
+    
+    private
+    def submenu(type = :all)
+      continue = true
+      while continue
+        status(type)
+        opt = ask "Which one?"
+        if opt.empty? or opt.downcase.eql?("q")
+          continue = false
+        else
+          if opt =~ /(\d+)-(\d+)/
+            opts = ($1..$2).to_a
+          elsif opt =~ /(\d+)/
+            opts = [$1]
+          end
+          opts.each do |opt|
+            table = @tables[opt.to_i]
+            if table.nil? or not opt =~ /[0-9+]/
+              say "Wrong answer!"
+              next
+            end
+            yield table
+          end
+        end
+      end
+    end
+    
+    def render_row(count, table, status)
+      if @changes.has_key?(table)
+        if @changes[table].type.eql?(:patch)
+          change = "/"
+        else
+          change = "*"
+        end
+      else
+        change = " "
+      end
+      
+      if status.eql?(:new)
+        say "%2d. [%s] N  %8d    %s" % [count, change, "+" + @md.count_rows(@md.newdb, table), table]
+      elsif status.eql?(:drop)
+        say "%2d. [%s] D  %8d    %s" % [count, change, "-" + @md.count_rows(@md.olddb, table), table]
+      elsif status.eql?(:change)
+        new_rows = @md.new_rows(table).size
+        deleted_rows = @md.deleted_rows(table).size
+        changed_rows = @md.changed_rows(table).size
+        new_rows += changed_rows
+        deleted_rows += changed_rows
+        changed_rows = "+#{new_rows}/-#{deleted_rows}"
+        say "%2d. [%s] C  %8s    %s" % [count, change, changed_rows, table]
+      end
+    end    
+  end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'test/unit'
+require File.join(File.dirname(__FILE__), *%w[.. lib mydiff])
+
+def absolute_project_path
+  File.expand_path(File.join(File.dirname(__FILE__), '..'))
+end

data/test/test_mydiff.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestMydiff < Test::Unit::TestCase
+  def setup
+    
+  end
+  
+  def test_true
+    assert(true)
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: koke-mydiff
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jorge Bernal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-13 00:00:00 -07:00
+default_executable: mydiff
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.7"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.1
+    version: 
+description: "== DESCRIPTION:"
+email: jbernal@warp.es
+executables: 
+- mydiff
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/mydiff
+- lib/mydiff/change.rb
+- lib/mydiff/cli.rb
+- lib/mydiff.rb
+- test/helper.rb
+- test/test_mydiff.rb
+has_rdoc: true
+homepage: http://github.com/koke/mydiff
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: mydiff
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: MySQL diff library
+test_files: 
+- test/test_mydiff.rb