db_structure_ext 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+log/*.log

data/Gemfile.ar01_r186

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "mysql", "2.7"
+gem "activerecord", "1.15.6"
+
+gem "rspec", "1.1.12"

data/Gemfile.ar01_r186.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    db_structure_ext (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activerecord (1.15.6)
+      activesupport (= 1.4.4)
+    activesupport (1.4.4)
+    mysql (2.7)
+    rspec (1.1.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (= 1.15.6)
+  db_structure_ext!
+  mysql (= 2.7)
+  rspec (= 1.1.12)

data/Gemfile.ar30_r192

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "mysql2", "0.2.11"
+gem "activerecord", "3.0.10"
+
+gem "rspec", "2.6.0"

data/Gemfile.ar30_r192.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    db_structure_ext (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.10)
+      activesupport (= 3.0.10)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.10)
+      activemodel (= 3.0.10)
+      activesupport (= 3.0.10)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.10)
+    arel (2.0.10)
+    builder (2.1.2)
+    diff-lcs (1.1.3)
+    i18n (0.5.0)
+    mysql2 (0.2.11)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    tzinfo (0.3.30)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (= 3.0.10)
+  db_structure_ext!
+  mysql2 (= 0.2.11)
+  rspec (= 2.6.0)

data/README.md

@@ -0,0 +1,136 @@
+# DbStructureExt
+
+ActiveRecord connection adapter extensions.
+
+Currently it extends only mysql/mysql2 adapter with structure_dump/structure_load methods.
+
+Library **does not override** mysql adapter by default.
+
+So you can use extensions independently (via MysqlConnectionProxy) or include extension methods into adapter.
+
+## Installation
+
+    gem install db_structure_ext
+
+## Using MysqlConnectionProxy
+
+    connection = ActiveRecord::Base.connection
+    connection_proxy = DbStructureExt::MysqlConnectionProxy.new(connection)
+    connection_proxy.structure_dump
+
+## Extending mysql adapter
+
+    require 'db_structure_ext/init_mysql_adapter'
+    connection.structure_dump
+
+It automaticaly detects corresponding mysql/mysq2 adapter.
+So it should works with any rails version including v1.2.6
+
+## Dump structure
+
+Extended *structure_dump* for mysql/mysql2 adapter dumps not only *tables*. It dumps:
+
+* tables
+* views
+* triggers
+* routines (functions and procedures)
+
+## Load structure
+
+Method loads sql statements separated by *\n\n*
+
+### parallel_test support
+
+It prepends
+
+    ENV['TEST_ENV_NUMBER']
+
+to any table name with *_test* suffix in name
+
+## Rails db tasks extensions
+
+Add to your *Rakefile*
+
+    require 'db_structure_ext/tasks'
+
+In case Rails3 its loaded automaticaly via railtie mechanizm.
+
+### db:structure:dump
+
+Synopsis:
+
+    rake db:structure:dump[env,file]  # Dump the database structure to a SQL file
+
+By default it works as original well-known rails task.
+It dumps development structure to *db/development_structure.sql*
+But it dumps to NOT only TABLES. It dumps also VIEWS, TRIGGERS and ROUTINES.
+
+Additionally you can indicate another *environment* as first argument and optionally another dump *file* as second.
+By default dump filename is *db/{env}_structure.sql*
+
+### db:structure:load
+
+Synopsis:
+
+    rake db:structure:load[env,file]  # Load SQL structure file to the database
+
+Its opposite task to *db:structure:load* that allows to load db structure from specified file to specified db environment.
+The arguments is the same as for previous task.
+
+
+### Examples
+
+Dump *development* structure to db/development_structure.sql file:
+
+    rake db:structure:dump[development,db/development_structure.sql]
+    # or
+    rake db:structure:dump[development]
+    # or
+    RAILS_ENV=development db:structure:dump
+    # or just
+    rake db:structure:dump
+
+Dump development structure to db/my_structure.sql file:
+
+    rake db:structure:dump[development,db/my_structure.sql]
+
+Load db/my_structure.sql to test database:
+
+    rake db:structure:load[test,db/my_structure.sql]
+
+Load db/development_structure.sql to development database:
+
+    rake db:structure:load[development,db/development_structure.sql]
+    # or
+    rake db:structure:load[development]
+    # or
+    RAILS_ENV=development rake db:structure:load[development]
+    # or
+    rake db:structure:load
+
+
+## Testing
+
+We have tested library against AR 1.x.x and AR 3.0.x.
+
+We use [multiversion](https://github.com/railsware/multiversion) gem
+
+It assumes you use RVM and Bundler.
+
+### Create rvm aliases
+
+    rvm alias create ar01_r186 ruby-1.8.6-pYOUR_PATCH_LEVEL
+    rvm alias create ar30_r192 ruby-1.9.2-pYOUR_PATCH_LEVEL
+
+### Install multiversion
+
+    gem install multiversion
+
+### Install gems
+
+    multiversion all bundle install
+
+### Run tests
+
+    multiversion all rspec spec
+

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/config/database.yml

@@ -0,0 +1,8 @@
+test:
+  database: test
+  adapter: <%= defined?(Mysql2) ? 'mysql2' : 'mysql' %>
+  username: root
+  host: localhost
+  encoding: utf8
+  reconnect: false
+  pool: 5

data/db/structure.sql

@@ -0,0 +1,54 @@
+CREATE TABLE `users` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `email` varchar(127) DEFAULT NULL,
+  `state` varchar(127) DEFAULT NULL,
+  `created_at` datetime DEFAULT NULL,
+  `updated_at` datetime DEFAULT NULL,
+  PRIMARY KEY (`id`),
+  KEY `index_review_users_on_email` (`email`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `profiles` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `user_id` int(11) DEFAULT NULL,
+  `address1` varchar(127) DEFAULT NULL,
+  `address2` varchar(127) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE pending_users (
+  `id` int(11),
+  `email` varchar(127)
+) ENGINE=MyISAM;
+
+CREATE TABLE active_users (
+  `id` int(11),
+  `email` varchar(127)
+) ENGINE=MyISAM;
+
+DROP TABLE IF EXISTS pending_users;
+
+DROP VIEW IF EXISTS pending_users;
+
+CREATE VIEW `pending_users` AS select `users`.`id` AS `id`,`users`.`email` AS `email` from `users` where (`users`.`state` = 'pending');
+
+DROP TABLE IF EXISTS active_users;
+
+DROP VIEW IF EXISTS active_users;
+
+CREATE VIEW `active_users` AS select `users`.`id` AS `id`,`users`.`email` AS `email` from `users` where (`users`.`state` = 'active');
+
+CREATE TRIGGER update_user_state_on_insert BEFORE INSERT ON users FOR EACH ROW begin
+  set NEW.state = 'pending';
+end;
+
+CREATE PROCEDURE `fix_user_state`()
+BEGIN
+  UPDATE users SET users.state = 'pending'
+  WHERE  state IS NULL;
+END;
+
+CREATE FUNCTION `hello`(s char(20)) RETURNS char(50) CHARSET utf8
+    DETERMINISTIC
+RETURN CONCAT('Hello, ',s,'!');
+

data/db_structure_ext.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "db_structure_ext/version"
+
+Gem::Specification.new do |s|
+  s.name        = "db_structure_ext"
+  s.version     = DbStructureExt::VERSION
+  s.authors     = ["Andriy Yanko"]
+  s.email       = ["andriy.yanko@gmail.com"]
+  s.homepage    = "https://github.com/railsware/db_structure_ext/"
+  s.summary     = %q{ActiveRecord connection adapter extensions}
+  s.description = %q{Extended rails tasks db:structure:dump/load methods that supports mysql views/triggers/routines}
+
+  s.rubyforge_project = "db_structure_ext"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/db_structure_ext.rb

@@ -0,0 +1,9 @@
+require 'db_structure_ext/version'
+require 'db_structure_ext/railtie' if defined?(Rails::Railtie)
+
+module DbStructureExt
+  autoload :MysqlAdapter,         'db_structure_ext/mysql_adapter'
+  autoload :MysqlConnectionProxy, 'db_structure_ext/mysql_connection_proxy'
+  autoload :MysqlDumpMethods,     'db_structure_ext/mysql_dump_methods'
+  autoload :MysqlLoadMethods,     'db_structure_ext/mysql_load_methods'
+end

data/lib/db_structure_ext/init_mysql_adapter.rb

@@ -0,0 +1,20 @@
+begin
+  require 'mysql2'
+rescue LoadError
+end
+
+begin
+  require 'mysql'
+rescue LoadError
+end
+
+require 'active_record'
+require 'active_record/version'
+
+if defined?(Mysql2)
+  require 'active_record/connection_adapters/mysql2_adapter'
+  ActiveRecord::ConnectionAdapters::Mysql2Adapter.send :include, DbStructureExt::MysqlAdapter
+elsif defined?(Mysql)
+  require 'active_record/connection_adapters/mysql_adapter'
+  ActiveRecord::ConnectionAdapters::MysqlAdapter.send :include, DbStructureExt::MysqlAdapter
+end

data/lib/db_structure_ext/mysql_adapter.rb

@@ -0,0 +1,7 @@
+module DbStructureExt
+  module MysqlAdapter
+    include MysqlDumpMethods
+    include MysqlLoadMethods
+  end
+end
+

data/lib/db_structure_ext/mysql_connection_proxy.rb

@@ -0,0 +1,16 @@
+module DbStructureExt
+  class MysqlConnectionProxy
+
+    include DbStructureExt::MysqlAdapter
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    private
+
+    def method_missing(sym, *args, &block)
+      @connection.__send__(sym, *args, &block)
+    end
+  end
+end

data/lib/db_structure_ext/mysql_dump_methods.rb

@@ -0,0 +1,110 @@
+module DbStructureExt
+  module MysqlDumpMethods
+
+    # Dump mysql base tables
+    def tables_dump
+      structure = ""
+
+      sql = supports_views? ?
+        "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'" : "SHOW TABLES"
+
+      table_names = select_all(sql).map { |table|
+        table.delete('Table_type')
+        table.to_a.first.last
+      }
+
+      table_names.each do |table_name|
+        structure << select_one("SHOW CREATE TABLE `#{table_name}`")["Create Table"]
+        structure << ";\n\n"
+      end
+
+      structure
+    end
+
+    # Dump mysql views
+    def views_dump
+      structure = ""
+      return structure unless supports_views?
+
+      table_names = select_all("SHOW FULL TABLES WHERE Table_type = 'VIEW'").map { |table|
+        table.delete('Table_type')
+        table.to_a.first.last
+      }
+
+      # Temporary structure
+      table_names.each do |table_name|
+        fields = select_all("SHOW FIELDS FROM #{table_name}")
+        structure << "CREATE TABLE #{table_name} (\n"
+        structure << fields.map { |field| "  #{quote_column_name(field['Field'])} #{field['Type']}" }.join(",\n")
+        structure << "\n) ENGINE=MyISAM"
+        structure << ";\n\n"
+      end
+
+      # Final structure
+      table_names.each do |table_name|
+        structure << "DROP TABLE IF EXISTS #{table_name}" 
+        structure << ";\n\n"
+        structure << "DROP VIEW IF EXISTS #{table_name}"
+        structure << ";\n\n"
+        structure << select_one("SHOW CREATE VIEW #{table_name}")["Create View"] 
+        structure << ";\n\n"
+      end
+
+      structure.gsub!(/^(CREATE).+(VIEW)/, '\1 \2')
+
+      structure
+    end
+
+    # dump mysql triggers
+    def triggers_dump
+      structure = ""
+      return structure unless supports_triggers?
+
+      sql = "SHOW TRIGGERS"
+
+      select_all(sql).each do |row|
+        structure << "CREATE TRIGGER #{row['Trigger']} #{row['Timing']} #{row['Event']} ON #{row['Table']} FOR EACH ROW #{row['Statement']}"
+        structure << ";\n\n"
+      end
+
+      structure
+    end
+
+    # dump mysql routines: procedures and functions
+    def routines_dump
+      structure = ""
+      return structure unless supports_routines?
+
+      sql = "SELECT ROUTINE_TYPE as type, ROUTINE_NAME as name FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA='#{current_database}'"
+
+      select_all(sql).each do |row|
+        structure << select_one("SHOW CREATE #{row['type']} #{row['name']}")["Create #{row['type'].capitalize}"]
+        structure.gsub!(/^(CREATE).+(PROCEDURE|FUNCTION)/, '\1 \2')
+        structure << ";\n\n"
+      end
+
+      structure
+    end
+
+    def structure_dump
+      structure = ""
+      structure << tables_dump
+      structure << views_dump
+      structure << triggers_dump
+      structure << routines_dump
+      structure
+    end
+
+    private
+
+    # Does mysql support triggers?
+    def supports_triggers?
+      version[0] >= 5
+    end
+
+    # Does mysql support routines?
+    def supports_routines?
+      version[0] >= 5
+    end
+  end
+end

data/lib/db_structure_ext/mysql_load_methods.rb

@@ -0,0 +1,12 @@
+module DbStructureExt
+  module MysqlLoadMethods
+
+    def structure_load(schema_file)
+      IO.readlines(schema_file).join.split("\n\n").each do |statement|
+        statement.gsub!(/`([\w\d_]+)_test`\./, "`\\1_test#{ENV['TEST_ENV_NUMBER']}`.")
+        execute(statement)
+      end
+    end
+
+  end
+end

data/lib/db_structure_ext/railtie.rb

@@ -0,0 +1,8 @@
+module DbStructureExt
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'db_structure_ext/tasks'
+    end
+  end
+end
+

data/lib/db_structure_ext/tasks.rb

@@ -0,0 +1 @@
+load File.expand_path('../../tasks/database.rake', __FILE__)

data/lib/db_structure_ext/version.rb

@@ -0,0 +1,3 @@
+module DbStructureExt
+  VERSION = "0.0.1"
+end

data/lib/tasks/database.rake

@@ -0,0 +1,46 @@
+# Remove standard rails tasks
+original_db_structure_dump_task = Rake.application.instance_variable_get(:@tasks).delete('db:structure:dump')
+
+namespace :db do
+  namespace :structure do
+
+    desc "Dump the database structure to a SQL file"
+    task :dump, [:env, :file] => :environment do |t, args|
+      env  = args[:env]  || ENV['RAILS_ENV'] || 'development'
+      file = args[:file] || "db/#{env}_structure.sql"
+
+      ActiveRecord::Base.establish_connection(env)
+
+      puts "Dumping #{env} database to #{file}"
+
+      case adapter_name = ActiveRecord::Base.connection.adapter_name
+      when /mysql/i
+        require 'db_structure_ext/mysql_connection_proxy'
+        connection_proxy = DbStructureExt::MysqlConnectionProxy.new(ActiveRecord::Base.connection)
+        File.open(file, "w+") { |f| f << connection_proxy.structure_dump }
+      else
+        original_db_structure_dump_task.invoke
+      end
+    end
+
+    desc "Load SQL structure file to the database"
+    task :load, [:env, :file] => :environment do |t, args|
+      env  = args[:env]  || ENV['RAILS_ENV'] || 'development'
+      file = args[:file] || "db/#{env}_structure.sql"
+
+      ActiveRecord::Base.establish_connection(env)
+
+      puts "Loading #{file} structure to #{env} database"
+
+      case adapter_name = ActiveRecord::Base.connection.adapter_name
+      when /mysql/i
+        require 'db_structure_ext/mysql_connection_proxy'
+        connection_proxy = DbStructureExt::MysqlConnectionProxy.new(ActiveRecord::Base.connection)
+        connection_proxy.structure_load(file)
+      else
+        raise "Task not supported by #{adapter_name.inspect} adapter"
+      end
+    end
+
+  end
+end

data/spec/db_sctructure_ext/mysql_connection_proxy_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe DbStructureExt::MysqlConnectionProxy do
+
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+  before(:all) do
+    @connection_proxy = DbStructureExt::MysqlConnectionProxy.new(connection)
+
+    @all_statements = File.read("db/structure.sql").strip.split("\n\n")
+
+    connection.recreate_database "db_structure_ext_test"
+    connection.execute "USE db_structure_ext_test"
+    @all_statements.each { |statement| connection.execute statement }
+  end
+
+  describe "#tables_dump" do
+    it "should return 'CREATE TABLE' statements" do
+      statements = @connection_proxy.tables_dump.split("\n\n")
+
+      statements.should have(2).items
+
+      statements.should include(@all_statements[0])
+      statements.should include(@all_statements[1])
+    end
+  end
+
+  describe "#views_dump" do
+    it "should return 'CREATE VIEW' statements" do
+      statements = @connection_proxy.views_dump.split("\n\n")
+
+      statements.should have(8).items
+
+      statements.should include(@all_statements[2])
+      statements.should include(@all_statements[3])
+      statements.should include(@all_statements[4])
+      statements.should include(@all_statements[5])
+      statements.should include(@all_statements[6])
+      statements.should include(@all_statements[7])
+      statements.should include(@all_statements[8])
+      statements.should include(@all_statements[9])
+    end
+  end
+
+  describe "#triggers_dump" do
+    it "should return 'CREATE TRIGGER' statements" do
+      statements = @connection_proxy.triggers_dump.split("\n\n")
+
+      statements.should have(1).items
+
+      statements.should include(@all_statements[10])
+    end
+  end
+
+  describe "#routines_dump" do
+    it "should return 'CREATE PROCEDURE' and 'CREATE FUNCTION' statements" do
+      statements = @connection_proxy.routines_dump.split("\n\n")
+
+      statements.should have(2).items
+
+      statements.should include(@all_statements[11])
+      statements.should include(@all_statements[12])
+    end
+  end
+
+  describe "#structure_dump" do
+    it "should return structure with TABLES VIEWS TRIGGER PROCEDURES and FUNCTIONS statements" do
+      statements = @connection_proxy.structure_dump.split("\n\n")
+      statements.should have(13).items
+
+      # tables
+      tables = statements[0..1]
+      tables.should include(@all_statements[0])
+      tables.should include(@all_statements[1])
+
+      # views
+      views = statements[2..9]
+      views.should include(@all_statements[2])
+      views.should include(@all_statements[3])
+      views.should include(@all_statements[4])
+      views.should include(@all_statements[5])
+      views.should include(@all_statements[6])
+      views.should include(@all_statements[7])
+      views.should include(@all_statements[8])
+      views.should include(@all_statements[9])
+
+      # triggers
+      triggers = statements[10..10]
+      triggers.should include(@all_statements[10])
+
+      # routines
+      routines = statements[11..12]
+      routines.should include(@all_statements[11])
+      routines.should include(@all_statements[12])
+    end
+  end
+
+  describe "#structure_load" do
+    before(:all) do
+      connection.recreate_database "db_structure_ext_test"
+      connection.execute "USE db_structure_ext_test"
+    end
+
+    it "should load structures from file to database" do
+      @connection_proxy.structure_load 'db/structure.sql'
+
+      connection.select_values('SHOW TABLES').sort.should == [
+        "active_users", "pending_users", "profiles", "users"
+      ]
+
+      connection.select_all('SHOW TRIGGERS').map { |r| r['Trigger'] }.sort.should == [
+        "update_user_state_on_insert"
+      ]
+
+      connection.select_values("SELECT ROUTINE_NAME FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA='db_structure_ext_test'").sort.should == [
+        "fix_user_state", "hello"
+      ]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# logging
+require 'active_record'
+require 'logger'
+ActiveRecord::Base.logger = ::Logger.new('log/test.log')
+
+# mysql adapter
+require 'active_record/version'
+case ActiveRecord::VERSION::MAJOR
+when 1
+  require 'active_record/connection_adapters/mysql_adapter'
+when 3
+  require 'active_record/connection_adapters/mysql2_adapter'
+end
+
+# mysql connection
+require 'yaml'
+require 'erb'
+ActiveRecord::Base.establish_connection YAML::load(ERB.new(IO.read('config/database.yml')).result)['test']
+
+# lib
+require 'db_structure_ext'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: db_structure_ext
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andriy Yanko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-12 00:00:00 Z
+dependencies: []
+
+description: Extended rails tasks db:structure:dump/load methods that supports mysql views/triggers/routines
+email: 
+- andriy.yanko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile.ar01_r186
+- Gemfile.ar01_r186.lock
+- Gemfile.ar30_r192
+- Gemfile.ar30_r192.lock
+- README.md
+- Rakefile
+- config/database.yml
+- db/structure.sql
+- db_structure_ext.gemspec
+- lib/db_structure_ext.rb
+- lib/db_structure_ext/init_mysql_adapter.rb
+- lib/db_structure_ext/mysql_adapter.rb
+- lib/db_structure_ext/mysql_connection_proxy.rb
+- lib/db_structure_ext/mysql_dump_methods.rb
+- lib/db_structure_ext/mysql_load_methods.rb
+- lib/db_structure_ext/railtie.rb
+- lib/db_structure_ext/tasks.rb
+- lib/db_structure_ext/version.rb
+- lib/tasks/database.rake
+- log/.gitkeep
+- spec/db_sctructure_ext/mysql_connection_proxy_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/railsware/db_structure_ext/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: db_structure_ext
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: ActiveRecord connection adapter extensions
+test_files: 
+- spec/db_sctructure_ext/mysql_connection_proxy_spec.rb
+- spec/spec_helper.rb