mysql-inspector 0.0.6 → 0.1.0

data/lib/mysql_inspector/config.rb

@@ -0,0 +1,82 @@
+module MysqlInspector
+  class Config
+
+    def initialize
+      @mysql_user = "root"
+      @mysql_password = nil
+      @mysql_binary = "mysql"
+      @dir = File.expand_path(Dir.pwd)
+      @migrations = false
+      @rails = false
+    end
+
+    #
+    # Config
+    #
+
+    attr_accessor :mysql_user
+    attr_accessor :mysql_password
+    attr_accessor :mysql_binary
+
+    attr_accessor :database_name
+    attr_accessor :dir
+
+    attr_accessor :migrations
+    attr_accessor :rails
+
+    def rails!
+      @rails = true
+      @migrations = true
+      @dir = "db"
+    end
+
+    #
+    # API
+    #
+
+    def create_dump(version)
+      raise ["Missing dir or version", dir, version].inspect if dir.nil? or version.nil?
+      file = File.join(dir, version)
+      extras = []
+      extras << Migrations.new(file) if migrations
+      Dump.new(file, *extras)
+    end
+
+    def write_dump(version)
+      create_dump(version).write!(access)
+    end
+
+    def load_dump(version)
+      create_dump(version).load!(access)
+    end
+
+    #
+    # Impl
+    #
+
+    def load_rails_env!
+      if rails
+        if !defined?(Rails)
+          rails_env = File.expand_path('config/environment',  Dir.pwd)
+          if File.exist?(rails_env + ".rb")
+            require rails_env
+          end
+        end
+        if database_name
+          config = ActiveRecord::Base.configurations[database_name]
+          config or raise MysqlInspector::Access::Error, "The database configuration #{database_name.inspect} does not exist"
+          ActiveRecord::Base.establish_connection(config)
+        end
+      end
+    end
+
+    def access
+      load_rails_env!
+      if migrations
+        MysqlInspector::AR::Access.new(ActiveRecord::Base.connection)
+      else
+        MysqlInspector::Access.new(database_name, mysql_user, mysql_password, mysql_binary)
+      end
+    end
+  end
+end

data/lib/mysql_inspector/constraint.rb

@@ -0,0 +1,28 @@
+module MysqlInspector
+  class Constraint < Struct.new(:name, :column_names, :foreign_table, :foreign_column_names, :on_update, :on_delete)
+
+    include MysqlInspector::TablePart
+
+    def to_sql
+      parts = []
+      parts << "CONSTRAINT"
+      parts << quote(name)
+      parts << "FOREIGN KEY"
+      parts << paren(column_names.map { |c| quote(c) })
+      parts << "REFERENCES"
+      parts << quote(foreign_table)
+      parts << paren(foreign_column_names.map { |c| quote(c) })
+      parts << "ON DELETE #{on_delete}"
+      parts << "ON UPDATE #{on_update}"
+      parts * " "
+    end
+
+    def =~(matcher)
+      name =~ matcher ||
+        column_names.any? { |c| c =~ matcher } ||
+        foreign_table =~ matcher ||
+        foreign_column_names.any? { |c| c =~ matcher }
+    end
+
+  end
+end

data/lib/mysql_inspector/diff.rb

@@ -0,0 +1,82 @@
+module MysqlInspector
+  class Diff
+
+    def initialize(current_dump, target_dump)
+      @current_dump = current_dump
+      @target_dump = target_dump
+    end
+
+    attr_reader :added_tables
+    attr_reader :missing_tables
+    attr_reader :equal_tables
+    attr_reader :different_tables
+
+    def execute
+      @added_tables = []
+      @missing_tables = []
+      @equal_tables = []
+      @different_tables = []
+
+      target_tables = Hash[*@target_dump.tables.map { |t| [t.table_name, t] }.flatten]
+      current_tables = Hash[*@current_dump.tables.map { |t| [t.table_name, t] }.flatten]
+
+      (target_tables.keys + current_tables.keys).uniq.each { |n|
+        target = target_tables[n]
+        current = current_tables[n]
+        if target && current
+          if target == current
+            @equal_tables << target
+          else
+            @different_tables << TableDiff.new(target, current)
+          end
+        else
+          @added_tables << target if target_tables.has_key?(n)
+          @missing_tables << current if current_tables.has_key?(n)
+        end
+      }
+    end
+
+  protected
+
+    class TableDiff
+
+      def initialize(target_table, current_table)
+        @target_table = target_table
+        @current_table = current_table
+      end
+
+      def table_name
+        @target_table.table_name
+      end
+
+      def added_columns
+        @target_table.columns - @current_table.columns
+      end
+
+      def missing_columns
+        @current_table.columns - @target_table.columns
+      end
+
+      def added_indices
+        @target_table.indices - @current_table.indices
+      end
+
+      def missing_indices
+        @current_table.indices - @target_table.indices
+      end
+
+      def added_constraints
+        @target_table.constraints - @current_table.constraints
+      end
+
+      def missing_constraints
+        @current_table.constraints - @target_table.constraints
+      end
+
+      def <=>(other)
+        table_name <=> other.table_name
+      end
+    end
+
+  end
+end

data/lib/mysql_inspector/dump.rb

@@ -0,0 +1,70 @@
+module MysqlInspector
+  class Dump
+
+    def initialize(dir, *extras)
+      @dir = dir
+      @extras = extras
+    end
+
+    # Public: Get the dump directory.
+    #
+    # Returns a String.
+    attr_reader :dir
+
+    # Public: Delete this dump from the filesystem.
+    #
+    # Returns nothing.
+    def clean!
+      FileUtils.rm_rf(dir)
+    end
+
+    # Public: Determine if a dump currently exists at the dump directory.
+    #
+    # Returns a boolean.
+    def exists?
+      Dir[File.join(dir, "*")].any?
+    end
+
+    # Public: Get the tables written by the dump.
+    #
+    # Returns an Array of MysqlInspector::Table.
+    def tables
+      Dir[File.join(dir, "*.table")].map { |file| Table.new(File.read(file)) }
+    end
+
+    # Public: Write to the dump directory. Any existing dump will be deleted.
+    #
+    # access - Instance of Access.
+    #
+    # Returns nothing.
+    def write!(access)
+      clean! if exists?
+      FileUtils.mkdir_p(dir)
+      begin
+        access.tables.each { |table|
+          File.open(File.join(dir, "#{table.table_name}.table"), "w") { |f|
+            f.print table.to_simple_schema
+          }
+        }
+        @extras.each { |extra| extra.write!(access) }
+      rescue
+        FileUtils.rm_rf(dir) # note this does not remove all the dirs that may have been created.
+        raise
+      end
+    end
+
+    # Public: Load this dump into a database. All existing tables will
+    # be deleted from the database and replaced by those from this dump.
+    #
+    # access - Instance of Access.
+    #
+    # Returns nothing.
+    def load!(access)
+      schema = tables.map { |t| t.to_sql }.join(";")
+      access.drop_all_tables
+      access.load(schema)
+      @extras.each { |extra| extra.load!(access) }
+    end
+
+  end
+end

data/lib/mysql_inspector/grep.rb

@@ -0,0 +1,65 @@
+module MysqlInspector
+  class Grep
+
+    def initialize(dump, matchers)
+      @dump = dump
+      @matchers = matchers
+      @columns = []
+      @indices = []
+      @constraints = []
+    end
+
+    attr_reader :columns
+    attr_reader :indices
+    attr_reader :constraints
+
+    def execute
+      @columns = []
+      @indices = []
+      @constraints = []
+      @dump.tables.each { |table|
+        @columns.concat find(table.columns)
+        @indices.concat find(table.indices)
+        @constraints.concat find(table.constraints)
+      }
+      @columns.sort!
+      @indices.sort!
+      @constraints.sort!
+    end
+
+    def any_matches?
+      (columns + indices + constraints).any?
+    end
+
+    def tables
+      (columns + indices + constraints).map { |x| x.table }.uniq.sort
+    end
+
+    def each_table
+      tables.each { |t| yield t, in_table(t) }
+    end
+
+    class Subset < Struct.new(:columns, :indices, :constraints)
+      def any_matches?
+        (columns + indices + constraints).any?
+      end
+    end
+
+    def in_table(table)
+      Subset.new(
+        @columns.find_all { |c| c.table == table },
+        @indices.find_all { |i| i.table == table },
+        @constraints.find_all { |c| c.table == table }
+      )
+    end
+
+  protected
+
+    def find(parts)
+      parts.find_all { |col|
+        @matchers.all? { |m| col =~ m }
+      }
+    end
+
+  end
+end

data/lib/mysql_inspector/index.rb

@@ -0,0 +1,25 @@
+module MysqlInspector
+  class Index < Struct.new(:name, :column_names, :unique)
+
+    include MysqlInspector::TablePart
+
+    def to_sql
+      parts = []
+      if name == "PRIMARY KEY" && unique
+        parts << "PRIMARY KEY"
+        parts << paren(column_names.map { |c| quote(c) })
+      else
+        parts << "UNIQUE" if unique
+        parts << "KEY"
+        parts << quote(name)
+        parts << paren(column_names.map { |c| quote(c) })
+      end
+      parts * " "
+    end
+
+    def =~(matcher)
+      name =~ matcher || column_names.any? { |c| c =~ matcher }
+    end
+
+  end
+end

data/lib/mysql_inspector/migrations.rb

@@ -0,0 +1,37 @@
+module MysqlInspector
+  class Migrations
+
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def write!(access)
+      migrations = access.read_migrations(migrations_table_name)
+      File.open(File.join(@dir, "#{migrations_table_name}.tsv"), "w") { |f|
+        f.puts migrations.sort.join("\n")
+      }
+    end
+
+    def load!(access)
+      access.write_migrations(migrations_table_name, migrations_column, migrations)
+    end
+
+    def migrations_table_name
+      "schema_migrations"
+    end
+
+    def migrations_column
+      "version"
+    end
+
+    def migrations
+      file = File.join(@dir, "#{migrations_table_name}.tsv")
+      if File.exist?(file)
+        File.readlines(file).map { |line| line.chomp }
+      else
+        []
+      end
+    end
+
+  end
+end

data/lib/mysql_inspector/railtie.rb

@@ -0,0 +1,17 @@
+require 'mysql_inspector'
+
+# Ensure that ActiveRecord has initialized.
+require "active_record/railtie"
+
+module MysqlInspector
+  class Railtie < Rails::Railtie
+
+    # Store your schema in the MysqlInspector schema format.
+    config.active_record.schema_format = :mysql_inspector
+
+    rake_tasks do
+      load "mysql_inspector/railties/databases.rake"
+    end
+  end
+end
+

data/lib/mysql_inspector/railties/databases.rake

@@ -0,0 +1,92 @@
+# This file patches ActiveRecord's databases.rake so that when you dump and
+# load databases it goes through mysql-inspector. Patching the existing rake
+# tasks is very brittle do the spaghetti nature of the existing code, so if a
+# specific task doesn't work please file an issue.
+
+mysql_inspector_db_namespace = namespace :db do
+
+  def mysql_inspector_config(database=nil)
+    config = MysqlInspector::Config.new
+    config.rails!
+    config.database_name = database if database
+    config
+  end
+
+
+  #
+  # Rewrite public the db:setup task.
+  #
+
+  # Totally reset the setup task.
+  task(:setup).clear_prerequisites.clear_actions
+
+  # Redefine the setup task to use mysql_inspector.
+  task :setup => ['db:create', 'mysql_inspector:load']
+
+
+  #
+  # Rewrite internal the db:_dump task.
+  #
+
+  # Totally reset the _dump task.
+  task(:_dump).clear_prerequisites.clear_actions
+
+  # Redefine the dump task to always call mysql_inspector:dump.
+  task :_dump => "db:mysql_inspector:dump" do
+    # Allow this task to be called as many times as required. An example is the
+    # migrate:redo task, which calls other two internally that depend on this one.
+    mysql_inspector_db_namespace['_dump'].reenable
+  end
+
+
+  #
+  # Fix that abort_if_pending_migrations does not properly connect to a database.
+  #
+
+  # Reset the prerequisites for the migration check.
+  task(:abort_if_pending_migrations).clear_prerequisites
+
+  # Fix that we need to connect to the dev database.
+  task :abort_if_pending_migrations => :mysql_inspector_connect_to_dev
+  task :mysql_inspector_connect_to_dev do
+    ActiveRecord::Base.establish_connection(:development)
+  end
+
+
+  namespace :test do
+
+    #
+    # Rewrite the public db:prepare task.
+    #
+
+    # Totally reset the db:test:prepare task.
+    task(:prepare).clear_prerequisites.clear_actions
+
+    # Redefine db:test:prepare to load the mysql_inspector structure.
+    task :prepare => ["db:test:purge", "db:abort_if_pending_migrations", "db:mysql_inspector:load_to_test"]
+  end
+
+
+  #
+  # mysql_inspector tasks.
+  #
+
+  namespace :mysql_inspector do
+
+    desc "Write the current development database to db/current"
+    task :dump => :environment do
+      mysql_inspector_config("development").write_dump("current")
+    end
+
+    desc "Load the development database from db/current"
+    task :load => [:environment, :load_config] do
+      mysql_inspector_config("development").load_dump("current")
+    end
+
+    # Internal: Load the test database from db/current.
+    task :load_to_test do
+      mysql_inspector_config("test").load_dump("current")
+    end
+  end
+
+end