db_schema-reader-postgres 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06c75ff7d43c7a7fcf852e6e96a2cea6da4e517c
+  data.tar.gz: 69866cfefe8454539deca882a00cdbd3f85c1238
+SHA512:
+  metadata.gz: d51763814f5e752b7b5a313287780aa39e4e5a7ccf32649620251b128673006f16ccc8192f43ee3a54d47e1644897eeff602b2b3b15ffdf6987245cf774fe816
+  data.tar.gz: 6bfb55ff18fde36a8efaac023a8ef07e211daa040d99477797c9a16878253b4da9eb058709f7789c0662a4b7dd313a64ecf3f64914c65f6a00ea42cef375431b

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.8
+  - 2.3.5
+  - 2.4.2
+before_install: gem install bundler -v 1.16.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at 7@7vn.ru. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Guardfile

@@ -0,0 +1,15 @@
+guard :rspec, cmd: 'bundle exec rspec', all_on_start: true do
+  require 'guard/rspec/dsl'
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+  watch('lib/db_schema/reader/postgres/table.rb') { 'spec/db_schema/reader/postgres_spec.rb' }
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Vsevolod Romashov
+
+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,92 @@
+# DbSchema::Reader::Postgres
+
+DbSchema::Reader::Postgres is a library for reading the database
+structure from PostgreSQL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+``` ruby
+gem 'db_schema-reader-postgres'
+```
+
+And then execute:
+
+``` sh
+$ bundle
+```
+Or install it yourself as:
+
+``` ruby
+$ gem install db_schema-reader-postgres
+```
+
+## Usage
+
+First you need a Sequel connection object with `:pg_enum` and `:pg_array`
+Sequel extensions enabled; once you have that object just pass it to
+the `.read_schema` method to get full database schema definition:
+
+``` ruby
+connection = Sequel.connect(adapter: 'postgres', database: 'db_schema_test').tap do |db|
+  db.extension :pg_enum
+  db.extension :pg_array
+end
+
+DbSchema::Reader::Postgres.read_schema(connection)
+# => #<DbSchema::Definitions::Schema ...>
+```
+
+Other useful methods are `.read_tables`, `.read_table`, `.read_enums` & `.read_extensions`;
+they return definitions of respective parts of the database schema:
+
+``` ruby
+DbSchema::Reader::Postgres.read_tables(connection)
+# => [#<DbSchema::Definitions::Table ...>, #<DbSchema::Definitions::Table ...>, ...]
+
+DbSchema::Reader::Postgres.read_table(:users, connection)
+# => #<DbSchema::Definitions::Table name=:users ...>
+
+DbSchema::Reader::Postgres.read_enums(connection)
+# => [#<DbSchema::Definitions::Enum ...>, #<DbSchema::Definitions::Enum ...>, ...]
+
+DbSchema::Reader::Postgres.read_extensions(connection)
+# => [#<DbSchema::Definitions::Extension ...>, #<DbSchema::Definitions::Extension ...>, ...]
+```
+
+DbSchema::Reader::Postgres emits objects of classes from
+[DbSchema::Definitions](https://github.com/db-schema/definitions).
+Read [here](https://github.com/db-schema/core/wiki/Schema-analysis-DSL)
+how to analyze the schema and all of it's parts.
+
+## 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 [db-schema/reader-postgres](https://github.com/db-schema/reader-postgres).
+This project is intended to be a safe, welcoming space for collaboration,
+and contributors are expected to adhere to the
+[Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of
+the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the DbSchema::Definitions project’s codebases,
+issue trackers, chat rooms and mailing lists is expected to follow
+the [code of conduct](https://github.com/db-schema/reader-postgres/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

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

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'db_schema/reader/postgres'
+require 'sequel'
+
+require 'pry'
+require 'awesome_print'
+AwesomePrint.pry!
+
+Pry.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/db_schema-reader-postgres.gemspec

@@ -0,0 +1,34 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'db_schema/reader/postgres/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'db_schema-reader-postgres'
+  spec.version       = DbSchema::Reader::Postgres::VERSION
+  spec.authors       = ['Vsevolod Romashov']
+  spec.email         = ['7@7vn.ru']
+
+  spec.summary       = 'Database schema reader for PostgreSQL'
+  spec.description   = 'A database structure reader for PostgreSQL with support for tables, fields, indexes, foreign keys, check constraints, enum types and extensions.'
+  spec.homepage      = 'https://github.com/db-schema/reader-postgres'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^spec/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'sequel'
+  spec.add_runtime_dependency 'pg'
+  spec.add_runtime_dependency 'db_schema-definitions', '~> 0.1.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'awesome_print', '~> 1.7'
+
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'terminal-notifier'
+  spec.add_development_dependency 'terminal-notifier-guard'
+end

data/lib/db_schema/reader/postgres.rb

@@ -0,0 +1,56 @@
+require 'db_schema/definitions'
+require_relative 'postgres/table'
+require_relative 'postgres/version'
+
+module DbSchema
+  module Reader
+    module Postgres
+      ENUMS_QUERY = <<-SQL.freeze
+  SELECT t.typname AS name,
+         array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+    FROM pg_enum AS e
+    JOIN pg_type AS t
+      ON t.oid = e.enumtypid
+GROUP BY name
+      SQL
+
+      EXTENSIONS_QUERY = <<-SQL.freeze
+SELECT extname
+  FROM pg_extension
+ WHERE extname != 'plpgsql'
+      SQL
+
+      class << self
+        def read_schema(connection)
+          Definitions::Schema.new(
+            tables:     read_tables(connection),
+            enums:      read_enums(connection),
+            extensions: read_extensions(connection)
+          )
+        end
+
+        def read_tables(connection)
+          connection.tables.map do |table_name|
+            read_table(table_name, connection)
+          end
+        end
+
+        def read_table(table_name, connection)
+          Table.new(connection, table_name).read
+        end
+
+        def read_enums(connection)
+          connection[ENUMS_QUERY].map do |enum_data|
+            Definitions::Enum.new(enum_data[:name].to_sym, enum_data[:values].map(&:to_sym))
+          end
+        end
+
+        def read_extensions(connection)
+          connection[EXTENSIONS_QUERY].map do |extension_data|
+            Definitions::Extension.new(extension_data[:extname].to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/db_schema/reader/postgres/table.rb

@@ -0,0 +1,319 @@
+module DbSchema
+  module Reader
+    module Postgres
+      class Table
+        DEFAULT_VALUE = /\A(
+          ('(?<date>\d{4}-\d{2}-\d{2})'::date)
+            |
+          ('(?<time>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}([+-]\d{2})?)'::timestamp)
+            |
+          ('(?<string>.*)')
+            |
+          (?<float>\d+\.\d+)
+            |
+          (?<integer>\d+)
+            |
+          (?<boolean>true|false)
+        )/x
+
+        COLUMN_NAMES_QUERY = <<-SQL.freeze
+   SELECT c.column_name AS name,
+          c.ordinal_position AS pos,
+          c.column_default AS default,
+          c.is_nullable AS null,
+          c.data_type AS type,
+          c.udt_name AS custom_type_name,
+          c.character_maximum_length AS char_length,
+          c.numeric_precision AS num_precision,
+          c.numeric_scale AS num_scale,
+          c.datetime_precision AS dt_precision,
+          c.interval_type,
+          e.data_type AS element_type,
+          e.udt_name AS element_custom_type_name
+     FROM information_schema.columns AS c
+LEFT JOIN information_schema.element_types AS e
+       ON e.object_catalog = c.table_catalog
+      AND e.object_schema = c.table_schema
+      AND e.object_name = c.table_name
+      AND e.object_type = 'TABLE'
+      AND e.collection_type_identifier = c.dtd_identifier
+    WHERE c.table_schema = 'public'
+      AND c.table_name = ?
+        SQL
+
+        CONSTRAINTS_QUERY = <<-SQL.freeze
+SELECT conname AS name,
+       pg_get_expr(conbin, conrelid, true) AS condition
+  FROM pg_constraint, pg_class
+ WHERE conrelid = pg_class.oid
+   AND relname = ?
+   AND contype = 'c'
+        SQL
+
+        INDEXES_QUERY = <<-SQL.freeze
+   SELECT relname AS name,
+          indkey AS column_positions,
+          indisunique AS unique,
+          indoption AS index_options,
+          pg_get_expr(indpred, indrelid, true) AS condition,
+          amname AS index_type,
+          indexrelid AS index_oid
+     FROM pg_class, pg_index
+LEFT JOIN pg_opclass
+       ON pg_opclass.oid = ANY(pg_index.indclass::int[])
+LEFT JOIN pg_am
+       ON pg_am.oid = pg_opclass.opcmethod
+    WHERE pg_class.oid = pg_index.indexrelid
+      AND pg_class.oid IN (
+     SELECT indexrelid
+       FROM pg_index, pg_class
+      WHERE pg_class.relname = ?
+        AND pg_class.oid = pg_index.indrelid
+        AND indisprimary != 't'
+)
+  GROUP BY name, column_positions, indisunique, index_options, condition, index_type, index_oid
+        SQL
+
+        EXPRESSION_INDEXES_QUERY = <<-SQL.freeze
+    WITH index_ids AS (SELECT unnest(?) AS index_id),
+         elements AS (SELECT unnest(?) AS element)
+  SELECT index_id,
+         array_agg(pg_get_indexdef(index_id, element, 't')) AS definitions
+    FROM index_ids, elements
+GROUP BY index_id;
+        SQL
+
+        attr_reader :connection, :table_name
+
+        def initialize(connection, table_name)
+          @connection = connection
+          @table_name = table_name
+        end
+
+        def read
+          primary_key_name = connection.primary_key(table_name)
+
+          fields = columns_data.map do |column_data|
+            build_field(column_data, primary_key: column_data[:name] == primary_key_name)
+          end
+
+          indexes = indexes_data.map do |index_data|
+            Definitions::Index.new(index_data)
+          end.sort_by(&:name)
+
+          foreign_keys = connection.foreign_key_list(table_name).map do |foreign_key_data|
+            build_foreign_key(foreign_key_data)
+          end
+
+          checks = connection[CONSTRAINTS_QUERY, table_name.to_s].map do |check_data|
+            Definitions::CheckConstraint.new(
+              name:      check_data[:name].to_sym,
+              condition: check_data[:condition]
+            )
+          end
+
+          Definitions::Table.new(
+            table_name,
+            fields:       fields,
+            indexes:      indexes,
+            checks:       checks,
+            foreign_keys: foreign_keys
+          )
+        end
+
+      private
+        def columns_data
+          @columns_data ||= connection[COLUMN_NAMES_QUERY, table_name.to_s]
+        end
+
+        def indexes_data
+          column_names = columns_data.reduce({}) do |names, column|
+            names.merge(column[:pos] => column[:name].to_sym)
+          end
+
+          indexes_data     = connection[INDEXES_QUERY, table_name.to_s].to_a
+          expressions_data = index_expressions_data(indexes_data)
+
+          indexes_data.map do |index|
+            positions = index[:column_positions].split(' ').map(&:to_i)
+            options   = index[:index_options].split(' ').map(&:to_i)
+
+            columns = positions.zip(options).map do |column_position, column_order_options|
+              options = case column_order_options
+              when 0
+                {}
+              when 3
+                { order: :desc }
+              when 2
+                { nulls: :first }
+              when 1
+                { order: :desc, nulls: :last }
+              end
+
+              if column_position.zero?
+                expression = expressions_data.fetch(index[:index_oid]).shift
+                DbSchema::Definitions::Index::Expression.new(expression, **options)
+              else
+                DbSchema::Definitions::Index::TableField.new(column_names.fetch(column_position), **options)
+              end
+            end
+
+            {
+              name:      index[:name].to_sym,
+              columns:   columns,
+              unique:    index[:unique],
+              type:      index[:index_type].to_sym,
+              condition: index[:condition]
+            }
+          end
+        end
+
+        def index_expressions_data(indexes_data)
+          all_positions, max_position = {}, 0
+
+          indexes_data.each do |index_data|
+            positions = index_data[:column_positions].split(' ').map(&:to_i)
+            expression_positions = positions.each_index.select { |i| positions[i].zero? }
+
+            if expression_positions.any?
+              all_positions[index_data[:index_oid]] = expression_positions
+              max_position = [max_position, expression_positions.max].max
+            end
+          end
+
+          if all_positions.any?
+            connection[
+              EXPRESSION_INDEXES_QUERY,
+              Sequel.pg_array(all_positions.keys),
+              Sequel.pg_array((1..max_position.succ).to_a)
+            ].each_with_object({}) do |index_data, indexes_data|
+              index_id = index_data[:index_id]
+              expressions = all_positions[index_id].map { |pos| index_data[:definitions][pos] }
+
+              indexes_data[index_id] = expressions
+            end
+          else
+            {}
+          end
+        end
+
+        def build_field(data, primary_key: false)
+          type = data[:type].to_sym.downcase
+          if type == :'user-defined'
+            type = data[:custom_type_name].to_sym
+          end
+
+          nullable = (data[:null] != 'NO')
+
+          unless primary_key || data[:default].nil?
+            default = if match = DEFAULT_VALUE.match(data[:default])
+              if match[:date]
+                Date.parse(match[:date])
+              elsif match[:time]
+                Time.parse(match[:time])
+              elsif match[:string]
+                match[:string]
+              elsif match[:integer]
+                match[:integer].to_i
+              elsif match[:float]
+                match[:float].to_f
+              elsif match[:boolean]
+                match[:boolean] == 'true'
+              end
+            else
+              data[:default].to_sym
+            end
+          end
+
+          options = case type
+          when :character, :'character varying', :bit, :'bit varying'
+            rename_keys(
+              filter_by_keys(data, :char_length),
+              char_length: :length
+            )
+          when :numeric
+            rename_keys(
+              filter_by_keys(data, :num_precision, :num_scale),
+              num_precision: :precision,
+              num_scale: :scale
+            )
+          when :interval
+            rename_keys(
+              filter_by_keys(data, :dt_precision, :interval_type),
+              dt_precision: :precision
+            ) do |attributes|
+              if interval_type = attributes.delete(:interval_type)
+                attributes[:fields] = interval_type.gsub(/\(\d\)/, '').downcase.to_sym
+              end
+            end
+          when :array
+            rename_keys(
+              filter_by_keys(data, :element_type, :element_custom_type_name)
+            ) do |attributes|
+              attributes[:element_type] = if attributes[:element_type] == 'USER-DEFINED'
+                attributes[:element_custom_type_name]
+              else
+                attributes[:element_type]
+              end.to_sym
+            end
+          else
+            {}
+          end
+
+          Definitions::Field.build(
+            data[:name].to_sym,
+            type,
+            primary_key: primary_key,
+            null:        nullable,
+            default:     default,
+            **options
+          )
+        end
+
+        def build_foreign_key(data)
+          keys = if data[:key] == [primary_key_for(data[:table])]
+            [] # this foreign key references a primary key
+          else
+            data[:key]
+          end
+
+          Definitions::ForeignKey.new(
+            name:       data[:name],
+            fields:     data[:columns],
+            table:      data[:table],
+            keys:       keys,
+            on_delete:  data[:on_delete],
+            on_update:  data[:on_update],
+            deferrable: data[:deferrable]
+          )
+        end
+
+        def primary_key_for(table_name)
+          if pkey = connection.primary_key(table_name)
+            pkey.to_sym
+          end
+        end
+
+        # TODO: replace following methods with Transproc
+        def rename_keys(hash, mapping = {})
+          hash.reduce({}) do |final_hash, (key, value)|
+            new_key = mapping.fetch(key, key)
+            final_hash.merge(new_key => value)
+          end.tap do |final_hash|
+            yield(final_hash) if block_given?
+          end
+        end
+
+        def filter_by_keys(hash, *needed_keys)
+          hash.reduce({}) do |final_hash, (key, value)|
+            if needed_keys.include?(key)
+              final_hash.merge(key => value)
+            else
+              final_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/db_schema/reader/postgres/version.rb

@@ -0,0 +1,7 @@
+module DbSchema
+  module Reader
+    module Postgres
+      VERSION = '0.1'
+    end
+  end
+end

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: db_schema-reader-postgres
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Vsevolod Romashov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  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'
+- !ruby/object:Gem::Dependency
+  name: db_schema-definitions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !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: pry
+  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: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: guard-rspec
+  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: terminal-notifier
+  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: terminal-notifier-guard
+  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'
+description: A database structure reader for PostgreSQL with support for tables, fields,
+  indexes, foreign keys, check constraints, enum types and extensions.
+email:
+- 7@7vn.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- db_schema-reader-postgres.gemspec
+- lib/db_schema/reader/postgres.rb
+- lib/db_schema/reader/postgres/table.rb
+- lib/db_schema/reader/postgres/version.rb
+homepage: https://github.com/db-schema/reader-postgres
+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.6.13
+signing_key: 
+specification_version: 4
+summary: Database schema reader for PostgreSQL
+test_files: []