model_schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1f90013060ee4c6589d5da0f52a6d43d122f1098
+  data.tar.gz: e6a196f114bfdfb96f360404cdb7e3b318f43545
+SHA512:
+  metadata.gz: 40b269d838239123dad028eb77512fac7299ed248b249daa567243a38c99e64e13d9b465b5eaf97ea8b7f02d8820be1b52b388b48ea0e5de2834ebac6d9d9148
+  data.tar.gz: e2d6ffe9929ea0940a7c2e94a29fa47747feb8c03749c8ac49c1385d6f66ffd00044f510d2e98fda5072e5d3d4758c42a8ebfb93abd019f9b4bfaf5e54e7891a

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+*.sw[pon]

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.1.5
+before_install: gem install bundler -v 1.10.6
+
+services:
+  - postgresql
+before_script:
+  - psql -c 'create database model_schema;' -U postgres
+env:
+  - DB_URL=postgres://localhost:5432/model_schema

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Karthik Viswanathan
+
+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,251 @@
+# ModelSchema [![Build Status](https://travis-ci.org/karthikv/model_schema.svg?branch=master)](https://travis-ci.org/karthikv/model_schema)
+ModelSchema lets you annotate a [Sequel](https://github.com/jeremyevans/sequel/)
+Model with its expected schema (columns and indexes). Instead of seeing
+a Sequel Model file that looks like this:
+
+```rb
+class User < Sequel::Model(:users)
+end
+```
+
+You'll see one that looks like this:
+
+```rb
+class User < Sequel::Model(:users)
+  model_schema do
+    primary_key :id
+
+    String :email, :null => false
+    String :password, :null => false
+
+    TrueClass :is_admin, :default => false
+
+    DateTime :created_at, :null => false
+    DateTime :updated_at
+
+    index :email
+  end
+end
+```
+
+Unlike other similar gems, ModelSchema provides *enforcement*; if the schema you
+specify doesn't match the table schema, ModelSchema will raise an error and
+tell you exactly what's wrong, like so:
+
+```
+ModelSchema::SchemaError: Table users does not match the expected schema.
+
+Table users has extra columns:
+
+  Integer :age
+
+Table users is missing columns:
+
+  TrueClass :is_admin, :default => false
+
+Table users has mismatched indexes:
+
+  actual:    index [:email], :unique => true
+  expected:  index [:email]
+
+You may disable schema checks by passing :disable => true to model_schema or by
+setting the ENV variable DISABLE_MODEL_SCHEMA=1.
+```
+
+When developing on a team, local databases of team members can easily get out
+of sync due to differing migrations. ModelSchema immediately lets you know if
+the schema you expect differs from the actual schema. This ensures you identify
+database inconsistencies before they cause problems. As a nice added benefit,
+ModelSchema lets you see a list of columns for a model directly within the
+class itself.
+
+## Support for ActiveRecord
+Currently, ModelSchema only works with [Sequel](https://github.com/jeremyevans/sequel/).
+If you'd like something similar for other Ruby ORMs, like ActiveRecord, please
+express your interest in [this issue](https://github.com/karthikv/model_schema/issues/1).
+
+## Installation
+Add `model_schema` to your Gemfile:
+
+```rb
+gem 'model_schema'
+```
+
+And then execute `bundle` in your terminal. You can also install `model_schema`
+with `gem` directly by running `gem install model_schema`.
+
+## Usage
+Require `model_schema` and register the plugin with Sequel:
+
+```rb
+require 'model_schema'
+Sequel.plugin(ModelSchema::Plugin)
+```
+
+Then, in each model where you'd like to use ModelSchema, introduce a call to
+`model_schema`, passing in a block that defines the schema. The block operates
+exactly as a [Sequel `create_table`
+block](http://sequel.jeremyevans.net/rdoc/files/doc/schema_modification_rdoc.html).
+See the documentation on that page for further details.
+
+```rb
+class Post < Sequel::Model(:posts)
+  model_schema do
+    primary_key :id
+
+    String :title, :null => false
+    String :description, :text => true, :null => false
+    DateTime :date_posted, :null => false
+  end
+end
+```
+
+When the class is loaded, ModelSchema will ensure the table schema matches the
+given schema. If there are any errors, it will raise
+a `ModelSchema::SchemaError`, notifying you of any inconsistencies.
+
+You may pass an optional hash to `model_schema` with the following options:
+
+`disable`: `true` to disable all schema checks, `false` otherwise  
+`no_indexes`: `true` to disable schema checks for indexes (columns will still
+be checked), `false` otherwise
+
+For instance, to disable index checking:
+
+```rb
+class Item < Sequel::Model(:items)
+  model_schema(:no_indexes => true) do
+    ...
+  end
+end
+```
+
+Note that you can disable ModelSchema in two ways: either pass `:disable =>
+true` to the `model_schema` method, or set the environment variable
+`DISABLE_MODEL_SCHEMA=1` .
+
+## Bootstrap Existing Project
+To help bootstrap existing projects that don't yet use ModelSchema, you can use
+the `dump_model_schema` executable. It will automatically dump an up-to-date
+`model_schema` block in each Sequel Model class. Use it like so:
+
+```sh
+$ dump_model_schema -m [model_file] -c [connection_string]
+```
+
+where `model_file` is a path to a ruby file that contains a single Sequel
+Model, and `connection_string` is the database connection string to pass to
+`Sequel.connect()`.
+
+`dump_model_schema` will insert a `model_schema` block right after the
+definition of the Sequel Model class. Specifically, it looks for a line of the
+form `class SomeClassName < Sequel::Model(:table_name)`, and inserts a valid
+schema for table `table_name` directly after that line. Note that
+`dump_model_schema` overwrites the model file.
+
+For instance, say you had a file `items.rb` that looks like this:
+
+```rb
+module SomeModule
+  class Item < Sequel::Model(:items)
+  end
+end
+```
+
+If you run:
+
+```sh
+$ dump_model_schema -m items.rb -c [connection_string]
+```
+
+`items.rb` might now look like:
+
+```rb
+module SomeModule
+  class Item < Sequel::Model(:items)
+    model_schema do
+      primary_key :id,
+
+      String :name, :null => false
+      Integer :quantity
+
+      index [:name], :name => :items_name_key
+    end
+  end
+end
+```
+
+By default, `dump_model_schema` assumes a tab size of 2 spaces, but you can
+change this with the `-t` option. Pass an integer representing the number of
+spaces, or 0 if you want to use hard tabs.
+
+You may see help text with `dump_model_schema -h` and view the version of
+ModelSchema with `dump_model_schema -v`.
+
+## Limitations
+ModelSchema has a few notable limitations:
+
+- It checks columns independently from indexes. Say you create a table like so:
+
+  ```rb
+  DB.create_table(:items) do
+    String :name, :unique => true
+    Integer :value, :index => true
+  end
+  ```
+
+  The corresponding `model_schema` block would be:
+
+  ```rb
+  class Item < Sequel::Model(:items)
+    model_schema do
+      String :name
+      Integer :value
+
+      index :name, :unique => true
+      index :value
+    end
+  end
+  ```
+
+  You have to separate the columns from the indexes, since the schema dumper
+  reads them independently of one another.
+
+- It relies on Sequel's [schema dumper extension](http://sequel.jeremyevans.net/rdoc/files/doc/migration_rdoc.html#label-Dumping+the+current+schema+as+a+migration)
+  to read your table's schema. The schema dumper doesn't read constraints,
+  triggers, special index types (e.g. gin, gist) or partial indexes; you'll
+  have to omit these from your `model_schema` block.
+
+- It doesn't handle all type aliasing. For instance, the Postgres types
+  `character varying(255)[]` and `varchar(255)[]` are equivalent, but
+  ModelSchema is unaware of this. In turn, you might see this error message:
+
+  ```
+  Table complex has mismatched columns:
+
+    actual:    column :advisors, "character varying(255)[]", :null=>false
+    expected:  column :advisors, "varchar(255)[]", :null=>false
+  ```
+
+  In the above case, you'll need to change `varchar(255)[]` to `character
+  varying(255)[]` in your `model_schema` block to fix the issue.
+
+  A similar problem occurs with `numeric(x, 0)` and `numeric(x)`, where x is an
+  integer; they are equivalent in Postgres, but ModelSchema doesn't know this.
+
+## Development and Contributing
+After cloning this repository, execute `bundle` to install dependencies. You
+may run tests with `rake test`, and open up a REPL using `bin/repl`.
+
+Note that tests require access to a Postgres database. Set the environment
+variable `DB_URL` to a Postgres connection string (e.g.
+`postgres://localhost:5432/model_schema`) prior to running tests. See
+[connecting to a database](http://sequel.jeremyevans.net/rdoc/files/doc/opening_databases_rdoc.html)
+for information about connection strings.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+Any bug reports and pull requests are welcome.
+
+## License
+See the [LICENSE.txt](LICENSE.txt) file.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/dump_model_schema

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+require 'bundler/setup'
+require 'model_schema'
+require 'slop'
+
+SEQUEL_MODEL_REGEX = /class\s+.*?<\s+Sequel::Model\((.*?)\)/
+LEADING_WHITESPACE_REGEX = /^\s*/
+
+# Parses options and then dumps the model schema.
+def main(args)
+  opts = {}
+  opts[:tabbing] = 2
+
+  parser = OptionParser.new do |p|
+    p.banner = "Usage: dump_model_schema [options]"
+
+    p.on('-m', '--model MODEL', 'Model file to dump schema in') do |model|
+      opts[:model] = model
+    end
+
+    p.on('-c', '--connection CONNECTION',
+         'Connection string for database') do |connection|
+      opts[:connection] = connection
+    end
+
+    p.on('-t', '--tabbing TABBING', Integer,
+              'Number of spaces for tabbing, or 0 for hard tabs') do |tabbing|
+      opts[:tabbing] = tabbing
+    end
+
+    p.on('-v', '--version', 'Print version') do
+      puts ModelSchema::VERSION
+      exit
+    end
+
+    p.on('-h', '--help', 'Print help') do
+      puts parser
+      exit
+    end
+  end
+
+  parser.parse(args)
+
+  # model and connection are required
+  abort 'Must provide a model file with -m or --model.' if !opts[:model]
+  abort 'Must provide a connection string with -c or --connection.' if !opts[:connection]
+
+  dump_model_schema(opts)
+end
+
+# Dumps the model schema based on the given options (see option parsing above).
+def dump_model_schema(opts)
+  model_info = parse_model_file(opts[:model])
+  abort "Couldn't find class that extends Sequel::Model" if !model_info
+
+  db = Sequel.connect(opts[:connection])
+  db.extension(:schema_dumper)
+
+  klass = Class.new(Sequel::Model(model_info[:table_name]))
+  klass.db = db
+
+  # dump table generator given by model_schema
+  generator = klass.send(:table_generator)
+  commands = [generator.dump_columns, generator.dump_constraints,
+              generator.dump_indexes].reject{|s| s == ''}.join("\n\n")
+
+  # account for indentation
+  tab = opts[:tabbing] == 0 ? "\t" : ' ' * opts[:tabbing]
+  schema_indentation = model_info[:indentation] + tab
+  command_indentation = schema_indentation + tab
+
+  commands = commands.lines.map {|l| l == "\n" ? l : command_indentation + l}.join
+  commands = commands.gsub('=>', ' => ')
+
+  dump_lines = ["#{schema_indentation}model_schema do\n",
+                "#{commands}\n",
+                "#{schema_indentation}end\n"]
+
+  lines = model_info[:lines_before] + dump_lines + model_info[:lines_after]
+  File.write(opts[:model], lines.join)
+end
+
+# Parses the model file at the given path, returning a hash of the form:
+#
+# :table_name => the model table name
+# :lines_before => an array of lines before the expected model schema dump
+# :lines_after => an array of lines after the expected model schema dump
+# :indentation => the indentation (leading whitespace) of the model class
+#
+# Returns nil if the file couldn't be parsed.
+def parse_model_file(path)
+  lines = File.read(path).lines
+
+  lines.each_with_index do |line, index|
+    match = SEQUEL_MODEL_REGEX.match(line)
+
+    if match
+      # extract table name as symbol
+      table_name = match[1]
+      if table_name[0] == ':'
+        table_name = table_name[1..-1].to_sym
+      else
+        abort "Can't find a symbol table name on line: #{line}"
+      end
+
+      # indentation for model_schema block
+      indentation = LEADING_WHITESPACE_REGEX.match(line)[0]
+
+      return {
+        :table_name => table_name.to_sym,
+        :lines_before => lines[0..index],
+        :lines_after => lines[(index + 1)..-1],
+        :indentation => indentation,
+      }
+    end
+  end
+
+  nil
+end
+
+main(ARGV) if $PROGRAM_NAME == __FILE__

data/bin/repl

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'bundler/setup'
+require 'model_schema'
+
+require 'pry'
+Pry.start

data/lib/model_schema.rb

@@ -0,0 +1,6 @@
+module ModelSchema; end
+
+require 'model_schema/version'
+require 'model_schema/constants'
+require 'model_schema/schema_error'
+require 'model_schema/plugin'

data/lib/model_schema/constants.rb

@@ -0,0 +1,42 @@
+module ModelSchema
+  # ENV variable name to disable schema checks.
+  DISABLE_MODEL_SCHEMA_KEY = 'DISABLE_MODEL_SCHEMA'
+
+  # field types representing table columns and table indexes
+  FIELD_COLUMNS = :columns
+  FIELD_INDEXES = :indexes
+  FIELDS = [FIELD_COLUMNS, FIELD_INDEXES]
+
+  # default column parameters
+  DEFAULT_COL = {
+    :name => nil,
+    :type => nil,
+    :collate => nil,
+    :default => nil,
+    :deferrable => nil,
+    :index => nil,
+    :key => [:id],
+    :null => nil,
+    :on_delete => :no_action,
+    :on_update => :no_action,
+    :primary_key => nil,
+    :primary_key_constraint_name => nil,
+    :unique => nil,
+    :unique_constraint_name => nil,
+    :serial => nil,
+    :table => nil,
+    :text => nil,
+    :fixed => nil,
+    :size => nil,
+    :only_time => nil,
+  }
+
+  # default index parameters
+  DEFAULT_INDEX = {
+    :columns => nil,
+    :name => nil,
+    :type => nil,
+    :unique => nil,
+    :where => nil,
+  }
+end

data/lib/model_schema/plugin.rb

@@ -0,0 +1,216 @@
+require 'sequel'
+
+module ModelSchema
+  # Allows you to define an expected schema for a Sequel::Model class and fail
+  # if that schema is not met.
+  module Plugin
+    module ClassMethods
+      # Checks if the model's table schema matches the schema specified by the
+      # given block. Raises a SchemaError if this isn't the case.
+      #
+      # options:
+      # :disable => true to disable schema checks;
+      #             you may also set the ENV variable DISABLE_MODEL_SCHEMA=1
+      # :no_indexes => true to disable index checks
+      def model_schema(options={}, &block)
+        return if ENV[DISABLE_MODEL_SCHEMA_KEY] == '1' || options[:disable]
+        db.extension(:schema_dumper)
+
+        # table generators are Sequel's way of representing schemas
+        db_generator = table_generator
+        exp_generator = db.create_table_generator(&block)
+        
+        schema_errors = check_all(FIELD_COLUMNS, db_generator, exp_generator)
+        if !options[:no_indexes]
+          schema_errors += check_all(FIELD_INDEXES, db_generator, exp_generator)
+        end
+        
+        raise SchemaError.new(table_name, schema_errors) if schema_errors.length > 0
+      end
+
+      private
+
+      # Returns the table generator representing this table.
+      def table_generator
+        begin
+          db_generator_explicit = db.send(:dump_table_generator, table_name,
+                                          :same_db => true)
+          db_generator_generic = db.send(:dump_table_generator, table_name)
+        rescue Sequel::DatabaseError => error
+          if error.message.include?('PG::UndefinedTable:')
+            fail NameError, "Table #{table_name} doesn't exist."
+          end
+        end
+
+        # db_generator_explicit contains explicit string types for each field,
+        # specific to the current database; db_generator_generic contains ruby
+        # types for each field. When there's no corresponding ruby type,
+        # db_generator_generic defaults to the String type. We'd like to
+        # combine db_generator_explicit and db_generator_generic into one
+        # generator, where ruby types are used if they are accurate. If there
+        # is no accurate ruby type, we use the explicit database type. This
+        # gives us cleaner column dumps, as ruby types have a better, more
+        # generic interface (e.g. `String :col_name` as opposed to
+        # `column :col_name, 'varchar(255)`).
+        
+        # start with db_generator_generic, and correct as need be
+        db_generator = db_generator_generic.dup
+
+        # avoid using Sequel::Model.db_schema because it has odd caching
+        # behavior across classes that breaks tests
+        db.schema(table_name).each do |name, col_schema|
+          type_hash = db.column_schema_to_ruby_type(col_schema)
+
+          if type_hash == {:type => String}
+            # There's no corresponding ruby type, as per:
+            # <https://github.com/jeremyevans/sequel/blob/a2cfbb9/lib/sequel/
+            #  extensions/schema_dumper.rb#L59-L61>
+            # Copy over the column from db_generator_explicit.
+            index = db_generator.columns.find_index {|c| c[:name] == name}
+            col = db_generator_explicit.columns.find {|c| c[:name] == name}
+            db_generator.columns[index] = col
+          end
+        end
+
+        db_generator
+      end
+
+      # Check if db_generator and exp_generator match for the given field
+      # (FIELD_COLUMNS for columns or FIELD_INDEXES for indexes).
+      def check_all(field, db_generator, exp_generator)
+        # To find an accurate diff, we perform two passes on exp_array. In the
+        # first pass, we find perfect matches between exp_array and db_array,
+        # deleting the corresponding elements. In the second pass, for each
+        # exp_elem in exp_array, we find the closest db_elem in db_array that
+        # matches it. We then add a mismatch diff between db_elem and exp_elem
+        # and remove db_elem from db_array. If no db_elem is deemed close
+        # enough, we add a missing diff for exp_elem. Finally, we add an extra
+        # diff for each remaining db_elem in db_array.
+
+        # don't modify original arrays
+        db_array = db_generator.send(field).dup
+        exp_array = exp_generator.send(field).dup
+
+        # first pass: remove perfect matches
+        exp_array.select! do |exp_elem|
+          diffs = db_array.map do |db_elem|
+            check_single(field, :db_generator => db_generator,
+                                :exp_generator => exp_generator,
+                                :db_elem => db_elem,
+                                :exp_elem => exp_elem)
+          end
+
+          index = diffs.find_index(nil)
+          if index
+            # found perfect match; delete elem so it won't be matched again
+            db_array.delete_at(index)
+            false  # we've accounted for this element
+          else
+            true  # we still need to account for this element
+          end
+        end
+
+        schema_diffs = []
+
+        # second pass: find diffs
+        exp_array.each do |exp_elem|
+          index = find_close_match(field, exp_elem, db_array)
+
+          if index
+            # add mismatch diff between exp_elem and db_array[index]
+            schema_diffs << check_single(field, :db_generator => db_generator,
+                                                :exp_generator => exp_generator,
+                                                :db_elem => db_array[index],
+                                                :exp_elem => exp_elem)
+            db_array.delete_at(index)
+          else
+            # add missing diff, since no db_elem is deemed close enough
+            schema_diffs << {:field => field,
+                             :type => SchemaError::TYPE_MISSING,
+                             :generator => exp_generator,
+                             :elem => exp_elem}
+          end
+        end
+
+        # because we deleted as we went on, db_array holds extra elements
+        db_array.each do |db_elem|
+          schema_diffs << {:field => field,
+                           :type => SchemaError::TYPE_EXTRA,
+                           :generator => db_generator,
+                           :elem => db_elem}
+        end
+
+        schema_diffs
+      end
+
+      # Returns the index of an element in db_array that closely matches exp_elem,
+      # or nil if no such element exists.
+      def find_close_match(field, exp_elem, db_array)
+        case field
+        when FIELD_COLUMNS
+          db_array.find_index {|e| e[:name] == exp_elem[:name]}
+        when FIELD_INDEXES
+          db_array.find_index do |e|
+            e[:name] == exp_elem[:name] || e[:columns] == exp_elem[:columns]
+          end
+        end
+      end
+
+      # Check if the given database element matches the expected element.
+      #
+      # field: FIELD_COLUMNS for columns or FIELD_INDEXES for indexes
+      # opts:
+      #   :db_generator => db table generator
+      #   :exp_generator => expected table generator
+      #   :db_elem => column, constraint, or index from db_generator
+      #   :exp_elem => column, constraint, or index from exp_generator
+      def check_single(field, opts)
+        db_generator, exp_generator = opts.values_at(:db_generator, :exp_generator)
+        db_elem, exp_elem = opts.values_at(:db_elem, :exp_elem)
+
+        error = {:field => field,
+                 :type => SchemaError::TYPE_MISMATCH,
+                 :db_generator => db_generator,
+                 :exp_generator => exp_generator,
+                 :db_elem => db_elem,
+                 :exp_elem => exp_elem}
+
+        # db_elem and exp_elem now have the same keys; compare then
+        case field
+        when FIELD_COLUMNS
+          db_elem_defaults = DEFAULT_COL.merge(db_elem)
+          exp_elem_defaults = DEFAULT_COL.merge(exp_elem)
+          return error if db_elem_defaults.length != exp_elem_defaults.length
+
+          type_literal = db.method(:type_literal)
+          # already accounted for in type check
+          keys_accounted_for = [:text, :fixed, :size, :serial]
+
+          match = db_elem_defaults.all? do |key, value|
+            if key == :type
+              # types could either be strings or ruby types; normalize them
+              db_type = type_literal.call(db_elem_defaults).to_s
+              exp_type = type_literal.call(exp_elem_defaults).to_s
+              db_type == exp_type
+            elsif keys_accounted_for.include?(key)
+              true
+            else
+              value == exp_elem_defaults[key]
+            end
+          end
+
+        when FIELD_INDEXES
+          db_elem_defaults = DEFAULT_INDEX.merge(db_elem)
+          exp_elem_defaults = DEFAULT_INDEX.merge(exp_elem)
+          return error if db_elem_defaults.length != exp_elem_defaults.length
+
+          # if no index name is specified, accept any name
+          db_elem_defaults.delete(:name) if !exp_elem_defaults[:name]
+          match = db_elem_defaults.all? {|key, value| value == exp_elem_defaults[key]}
+        end
+
+        match ? nil : error
+      end
+    end
+  end
+end

data/lib/model_schema/schema_error.rb

@@ -0,0 +1,112 @@
+module ModelSchema
+  # Tracks differences between the expected schema and database table schema.
+  class SchemaError < StandardError
+    TYPE_EXTRA = :extra
+    TYPE_MISSING = :missing
+    TYPE_MISMATCH = :mismatch
+
+    attr_reader :schema_diffs
+
+    # Creates a SchemaError for the given table with an array of schema
+    # differences. Each element of schema_diffs should be a hash of the
+    # following form:
+    #
+    # :field => if a column is different, use FIELD_COLUMNS;
+    #           if an index is different, use FIELD_INDEXES
+    # :type => if there's an extra column/index, use TYPE_EXTRA;
+    #          if there's a missing column/index, use TYPE_MISSING;
+    #          if there's a mismatched column/index, use TYPE_MISMATCH
+    #
+    # For TYPE_EXTRA and TYPE_MISSING:
+    # :generator => the table generator that contains the extra/missing index/column
+    # :elem => the missing index/column, as a hash from the table generator
+    #
+    # For TYPE_MISMATCH:
+    # :db_generator => the db table generator
+    # :exp_generator => the expected table generator
+    # :db_elem => the index/column in the db table generator as a hash
+    # :exp_elem => the index/column in the exp table generator as a hash
+    def initialize(table_name, schema_diffs)
+      @table_name = table_name
+      @schema_diffs = schema_diffs
+    end
+
+    # Dumps a single column/index from the generator to its string representation.
+    #
+    # field: FIELD_COLUMNS for a column or FIELD_INDEXES for an index
+    # generator: the table generator
+    # elem: the index/column in the generator as a hash
+    def dump_single(field, generator, elem)
+      array = generator.send(field)
+      index = array.find_index(elem)
+      fail ArgumentError, "#{elem.inspect} not part of #{array.inspect}" if !index
+
+      lines = generator.send(:"dump_#{field}").lines.map(&:strip)
+      lines[index]
+    end
+
+    # Returns the diffs in schema_diffs that have the given field and type.
+    def diffs_by_field_type(field, type)
+      @schema_diffs.select {|diff| diff[:field] == field && diff[:type] == type}
+    end
+
+    # Dumps all diffs that have the given field and are of TYPE_EXTRA.
+    def dump_extra_diffs(field)
+      extra_diffs = diffs_by_field_type(field, TYPE_EXTRA)
+
+      if extra_diffs.length > 0
+        header = "Table #{@table_name} has extra #{field}:\n"
+        diff_str = extra_diffs.map do |diff|
+          dump_single(field, diff[:generator], diff[:elem])
+        end.join("\n\t")
+
+        "#{header}\n\t#{diff_str}\n"
+      end
+    end
+
+    # Dumps all diffs that have the given field and are of TYPE_MISSING.
+    def dump_missing_diffs(field)
+      missing_diffs = diffs_by_field_type(field, TYPE_MISSING)
+
+      if missing_diffs.length > 0
+        header = "Table #{@table_name} is missing #{field}:\n"
+        diff_str = missing_diffs.map do |diff|
+          dump_single(field, diff[:generator], diff[:elem])
+        end.join("\n\t")
+
+        "#{header}\n\t#{diff_str}\n"
+      end
+    end
+
+    # Dumps all diffs that have the given field and are of TYPE_MISMATCH.
+    def dump_mismatch_diffs(field)
+      mismatch_diffs = diffs_by_field_type(field, TYPE_MISMATCH)
+
+      if mismatch_diffs.length > 0
+        header = "Table #{@table_name} has mismatched #{field}:\n"
+        diff_str = mismatch_diffs.map do |diff|
+          "actual:    #{dump_single(field, diff[:db_generator], diff[:db_elem])}\n\t" +
+          "expected:  #{dump_single(field, diff[:exp_generator], diff[:exp_elem])}"
+        end.join("\n\n\t")
+
+        "#{header}\n\t#{diff_str}\n"
+      end
+    end
+
+    # Combines all dumps into one cohesive error message.
+    def to_s
+      parts = FIELDS.flat_map do |field|
+        [dump_extra_diffs(field),
+         dump_missing_diffs(field),
+         dump_mismatch_diffs(field)]
+      end
+
+      [
+        "Table #{@table_name} does not match the expected schema.\n\n",
+        parts.compact.join("\n"),
+        "\nYou may disable schema checks by passing :disable => true to model_",
+        "schema or by setting the ENV variable #{DISABLE_MODEL_SCHEMA_KEY}=1.\n"
+      ].join
+    end
+  end
+end

data/lib/model_schema/version.rb

@@ -0,0 +1,3 @@
+module ModelSchema
+  VERSION = '0.1.0'
+end

data/model_schema.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'model_schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'model_schema'
+  spec.version = ModelSchema::VERSION
+  spec.authors = ['Karthik Viswanathan']
+  spec.email = ['karthik.ksv@gmail.com']
+
+  spec.summary = %(Enforced, Annotated Schema for Ruby Sequel Models)
+  spec.description = %(Annotate a Sequel Model with its expected schema 
+                       and immediately identify inconsistencies.).gsub(/\n\s+/, '')
+  spec.homepage = 'https://github.com/karthikv/model_schema'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject {|f| f.match(%r{^(test|spec|features)/})}
+  spec.bindir = 'bin'
+  spec.executables << 'dump_model_schema'
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency('bundler', '~> 1.10')
+  spec.add_development_dependency('rake', '~> 10.0')
+  spec.add_development_dependency('minitest')
+  spec.add_development_dependency('minitest-hooks')
+  spec.add_development_dependency('mocha')
+  spec.add_development_dependency('pg')
+  spec.add_development_dependency('pry')
+  spec.add_development_dependency('awesome_print')
+
+  spec.add_runtime_dependency('sequel')
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: model_schema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Karthik Viswanathan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: minitest
+  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: minitest-hooks
+  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: mocha
+  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: pg
+  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: 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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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'
+description: Annotate a Sequel Model with its expected schema and immediately identify
+  inconsistencies.
+email:
+- karthik.ksv@gmail.com
+executables:
+- dump_model_schema
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/dump_model_schema
+- bin/repl
+- lib/model_schema.rb
+- lib/model_schema/constants.rb
+- lib/model_schema/plugin.rb
+- lib/model_schema/schema_error.rb
+- lib/model_schema/version.rb
+- model_schema.gemspec
+homepage: https://github.com/karthikv/model_schema
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Enforced, Annotated Schema for Ruby Sequel Models
+test_files: []