meta_db 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e0499ce2a211cd8e953ffd5ce447913f59d7f40d4db6c56b3515d1f0f810d74
+  data.tar.gz: cca551c4c6e6537d267ab140f789977cca5ca2a8ccac12d976527780071e3e02
+SHA512:
+  metadata.gz: 2d8670680900ef650d36a453904f13e635c996e1634ccbf0d9cf197355652eb84f74cb07405f0a62e632a5ee70f5425381886edfddc1eb8d32c42a5065804ee7
+  data.tar.gz: 452f2f681469529b9deb7f7e70ca91cc492c9d7a87d2c0bf22d6c7fd36f7e2e74a1635f6b7a15b80312d793851142fadc5ce9289c62b362e12812b539b07b7db

data/.gitignore

@@ -0,0 +1,18 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# Ignore Gemfile.lock. See https://stackoverflow.com/questions/4151495/should-gemfile-lock-be-included-in-gitignore
+/Gemfile.lock
+
+# Ignore generated yaml and marshall files
+/*.yaml
+/*.marshal

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.6.6

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.5

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in meta_db.gemspec
+gemspec

data/README.md

@@ -0,0 +1,37 @@
+# MetaDb
+
+Models the meta data (schema) of a database. The model implements parts of the
+information schema and extends it with postgresql specific features and
+features for practical use. 
+
+This is work in progress. Use at your own peril
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'meta_db'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install meta_db
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/clrgit/meta_db.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/TODO

@@ -0,0 +1,12 @@
+o Tests
+o Handle trigger constraints
+o Handle exclusion constraints
+o Handle array types better
+
++ Use information_schema
++ Implement Schema
++ Default values
++ Include schemas in [] and lookup on MetaDb::Db
+
+- Rename to PgMeta
+- Implement RDBMS

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "meta_db"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/meta_db.rb

@@ -0,0 +1,182 @@
+require "meta_db/version"
+
+require "indented_io"
+
+require 'pg'
+require 'yaml'
+
+require 'meta_db/connection.rb'
+require 'meta_db/db_object.rb'
+
+module MetaDb
+  # TODO
+  def self.load_yaml(file)
+    YAML.load_file(file)
+  end
+
+  def self.save_yaml(db, file, pretty: true)
+    File.open(file, 'w') do |f|
+      arg = pretty ? { :indentation => 3 } : {}
+      f.write(YAML.dump(db, arg))
+    end
+  end
+
+  def self.load_marshal(file)
+    File.open(file) { |f| Marshal.load(f) }
+  end
+
+  def self.save_marshal(db, file)
+    File.open(file, 'w') { |f| Marshal.dump(db, f) }
+  end
+
+  # The options argument is a hash as PG::Connection options. :host, :port,
+  # :dbname, :user, and :password are some of the most used
+  def self.load_pg_conn(options)
+    PostgresConnection.open(options) { |conn| load_conn(conn) }
+  end
+
+private
+  # Connect to the given database and return a MetaDb::Db object. If host is
+  # nil, a socket is used to connect to the database
+  #
+  # The connection object should support #name and #exec
+  def self.load_conn(conn)
+    # TODO: Start transaction
+
+    # Build database
+    r = conn.select %(
+      select  usename::varchar
+      from    pg_database d
+      join    pg_user u on u.usesysid = d.datdba
+      where   d.datname = '#{conn.database}'
+    )
+    r.size == 1 or raise "Internal error"
+    db = MetaDb::Database.new(conn.database, r.each_array.first)
+
+    # Build schemas
+    conn.select(%(
+      select  schema_name::varchar as name,
+              schema_owner::varchar as owner
+      from    information_schema.schemata
+      where   schema_name !~ '^pg_' AND schema_name <> 'information_schema' 
+    )).each_hash { |row|
+      row[:database] = db
+      MetaDb::Schema.init(row)
+    }
+
+    # Build tables
+    conn.select(%(
+      select  table_schema::varchar as schema,
+              table_name::varchar as name,
+              table_type::varchar as type,
+              is_insertable_into = 'YES' as "insertable?",
+              is_typed = 'YES' as "typed?"
+      from    information_schema.tables
+      where   table_schema !~ '^pg_' AND table_schema <> 'information_schema'
+    )).each_hash { |row|
+      row[:schema] = db.dot row[:schema]
+      klass = (row[:type] == 'VIEW' ? MetaDb::View : MetaDb::Table)
+      klass.init(row)
+    }
+
+    # Build columns
+    conn.select(%(
+      select  table_schema::varchar || '.' || table_name as table,
+              ordinal_position as ordinal,
+              column_name::varchar as name,
+              data_type::varchar as type,
+              column_default as default,
+              is_identity = 'YES' as "identity?",
+              is_generated = 'YES' as "generated?",
+              is_nullable = 'YES' as "nullable?",
+              is_updatable = 'YES' as "updatable?"
+      from    information_schema.columns
+      where   table_schema !~ '^pg_' AND table_schema <> 'information_schema'
+    )).each_hash { |row|
+      row[:table] = db.dot row[:table]
+      MetaDb::Column.init(row)
+    }
+
+    # Build simple constraints
+    conn.select(%(
+      select  c.constraint_type::varchar,
+              c.table_schema || '.' || c.table_name as table,
+              c.constraint_name::varchar as name,
+              cc.check_clause as expression,
+              (
+                select  array_agg(column_name::varchar)
+                from    information_schema.constraint_column_usage ccu
+                where   ccu.table_schema = c.table_schema
+                and     ccu.table_name = c.table_name
+                and     ccu.constraint_schema = c.constraint_schema
+                and     ccu.constraint_name = c.constraint_name
+              ) as columns
+      from    information_schema.table_constraints c
+        left join information_schema.check_constraints cc
+          on cc.constraint_schema = c.table_schema and
+             cc.constraint_name = c.constraint_name
+      where   c.table_schema !~ '^pg_' AND c.table_schema <> 'information_schema'
+      and     c.constraint_type in ('PRIMARY KEY', 'UNIQUE', 'CHECK')
+    )).each_hash { |row|
+      row[:table] = db.dot row[:table]
+      row[:columns] = lookup_columns(row[:table], row[:columns] || [])
+      case row[:constraint_type]
+        when "PRIMARY KEY"; MetaDb::PrimaryKeyConstraint.init(row)
+        when "UNIQUE"; MetaDb::UniqueConstraint.init(row)
+        when "CHECK"; MetaDb::CheckConstraint.init(row)
+      else
+        raise "Oops"
+      end
+    }
+
+    # Build referential constraints
+    #
+    # Referential constraints has to be initialized after unique constraints
+    #
+    # The GROUP BY is necessary because we re-assign constraints from schema to
+    # table. This requires joining key_column_usage again to get the name of
+    # the referenced table and that yields a row for each column in the unique
+    # key (TODO: Can this be omitted?)
+    #
+    conn.select(%(
+      select  rc.constraint_schema::varchar as schema,
+              rc.constraint_name::varchar as name,
+              cu_refing.table_schema || '.' || cu_refing.table_name as "referencing_table",
+              (
+                select  array_agg(column_name::varchar order by ordinal_position)
+                from    information_schema.key_column_usage kcu
+                where   kcu.constraint_name = rc.constraint_name
+              ) as "referencing_columns",
+              cu_refed.table_schema || '.' || cu_refed.table_name || '.' || cu_refed.constraint_name 
+                  as "referenced_constraint"
+      from    information_schema.referential_constraints rc
+      join    information_schema.key_column_usage cu_refing on 
+                  cu_refing.constraint_schema = rc.constraint_schema
+                  and cu_refing.constraint_name = rc.constraint_name
+      join    information_schema.key_column_usage cu_refed on 
+                  cu_refed.constraint_schema = rc.unique_constraint_schema
+                  and cu_refed.constraint_name = rc.unique_constraint_name
+      where   cu_refing.table_schema !~ '^pg_' AND cu_refing.table_schema <> 'information_schema'
+      group by
+              rc.constraint_schema,
+              rc.constraint_name,
+              cu_refing.table_schema,
+              cu_refing.table_name,
+              cu_refed.table_schema,
+              cu_refed.table_name,
+              cu_refed.constraint_name
+    )).each_hash { |row|
+      row[:schema] = db.dot row[:schema]
+      row[:referencing_table] = db.dot row[:referencing_table]
+      row[:referencing_columns] = lookup_columns(row[:referencing_table], row[:referencing_columns])
+      row[:referenced_constraint] = db.dot row[:referenced_constraint]
+      MetaDb::ReferentialConstraint.init(row)
+    }
+    db
+  end
+
+  def self.lookup_columns(table, column_names)
+    column_names.map { |n| table.children[n] }
+  end
+end
+

data/lib/meta_db/connection.rb

@@ -0,0 +1,97 @@
+
+module MetaDb
+  class Connection
+    # In derived classes, no initialization may take place after the call to
+    # super because otherwise #initialize would call the user-supplied block
+    # with a partial initialized object
+    def initialize(options)
+      @conn = self.class.connect(options)
+    end
+
+    def self.open(options, &block)
+      if block_given?
+        begin
+          conn = self.new(options)
+          return yield(conn)
+        ensure
+          conn&.close
+        end
+      else
+        self.new(options)
+      end
+    end
+
+    def host() raise end
+    def port() raise end
+    def database() raise end
+    def user() raise end
+    def password() raise end
+
+    # Escapes s as a SQL string value
+    def escape(s) raise end
+
+    def execute(sql) raise end
+    def select(sql, &block) raise end
+
+    def close() raise end
+    def closed?() raise end
+
+  private
+    def self.connect(options) raise end
+  end
+
+  class Result
+    def initialize(result) @result = result end
+    def size() raise end
+    def each_hash() raise end
+    def each_array() raise end
+    def to_a() each_array end
+  end
+
+  class PostgresResult < Result
+    def size()
+      @result.ntuples
+    end
+
+    def each_hash(&block) 
+      if block_given?
+        each_hash.each(&block)
+      else
+        @result.map { |row| row.map { |field, value| [field.to_sym, value] }.to_h }
+      end
+    end
+
+    def each_array(&block)
+      if block_given?
+        each_array.each(&block)
+      else
+        @result.each_row
+      end
+    end
+
+    def to_a() @result.values end
+  end
+
+  class PostgresConnection < Connection
+    def host() @conn.host end
+    def port() @conn.port end
+    def database() @conn.db end
+    def user() @conn.user end
+    def password() @conn.pass end
+
+    def escape(s) @conn.escape_string(s) end
+
+    def execute(sql) @conn.exec(sql) end
+    def select(sql) PostgresResult.new(@conn.exec(sql)) end
+
+    def close() @conn.finish end
+    def closed?() @conn.finished? end
+
+  private
+    def self.connect(options) 
+      conn = PG::Connection.new(options) 
+      conn.type_map_for_results = PG::BasicTypeMapForResults.new conn
+      conn
+    end
+  end
+end

data/lib/meta_db/db_object.rb

@@ -0,0 +1,352 @@
+
+require 'meta_db/dump.rb'
+
+module MetaDb
+  class DbObject
+    # Used to multi-assign values and for dump
+    #
+    # TODO: rename db_attr or 'column', and create read/writer methods
+    def self.attrs(*attrs)
+      attrs = Array(attrs)
+      if attrs.empty?
+        @attrs
+      else
+        @attrs = attrs
+      end
+    end
+
+    def self.init(row)
+      h = []
+      self.attrs.each { |a| h << row[a] if row.key?(a) }
+      self.new(*h)
+    end
+
+    attrs :parent, :name, :children
+
+    # Name of object. Unique within contianing object. Not nil
+    attr_reader :name 
+
+    # Parent DbObject. Non-nil except for the top-level MetaDb::Database object
+    attr_reader :parent
+
+    # Hash from name to contained objects
+    attr_reader :children
+
+    def initialize(parent, name)
+      @name, @parent = name, parent
+      @children = {}
+      parent&.send(:attach, self)
+    end
+
+    # Unique dot-separated list of names leading from the top-level MetaDb::Database object to 
+    # self. Omits the first path-element if strip is true
+    def path(strip: false)
+      r = []
+      node = self
+      while node
+        r << node.name
+        node = node.parent
+      end
+      r.pop if strip
+      r.reverse.compact.join(".")
+    end
+
+    # Return child object with the given name
+    def [](name) @children[name] end
+
+    # Recursively lookup object by dot-separated list of names. If strip is true, the first element
+    # will be stripped from the path
+    def dot(path, strip: false)
+      elems = path.split(".")
+      elems.shift if strip
+      elems.inject(self) { |a,e| a[e] } or raise "Can't lookup '#{path}' in #{self.path}"
+    end
+
+    # Compare two objects by identity
+    def <=>(r) path <=> r.path end
+
+    # Mostly for debug
+    def inspect
+      string = StringIO.new
+      stdout = $stdout
+      begin
+        $stdout = string
+        dump
+      ensure
+        $stdout = stdout
+      end
+      string.string
+    end
+
+  protected
+    def constrain_children(klass)
+      children.values.select { |v| v.is_a?(klass) }
+    end
+
+  private
+    def attach(child)
+      !@children.key?(child.name) or raise "Duplicate child key: #{child.name.inspect}"
+      child.instance_variable_set(:@parent, self)
+      @children[child.name] = child
+    end
+
+    def detach(child)
+      @children.key?(child.name) or raise "Non-existing child key: #{child.name.inspect}"
+      child.instance_variable_set(:@parent, nil)
+      @children.delete(child.name)
+    end
+  end
+
+  class Database < DbObject
+    attrs :name, :owner, :schemas
+
+    # List of schemas
+    def schemas()
+      @schemas ||= children.values
+    end
+
+    # Owner of the database
+    attr_reader :owner
+
+    def initialize(name, owner)
+      super(nil, name)
+      @owner = owner
+    end
+  end
+
+  class Schema < DbObject
+    attrs :database, :name, :owner, :tables, :views, :functions, :procedures
+
+    # Database of the schema
+    alias_method :database, :parent
+
+    # Owner of the schema
+    attr_reader :owner
+
+    # List of tables (and views)
+    def tables() @tables ||= constrain_children(MetaDb::Table) end
+
+    # List of views
+    def views() @views ||= constrain_children(MetaDb::View) end
+
+    # List of functions
+    def functions() @functions ||= constrain_children(MetaDb::Function) end
+
+    # List of procedures
+    def procedures() @procedures ||= constrain_children(MetaDb::Procedure) end
+
+    def initialize(database, name, owner)
+      super(database, name)
+      @owner = owner
+    end
+  end
+
+  class Table < DbObject
+    attrs \
+      :schema, :name, :type, :table?, :view?, :insertable?, :typed?, :columns,
+      :primary_key_columns, :constraints, :referential_constraints, :triggers
+
+    # Schema of the table. Redefines #parent
+    alias_method :schema, :parent
+
+    # Type of table. Either 'BASE TABLE' or 'VIEW'
+    attr_reader :type
+
+    # True iff table is a real table and not a view
+    def table?() true end
+
+    # True iff table is a view
+    def view?() !table? end
+
+    # True if the table/view is insertable
+    def insertable?() @is_insertable end
+
+    # True if the table/view is typed
+    def typed?() @is_typed end
+
+    # List of columns. Columns are sorted by ordinal
+    def columns() @columns ||= constrain_children(MetaDb::Column).sort end
+
+    # The primary key column. nil if the table has multiple primary key columns
+    def primary_key_column
+      return @primary_key_column if @primary_key_column != :undefined
+      if primary_key_columns.size == 1
+        @primary_key_column = primary_key_columns.first
+      else
+        @primary_key_column = nil
+      end
+    end
+
+    # List of primary key columns
+    #
+    # Note: Assigned by PrimaryKeyConstraint#initialize
+    attr_reader :primary_key_columns
+
+    # List of constraints
+    def constraints() 
+      @constraints ||= constrain_children(MetaDb::Constraint) 
+    end
+
+    # List of referential constraints
+    def referential_constraints() 
+      @referential_constraints ||= constrain_children(MetaDb::ReferentialConstraint) 
+    end
+
+    # List of triggers
+    def triggers() @triggers ||= constrain_children(MetaDb::Trigger) end
+
+    def initialize(schema, name, type, is_insertable, is_typed)
+      super(schema, name)
+      @type, @is_insertable, @is_typed = type, is_insertable, is_typed
+      @primary_key_column = :undefined
+      @primary_key_columns = []
+    end
+
+  end
+
+  class View < Table
+    def table?() false end
+  end
+
+  class Column < DbObject
+    attrs \
+      :table, :ordinal, :name, :type, :default, :identity?, :generated?,
+      :nullable?, :updatable?, :primary_key?
+
+    # Table of the column
+    alias_method :table, :parent
+
+    # Ordinal number of the column
+    attr_reader :ordinal
+
+    # Type of the column
+    attr_reader :type
+
+    # Default value
+    attr_reader :default
+
+    # True if column is an identity column
+    def identity?() @is_identity end
+
+    # True if column is auto generated
+    def generated?() @is_generated end
+
+    # True if column is nullable
+    def nullable?() @is_nullable end
+
+    # True if column is updatable
+    def updatable?() @is_updatable end
+
+    # True if column is the single primary key of the table. Always false for tables
+    # with multiple primary keys
+    def primary_key?() table.table? && self == table.primary_key_column end
+
+    # True is column is (part of) the primary key of the table
+    def primary_key_column?() table.table? && table.primary_key_columns.include?(self) end
+
+    def initialize(table, ordinal, name, type, default, is_identity, is_generated, is_nullable, is_updatable)
+      super(table, name)
+      @type, @ordinal, @default, @is_identity, @is_generated, @is_nullable, @is_updatable =
+          type, ordinal, default, is_identity, is_generated, is_nullable, is_updatable
+    end
+
+    # Compare columns by table and ordinal
+    def <=>(other)
+      if other.is_a?(Column) && table == other.table
+        ordinal <=> other.ordinal
+      else
+        super
+      end
+    end
+  end
+
+  class Constraint < DbObject
+    attrs :table, :name, :columns
+
+    # Table of the constraint
+    alias_method :table, :parent
+
+    # List of columns in the constraint. Empty for CheckConstraint objects
+    attr_reader :columns
+
+    # Constraint kind. Either :primary_key, :foreign_key, :unique, or :check
+    def kind() CONSTRAINT_KINDS[self.class] end
+
+    def initialize(table, name, columns)
+      super(table, name)
+      @columns = columns
+    end
+  end
+
+  class PrimaryKeyConstraint < Constraint
+    attrs :table, :name, :columns
+
+    def initialize(table, name, columns)
+      super
+      columns.each { |c| c.table.primary_key_columns << c }
+    end
+  end
+
+  class UniqueConstraint < Constraint
+    attrs :table, :name, :columns
+  end
+
+  # Note that #columns is always empty for check constraints
+  class CheckConstraint < Constraint
+    attrs :table, :name, :expression
+
+    # SQL check expression
+    attr_reader :expression
+
+    # Half-baked SQL-to-ruby expression transpiler
+    def ruby_expression # Very simple
+      @ruby ||= sql.sub(/\((.*)\)/, "\\1").gsub(/\((\w+) IS NOT NULL\)/, "!\\1.nil?").gsub(/ OR /, " || ")
+    end
+
+    def initialize(table, name, expression)
+      super(table, name, [])
+      @expression = expression
+    end
+  end
+
+  class ReferentialConstraint < Constraint
+    attrs :referencing_table, :name, :referencing_columns, :referenced_constraint
+
+    # The referencing tabla
+    alias_method :referencing_table, :table
+
+    # The referencing columns. Can't be empty
+    alias_method :referencing_columns, :columns
+
+    # The referenced constraint
+    attr_reader :referenced_constraint
+
+    # The referenced table
+    def referenced_table() referenced_constraint.table end
+
+    # The referenced columns
+    def referenced_columns() referenced_constraints.columns end
+
+    def initialize(referencing_table, name, referencing_columns, referenced_constraint)
+      super(referencing_table, name, referencing_columns)
+      @referenced_constraint = referenced_constraint
+    end
+  end
+
+  class Function < DbObject
+  end
+
+  class Procedure < DbObject
+  end
+
+  class Trigger < DbObject
+  end
+
+  CONSTRAINT_KINDS = {
+    PrimaryKeyConstraint => :primary_key,
+    ReferentialConstraint => :foreign_key,
+    UniqueConstraint => :unique,
+    CheckConstraint => :check
+  }
+end
+

data/lib/meta_db/dump.rb

@@ -0,0 +1,31 @@
+
+require 'indented_io'
+
+module MetaDb
+  class DbObject
+    def dump
+      puts self.class.to_s
+      dump_attrs
+    end
+    
+    def dump_attrs(*attrs)
+      attrs = Array(attrs)
+      attrs = self.class.attrs if attrs.empty?
+      indent {
+        for attr in Array(attrs)
+          value = self.send(attr)
+          case value
+            when Array
+              puts "#{attr}:"
+              indent { value.each { |v| v.dump } }
+            when DbObject
+              puts "#{attr}: #{value.name} (#{value.class})"
+          else
+            puts "#{attr}: #{self.send(attr).inspect}"
+          end
+        end
+      }
+    end
+  end
+end
+

data/lib/meta_db/version.rb

@@ -0,0 +1,3 @@
+module MetaDb
+  VERSION = "0.1.0"
+end

data/meta_db.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "meta_db/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "meta_db"
+  spec.version       = MetaDb::VERSION
+  spec.authors       = ["Claus Rasmussen"]
+  spec.email         = ["claus.l.rasmussen@gmail.com"]
+
+  spec.summary       = %q{Meta model of database}
+  spec.description   = %q{Reads in the information schema of a database and models it as ruby objects}
+  spec.homepage      = "http://www.nowhere.com/meta_db"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "indented_io"
+  spec.add_dependency "pg"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: meta_db
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Claus Rasmussen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: indented_io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Reads in the information schema of a database and models it as ruby objects
+email:
+- claus.l.rasmussen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- TODO
+- bin/console
+- bin/setup
+- lib/meta_db.rb
+- lib/meta_db/connection.rb
+- lib/meta_db/db_object.rb
+- lib/meta_db/dump.rb
+- lib/meta_db/version.rb
+- meta_db.gemspec
+homepage: http://www.nowhere.com/meta_db
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+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: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Meta model of database
+test_files: []