mysql-inspector 0.0.6 → 0.1.0

data/.gitignore

@@ -1,3 +1,5 @@
-current
-target
-pkg
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+
+0.0.9 / 2013-05-26 
+==================
+
+  * Total rewrite:
+  * Custom storage format
+  * Better CLI interface
+  * Can act as a Railtie to replace ActiveRecord schema management

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "activerecord", ">=3.2", :require => false
+gem "mysql2", :require => false

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Ryan Carver
+
+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/README.md

@@ -0,0 +1,82 @@
+# mysql-inspector
+
+mysql-inspector is a command line tool that helps you understand your
+MySQL database schema. It works by writing a special type of dump file
+to disk and then parsing it for various purposes.
+
+## Usage
+
+mysql-inspector supports several useful commands, but the first thing
+you'll want to do is write at least one copy of your database to disk.
+
+### write
+
+Write a copy of your database to disk for mysql-inspector to operate on.
+You can name this copy whatever you want, by default it's called
+`current`.
+
+    mysql-inspector write my_database
+
+The result of this command will be a directory full of `.table` files at
+`./current`, one for each table in your database. A `.table` file is a
+simplified and consistent representation of a table. Most importantly,
+it will not change arbitrarly like a `mysqldump` file if the order of
+columns changes or an `AUTO_INCREMENT` value is defined on the table.
+mysql-inspector is purely concerned with the relational structure of the
+table and favors this over an exact representation of the current
+database schema. In practice, this means that you can commit this
+directory to source control and easily view diffs over time without
+excess line noise.
+
+### grep
+
+Search your entire database for columns, indices and constraints that
+match a string or regex. For example, find everything that includes
+'user_id' to see which tables relate to a user.
+
+    mysql-inspector grep user_id
+    mysql-inspector grep '^name'
+
+Multiple matchers may be specified, which are AND'd together.
+
+    mysql-inspector grep first name
+
+### diff
+
+Compare two schemas against each other. Perhaps your local development
+and production databases have gone out of sync. First write a copy of
+each and then let mysql-inspector show you the tables and attributes
+that differ.
+
+By default, a diff is performed on dumps named `current` and `target`.
+
+    mysql-inspector write dev_database current
+    mysql-inspector write prod_database target
+    mysql-inspector diff
+
+### load
+
+Restore a version of your database schema. By default, the `current`
+schema is used.
+
+    mysql-inspector load my_database
+
+## Rails and ActiveRecord Migrations
+
+mysql-inspector can help you manage your database schema in a Rails
+project. It replaces rake tasks such as `db:structure:dump` and writes
+its own version at `db/current` instead of `db/structure.sql`. You'll
+find this format much more convenient for checking into version control.
+
+When a `schema_migrations` table is found, mysql-inspector writes its
+contents to a file called `schema_migrations` within the dump directory.
+When a dump is loaded via `mysql-inspector load` or `rake
+db:structure:load`, the migrations will be restored.
+
+## Author
+
+Ryan Carver (@rcarver / ryan@ryancarver.com)
+
+## License
+
+Copyright © 2012 Ryan Carver. Licensed under Ruby/MIT, see LICENSE.

data/Rakefile

@@ -1,14 +1,36 @@
-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"]
-    gemspec.executables = ["mysql-inspector"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
-end
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+task :test => [:test_default, :test_ar]
+
+Rake::TestTask.new(:test_default) do |t|
+  t.libs.push "lib", "test"
+  t.pattern = 'test/mysql_inspector/**/*_test.rb'
+end
+
+Rake::TestTask.new(:test_ar) do |t|
+  t.libs.push "lib", "test"
+  t.pattern = 'test/mysql_inspector_ar/**/*_test.rb'
+end
+
+
+def load_schema(name)
+  $LOAD_PATH.unshift "test"
+  require 'helpers/mysql_schemas'
+  require 'helpers/mysql_utils'
+
+  schemas = Object.new
+  schemas.extend MysqlSchemas
+
+  MysqlUtils.create_mysql_database("mysql_inspector_development", schemas.send(name))
+end
+
+task :db1 do
+  load_schema(:schema_a)
+end
+
+task :db2 do
+  load_schema(:schema_b)
+end

data/bin/mysql-inspector

@@ -1,94 +1,18 @@
 #!/usr/bin/env ruby
 
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'optparse'
-require "mysql-inspector"
 
-options = {
-  :versions => [],
-  :base_dir => ".",
-  :diff => false,
-  :grep => false,
-  :write => false,
-  :clean => false
-}
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: #{File.basename $0} [options]"
-
-  opts.on("-c", "--current", "Perform the given action(s) with the current version.") do
-    options[:versions] << "current"
-  end
-
-  opts.on("-t", "--target", "Perform the given action(s) with the target version.") do
-    options[:versions] << "target"
-  end
-
-  opts.on("-w", "--write DB", "Store a schema for the database") do |db_name|
-    options[:write] = db_name
-  end
-
-  opts.on("-f", "--force", "Overwrite a previously stored schema") do |ok|
-    options[:clean] = true
-  end
-
-  opts.on("-d", "--diff", "Output a comparison between the current and target schemas") do |info|
-    options[:diff] = true
-  end
-
-  opts.on("-g", "--grep foo_id,bar_id", "Find columns and/or indices matching the pattern") do |columns|
-    options[:grep] = columns.split(",").collect { |c| c.strip }
-  end
-
-  opts.on("--to DIR", "Where to store schemas. Defaults to '.'") do |dir|
-    options[:base_dir] = dir
-  end
-
-  opts.on("-h", "--help", "What you're looking at") do
-    puts opts
-  end
-
-  puts opts if ARGV.empty?
-
-end.parse!
-
-def how_to_write_version(input)
-  "#{File.basename $0} --#{input.version} --write DB_NAME"
+# Detect a Rails project.
+rails_env = File.expand_path('config/environment',  Dir.pwd)
+if File.exist?(rails_env + ".rb")
+  ARGV.unshift("--rails")
 end
 
-begin
+require "mysql_inspector"
 
-  options[:versions].collect! do |version|
-    MysqlInspector::Dump.new(version, options[:base_dir])
-  end
+config = MysqlInspector::Config.new
 
-  if options[:clean]
-    options[:versions].each { |v| v.clean! }
-  end
+cli = MysqlInspector::CLI.new(config, $stdout, $stderr)
+cli.run!(ARGV)
 
-  if options[:write]
-    raise MysqlInspector::Precondition, "Please specify which version to write" if options[:versions].size == 0
-    raise MysqlInspector::Precondition, "I can only write one version at a time" unless options[:versions].size == 1
-    version = options[:versions].first
-    version.dump!(options[:write])
-  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]) }
-    inputs.each do |input|
-      raise MysqlInspector::Precondition, "No #{input.version} version exists. Write one with `#{how_to_write_version(input)}`" unless input.exists?
-    end
-    comparison = MysqlInspector::Comparison.new(*inputs)
-    comparison.compare(STDOUT)
-  end
-
-rescue MysqlInspector::Precondition => e
-  puts "#{e.message}."
-end
+exit cli.status

data/lib/mysql-inspector.rb

@@ -1,226 +1 @@
-require "fileutils"
-
-module MysqlInspector
-
-  Precondition = Class.new(StandardError)
-
-  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
-
-  module Config
-    extend self
-    extend Utils
-
-    def mysqldump(*args)
-      all_args = ["-u #{mysql_user}"] + args
-      Command.new(mysqldump_path, *all_args)
-    end
-
-    def strip_noise_from_dump!(dir)
-      Dir[File.join(dir, "*.sql")].each do |file|
-        lines = sanitize_schema!(File.readlines(file))
-        File.open(file, "w") do |f|
-          f.puts lines.join("\n")
-        end
-      end
-    end
-
-    def mysql_user
-      @mysql_user ||= "root"
-    end
-
-    def mysqldump_path
-      @mysqldump_path ||= begin
-        path = `which mysqldump`.chomp
-        raise Precondition, "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_date
-      @db_date ||= read_db_date
-    end
-
-    def dir
-      File.join(base_dir, version)
-    end
-
-    def clean!
-      FileUtils.rm_rf(dir)
-    end
-
-    def exists?
-      File.exist?(dir)
-    end
-
-    def dump!(db_name)
-      raise Precondition, "Can't overwrite an existing schema at #{dir.inspect}" if exists?
-      FileUtils.mkdir_p(dir)
-      Config.mysqldump("--no-data", "-T #{dir}", "--skip-opt", db_name).run!
-      Config.strip_noise_from_dump!(dir)
-      File.open(info_file, "w") { |f| f.puts(Time.now.utc.strftime("%Y-%m-%d")) }
-    end
-
-  protected
-
-    def info_file
-      File.join(dir, ".info")
-    end
-
-    def read_db_date
-      raise Precondition, "No dump exists at #{dir.inspect}" unless File.exist?(info_file)
-      File.read(info_file).strip
-    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_date}) 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_date})"
-      writer.puts "Target:  #{target.version} (#{target.db_date})"
-
-      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
+require 'mysql_inspector'