database_introspection 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb2ff4ce8131add8f4e7cfc4830240d8ba45df98
+  data.tar.gz: 524b268bdb6f8f11bd6ef6798c00dbf5c5e34bff
+SHA512:
+  metadata.gz: ac56205a6698c903436d4d5935861abad37fce34a7fc0e3652b5f33def754270fb71af500e4dff03a77d9a5ac93efd6456e29787ca0036302cfc83f5d2fc397c
+  data.tar.gz: 3f8fd05f31a29d3cecf0b72d29427c1d5c9121cb42736a96cde92a49bff786f62026ac59e1e6c893ca619dd28a989503bc0050be6026c5c040c703dc059edf70

data/.gitignore

@@ -0,0 +1,47 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+# Standard
+*~
+# Standard Rails project
+/tmp/
+/log/
+/db/*.sqlite3
+# SASS CSS generation
+/public/stylesheets/.sass-cache/
+# Netbeans
+/nbproject/
+# Sublime Text 2 project
+*.sublime-project
+*.sublime-workspace
+*(copie)*
+# RVM
+.rvmrc
+# VisualRuby
+.vr_settings.yaml
+# Emacs
+*# 
+*\# 
+\#*
+.#*
+\#*\#
+# Geany
+*.geany
+# RubyMine
+.idea
+#RedCar
+.redcar

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in database_introspection.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Laurent
+
+MIT License
+
+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,107 @@
+# Database Introspection
+
+This gem will introspect the database and create __dynamically__ ActiveRecord::Base descendants that can be used by your application, including some Rails associations helper methods.
+
+It is intended to be primarily used within rails applications but nothing prevents you to use standalone, provided the fact you are already connected to a database.
+This gem does a bit the reverse action of what you do with Rails generator, when you want to generate the database from you migrations.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'database_introspection'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install database_introspection
+
+## Usage
+
+### Basic database introspection
+
+To introspect the database, you just have to call the following method:
+
+```ruby
+DynamicModel.introspect_database
+```
+
+By default it will analyse all database tables starting by "user_defined_", and will create ActiveRecord::Base descendant to handle them.
+
+For example if your database contains the following tables:
+
+```
+user_defined_table1
+user_defined_table2
+user_defined_table3
+user_defined_table4
+```
+The call to `DynamicModel.introspect_database`, will inject the following classes in your application:
+
+```ruby
+DynamicModel::ManagedDomains::UserDefined::Table1
+DynamicModel::ManagedDomains::UserDefined::Table2
+DynamicModel::ManagedDomains::UserDefined::Table3
+DynamicModel::ManagedDomains::UserDefined::Table4
+```
+
+### Architecture
+
+#### Classes and modules generated
+
+* `DynamicModel` is the module that contains methods to introspect the database.
+* `DynamicModel::ManagedDomain` contains some methods to manipulate the domains introspected.
+* Then for example in the first example, `DynamicModel::ManagedDomains::UserDefined` is a module created dynamically from the domain name (ie tables prefix). It contains itself some methods to easily manipulate the tables or generated classes of this particular domain.
+* The `DynamicModel::ManagedDomains::UserDefined::Tablex` classes are descendants of ActiveRecord::Base that you will use in your application.
+
+Of course if you provide another domain name (ie tables prefix) the corresponding modules and classes will be created accordingly. Running:
+
+```ruby
+DynamicModel.introspect_database :another_domain
+```
+
+On a database containing the following tables:
+
+```
+another_domain_table1
+another_domain_table2
+```
+
+Will inject the following classes in your application:
+
+```ruby
+DynamicModel::ManagedDomains::AnotherDomain::Table1
+DynamicModel::ManagedDomains::AnotherDomain::Table2
+```
+and of course the following module:
+```ruby
+DynamicModel::ManagedDomains::AnotherDomain
+```
+
+#### Generated classes
+
+The classes generated will actually have some behaviour added by extending the module `DynamicModel::ActiveRecordExtension` to basically be aware of the domain they belong to.
+
+### Database relationships
+
+Provided you follow the standard rails rules for ids, for example:
+
+if `user_defined_table1` contains `user_defined_table2_id` (not yet implemented) or `table2_id`, the introspector will understand there is a relationship between the tables and create the ActiveRecord associations accordingly adding all the standard helper methods to the generated classes !
+
+## To do
+
+* Improve Readme.
+* Add code comments.
+* Improve table relationship introspection.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/database_introspection.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'database_introspection/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "database_introspection"
+  spec.version       = DatabaseIntrospection::VERSION
+  spec.authors       = ["L.Briais"]
+  spec.email         = ["lbnetid+rb@gmail.com"]
+  spec.description   = %q{This gem will generate classes (by default ActiveRecord::Base descendants) from database introspection}
+  spec.summary       = %q{Database Introspection}
+  spec.homepage      = "https://github.com/lbriais/database_introspection"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "activemodel", ">= 3.2.13"
+  spec.add_runtime_dependency "activerecord", ">= 3.2.13"
+  spec.add_runtime_dependency "activeresource", ">= 3.2.13"
+  spec.add_runtime_dependency "activesupport", ">= 3.2.13"
+
+
+end

data/lib/database_introspection/dynamic_model/active_record_extension.rb

@@ -0,0 +1,39 @@
+module DynamicModel::ActiveRecordExtension
+
+  def self.included(base) # :nodoc:
+    base.extend ClassMethods
+  end
+
+  # Be very careful with what is added here as it may conflict with whatever is generated by active record.
+  module InstanceMethods
+
+  end
+
+  # This one, only for the class
+  module ClassMethods
+    def to_param
+      "#{self.name_space}/#{self.list_name}"
+    end
+
+    def display_name
+      self.name.gsub(/^.*::([^:]+)$/, "\\1").titleize
+    end
+
+    def domain
+      puts name.gsub(/^.*::[^:]+$/, '')
+      name.gsub(/::[^:]+$/, '').constantize
+    end
+
+    def name_space
+      self.name.gsub( /DynamicModel::ManagedDomains::([^:]+)::.*$/, "\\1") .underscore
+    end
+
+    def list_name
+      self.name.gsub( /^.*::([^:]+)$/, "\\1") .underscore.pluralize
+    end
+
+  end
+
+  include InstanceMethods
+
+end

data/lib/database_introspection/dynamic_model/domain_extension.rb

@@ -0,0 +1,28 @@
+require 'active_record'
+
+module DynamicModel::DomainExtension
+
+  def model_classes
+    self.constants.map {|sym| "#{self.name}::#{sym.to_s}".constantize}
+  end
+
+  def table_names
+    ActiveRecord::Base.connection.tables.grep(/^#{prefix}_/)
+  end
+
+  def scoped_table_names
+    table_names.map{|table_name| table_name.gsub /^#{prefix}_/, ''}
+  end
+
+  def prefix
+    DynamicModel::ManagedDomains.to_hash[self]
+  end
+
+  def add_table(scoped_table_name, &block)
+    DynamicModel.add_table scoped_table_name, table_prefix: prefix, &block
+  end
+
+  def model_class(scoped_table_name)
+    Hash[scoped_table_names.zip model_classes][scoped_table_name]
+  end
+end

data/lib/database_introspection/dynamic_model/managed_domains.rb

@@ -0,0 +1,23 @@
+# Namespace for domains
+module DynamicModel::ManagedDomains
+  def self.domain_prefixes
+    constants.map {|c| c.to_s.underscore}
+  end
+
+  def self.domain_modules
+    constants.map {|c| "#{self.name}::#{c.to_s}".constantize}
+  end
+
+  def self.to_hash
+    Hash[domain_modules.zip domain_prefixes]
+  end
+
+  def self.tables
+    self.domain_modules.map {|mod| mod.table_names}.flatten
+  end
+
+  def self.domain_module(table_prefix)
+    Hash[domain_prefixes.zip domain_modules][table_prefix]
+  end
+
+end

data/lib/database_introspection/dynamic_model/migration.rb

@@ -0,0 +1,13 @@
+require 'active_record'
+class DynamicModel::Migration < ActiveRecord::Migration
+  def self.create_with(name, &block)
+    create_table name.to_sym do |t|
+      block.call(t) if block_given?
+      begin
+        t.timestamps
+      rescue
+        puts "Cannot create timestamps... Probably already created."
+      end
+    end
+  end
+end

data/lib/database_introspection/dynamic_model/relations_analyser.rb

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+class DynamicModel::RelationsAnalyser
+  KEY_IDENTIFIER = /_id$/
+
+  attr_reader :alterations
+
+  def initialize(klasses)
+    @klasses = klasses
+    @alterations = {}
+  end
+
+  def run
+    raise "cannot rerun analysis with the same object... Create a new instance !" if @did_run
+    return if @klasses.empty?
+    @domain = @klasses[0].domain
+    introspect_belongs_to
+    verify_if_has_many_relations_could_be_actually_has_one
+    discover_has_many_through_from_belongs_to
+    apply_alterations
+    @did_run = true
+  end
+
+
+  private
+
+  def discover_has_many_through_from_belongs_to
+    puts "Has_many_through analysis started."
+    @alterations.each do |model, alterations|
+      alterations[:has_many_though] ||= []
+      alterations.each do |association_type, associations|
+        next unless association_type == :belongs_to
+        # If there is only one belongs_to, there cannot be a has_many_through
+        next if associations.size < 2
+        analyses_has_many_through_association model, associations
+      end
+    end
+  ensure
+    puts "Has_many_though analysis completed."
+  end
+
+  def introspect_belongs_to
+    puts "Belongs_to analysis started."
+    scoped_table_names_hash = Hash[@domain.scoped_table_names.zip @domain.model_classes]
+    @klasses.each do |klass|
+      @alterations[klass] ||= {}
+      # Find attributes ending by "_id"
+      klass.attribute_names.grep(KEY_IDENTIFIER) do |attr_name|
+        if klass.columns_hash[attr_name].type == :integer
+          # Check if there is a table in the domain that may be linked to this field
+          candidate_table_name = attr_name.gsub(KEY_IDENTIFIER, '').pluralize
+          candidate_target_class = scoped_table_names_hash[candidate_table_name]
+          # Creates a belongs_to relation
+          if scoped_table_names_hash.keys.include? candidate_table_name
+            @alterations[klass][:belongs_to] ||= []
+            @alterations[klass][:belongs_to] << {
+                key: attr_name,
+                class: candidate_target_class
+            }
+            # and the reverse, by default has_many
+            @alterations[candidate_target_class] ||= {}
+            @alterations[candidate_target_class][:has_many] ||= []
+            @alterations[candidate_target_class][:has_many] << {
+                class: klass
+            }
+          end
+        end
+      end
+    end
+  ensure
+    puts "Belongs_to analysis completed."
+  end
+
+
+  def verify_if_has_many_relations_could_be_actually_has_one
+    puts "Has_many analysis started."
+    @alterations.each do |model, alterations|
+      alterations[:has_one] ||= []
+      alterations.each do |association_type, associations|
+        next unless association_type == :has_many
+        associations.map! do |description|
+          if analyses_has_many_association model, description
+            # This is actually a has_one
+            alterations[:has_one] << description
+            nil
+          else
+            description
+          end
+        end
+        associations.compact!
+      end
+    end
+  ensure
+    puts "Has_many analysis completed."
+  end
+
+  def analyses_has_many_through_association(model, associations)
+    # As there are multiple belongs_to in this class, all combinations
+    # should lead to a has_many_through
+    # Waouh, Ruby rocks !!
+    associations.combination(2).each do |left, right|
+      @alterations[left[:class]][:has_many_through] ||= []
+      @alterations[right[:class]][:has_many_through] ||= []
+
+
+      @alterations[left[:class]][:has_many_through] << {
+        self_key: left[:key],
+        key: right[:key],
+        middle_class: model,
+        class: right[:class]
+      }
+       @alterations[right[:class]][:has_many_through] << {
+        self_key: right[:key],
+        key: left[:key],
+        middle_class: model,
+        class: left[:class]
+      }
+    end
+  end
+
+  def analyses_has_many_association(model, description)
+    # If one day I figure out how to determine if a has_many relation could be a has_one,
+    # should be implemented here... Doesn't look like solvable...
+    false
+  end
+
+
+  def apply_alterations
+    @alterations.each do |model, alterations|
+      puts "Processing alterations for #{model.list_name}"
+      alterations.each do |association_type, associations|
+        associations.each do |description|
+          method_name = "add_#{association_type}_behaviour"
+          self.send method_name, model, description
+        end
+      end
+    end
+  end
+
+
+  def add_belongs_to_behaviour(model, description)
+    field_name = description[:key].gsub KEY_IDENTIFIER, ''
+    model.belongs_to field_name, :foreign_key => description[:key], :class_name => description[:class].name
+    puts " - belongs_to :#{field_name}, :foreign_key => #{description[:key]}, :class_name => #{description[:class].name}"
+  end
+
+  def add_has_many_behaviour(model, description)
+    field_name = description[:class].list_name
+    model.has_many field_name, :class_name => description[:class].name
+    puts " - has_many :#{field_name}, :class_name => #{description[:class].name}"
+  end
+
+  def add_has_many_through_behaviour(model, description)
+    puts " - has_many #{description[:class]} through #{description[:middle_class]}" 
+  end
+
+
+  def add_has_one_behaviour(model, description)
+    field_name = description[:class].list_name.singularize
+    model.has_one field_name, :class_name => description[:class].name
+    puts " - has_one :#{field_name}, :class_name => #{description[:class].name}"
+  end
+
+end

data/lib/database_introspection/dynamic_model/tables_analyser.rb

@@ -0,0 +1,56 @@
+require 'active_record'
+
+class DynamicModel::TablesAnalyser
+
+  attr_reader :domain, :klasses_analysed
+
+  def initialize(domain, base_class = ActiveRecord::Base)
+    @domain = domain
+    @base_class = base_class
+    define_domain_module
+    @klasses_analysed = []
+  end
+
+  def scan_database
+    # Introspect database tables and creates ActiveRecord descendants in the name space module
+    @domain_module.table_names.map do |table_name|
+      inject_class table_name
+    end
+    @domain_module.model_classes
+  end
+
+  private
+
+
+  def inject_class(table_name)
+    short_model_name = table_name.gsub(/#{@domain_module.prefix}_/, '').singularize.camelize
+    klass = nil
+    if @domain_module.constants.include? short_model_name.to_sym
+      klass = @domain_module.const_get short_model_name
+      puts "Found #{klass.name} that already handles #{table_name}"
+    else
+      klass = @domain_module.const_set short_model_name, Class.new(@base_class)
+      puts "Created #{klass.name} to handle #{table_name}"
+      # Adds some class methods
+      klass.send :include, DynamicModel::ActiveRecordExtension
+    end
+
+    # Maps the class to the correct table
+    klass.table_name = table_name
+    # Adds attributes accessible for mass assign
+    klass.attr_accessible *(klass.attribute_names - [klass.primary_key])
+  end
+
+  def define_domain_module
+    domain_name = @domain.singularize.camelize
+    @domain_module = nil
+    if DynamicModel::ManagedDomains.constants.include? domain_name.to_sym
+      @domain_module = DynamicModel::ManagedDomains.const_get domain_name
+    else
+      @domain_module = DynamicModel::ManagedDomains.const_set(domain_name, Module.new)
+      @domain_module.extend DynamicModel::DomainExtension
+    end
+  end
+
+
+end

data/lib/database_introspection/dynamic_model.rb

@@ -0,0 +1,31 @@
+require 'active_record'
+
+module DynamicModel
+
+  # Creates ActiveRecord::Base descendants from the database.
+  # ActiveRecord descendant classes are dynamically created from database introspection in their own namespace
+  # (DynamicModel::<NameSpace>::) The name of the module NameSpace is derived from table_prefix.
+  def self.introspect_database(table_prefix = :user_defined, base_class = ActiveRecord::Base)
+    table_prefix = table_prefix.to_s
+    @domain_analyser ||= {}
+
+    # Confines Activerecord classes into a module named from table_prefix
+    @domain_analyser[table_prefix] ||= DynamicModel::TablesAnalyser.new table_prefix, base_class
+    klasses = @domain_analyser[table_prefix].scan_database
+    relation_analyser = RelationsAnalyser.new klasses
+    relation_analyser.run
+  end
+
+  # Creates a new table with auto numbered id in the database with the name prefix provided
+  # by creating a live migration.
+  # If block is provided it will behave like create_table method for migrations, allowing
+  # to create any other column.
+  def self.add_table(scoped_table_name, table_prefix: :user_defined, &block)
+    scoped_table_name = scoped_table_name.to_s
+    table_prefix = table_prefix.to_s
+    real_table_name = scoped_table_name.underscore.pluralize
+    Migration::create_with "#{table_prefix}_#{real_table_name}", &block
+  end
+
+
+end

data/lib/database_introspection/version.rb

@@ -0,0 +1,3 @@
+module DatabaseIntrospection
+  VERSION = "0.0.9"
+end

data/lib/database_introspection.rb

@@ -0,0 +1,13 @@
+require 'database_introspection/version'
+require 'database_introspection/dynamic_model'
+require 'database_introspection/dynamic_model/active_record_extension'
+require 'database_introspection/dynamic_model/domain_extension'
+require 'database_introspection/dynamic_model/managed_domains'
+require 'database_introspection/dynamic_model/tables_analyser'
+require 'database_introspection/dynamic_model/relations_analyser'
+require 'database_introspection/dynamic_model/migration'
+
+
+module DatabaseIntrospection
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: database_introspection
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: ruby
+authors:
+- L.Briais
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: activeresource
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+description: This gem will generate classes (by default ActiveRecord::Base descendants)
+  from database introspection
+email:
+- lbnetid+rb@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- database_introspection.gemspec
+- lib/database_introspection.rb
+- lib/database_introspection/dynamic_model.rb
+- lib/database_introspection/dynamic_model/active_record_extension.rb
+- lib/database_introspection/dynamic_model/domain_extension.rb
+- lib/database_introspection/dynamic_model/managed_domains.rb
+- lib/database_introspection/dynamic_model/migration.rb
+- lib/database_introspection/dynamic_model/relations_analyser.rb
+- lib/database_introspection/dynamic_model/tables_analyser.rb
+- lib/database_introspection/version.rb
+homepage: https://github.com/lbriais/database_introspection
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0.rc.2
+signing_key: 
+specification_version: 4
+summary: Database Introspection
+test_files: []
+has_rdoc: