reactive_record 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Njg2MDk2YTkyZDExNzdjODJhZWJkNTAwM2M3OWY3ZTBkNTE1YjdkMw==
+  data.tar.gz: !binary |-
+    NDBiM2E0YzViNDMzNjJjNWE3NjJjMThiZmQwZjI5NmI0ZjIyYTBhMQ==
+SHA512:
+  metadata.gz: !binary |-
+    YWRhOWFiMjE0YWI0MTM4N2E1MTAxZGY4N2MzOTMxYTIzOWEwNWJhYWFhOTMw
+    YThlOWNjMzc4ZTY0ODNjODA2M2MyM2Y2YjAyYTIwYjIzZTFmOTMwMGEzMTkz
+    MzIyZDQ4NWMxYmEwMDNkYzQzNDJkODA2NDQ3NzNmN2QzMjZkZDg=
+  data.tar.gz: !binary |-
+    YzBlMGU0ZDcxNzU5ZGZjZTZiYTc0YzJmNWRkNTk4N2E3ODI1ZjI0ZTE1NGRj
+    OTFhZWEwNjg2Yjc0NDQ5NGQxMjZhODQ0NWNjOTQ3N2I4ZjgxMDhlYTg0NDVk
+    YmJlYmNjNGE4MTczZThhNThmOWQ2MDI3NGE0MTliOTIzOWNiNTM=

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version
+.ruby-gemset
+lib/parser.rb

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Chris Wilson & Joe Nelson
+
+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,124 @@
+# reactive_record
+
+Generates ActiveRecord models to fit a pre-existing Postgres database.
+Now you can use Rails with the db schema you always wanted. It's
+**your** convention over configuration.
+
+## Why?
+
+1. Your app is specific to Postgres and proud of it. You use the mature
+   declarative data validation that only a real database can provide.
+1. You have inherited a database or are more comfortable creating one
+   yourself.
+1. You're a grown-ass DBA who doesn't want to speak ORM baby-talk.
+
+## Features
+
+* Fully automatic. It just works.
+* Creates a model for every table.
+* Creates a comprehensive initial migration.
+* Declares key-, uniqueness-, and presence-constraints.
+* Creates associations.
+* Adds custom validation methods for `CHECK` constraints.
+
+## Usage
+
+### Already familiar with Rails?
+
+* Set up a postgres db normally
+* Set `config.active_record.schema_format = :sql` to use a SQL `schema.rb`
+* After you have migrated up a table, use `rails generate reactive_record:install`
+* Go examine your generated models
+
+### Want more details?
+
+**First** Include the `reactive_record` gem in your project's
+`Gemfile`. *Oh by the way*, you'll have to use postgres in your
+project. Setting up Rails for use with postgres is a bit outside
+the scope of this document. Please see [Configuring a Database]
+(http://guides.rubyonrails.org/configuring.html#configuring-a-database)
+for what you need to do.
+
+``` ruby
+gem 'reactive_record'
+```
+
+Bundle to include the library
+
+``` shell
+$ bundle
+```
+
+**Next** Tell `ActiveRecord` to go into beast-mode. Edit your
+`config/application.rb`, adding this line to use sql as the schema
+format:
+
+``` ruby
+module YourApp
+  class Application < Rails::Application
+    # other configuration bric-a-brac...
+    config.active_record.schema_format = :sql
+  end
+end
+```
+
+**Next** Create the database(s) just like you normally would:
+
+``` shell
+rake db:create
+```
+
+**Next** Generate a migration that will create the initial table:
+
+``` shell
+$ rails generate migration create_employees
+```
+
+Use your SQL powers to craft some
+[DDL](http://en.wikipedia.org/wiki/Data_definition_language), perhaps
+the "Hello, World!" of DB applications, `employees`?
+
+``` ruby
+class CreateEmployees < ActiveRecord::Migration
+  def up
+    execute <<-SQL
+      CREATE TABLE employees (
+        id         SERIAL,
+        name       VARCHAR(255) NOT NULL,
+        email      VARCHAR(255) NOT NULL UNIQUE,
+        start_date DATE NOT NULL,
+
+        PRIMARY KEY (id),
+        CONSTRAINT company_email CHECK (email LIKE '%@example.com')
+      );
+    SQL
+  end
+
+  def down
+    drop_table :employees
+  end
+end
+```
+
+**Lastly** Deploy the `reactive_record` generator:
+
+``` shell
+$ rails generate reactive_record
+```
+
+Go look at the generated file:
+
+``` ruby
+class Employees < ActiveRecord::Base
+  set_table_name 'employees'
+  set_primary_key :id
+  validate :id, :name, :email, :start_date, presence: true
+  validate :email, uniqueness: true
+  validate { errors.add(:email, "Expected TODO") unless email =~ /.*@example.com/ }
+end
+```
+
+Reactive record does not currently attempt to generate any kind of
+reasonable error message (I'm working on it) :)
+
+**Enjoy**

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+rule '.rb' => '.y' do |t|
+  sh "racc -l -o #{t.name} #{t.source}"
+end
+
+task :compile => 'lib/parser.rb'
+
+task :spec => :compile
+
+task :default => :spec

data/lib/code_generator.rb

@@ -0,0 +1,279 @@
+class Node
+  def initialize val, *args
+    @value = val
+    @children = args
+  end
+
+  def gen
+    raise "gen is not implemented: #{self}"
+  end
+
+  def column
+    'base'
+  end
+end
+
+class UniqueNode < Node
+  def initialize val; super(val, nil); end
+
+  def gen
+    "validates :#{@value.gen}, uniqueness: true"
+  end
+end
+
+class IdentNode < Node
+  def initialize val; super(val, nil); end
+
+  def gen
+    # bottoms out: IDENT is a string
+    @value
+  end
+
+  def column
+    # ident is likely a column (must be?)
+    @value
+  end
+end
+
+class ExprNode < Node
+  def initialize val; super(val); end
+
+  def column
+    @value.column
+  end
+
+  def gen
+    @value.gen
+  end
+end
+
+class EmptyExprNode < Node
+  def gen
+    nil
+  end
+
+  def column
+    nil
+  end
+end
+
+class CheckNode < Node
+  def initialize val; super(val); end
+
+  def gen
+    column = @value.column
+    val = @value.gen
+    if val
+      "validate { errors.add(:#{column}, \"Expected TODO\") unless #{val} }"
+    else
+      "validate { true }"
+    end
+  end
+end
+
+class TypedExprNode < Node
+  def initialize val, *args
+    @children = args
+    @type = @children[0]
+    @value = case @type.gen
+             when 'text' then TextNode.new(val)
+             when 'date' then DateExprNode.new(val)
+             else
+               raise "Unknown type: #{@children[0]}"
+             end
+  end
+
+  def column
+    @value.column
+  end
+
+  def gen
+    @value.gen
+  end
+end
+
+class TextNode < Node
+  def gen
+    @value.gen
+  end
+
+  def column
+    @value.column
+  end
+end
+
+class DateExprNode < Node
+  def initialize val
+    @value = val
+  end
+
+  def gen
+    val = @value.gen
+    if val == 'now'
+      "Time.now.to_date"
+    else
+      # YYYY-MM-DD
+      "Date.parse(\"#{val}\")"
+    end
+  end
+end
+
+class StrLitNode < Node
+  def initialize val; super(val); end
+
+  def gen
+    #FIXME HACK
+    if @value.respond_to? :gen
+      val = @value.gen
+    else
+      val = @value
+    end
+    val.gsub(/^'(.*)'$/, '\1')
+  end
+end
+
+class IntNode < Node
+  def initialize val; super(val); end
+
+  def gen
+    @value.to_s
+  end
+end
+
+class OperatorNode < Node
+  def initialize op, *args
+    @value = op
+    @children = args
+    @expr1 = @children[0]
+    @expr2 = @children[1]
+  end
+
+  def operation
+    case @value
+    when :gteq, :lteq, :neq, :eq, :gt, :lt
+      ComparisonExpr.new @value, @expr1, @expr2
+    when :plus
+      MathExpr.new @value, @expr1, @expr2
+    when :match
+      MatchExpr.new @expr1, @expr2
+    end
+  end
+
+  def error_msg
+    case @value
+    when :gteq  then 'to be greater than or equal to'
+    when :lteq  then 'to be less than or equal to'
+    when :neq   then 'to not equal'
+    when :eq    then 'to be equal to'
+    when :gt    then 'to be greater than'
+    when :lt    then 'to be less than'
+    when :plus  then 'plus'
+    when :match then 'to match'
+    end
+  end
+
+  def column
+    c1 = @expr1.column
+    c2 = @expr1.column
+    return c1 if c1 != 'base'
+    return c2 if c2 != 'base'
+    'base'
+  end
+
+  def gen
+    operation.gen
+  end
+end
+
+class ComparisonExpr
+  def initialize comparison, e1, e2
+    @e1, @e2 = e1, e2
+    @comparison = {
+      gteq: '>=',
+      lteq: '<=',
+      neq: '!=',
+      eq: '==',
+      gt: '>',
+      lt: '<',
+    }[comparison]
+  end
+
+  def gen
+    "#{@e1.gen} #{@comparison} #{@e2.gen}"
+  end
+end
+
+class MathExpr
+  def initialize op, e1, e2
+    @e1, @e2 = e1, e2
+    @operation = { plus: '+', minus: '-' }[op]
+  end
+
+  def gen
+    "#{@e1.gen} #{@operation} #{@e2.gen}"
+  end
+end
+
+class MatchExpr
+  def initialize e1, e2
+    @e1 = e1
+    @e2 = e2
+  end
+
+  def convert_wildcard str
+    str.gsub(/%/, '.*')
+  end
+
+  def gen
+    #raise "RHS: #{@e2.class} #{@e2.gen.class}"
+    "#{@e1.gen} =~ /#{convert_wildcard @e2.gen}/"
+  end
+end
+
+class TableNode < Node
+  def initialize tab, col
+    @tab = tab
+    @col = col
+  end
+
+  def table_to_class
+    @tab.gen.capitalize
+  end
+
+  def key_name
+    @col.gen
+  end
+
+  def gen
+    @tab.gen
+  end
+end
+
+class ActionNode < Node
+  def initialize action, consequence
+    @action = action
+    @consequence = consequence
+  end
+
+  def gen
+    "ON #{@action} #{@consequence}"
+  end
+end
+
+class ForeignKeyNode < Node
+  def initialize col, table, *actions
+    @col = col
+    @table = table
+    if actions.count > 0
+      @action = actions[0]
+    end
+  end
+
+  def gen
+    col = @col.gen
+    table_name = @table.gen
+    class_name = @table.table_to_class
+    key = @table.key_name
+    "belongs_to :#{table_name}, foreign_key: '#{col}', class: '#{class_name}', primary_key: '#{key}'"
+  end
+end

data/lib/generators/reactive_record/install_generator.rb

@@ -0,0 +1,23 @@
+require "reactive_record"
+
+module ReactiveRecord
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ReactiveRecord
+
+      desc "Adds models based upon your existing Postgres DB"
+
+      def create_models
+        db_env = Rails.configuration.database_configuration[Rails.env]
+        raise 'You must use the pg database adapter' unless db_env['adapter'] == 'postgresql'
+        db = PG.connect dbname: db_env['database']
+        table_names(db).each do |table|
+          unless table == 'schema_migrations'
+            create_file "app/models/#{table.underscore.pluralize}.rb", model_definition(db, table)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/lexer.rb

@@ -0,0 +1,91 @@
+require 'strscan'
+
+module ConstraintParser
+  class Lexer
+    CASCADE     = /CASCADE/
+    CHECK       = /CHECK/
+    COMMA       = /,/
+    DELETE      = /DELETE/
+    EQ          = /\=/
+    FOREIGN_KEY = /FOREIGN KEY/
+    GT          = /\>/
+    GTEQ        = /\>=/
+    IDENT       = /[a-zA-Z][a-zA-Z0-9_]*/
+    INT         = /[0-9]+/
+    LPAREN      = /\(/
+    LT          = /\</
+    LTEQ        = /\<=/
+    MATCH_OP    = /~~/
+    NEQ         = /\<\>/
+    NEWLINE     = /\n/
+    ON          = /ON/
+    PLUS        = /\+/
+    PRIMARY_KEY = /PRIMARY KEY/
+    REFERENCES  = /REFERENCES/
+    RESTRICT    = /RESTRICT/
+    RPAREN      = /\)/
+    SPACE       = /[\ \t]+/
+    STRLIT      = /\'(\\.|[^\\'])*\'/
+    TYPE        = /::/
+    UNIQUE      = /UNIQUE/
+
+    def initialize io
+      @ss = StringScanner.new io.read
+    end
+
+    def next_token
+      return if @ss.eos?
+
+      result = false
+      while !result
+        result = case
+          when text = @ss.scan(SPACE)       then #ignore whitespace
+
+          # Operators
+          when text = @ss.scan(GTEQ)        then [:GTEQ, text]
+          when text = @ss.scan(LTEQ)        then [:LTEQ, text]
+          when text = @ss.scan(NEQ)         then [:NEQ, text]
+          when text = @ss.scan(GT)          then [:GT, text]
+          when text = @ss.scan(LT)          then [:LT, text]
+          when text = @ss.scan(EQ)          then [:EQ, text]
+          when text = @ss.scan(PLUS)        then [:PLUS, text]
+          when text = @ss.scan(MATCH_OP)    then [:MATCH_OP, text]
+
+          # SQL Keywords
+          when text = @ss.scan(CHECK)       then [:CHECK, text]
+          when text = @ss.scan(UNIQUE)      then [:UNIQUE, text]
+          when text = @ss.scan(PRIMARY_KEY) then [:PRIMARY_KEY, text]
+          when text = @ss.scan(FOREIGN_KEY) then [:FOREIGN_KEY, text]
+          when text = @ss.scan(REFERENCES)  then [:REFERENCES, text]
+          when text = @ss.scan(DELETE)      then [:DELETE, text]
+          when text = @ss.scan(ON)          then [:ON, text]
+          when text = @ss.scan(RESTRICT)    then [:RESTRICT, text]
+          when text = @ss.scan(CASCADE)     then [:CASCADE, text]
+
+          # Values
+          when text = @ss.scan(IDENT)       then [:IDENT, text]
+          when text = @ss.scan(STRLIT)      then [:STRLIT, text]
+          when text = @ss.scan(INT)         then [:INT, text]
+
+          # Syntax
+          when text = @ss.scan(LPAREN)      then [:LPAREN, text]
+          when text = @ss.scan(RPAREN)      then [:RPAREN, text]
+          when text = @ss.scan(TYPE)        then [:TYPE, text]
+          when text = @ss.scan(COMMA)       then [:COMMA, text]
+          else
+            x = @ss.getch
+            [x, x]
+        end
+      end
+      result
+    end
+
+    def tokenize
+      out = []
+      while (tok = next_token)
+        out << tok
+      end
+      out
+    end
+  end
+end

data/lib/parser.y

@@ -0,0 +1,98 @@
+class ConstraintParser::Parser
+prechigh
+  left PLUS MATCH_OP
+  left GTEQ LTEQ NEQ EQ GT LT
+preclow
+
+token CASCADE
+      CHECK
+      COMMA
+      DELETE
+      EQ
+      FOREIGN_KEY
+      GT
+      GTEQ
+      IDENT
+      INT
+      LPAREN
+      LT
+      LTEQ
+      MATCH_OP
+      NEQ
+      NEWLINE
+      ON
+      PLUS
+      PRIMARY_KEY
+      REFERENCES
+      RESTRICT
+      RPAREN
+      SPACE
+      STRLIT
+      TYPE
+      UNIQUE
+
+rule
+  constraint      : unique_column   { result = val[0] }
+                  | check_statement { result = val[0] }
+                  | foreign_key     { result = val[0] }
+                  ;
+
+  unique_column   : UNIQUE LPAREN IDENT RPAREN { result = UniqueNode.new(IdentNode.new(val[2])) }
+                  ;
+
+  check_statement : CHECK expr  { result = CheckNode.new(val[1]) }
+
+  expr            :                     { result = EmptyExprNode.new :empty }
+                  | LPAREN expr RPAREN  { result = ExprNode.new(val[1]) }
+                  | expr type_signature { result = TypedExprNode.new(val[0], val[1]) }
+                  | expr operator expr  { result = OperatorNode.new(val[1], val[0], val[2]) }
+                  | IDENT               { result = IdentNode.new(val[0]) }
+                  | STRLIT              { result = StrLitNode.new(val[0]) }
+                  | INT                 { result = IntNode.new(val[0]) }
+                  ;
+
+  operator        : GTEQ     { result = :gteq  }
+                  | LTEQ     { result = :lteq  }
+                  | NEQ      { result = :neq   }
+                  | EQ       { result = :eq    }
+                  | GT       { result = :gt    }
+                  | LT       { result = :lt    }
+                  | PLUS     { result = :plus  }
+                  | MATCH_OP { result = :match }
+                  ;
+
+  type_signature  : TYPE IDENT { result = IdentNode.new(val[1]) }
+                  ;
+
+  foreign_key     : FOREIGN_KEY column_spec REFERENCES table_spec             { result = ForeignKeyNode.new(val[1], val[3]) }
+                  | FOREIGN_KEY column_spec REFERENCES table_spec action_spec { result = ForeignKeyNode.new(val[1], val[3], val[4]) }
+                  ;
+
+  column_spec     : LPAREN IDENT RPAREN { result = IdentNode.new(val[1]) }
+                  ;
+
+  table_spec      : IDENT column_spec { result = TableNode.new(IdentNode.new(val[0]), val[1]) }
+                  ;
+
+  action_spec     : ON DELETE RESTRICT { result = ActionNode.new(:delete, :restrict) }
+                  | ON DELETE CASCADE  { result = ActionNode.new(:delete, :cascade) }
+                  ;
+end
+
+---- inner
+
+  require 'lexer'
+  require 'code_generator'
+
+  def initialize tokenizer, handler = nil
+    @tokenizer = tokenizer
+    super()
+  end
+
+  def next_token
+    @tokenizer.next_token
+  end
+
+  def parse
+    do_parse
+  end

data/lib/reactive_record.rb

@@ -0,0 +1,115 @@
+require_relative "./reactive_record/version"
+
+require 'pg'
+require 'active_support/inflector'
+require 'parser'
+
+module ReactiveRecord
+  def model_definition db, table_name
+    header = "class #{table_name.classify.pluralize} < ActiveRecord::Base\n"
+    footer = "end\n"
+
+    body = []
+    body << "set_table_name '#{table_name}'"
+    body << "set_primary_key :#{primary_key db, table_name}"
+    body << "#{validate_definition non_nullable_columns(db, table_name), 'presence'}"
+    body << "#{validate_definition unique_columns(db, table_name), 'uniqueness'}"
+
+    generate_constraints(db, table_name).each do |con|
+      body << con
+    end
+
+    indent = "  "
+    body = indent + body.join("\n" + indent) + "\n"
+    header + body + footer
+  end
+
+  def validate_definition cols, type
+    return '' if cols.empty?
+    symbols = cols.map { |c| ":#{c}" }
+    "validate #{symbols.join ', '}, #{type}: true"
+  end
+
+  def table_names db
+    results = db.exec(
+      "select table_name from information_schema.tables where table_schema = $1",
+      ['public']
+    )
+    results.map { |r| r['table_name'] }
+  end
+
+  def constraints db, table
+    db.exec("""
+      SELECT c.relname AS table_name,
+             con.conname AS constraint_name,
+             pg_get_constraintdef( con.oid, false) AS constraint_src
+      FROM pg_constraint con
+        JOIN pg_namespace n on (n.oid = con.connamespace)
+        JOIN pg_class c on (c.oid = con.conrelid)
+      WHERE con.conrelid != 0
+      AND c.relname = $1
+      ORDER BY con.conname;
+    """, [table])
+  end
+
+  def generate_constraints db, table
+    key_or_pkey = lambda do |row|
+      row['constraint_name'].end_with?('_key') || row['constraint_name'].end_with?('_pkey')
+    end
+
+    constraints(db, table)
+      .reject(&key_or_pkey)
+      .map(&parse_constraint)
+  end
+
+  def parse_constraint
+    lambda do |row|
+      src = row['constraint_src']
+      parser = ConstraintParser::Parser.new(ConstraintParser::Lexer.new(StringIO.new src))
+      parser.parse.gen
+    end
+  end
+
+  def cols_with_contype db, table_name, type
+    db.exec """
+      SELECT column_name, conname
+      FROM pg_constraint, information_schema.columns
+      WHERE table_name = $1
+      AND contype = $2
+      AND ordinal_position = any(conkey);
+    """, [table_name, type]
+  end
+
+  def column_name
+    lambda {|row| row['column_name']}
+  end
+
+  def table_name
+    lambda {|row| row['table_name']}
+  end
+
+  def primary_key db, table_name
+    matching_primary_key = lambda {|row| row['conname'] == "#{table_name}_pkey"}
+    cols_with_contype(db, table_name, 'p')
+      .select(&matching_primary_key)
+      .map(&column_name)
+      .first
+  end
+
+  def unique_columns db, table_name
+    matching_unique_constraint = lambda {|row| row['conname'] == "#{table_name}_#{row['column_name']}_key"}
+    cols_with_contype(db, table_name, 'u')
+      .select(&matching_unique_constraint)
+      .map(&column_name)
+  end
+
+  def non_nullable_columns db, table_name
+    result = db.exec """
+      SELECT column_name
+      FROM information_schema.columns
+      WHERE table_name = $1
+      AND is_nullable = $2
+    """, [table_name, 'NO']
+    result.map { |r| r['column_name'] }
+  end
+end

data/lib/reactive_record/version.rb

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

data/reactive_record.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reactive_record/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "reactive_record"
+  gem.version       = ReactiveRecord::VERSION
+  gem.authors       = ["Joe Nelson", "Chris Wilson"]
+  gem.email         = ["christopher.j.wilson@gmail.com"]
+  gem.description   = %q{Generate ActiveRecord models from a pre-existing Postgres db}
+  gem.summary       = %q{Use the schema you always wanted.}
+  gem.homepage      = "https://github.com/twopoint718/reactive_record"
+  gem.licenses      = ['MIT']
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "pg"
+  gem.add_dependency "activesupport"
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'racc'
+end

data/spec/lexer_spec.rb

@@ -0,0 +1,145 @@
+require 'rspec'
+require_relative '../lib/lexer.rb'
+
+describe ConstraintParser::Lexer do
+  let(:lex){ConstraintParser::Lexer}
+
+  it "CHECK (((email)::text ~~ '%@bendyworks.com'::text))" do
+    @lex = lex.new \
+      StringIO.new "CHECK (((email)::text ~~ '%@bendyworks.com'::text))"
+    @lex.tokenize.should == [
+      [:CHECK, 'CHECK'],
+      [:LPAREN, '('],
+      [:LPAREN, '('],
+      [:LPAREN, '('],
+      [:IDENT, 'email'],
+      [:RPAREN, ')'],
+      [:TYPE, '::'],
+      [:IDENT, 'text'],
+      [:MATCH_OP, '~~'],
+      [:STRLIT, "'%@bendyworks.com'"],
+      [:TYPE, '::'],
+      [:IDENT, 'text'],
+      [:RPAREN, ')'],
+      [:RPAREN, ')'],
+    ]
+  end
+
+  it "UNIQUE (email)" do
+    @lex = lex.new StringIO.new "UNIQUE (email)"
+    @lex.tokenize.should == [
+      [:UNIQUE, 'UNIQUE'],
+      [:LPAREN, '('],
+      [:IDENT, 'email'],
+      [:RPAREN, ')']
+    ]
+  end
+
+  it "PRIMARY KEY (employee_id)" do
+    @lex = lex.new StringIO.new "PRIMARY KEY (employee_id)"
+    @lex.tokenize.should == [
+      [:PRIMARY_KEY, 'PRIMARY KEY'],
+      [:LPAREN, '('],
+      [:IDENT, 'employee_id'],
+      [:RPAREN, ')']
+    ]
+  end
+
+  it "CHECK ((start_date >= '2009-04-13'::date))" do
+    @lex = lex.new StringIO.new "CHECK ((start_date >= '2009-04-13'::date))"
+    @lex.tokenize.should == [
+      [:CHECK, 'CHECK'],
+      [:LPAREN, '('],
+      [:LPAREN, '('],
+      [:IDENT, 'start_date'],
+      [:GTEQ, '>='],
+      [:STRLIT, "'2009-04-13'"],
+      [:TYPE, '::'],
+      [:IDENT, 'date'],
+      [:RPAREN, ')'],
+      [:RPAREN, ')'],
+    ]
+  end
+
+  it '"CHECK ((start_date <= ((\'now\'::text)::date + 365)))"' do
+    @lex = lex.new StringIO.new "CHECK ((start_date <= ((\'now\'::text)::date + 365)))"
+    @lex.tokenize.should == [
+      [:CHECK, 'CHECK'],
+      [:LPAREN, '('],
+      [:LPAREN, '('],
+      [:IDENT, 'start_date'],
+      [:LTEQ, '<='],
+      [:LPAREN, '('],
+      [:LPAREN, '('],
+      [:STRLIT, "'now'"],
+      [:TYPE, '::'],
+      [:IDENT, 'text'],
+      [:RPAREN, ')'],
+      [:TYPE, '::'],
+      [:IDENT, 'date'],
+      [:PLUS, '+'],
+      [:INT, '365'],
+      [:RPAREN, ')'],
+      [:RPAREN, ')'],
+      [:RPAREN, ')'],
+    ]
+  end
+
+  it "FOREIGN KEY (employee_id) REFERENCES employees(employee_id) ON DELETE RESTRICT" do
+    @lex = lex.new StringIO.new "FOREIGN KEY (employee_id) REFERENCES employees(employee_id) ON DELETE RESTRICT"
+    @lex.tokenize.should == [
+      [:FOREIGN_KEY, 'FOREIGN KEY'],
+      [:LPAREN, '('],
+      [:IDENT, 'employee_id'],
+      [:RPAREN, ')'],
+      [:REFERENCES, 'REFERENCES'],
+      [:IDENT, 'employees'],
+      [:LPAREN, '('],
+      [:IDENT, 'employee_id'],
+      [:RPAREN, ')'],
+      [:ON, 'ON'],
+      [:DELETE, 'DELETE'],
+      [:RESTRICT, 'RESTRICT'],
+    ]
+  end
+
+  it "PRIMARY KEY (employee_id, project_id)" do
+    @lex = lex.new StringIO.new "PRIMARY KEY (employee_id, project_id)"
+    @lex.tokenize.should == [
+      [:PRIMARY_KEY, 'PRIMARY KEY'],
+      [:LPAREN, '('],
+      [:IDENT, 'employee_id'],
+      [:COMMA, ','],
+      [:IDENT, 'project_id'],
+      [:RPAREN, ')']
+    ]
+  end
+
+  it "FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE CASCADE" do
+    @lex = lex.new StringIO.new "FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE CASCADE"
+    @lex.tokenize.should == [
+      [:FOREIGN_KEY, 'FOREIGN KEY'],
+      [:LPAREN, '('],
+      [:IDENT, 'project_id'],
+      [:RPAREN, ')'],
+      [:REFERENCES, 'REFERENCES'],
+      [:IDENT, 'projects'],
+      [:LPAREN, '('],
+      [:IDENT, 'project_id'],
+      [:RPAREN, ')'],
+      [:ON, 'ON'],
+      [:DELETE, 'DELETE'],
+      [:CASCADE, 'CASCADE'],
+    ]
+  end
+
+  it "PRIMARY KEY (project_id)" do
+    @lex = lex.new StringIO.new "PRIMARY KEY (project_id)"
+    @lex.tokenize.should == [
+      [:PRIMARY_KEY, 'PRIMARY KEY'],
+      [:LPAREN, '('],
+      [:IDENT, 'project_id'],
+      [:RPAREN, ')'],
+    ]
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,39 @@
+require 'rspec'
+require_relative '../lib/lexer.rb'
+require_relative '../lib/parser.rb'
+require_relative '../lib/code_generator.rb'
+
+describe ConstraintParser::Parser do
+  let(:lex){ConstraintParser::Lexer}
+  let(:par){ConstraintParser::Parser}
+
+  it 'CHECK ()' do
+    @parser = par.new(lex.new StringIO.new 'CHECK ()')
+    @parser.parse.gen.should == 'validate { true }'
+  end
+
+  it "CHECK (((email)::text ~~ '%@bendyworks.com'::text))" do
+    @parser = par.new(lex.new StringIO.new "CHECK (((email)::text ~~ '%@bendyworks.com'::text))")
+    @parser.parse.gen.should  == 'validate { errors.add(:email, "Expected TODO") unless email =~ /.*@bendyworks.com/ }'
+  end
+
+  it "UNIQUE (email)" do
+    @parser = par.new(lex.new StringIO.new 'UNIQUE (email)')
+    @parser.parse.gen.should == "validates :email, uniqueness: true"
+  end
+
+  it "CHECK ((start_date <= ('now'::text)::date))" do
+    @parser = par.new(lex.new StringIO.new "CHECK ((start_date <= ('now'::text)::date))")
+    @parser.parse.gen.should == "validate { errors.add(:start_date, \"Expected TODO\") unless start_date <= Time.now.to_date }"
+  end
+
+  it "CHECK ((start_date <= (('now'::text)::date + 365)))" do
+    @parser = par.new(lex.new StringIO.new "CHECK ((start_date <= (('now'::text)::date + 365)))")
+    @parser.parse.gen.should == 'validate { errors.add(:start_date, "Expected TODO") unless start_date <= Time.now.to_date + 365 }'
+  end
+
+  it "FOREIGN KEY (employee_id) REFERENCES employees(employee_id) ON DELETE RESTRICT" do
+    @parser = par.new(lex.new StringIO.new "FOREIGN KEY (employee_id) REFERENCES employees(employee_id) ON DELETE RESTRICT")
+    @parser.parse.gen.should == "belongs_to :employees, foreign_key: 'employee_id', class: 'Employees', primary_key: 'employee_id'"
+  end
+end

data/spec/reactive_record_spec.rb

@@ -0,0 +1,119 @@
+require 'rspec'
+require_relative '../lib/reactive_record'
+
+include ReactiveRecord
+
+describe 'ReactiveRecord' do
+  before :all do
+    # db setup
+    @dbname = "reactive_record_test_#{Process.pid}"
+
+    # N.B. all reactive_record methods are read only and so I believe
+    # that it is valid to share a db connection. Nothing reactive record
+    # does should mutate any global state
+    system "createdb #{@dbname}"
+    @db = PG.connect dbname: @dbname
+    @db.exec File.read('spec/seed/database.sql')
+  end
+
+  after :all do
+    # db teardown
+    @db.close
+    system "dropdb #{@dbname}"
+  end
+
+  context '#model_definition' do
+    it 'generates an employee model def' do
+      model_definition(@db, 'employees').should ==
+        <<-EOS.gsub(/^ {10}/, '')
+          class Employees < ActiveRecord::Base
+            set_table_name 'employees'
+            set_primary_key :id
+            validate :id, :name, :email, :start_date, presence: true
+            validate :email, uniqueness: true
+            validate { errors.add(:email, "Expected TODO") unless email =~ /.*@example.com/ }
+            validate { errors.add(:start_date, "Expected TODO") unless start_date >= Date.parse(\"2009-04-13\") }
+            validate { errors.add(:start_date, "Expected TODO") unless start_date <= Time.now.to_date + 365 }
+          end
+        EOS
+    end
+
+    it 'generates a project model def' do
+      model_definition(@db, 'projects').should ==
+        <<-EOS.gsub(/^ {10}/, '')
+          class Projects < ActiveRecord::Base
+            set_table_name 'projects'
+            set_primary_key :id
+            validate :id, :name, presence: true
+            validate :name, uniqueness: true
+          end
+        EOS
+    end
+  end
+
+  context '#constraints' do
+    it 'gathers all constraints on the employees table' do
+      constraints(@db, 'employees').to_a.should == [
+        {"table_name"=>"employees", "constraint_name"=>"company_email", "constraint_src"=>"CHECK (((email)::text ~~ '%@example.com'::text))"},
+        {"table_name"=>"employees", "constraint_name"=>"employees_email_key", "constraint_src"=>"UNIQUE (email)"},
+        {"table_name"=>"employees", "constraint_name"=>"employees_pkey", "constraint_src"=>"PRIMARY KEY (id)"},
+        {"table_name"=>"employees", "constraint_name"=>"founding_date", "constraint_src"=>"CHECK ((start_date >= '2009-04-13'::date))"},
+        {"table_name"=>"employees", "constraint_name"=>"future_start_date", "constraint_src"=>"CHECK ((start_date <= (('now'::text)::date + 365)))"}
+      ]
+    end
+    it 'gathers all constraints on the projects table' do
+      constraints(@db, 'projects').to_a.should == [
+        {"table_name"=>"projects", "constraint_name"=>"projects_name_key", "constraint_src"=>"UNIQUE (name)"},
+        {"table_name"=>"projects", "constraint_name"=>"projects_pkey", "constraint_src"=>"PRIMARY KEY (id)"}
+      ]
+    end
+    it 'gathers all constraints on the employees_projects table' do
+      constraints(@db, 'employees_projects').to_a.should == [
+        {
+          "table_name"=>"employees_projects",
+          "constraint_name"=>"employees_projects_employee_id_fkey",
+          "constraint_src"=>"FOREIGN KEY (employee_id) REFERENCES employees(id) ON DELETE RESTRICT"
+        },
+        {
+          "table_name"=>"employees_projects",
+          "constraint_name"=>"employees_projects_pkey",
+          "constraint_src"=>"PRIMARY KEY (employee_id, project_id)"
+        },
+        {
+          "table_name"=>"employees_projects",
+          "constraint_name"=>"employees_projects_project_id_fkey",
+          "constraint_src"=>"FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE"
+        }
+      ]
+    end
+  end
+
+  context '#generate_constraints' do
+    it 'generates ruby code for employees constraints' do
+      generate_constraints(@db, 'employees').should == [
+        "validate { errors.add(:email, \"Expected TODO\") unless email =~ /.*@example.com/ }",
+        "validate { errors.add(:start_date, \"Expected TODO\") unless start_date >= Date.parse(\"2009-04-13\") }",
+        "validate { errors.add(:start_date, \"Expected TODO\") unless start_date <= Time.now.to_date + 365 }",
+      ]
+    end
+  end
+
+  context '#unique_columns' do
+    it 'returns email for employees' do
+      unique_columns(@db, 'employees').should == ['email']
+    end
+  end
+
+  context '#cols_with_contype' do
+    it 'identifies UNIQUE columns in database' do
+      cols_with_contype(@db, 'employees', 'u').to_a.should == [{"column_name"=>"email", "conname"=>"employees_email_key"},
+                                                               {"column_name"=>"name", "conname"=>"projects_name_key"}]
+    end
+  end
+
+  context '#non_nullable_columns' do
+    it 'identifies NOT NULL columns in employees' do
+      non_nullable_columns(@db, 'employees').should == ['id', 'name', 'email', 'start_date']
+    end
+  end
+end

data/spec/seed/database.sql

@@ -0,0 +1,67 @@
+-- create tables
+
+CREATE TABLE employees (
+  id         SERIAL,
+  name       VARCHAR(255) NOT NULL,
+  email      VARCHAR(255) NOT NULL UNIQUE,
+  start_date DATE NOT NULL,
+
+  PRIMARY KEY (id),
+
+  CONSTRAINT founding_date     CHECK (start_date >= '2009-04-13'),
+  CONSTRAINT future_start_date CHECK (start_date <= CURRENT_DATE + 365),
+  CONSTRAINT company_email     CHECK (email LIKE '%@example.com')
+);
+
+CREATE TABLE projects (
+  id   INTEGER NOT NULL,
+  name VARCHAR(255) NOT NULL UNIQUE,
+
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE employees_projects (
+  employee_id INTEGER REFERENCES employees ON DELETE RESTRICT,
+  project_id  INTEGER REFERENCES projects  ON DELETE CASCADE,
+
+  PRIMARY KEY (employee_id, project_id)
+);
+
+-- seed data
+
+INSERT INTO employees (id, name, email, start_date)
+VALUES
+  (1,  'Alfred Arnold', 'alfred@example.com', '2009-04-13'),
+  (2,  'Benedict Burton', 'benedict@example.com', '2011-09-01'),
+  (3,  'Cat Cams', 'cat@example.com', '2009-04-13'),
+  (4,  'Duane Drummond', 'duane@example.com', '2009-04-13'),
+  (5,  'Elizabeth Eggers', 'elizabeth@example.com', '2009-04-13'),
+  (6,  'Fred Fitzgerald', 'fred@example.com', '2012-01-01'),
+  (7,  'Greg Gruber', 'greg@example.com', '2013-01-07'),
+  (8,  'Horatio Helms', 'horatio@example.com', '2012-01-01'),
+  (9,  'Ian Ives', 'ian@example.com', '2009-04-13'),
+  (10, 'Jan Jarvis', 'jan@example.com', '2013-01-28'),
+  (11, 'Kevin Kelvin', 'kevin@example.com', '2009-04-13'),
+  (12, 'Lucy Lemieux', 'lucy@example.com', '2009-04-13');
+
+INSERT INTO projects (id, name)
+VALUES
+  (1, 'Yoyodyne Inc.'),
+  (2, 'Global Omni Mega Corp.'),
+  (3, 'Murray''s Widgets Ltd.'),
+  (4, 'Spatula City'),
+  (5, 'Aperture Laboratories');
+
+INSERT INTO employees_projects (employee_id, project_id)
+VALUES
+  (1,1),
+  (2,1),
+  (3,2),
+  (4,2),
+  (5,3),
+  (6,3),
+  (7,4),
+  (8,4),
+  (9,5),
+  (10,5),
+  (11,5);

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: reactive_record
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joe Nelson
+- Chris Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-02 00:00:00.000000000 Z
+dependencies:
+- !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: activesupport
+  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: 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: racc
+  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: Generate ActiveRecord models from a pre-existing Postgres db
+email:
+- christopher.j.wilson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/code_generator.rb
+- lib/generators/reactive_record/install_generator.rb
+- lib/lexer.rb
+- lib/parser.y
+- lib/reactive_record.rb
+- lib/reactive_record/version.rb
+- reactive_record.gemspec
+- spec/lexer_spec.rb
+- spec/parser_spec.rb
+- spec/reactive_record_spec.rb
+- spec/seed/database.sql
+homepage: https://github.com/twopoint718/reactive_record
+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.1.5
+signing_key: 
+specification_version: 4
+summary: Use the schema you always wanted.
+test_files:
+- spec/lexer_spec.rb
+- spec/parser_spec.rb
+- spec/reactive_record_spec.rb
+- spec/seed/database.sql