mysql-inspector 0.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+current
+target
+pkg

data/README

@@ -0,0 +1,48 @@
+mysql-inspector is a simple tool for diffing and searching mysql dumps.
+
+Why do I need that?
+
+It helps you migrate your schema from one version to another.
+
+Ok, how?
+
+Say you have a project called zippers. Your development database is called
+zippers_development. You're working on a branch called smoother, based on
+master, which adds a new column metal_grade.
+
+Start by storing the new state of your database.
+
+% mysql-inspector --target zippers_development --write
+
+This command says "store the state of the zippers_development database as my
+target version".
+
+Now, go back to your master branch and load its database into
+zippers_development, then dump the contents.
+
+% mysql-inspector --current zippers_development --write
+
+Now, in order to write database migrations for master to smoother let's see
+what changes occurred.
+
+% mysql-inspector --diff
+
+[[ show sample output ]]
+
+Here we see that our target version contains one column that the current
+version does not. It's easy to write an alter statement, in fact most of the
+information is right here.
+
+mysql% alter table zippers add column metal_grade int(11) NOT NULL DEFAULT '0';
+
+Now we can compare the two again. This time we need to add the --force argument
+to say that it's ok to overwrite the previous dump.
+
+% mysql-inspector --current zippers_development --write --force
+% mysql-inspector --diff
+
+No differences!
+
+That was pretty simple. Is there more?
+
+Sure.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "mysql-inspector"
+    gemspec.summary = "Tools for identifying changes to a MySQL schema"
+    gemspec.email = "ryan@fivesevensix.com"
+    gemspec.homepage = "http://github.com/rcarver/mysql-inspector"
+    gemspec.authors = ["Ryan Carver"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/mysql-inspector

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require "lib/mysql-inspector"
+
+options = {
+  :databases => [],
+  :versions => [],
+  :base_dir => ".",
+  :diff => false,
+  :grep => false,
+  :dump => false,
+  :clean => false
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: ????"
+
+  opts.on("-c", "--current [db]") do |db_name|
+    options[:versions] << "current"
+    options[:databases] << db_name
+  end
+
+  opts.on("-t", "--target [db]") do |db_name|
+    options[:versions] << "target"
+    options[:databases] << db_name
+  end
+
+  opts.on("-w", "--write") do |yes|
+    options[:dump] = true
+  end
+
+  opts.on("-f", "--fresh") do |ok|
+    options[:clean] = true
+  end
+
+  opts.on("-g", "--grep foo_id,bar_id") do |columns|
+    options[:grep] = columns.split(",").collect { |c| c.strip }
+  end
+
+  opts.on("-d", "--diff") do |info|
+    options[:diff] = true
+  end
+
+end.parse!
+
+options[:versions].compact!
+options[:databases].compact!
+
+options[:versions].collect! do |version|
+  MysqlInspector::Dump.new(version, options[:base_dir])
+end
+
+if options[:clean]
+  options[:versions].each { |v| v.clean! }
+end
+
+if options[:dump]
+  raise "Missing database names" unless options[:versions].size == options[:databases].size
+  options[:versions].zip(options[:databases]).each do |v, d|
+    v.dump!(d)
+  end
+end
+
+if options[:grep]
+  options[:versions].each do |v|
+    grep = MysqlInspector::Grep.new(v)
+    grep.find(STDOUT, *options[:grep])
+  end
+end
+
+if options[:diff]
+  inputs = ["current", "target"].collect { |version| MysqlInspector::Dump.new(version, options[:base_dir]) }
+  comparison = MysqlInspector::Comparison.new(*inputs)
+  comparison.compare(STDOUT)
+end

data/lib/mysql-inspector.rb

@@ -0,0 +1,210 @@
+require "fileutils"
+
+module MysqlInspector
+
+  module Config
+    extend self
+
+    def mysqldump(*args)
+      all_args = ["-u #{mysql_user}"] + args
+      Command.new(mysqldump_path, *all_args)
+    end
+
+    def mysql_user
+      @mysql_user ||= "root"
+    end
+
+    def mysqldump_path
+      @mysqldump_path ||= begin
+        path = `which mysqldump`.chomp
+        raise "mysqldump was not in your path" if path.empty?
+        path
+      end
+    end
+  end
+
+  class Command
+    def initialize(path, *args)
+      @path = path
+      @args = args
+    end
+    def to_s
+      "#{@path} #{@args * " "}"
+    end
+    def run!
+      system to_s
+    end
+  end
+
+  class Dump
+    def initialize(version, base_dir)
+      @version = version
+      @base_dir = base_dir
+      # TODO: sanity check base_dir for either a relative dir or /tmp/...
+    end
+
+    attr_reader :version, :base_dir
+
+    def db_name
+      @db_name ||= read_db_name
+    end
+
+    def dir
+      File.join(base_dir, version)
+    end
+
+    def clean!
+      FileUtils.rm_rf(dir)
+    end
+
+    def dump!(db_name)
+      raise "Destination exists! (#{dir.inspect})" if File.exist?(dir)
+      @db_name = db_name
+      FileUtils.mkdir_p(dir)
+      Config.mysqldump("--no-data", "-T #{dir}", "--skip-opt", db_name).run!
+      File.open(info_file, "w") { |f| f.puts(db_name) }
+    end
+
+  protected
+
+    def info_file
+      File.join(dir, ".info")
+    end
+
+    def read_db_name
+      raise "No dump exists at #{dir.inspect}" unless File.exist?(info_file)
+      File.read(info_file).strip
+    end
+  end
+
+  module Utils
+
+    def file_to_table(file)
+      file[/(.*)\.sql/, 1]
+    end
+
+    def sanitize_schema!(schema)
+      schema.collect! { |line| line.rstrip[/(.*?),?$/, 1] }
+      schema.delete_if { |line| line =~ /(\/\*|--|CREATE TABLE)/ or line == ");" or line.strip.empty? }
+      schema.sort!
+      schema
+    end
+  end
+
+  class Grep
+    include Utils
+
+    def initialize(dump)
+      @dump = dump
+    end
+
+    attr_reader :dump
+
+    def find(writer, *matchers)
+      writer.puts
+      writer.puts "Searching #{dump.version} (#{dump.db_name}) for #{matchers.inspect}"
+      writer.puts
+      files = Dir[File.join(dump.dir, "*.sql")].collect { |f| File.basename(f) }.sort
+      files.each do |f|
+        schema = File.read(File.join(dump.dir, f)).split("\n")
+        sanitize_schema!(schema)
+
+        matches = schema.select do |line|
+          matchers.all? do |matcher|
+            col, *items = matcher.split(/\s+/)
+            col = "`#{col}`"
+            [col, items].flatten.all? { |item| line.downcase =~ /#{Regexp.escape item.downcase}/ }
+          end
+        end
+
+        if matches.any?
+        writer.puts
+          writer.puts file_to_table(f)
+          writer.puts "*" * file_to_table(f).size
+          writer.puts
+          writer.puts "Found matching:"
+          writer.puts matches.join("\n")
+          writer.puts
+          writer.puts "Full schema:"
+          writer.puts schema.join("\n")
+        writer.puts
+        end
+      end
+    end
+  end
+
+  class Comparison
+    include Utils
+
+    def initialize(current, target)
+      @current = current
+      @target = target
+    end
+
+    attr_reader :current, :target
+
+    def ignore_files
+      ["migration_info.sql"]
+    end
+
+    def compare(writer=STDOUT)
+      writer.puts
+      writer.puts "Current: #{current.version} (#{current.db_name})"
+      writer.puts "Target:  #{target.version} (#{target.db_name})"
+
+      current_files = Dir[File.join(current.dir, "*.sql")].collect { |f| File.basename(f) }.sort
+      target_files = Dir[File.join(target.dir, "*.sql")].collect { |f| File.basename(f) }.sort
+
+      # Ignore some tables
+      current_files -= ignore_files
+      target_files -= ignore_files
+
+      files_only_in_target = target_files - current_files
+      files_only_in_current = current_files - target_files
+      common_files = target_files & current_files
+
+      if files_only_in_current.any?
+        writer.puts
+        writer.puts "Tables only in current"
+        writer.puts files_only_in_current.collect { |f| file_to_table(f) }.join(", ")
+      end
+
+      if files_only_in_target.any?
+        writer.puts
+        writer.puts "Tables in target but not in current"
+        writer.puts files_only_in_target.collect { |f| file_to_table(f) }.join(", ")
+      end
+
+      common_files.each do |f|
+        current_schema = File.read(File.join(current.dir, f)).split("\n")
+        target_schema = File.read(File.join(target.dir, f)).split("\n")
+
+        sanitize_schema!(current_schema)
+        sanitize_schema!(target_schema)
+
+        next if current_schema == target_schema
+
+        writer.puts
+        writer.puts file_to_table(f)
+        writer.puts "*" * file_to_table(f).size
+        writer.puts
+
+        only_in_target = target_schema - current_schema
+        only_in_current = current_schema - target_schema
+
+        if only_in_current.any?
+          writer.puts "only in current"
+          writer.puts only_in_current.join("\n")
+          writer.puts
+        end
+        if only_in_target.any?
+          writer.puts "only in target"
+          writer.puts only_in_target.join("\n")
+          writer.puts
+        end
+      end
+    end
+
+  end
+
+end

data/mysql-inspector.gemspec

@@ -0,0 +1,44 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mysql-inspector}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ryan Carver"]
+  s.date = %q{2010-03-03}
+  s.default_executable = %q{mysql-inspector}
+  s.email = %q{ryan@fivesevensix.com}
+  s.executables = ["mysql-inspector"]
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "bin/mysql-inspector",
+     "lib/mysql-inspector.rb",
+     "mysql-inspector.gemspec"
+  ]
+  s.homepage = %q{http://github.com/rcarver/mysql-inspector}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Tools for identifying changes to a MySQL schema}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: mysql-inspector
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Ryan Carver
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-03 00:00:00 -08:00
+default_executable: mysql-inspector
+dependencies: []
+
+description: 
+email: ryan@fivesevensix.com
+executables: 
+- mysql-inspector
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- bin/mysql-inspector
+- lib/mysql-inspector.rb
+- mysql-inspector.gemspec
+has_rdoc: true
+homepage: http://github.com/rcarver/mysql-inspector
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Tools for identifying changes to a MySQL schema
+test_files: []
+