mystic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e7f8ba8f872bed5ad3946fb3eca8373a5262c820
+  data.tar.gz: 874d9a10179f9c9e15a6fffb7451ff03ad70788a
+SHA512:
+  metadata.gz: c10435a23302bdf3e5aec546b164b4dc73a021b9d12221e2e1387e26086a2db21f603896aa3ef0b49daaa464438d1cec143861ecac0cb7421e057c9489cfd98a
+  data.tar.gz: 5333e387710b4b0d19b81664359becf2a79f101e9d655820d256388a4488543b3587219514e4a2d2c212d931cb7806ee522546e75f974b2f838cdd8eb19af919

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> <copyright holders>
+
+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/bin/mystic

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require "mystic"
+require "irb"
+
+# Examples:
+# mystic create migration InitialMigration
+# mystic migrate development
+# mystic rollback production
+
+ErrorOutput = Class.new StandardError
+
+begin
+	case ARGV[0].to_sym
+	when :create
+	  case ARGV[1].to_sym
+	  when :migration
+			raise ErrorOutput, "No migration name provided" if ARGV[2].nil?
+			Mystic.create_migration ARGV[2].dup
+	  end
+	else
+		begin
+			Mystic.connect ARGV[1]
+		  case ARGV[0].to_sym
+		  when :migrate
+		  	Mystic.migrate
+		  when :rollback
+		  	Mystic.rollback
+			when :console
+				puts "Starting Mystic console: #{Mystic.env}"
+				IRB.setup nil
+				IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+				require "irb/ext/multi-irb"
+				IRB.irb nil, IRB::WorkSpace.new
+			end
+		 	Mystic.disconnect
+		rescue Mystic::EnvironmentError => e
+			puts e.message
+		end
+	end
+rescue ErrorOutput => e
+	puts e.message
+end

data/lib/mystic.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+require "pathname"
+require "mystic/extensions"
+require "mystic/constants"
+require "mystic/sql"
+require "mystic/adapter"
+require "mystic/migration"
+require "mystic/model"
+
+module Mystic	
+	@@adapter = nil
+	
+	class << self
+		def adapter
+			@@adapter
+		end
+		
+		# Mystic.connect
+		#   Connects to a database. It's recommended you use it like ActiveRecord::Base.establish_connection
+		# Arguments:
+		#   env - The env from database.yml you wish to use
+		def connect(env="")
+			load_env
+			@@env = (env || ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development").to_s
+			path = root.join("config","database.yml").to_s
+			db_yml = YAML.load_file path
+		
+			raise EnvironmentError, "Environment '#{@@env}' doesn't exist." unless db_yml.member? @@env
+		
+			conf = db_yml[@@env].symbolize
+			conf[:dbname] = conf[:database]
+			
+			@@adapter = Adapter.create(
+				conf[:adapter],
+				:pool_size => conf[:pool_size].to_i,
+				:pool_timeout => conf[:timeout].to_i,
+				:pool_expires => conf[:expires].to_i
+			)
+		
+			@@adapter.connect conf
+			true
+		end
+	
+		alias_method :env=, :connect
+	
+		def env
+			@@env
+		end
+		
+		# Mystic.disconnect
+		#   Disconnects from the connected database. Use it like ActiveRecord::Base.connection.disconnect!
+		def disconnect
+			@@adapter.disconnect
+			@@adapter = nil
+			true
+		end
+
+		# Mystic.execute
+		#   Execute some sql. It will be densified (the densify gem) and sent to the DB
+		# Arguments:
+		#   sql - The SQL to execute
+		# Returns: Native Ruby objects representing the response from the DB (Usually an Array of Hashes)
+		def execute(sql="")
+			raise AdapterError, "Adapter is nil, so Mystic is not connected." if @@adapter.nil?
+			@@adapter.execute sql.sql_terminate.densify
+		end
+  
+		# Mystic.sanitize
+		#   Escape a string so that it can be used safely as input. Mystic does not support statement preparation, so this is a must.
+		# Arguments:
+		#   str - The string to sanitize
+		# Returns: the sanitized string
+		def sanitize(str="")
+			raise AdapterError, "Adapter is nil, so Mystic is not connected." if @@adapter.nil?
+			@@adapter.sanitize str
+		end
+	
+		# Mystic.root
+		#   Get the app root
+		# Aguments:
+		#   To be ignored
+		# Returns:
+		#   A pathname to the application's root
+		def root(path=Pathname.new(Dir.pwd))
+			raise RootError, "Failed to find the application's root." if path == path.parent
+			mystic_path = path.join "config", "database.yml"
+			return path if mystic_path.file? # exist? is implicit with file?
+			root path.parent
+		end
+	
+		# TODO: Make this a migration
+		# TODO: Silence this
+		# Mystic.create_table
+		#   Create migration tracking table
+		def create_mig_table
+			execute "CREATE TABLE IF NOT EXISTS mystic_migrations (mig_number integer, filename text)"
+		end
+	
+		#
+		# Command line
+		#
+		
+		# Runs every yet-to-be-ran migration
+		def migrate
+			create_mig_table
+			migrated_filenames = execute("SELECT filename FROM mystic_migrations").map{ |r| r["filename"] }
+			mp = root.join("mystic","migrations").to_s
+		
+			Dir.entries(mp)
+				.reject{ |e| MIG_REGEX.match(e).nil? }
+				.reject{ |e| migrated_filenames.include? e }
+				.sort{ |a,b| MIG_REGEX.match(a)[:num].to_i <=> MIG_REGEX.match(b)[:num].to_i }
+				.each{ |fname|
+					load File.join mp,fname
+				
+					mig_num,mig_name = MIG_REGEX.match(fname).captures
+					Object.const_get(mig_name).new.migrate
+					execute "INSERT INTO mystic_migrations (mig_number, filename) VALUES (#{mig_num},'#{fname}')"
+				}
+		end
+	
+		# Rolls back a single migration
+		def rollback
+			create_mig_table
+			fname = execute("SELECT filename FROM mystic_migrations ORDER BY mig_number DESC LIMIT 1")[0]["filename"] rescue nil
+			return if fname.nil?
+
+			load root.join("mystic","migrations",fname).to_s
+		
+			mig_num,mig_name = MIG_REGEX.match(fname).captures
+
+			Object.const_get(mig_name).new.rollback
+		
+			execute "DELETE FROM mystic_migrations WHERE filename='#{fname}' and mig_number=#{mig_num}"
+		end
+	
+	  # Creates a blank migration in mystic/migrations
+		def create_migration(name="")
+			name.strip!
+			raise CLIError, "Migration name must not be empty." if name.empty?
+		
+			name[0] = name[0].capitalize
+    
+			migs = root.join "mystic","migrations"
+
+			num = migs.entries.map{ |e| MIG_REGEX.match(e.to_s)[:num].to_i rescue 0 }.max.to_i+1
+
+			File.open(migs.join("#{num}_#{name}.rb").to_s, 'w') { |f| f.write(template name) }
+		end
+	
+		private
+		
+		# Loads the .env file
+		def load_env
+			root.join(".env").read
+											 .split("\n")
+											 .map { |l| l.strip.split "=", 2 }
+											 .each { |k,v| ENV[k] = v }
+		end
+			
+		# Retuns a blank migration's code in a String
+		def template(name=nil)
+			raise ArgumentError, "Migrations must have a name." if name.nil?
+			<<-mig_template
+#!/usr/bin/env ruby
+
+require "mystic"
+
+class #{name} < Mystic::Migration
+  def up
+		
+  end
+  
+  def down
+		
+  end
+end
+			mig_template
+		end
+	end
+end

data/lib/mystic/adapter.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+
+require "densify"
+require "access_stack"
+
+module Mystic
+  class Adapter
+    attr_accessor :pool_size,
+									:pool_timeout,
+									:pool_expires
+  
+    @@blocks = {}
+
+    def self.create(name="",opts={})
+			name = name.to_s.downcase.strip
+			name = "postgres" if name =~ /^postg.*$/i # Includes PostGIS
+			name = "mysql" if name =~ /^mysql.*$/i
+		
+			require "mystic/adapters/" + name
+		
+			Object.const_get("Mystic::#{name.capitalize}Adapter").new opts
+    end
+    
+    def initialize(opts={})
+    	opts.symbolize.each do |k,v|
+    		k = ('@' + k.to_s).to_sym
+    		instance_variable_set k,v if instance_variables.include? k
+    	end
+    end
+	
+    # Gets the adapter name (examples: postgres, mysql)
+    def self.adapter
+      a = name.split("::").last.sub("Adapter","").downcase
+			a = "abstract" if a.empty?
+			a
+    end
+		
+		def adapter
+			self.class.adapter
+		end
+    
+    # Map a block to an adapter's block hash
+    #   This avoids cases where a subclass' class var
+    #   changes that class var on its superclass
+    def self.map_block(key, block)
+			@@blocks[adapter] ||= {}
+    	@@blocks[adapter][key] = block
+    end
+    
+    # Fetch a block for the current adapter
+    def block_for(key)
+    	b = @@blocks[adapter][key] rescue nil
+			b ||= @@blocks["abstract"][key] rescue nil
+			b ||= lambda { "" }
+			b
+    end
+    
+    #
+    # Adapter DSL
+    # Implemented using method_missing
+    #
+    
+    # example
+    # execute do |inst,sql|
+    #   inst.exec sql
+    # end
+    
+    # execute(inst,sql)
+    # Executes SQL and returns Ruby types
+    
+    # TODO: different kinds of escaping: ident & quote
+    
+    # sanitize(inst,sql)
+    # Escapes a literal
+    
+    # connect(opts)
+    # Creates an instance of the DB connection
+    
+    # disconnect(inst)
+    # Disconnects and destroys inst (a database connection)
+    
+    # validate(inst)
+    # Checks if inst is a valid connection
+
+		# Map missing methods to blocks
+		# DB ops or SQL generation
+		def self.method_missing(meth, *args, &block)
+			map_block meth, block
+		end
+		
+    #
+    # Adapter methods
+    #   These are called internally
+    #   They are called by class methods
+    #   in ../mystic.rb
+    #
+		def connect(opts)
+			disconnect unless @pool.nil?
+			@pool = AccessStack.new(
+				:size => @pool_size,
+				:timeout => @pool_timeout,
+				:expires => @pool_expires,
+				:create => lambda { block_for(:connect).call opts }
+			)
+    end
+  
+    def disconnect
+    	@pool.destroy ||= block_for :disconnect
+			@pool.empty!
+    end
+    
+    def reap
+    	@pool.validate ||= block_for :validate
+    	@pool.reap
+    end
+  
+    def execute(sql)
+			raise AdapterError, "Adapter's connection pool doesn't exist and so Mystic has not connected to the database." if @pool.nil?
+			@pool.with { |inst| block_for(:execute).call inst, sql }
+    end
+  
+    def sanitize(str)
+			@pool.with { |inst| block_for(:sanitize).call inst, str }
+    end
+		
+		def json_supported?
+			block_for(:json_supported).call
+		end
+  
+    def serialize_sql(obj)
+			return case obj
+			when SQL::Table
+				block_for(:table).call obj
+			when SQL::Index
+				block_for(:index).call obj
+			when SQL::Column
+				block_for(:column).call obj
+			when SQL::Operation
+				res = block_for(obj.kind).call obj
+				obj.callback.call unless obj.callback.nil?
+				res
+			end
+    end
+  end
+end

data/lib/mystic/adapters/abstract.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require "mystic"
+require "mystic/adapter"
+require "mystic/sql"
+
+#
+# This adapter is designed to hold
+# basic, spec-adherent SQL generation
+#	so adapters can be more DRY
+#
+
+module Mystic
+	class Adapter
+		
+		json_supported { false }
+		
+		table do |obj|
+			sql = []
+      sql.push "CREATE TABLE #{obj.name} (#{obj.columns.map(&:to_sql)*","})" if obj.create?
+      sql.push "ALTER TABLE #{obj.name} #{obj.columns.map{|c| "ADD COLUMN #{c.to_sql}" }*', '}" unless obj.create?
+			sql.push *(obj.indeces.map(&:to_sql)) unless obj.indeces.empty?
+	    sql.push *(obj.operations.map(&:to_sql)) unless obj.operations.empty?
+			sql*"; "
+		end
+		
+		column do |obj|
+			sql = []
+			sql << obj.name
+			sql << obj.kind.downcase
+			sql << "(#{obj.size})" if obj.size && !obj.size.empty? && !obj.geospatial?
+			sql << "(#{obj.geom_kind}, #{obj.geom_srid})" if obj.geospatial?
+      sql << (obj.constraints[:null] ? "NULL" : "NOT NULL") if obj.constraints.member?(:null)
+			sql << "UNIQUE" if obj.constraints[:unique]
+			sql << "PRIMARY KEY" if obj.constraints[:primary_key]
+			sql << "REFERENCES " + obj.constraints[:references] if obj.constraints.member?(:references)
+			sql << "DEFAULT " + obj.constraints[:default] if obj.constraints.member?(:default)
+			sql << "CHECK(#{obj.constraints[:check]})" if obj.constraints.member?(:check)
+			sql*" "
+		end
+		
+		index do |index|
+			sql = []
+			sql << "CREATE"
+			sql << "UNIQUE" if index.unique
+			sql << "INDEX"
+		  sql << index.name if index.name
+		  sql << "ON"
+			sql << index.table_name
+			sql << "(#{index.columns.map(&:to_s).join(',')})"
+			sql*" "
+		end
+		
+		#
+		## Operations
+		#
+		
+		drop_columns do |obj|
+			"ALTER TABLE #{obj.table_name} #{obj.column_names.map{|c| "DROP COLUMN #{c.to_s}" }*', '}"
+		end
+		
+		rename_column do |obj|
+			"ALTER TABLE #{obj.table_name} RENAME COLUMN #{obj.old_name} TO #{obj.new_name}"
+		end
+		
+		create_view do |obj|
+			"CREATE VIEW #{obj.name} AS #{obj.sql}"
+		end
+		
+		drop_view do |obj|
+			"DROP VIEW #{obj.name}"
+		end
+		
+		drop_table do |obj|
+			"DROP TABLE #{obj.table_name}"
+		end
+		
+		rename_table do |obj|
+			"ALTER TABLE #{obj.old_name} RENAME TO #{obj.new_name}"
+		end
+		
+		#
+		## Transaction Operations
+		#
+		
+		start_transaction { "BEGIN" }
+		commit_transaction { "COMMIT" }
+		rollback_transaction { "ROLLBACK" }
+	end
+end

data/lib/mystic/adapters/mysql.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require "mysql2"
+
+# TODO:
+# 1. Implement geometry
+
+module Mystic
+	class MysqlAdapter < Mystic::Adapter
+		ALGORITHMS = [:default, :inplace, :copy]
+		LOCKS = [:default, :none, :shared, :exclusive]
+		
+		connect { |opts| Mysql2::client.new opts }
+		disconnect { |mysql| mysql.close }
+		validate { |mysql| mysql.ping }
+		execute { |mysql, sql| mysql.query(sql).to_a }
+		sanitize { |mysql, str| mysql.escape str }
+		
+		drop_index do |index|
+			"DROP INDEX #{index.name} ON #{index.table_name}"
+		end
+		
+		index do |index|
+			sql = []
+			sql << "CREATE"
+			sql << "UNIQUE" if index.unique
+			sql << "INDEX"
+		  sql << index.name if index.name
+		  sql << "ON"
+			sql << index.table_name
+			sql << "USING #{obj.type.to_s.capitalize}" if index.type
+			sql << "(#{index.columns.map(&:to_s).join ',' })"
+			sql << "COMMENT #{index.comment.truncate 1024}" if index.comment
+			sql << "ALGORITHM #{index.algorithm.to_s.upcase}" if !index.lock && ALGORITHMS.include? index.algorithm
+			sql << "LOCK #{index.lock.to_s.upcase}" if !index.algorithm && LOCKS.include? index.lock
+			sql*" "
+		end
+		
+		# Leverage MySQL savepoints to make up for transactions' flaws
+		start_transaction { <<-sql
+			BEGIN;
+			SAVEPOINT mystic_migration8889;
+			DECLARE EXIT HANDLER FOR SQLWARNING ROLLBACK TO mystic_migration8889;
+			DECLARE EXIT HANDLER FOR NOT FOUND ROLLBACK TO mystic_migration8889;
+			DECLARE EXIT HANDLER FOR SQLEXCEPTION ROLLBACK TO mystic_migration8889;
+			sql
+		}
+		commit_transaction { "RELEASE SAVEPOINT mystic_migration8889;COMMIT" }
+		rollback_transaction { "ROLLBACK TO mystic_migration8889; RELEASE SAVEPOINT mystic_migration8889; ROLLBACK" }
+	end
+end

data/lib/mystic/adapters/postgres.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require "mystic/adapters/abstract"
+require "pg"
+
+# Mystic adapter for Postgres, includes PostGIS
+
+module Mystic
+	class PostgresAdapter < Mystic::Adapter
+		INDEX_TYPES = [
+			:btree,
+			:hash,
+			:gist,
+			:spgist,
+			:gin
+		].freeze
+		
+		CONNECT_FIELDS = [
+			:host,
+			:hostaddr,
+			:port,
+			:dbname,
+			:user,
+			:password,
+			:connect_timeout,
+			:options,
+			:tty,
+			:sslmode,
+			:krbsrvname,
+			:gsslib
+		].freeze
+		
+		connect { |opts| PG.connect opts.subhash(*CONNECT_FIELDS) }
+		disconnect { |pg| pg.close }
+		validate { |pg| pg.status == CONNECTION_OK }
+		sanitize { |pg, str| pg.escape_string str }
+		json_supported { true }
+		
+		execute do |pg, sql|
+			res = pg.exec sql
+			v = res[0][Mystic::JSON_COL] if res.ntuples == 1 && res.nfields == 1
+			v ||= res.ntuples.times.map { |i| res[i] } unless res.nil?
+			v ||= []
+			v
+		end
+		
+		drop_index do |index| 
+			"DROP INDEX #{index.index_name}"
+		end
+		
+		create_ext do |ext| 
+			"CREATE EXTENSION \"#{ext.name}\""
+		end
+		
+		drop_ext do |ext|
+			"DROP EXTENSION \"#{ext.name}\"" 
+		end
+		
+		index do |index|
+			storage_params = index.opts.subhash :fillfactor, :buffering, :fastupdate
+			
+			sql = []
+			sql << "CREATE"
+			sql << "UNIQUE" if index.unique
+			sql << "INDEX"
+			sql << "CONCURENTLY" if index.concurrently
+		  sql << index.name unless index.name.nil?
+		  sql << "ON #{index.table_name}"
+			sql << "USING #{index.type}" if INDEX_TYPES.include? index.type
+			sql << "(#{index.columns.map(&:to_s).join ',' })"
+			sql << "WITH (#{storage_params.sqlize})" unless storage_params.empty?
+			sql << "TABLESPACE #{index.tablespace}" unless index.tablespace.nil?
+			sql << "WHERE #{index.where}" unless index.where.nil?
+			sql*' '
+		end
+
+		table do |table|
+			sql = []
+			
+			if table.create?
+				tbl = []
+				tbl << "CREATE TABLE #{table.name} (#{table.columns.map(&:to_sql)*","})"
+				tbl << "INHERITS #{table.inherits}" if table.inherits
+				tbl << "TABLESPACE #{table.tablespace}" if table.tablespace
+				sql << tbl*' '
+			else
+				sql << "ALTER TABLE #{table.name} #{table.columns.map{ |c| "ADD COLUMN #{c.to_sql}" }*', ' }"
+			end
+      
+			sql.push(*table.indeces.map(&:to_sql)) unless table.indeces.empty?
+	    sql.push(*table.operations.map(&:to_sql)) unless table.operations.empty?
+			sql*'; '
+		end
+	end
+end

data/lib/mystic/constants.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+module Mystic
+	MysticError = Class.new StandardError
+	RootError = Class.new StandardError
+	EnvironmentError = Class.new StandardError
+	AdapterError = Class.new StandardError
+	CLIError = Class.new StandardError
+	MIG_REGEX = /(?<num>\d+)_(?<name>[a-z]+)\.rb$/i # matches migration files (ex '1_MigrationClassName.rb')
+	JSON_COL = "mystic_return_json89788"
+end

data/lib/mystic/extensions.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+module Kernel
+	def self.silent
+		v = $VERBOSE
+		$VERBOSE = false
+		yield
+		$VERBOSE = v
+		nil
+	end
+end
+
+class String
+  def desnake
+    downcase.split("_").map(&:capitalize)*' '
+  end
+	
+  def sanitize
+    Mystic.sanitize(self).untaint
+  end
+	
+	def truncate(len)
+		self[0..len-1]
+	end
+	
+	def sql_terminate
+		return self + ";" unless dup.strip.end_with? ";"
+		self
+	end
+end
+
+class Array
+  def merge_keys(*keys)
+		raise ArgumentError, "No keys to merge." if keys.nil? || keys.empty?
+    raise ArgumentError, "Argument array must have the same number of elements as self." if keys.count != self.count
+    Hash[each_with_index.map{ |v,i| [keys[i],v] }]
+  end
+	
+	def symbolize
+		map(&:to_sym)
+	end
+	
+	def symbolize!
+		map!(&:to_sym)
+	end
+	
+	def sqlize
+		map { |o|
+			case o
+			when String
+				"'#{o.sanitize}'"
+			when Numeric
+				o.to_s
+			end
+		}.compact
+	end
+end
+
+class Hash
+	def subhash(*keys)
+		Hash[values_at(*keys).merge_keys(*keys).reject{ |k,v| v.nil? }]
+	end
+	
+  def parify(delim=" ")
+    map { |pair| pair * delim }
+  end
+	
+	def compact
+		reject { |k,v| v.nil? }
+	end
+	
+	def compact!
+		reject! { |k,v| v.nil? }
+	end
+	
+	def symbolize
+		Hash[map { |k,v| [k.to_sym, v]}]
+	end
+	
+	def symbolize!
+		keys.each { |key| self[key.to_sym] = delete key }
+	end
+  
+  def sqlize
+    reject { |k,v| v.nil? || v.empty? }.map{ |k,v| "#{k}=#{Integer === v ? v : "'#{v.to_s.sanitize}'" }" }
+  end
+end
+
+class Pathname
+	Kernel.silent do
+	  def relative?
+	    @path[0] != File::SEPARATOR
+	  end
+	
+		def join(*args)
+			Pathname.new(File.join @path, *args.map(&:to_s))
+		end
+	end
+end

data/lib/mystic/migration.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+module Mystic  
+  class Migration
+		Error = Class.new(StandardError)
+		IrreversibleError = Class.new(StandardError)
+
+		def initialize
+			@irreversible = false
+			@sql = ""
+		end
+		
+		def migrate
+			exec_migration :up
+		end
+		
+		def rollback
+			exec_migration :down
+		end
+		
+		# TODO: This is ugly... It needs cleaning up.
+		def exec_migration(direction)
+			@sql = ""
+			
+			direction = direction.to_sym
+			
+			raise ArgumentError, "Direction must be either :up or :down." unless [:up, :down].include? direction
+			raise IrreversibleError, "Impossible to roll back an irreversible migration." if direction == :down && irreversible?
+			
+			execute Mystic::SQL::Operation.start_transaction
+			method(direction).call
+			execute Mystic::SQL::Operation.commit_transaction
+			
+			Mystic.adapter.execute @sql # bypass densification
+		end
+		
+		
+		#
+		# DSL
+		#
+		
+		# All migration SQL goes through here
+    def execute(obj)
+			@sql << obj.to_s.sql_terminate # to_sql isn't defined for strings, to_sql is aliased to to_s
+    end
+		
+		def irreversible!
+			@irreversible = true
+		end
+		
+		def irreversible?
+			@irreversible
+		end
+
+    def create_table(name)
+      raise ArgumentError, "No block provided, a block is required to create a table." unless block_given?
+      table = Mystic::SQL::Table.create :name => name
+      yield table
+      execute table
+    end
+    
+    def alter_table(name)
+			raise ArgumentError, "No block provided, a block is required to alter a table." unless block_given?
+      table = Mystic::SQL::Table.alter :name => name
+      yield table
+      execute table
+    end
+    
+    def drop_table(name)
+			irreversible!
+			execute Mystic::SQL::Operation.drop_table(
+				:table_name => name.to_s
+			)
+    end
+		
+		def drop_index(*args)
+			execute Mystic::SQL::Operation.drop_index(
+				:index_name => args[0],
+				:table_name => args[1]
+			)
+		end
+    
+    def create_ext(extname)
+			execute Mystic::SQL::Operation.create_ext(
+				:name => extname.to_s
+			)
+    end
+    
+    def drop_ext(extname)
+			execute Mystic::SQL::Operation.drop_ext(
+				:name => extname.to_s
+			)
+    end
+    
+    def create_view(name, sql)
+			execute Mystic::SQL::Operation.create_view(
+				:name => name.to_s,
+				:sql => sql.to_s
+			)
+    end
+    
+    def drop_view(name)
+			execute Mystic::SQL::Operation.drop_view(
+				:name => name.to_s
+			)
+    end
+  end
+end

data/lib/mystic/model.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+module Mystic
+  class Model
+    def self.table_name
+      to_s.downcase
+    end
+		
+		def self.visible_cols
+			["*"]
+		end
+		
+		def self.wrapper_sql(opts={})
+			sym_opts = opts.symbolize
+
+			sql = sym_opts[:sql] || "SELECT 1"
+			return_rows = sym_opts[:return_rows] || false
+			return_json = sym_opts[:return_json] || false
+			return_rows = true if return_json
+			
+			op = sql.split(/\s+/,2).first
+			
+			sql << " RETURNING #{visible_cols*','}" if return_rows && op != "SELECT"
+			
+			s = []
+			
+			if return_json
+				s << "WITH res AS (#{sql}) SELECT"
+				s << "row_to_json(res)" if op == "INSERT"
+				s << "array_to_json(array_agg(res))" unless op == "INSERT"
+				s << "AS #{Mystic::JSON_COL}"
+				s << "FROM res"
+			else
+				s << sql
+			end
+			
+			s*' '
+		end
+
+    def self.function_sql(returns_rows, funcname, *params)
+			"SELECT #{returns_rows ? "* FROM" : ""} #{funcname}(#{params.sqlize*','})"
+    end
+    
+    def self.select_sql(params={}, opts={})
+			sym_opts = opts.symbolize
+      count = sym_opts[:count] || 0
+			where = params.sqlize
+			
+			sql = []
+			sql << "SELECT #{visible_cols*','} FROM #{table_name}"
+			sql << "WHERE #{where*' AND '}" if where.count > 0
+			sql << "LIMIT #{count.to_i}" if count > 0
+			
+			wrapper_sql(
+				:sql => sql.join(' '),
+				:return_rows => true,
+				:return_json => sym_opts[:return_json] && Mystic.adapter.json_supported?
+			)
+    end
+    
+    def self.update_sql(where={}, set={}, opts={})
+      return "" if where.empty?
+      return "" if set.empty?
+			
+			sym_opts = opts.symbolize
+			
+			wrapper_sql(
+				:sql => "UPDATE #{table_name} SET #{set.sqlize*','} WHERE #{where.sqlize*' AND '}",
+				:return_rows => sym_opts[:return_rows],
+				:return_json => sym_opts[:return_json] && Mystic.adapter.json_supported?
+			)
+    end
+    
+    def self.insert_sql(params={}, opts={})
+			return "" if params.empty?
+      
+			sym_opts = opts.symbolize
+			
+			wrapper_sql(
+				:sql => "INSERT INTO #{table_name} (#{params.keys*','}) VALUES (#{params.values.sqlize*','})",
+				:return_rows => sym_opts[:return_rows],
+				:return_json => sym_opts[:return_json] && Mystic.adapter.json_supported?
+			)
+    end
+    
+    def self.delete_sql(params={}, opts={})
+      return "" if params.empty?
+			
+			sym_opts = opts.symbolize
+
+			wrapper_sql(
+				:sql => "DELETE FROM #{table_name} WHERE #{params.sqlize*' AND '}",
+				:return_rows => sym_opts[:return_rows],
+				:return_json => sym_opts[:return_json] && Mystic.adapter.json_supported?
+			)
+    end
+    
+    def self.select(params={}, opts={})
+      Mystic.execute select_sql(params, opts)
+    end
+    
+    def self.fetch(params={}, opts={})
+      res = select params, opts.merge({:count => 1})
+			return res if res.is_a? String
+			res.first rescue nil
+    end
+    
+    def self.create(params={}, opts={})
+      res = Mystic.execute insert_sql(params, opts)
+			return res if res.is_a? String
+			res.first rescue nil
+    end
+    
+    def self.update(where={}, set={}, opts={})
+      Mystic.execute update_sql(where, set, opts.merge({ :return_rows => true }))
+    end
+    
+    def self.delete(params={}, opts={})
+			Mystic.execute delete_sql(params, opts)
+    end
+		
+		def self.exec_func(funcname, *params)
+			Mystic.execute function_sql(false, funcname, *params)
+		end
+		
+		def self.exec_func_rows(funcname, *params)
+			Mystic.execute function_sql(true, funcname, *params)
+		end
+  end
+end

data/lib/mystic/sql.rb

@@ -0,0 +1,244 @@
+#!/usr/bin/env ruby
+
+module Mystic
+  module SQL
+		Error = Class.new(StandardError)
+		
+    class SQLObject
+      def to_sql
+        Mystic.adapter.serialize_sql self
+      end
+      
+      alias_method :to_s, :to_sql
+    end
+    
+    class Index < SQLObject
+      attr_accessor :name, # Symbol or string
+										:table_name, # Symbol or string
+										:type, # Symbol
+										:unique, # TrueClass/FalseClass
+										:columns, # Array of Strings
+										:opts # Hash, see below
+      
+			# opts
+			# It's a Hash that represents options
+			#
+			# MYSQL ONLY
+			# Key => Value (type)
+			# :comment => A string that's up to 1024 chars (String)
+			# :algorithm => The algorithm to use (Symbol)
+			# :lock => The lock to use (Symbol)
+			#
+			# POSTGRES ONLY
+			# Key => Value (type)
+			# :fillfactor => A value in the range 10..100 (Integer)
+			# :fastupdate => true/false (TrueClass/FalseClass)
+			# :concurrently => true/false (TrueClass/FalseClass)
+			# :tablespace => The name of the desired tablespace (String)
+			# :buffering => :on/:off/:auto (Symbol)
+			# :concurrently => true/false (TrueClass/FalseClass)
+			# :where => The conditions for including entries in your index, same as SELECT * FROM table WHERE ____ (String)
+			
+      def initialize(opts={})
+				opts.symbolize!
+				raise ArgumentError, "Indeces need a table_name or else what's the point?." unless opts.member? :table_name
+				raise ArgumentError, "Indeces need columns or else what's the point?" unless opts.member? :columns
+        @name = opts.delete(:name).to_sym if opts.member? :name
+        @table_name = opts.delete(:table_name).to_sym
+        @type = (opts.delete :type || :btree).to_s.downcase.to_sym
+				@unique = opts.delete :unique || false
+        @columns = opts.delete(:columns).symbolize rescue []
+				@opts = opts
+      end
+      
+      # can accept shit other than columns like
+      # box(location,location)
+      def <<(col)
+        case col
+        when Column
+          @columns << col.name.to_s
+        when String
+          @columns << col
+        else
+          raise ArgumentError, "Column must be a String or a Mystic::SQL::Column"
+        end
+      end
+
+      alias_method :push, :<<
+			
+			def method_missing(meth, *args, &block)
+				return @opts[meth] if @opts.member? meth
+				nil
+			end
+    end
+		
+    class Column < SQLObject
+      attr_accessor :name, :kind, :size, :constraints, :geom_kind, :geom_srid
+      
+      def initialize(opts={})
+        @name = opts.delete(:name).to_s
+        @kind = opts.delete(:kind).to_sym
+        @size = opts.delete(:size).to_s if opts.member? :size
+        @geom_kind = opts.delete(:geom_kind)
+        @geom_srid = opts.delete(:geom_srid).to_i
+        @constraints = opts
+      end
+      
+      def geospatial?
+				@geom_kind && @geom_srid
+      end
+    end
+
+    class Table < SQLObject
+      attr_reader :name
+      attr_accessor :columns,
+										:indeces,
+										:operations,
+										:opts
+										
+			def self.create(opts={})
+				new true, opts
+			end
+			
+			def self.alter(opts={})
+				new false, opts
+			end
+      
+      def initialize(is_create=true, opts={})
+				@is_create = is_create
+				@opts = opts.symbolize
+        @columns = []
+        @indeces = []
+        @operations = []
+				
+        @name = @opts.delete(:name).to_s
+        raise ArgumentError, "Argument 'name' is invalid." if @name.empty?
+      end
+			
+			def create?
+				@is_create
+			end
+    
+      def <<(obj)
+        case obj
+        when Column
+          @columns << obj
+        when Index
+          @indeces << obj
+        when Operation
+          @operations << obj
+        else
+          raise ArgumentError, "Argument is not a Mystic::SQL::Column, Mystic::SQL::Operation, or Mystic::SQL::Index."
+        end
+      end
+    
+      def to_sql
+        raise ArgumentError, "Table cannot have zero columns." if @columns.empty?
+        super
+      end
+
+      alias_method :push, :<<
+
+			#
+			## Operation DSL
+			#
+			
+      def drop_index(idx_name)
+				raise Mystic::SQL::Error, "Cannot drop an index on a table that doesn't exist." if create?
+        self << Mystic::SQL::Operation.drop_index(
+          :index_name => idx_name.to_s,
+          :table_name => self.name.to_s
+        )
+      end
+    
+      def rename_column(oldname, newname)
+				raise Mystic::SQL::Error, "Cannot rename a column on a table that doesn't exist." if create?
+        self << Mystic::SQL::Operation.rename_column(
+          :table_name => self.name.to_s,
+          :old_name => oldname.to_s,
+          :new_name => newname.to_s
+        )
+      end
+    
+      def rename(newname)
+				raise Mystic::SQL::Error, "Cannot rename a table that doesn't exist." if create?
+        self << Mystic::SQL::Operation.rename_table(
+          :old_name => self.name.dup.to_s,
+          :new_name => newname.to_s,
+					:callback => lambda { self.name = newname }
+        )
+      end
+    
+      def drop_columns(*col_names)
+				raise Mystic::SQL::Error, "Cannot drop a column(s) on a table that doesn't exist." if create?
+        self << Mystic::SQL::Operation.drop_columns(
+          :table_name => self.name.to_s,
+          :column_names => col_names.map(&:to_s)
+        )
+      end
+      
+      #
+      ## Column DSL
+      #
+      
+      def column(col_name, kind, opts={})
+        self << Mystic::SQL::Column.new({
+          :name => col_name,
+          :kind => kind.to_sym
+        }.merge(opts || {}))
+      end
+
+      def geometry(col_name, kind, srid, opts={})
+				self << Mystic::SQL::Column.new({
+          :name => col_name,
+					:kind => :geometry,
+          :geom_kind => kind,
+          :geom_srid => srid
+        }.merge(opts || {}))
+      end
+      
+      def index(*cols)
+        opts = cols.delete_at -1 if cols.last.is_a? Hash
+        opts ||= {}
+        opts[:columns] = cols
+				opts[:table_name] = @name
+        self << Mystic::SQL::Index.new(opts)
+      end
+      
+      def method_missing(meth, *args, &block)
+				return column args[0], meth.to_s, args[1] if args.count > 0
+				return @opts[meth] if @opts.member?(meth)
+				nil
+      end
+    end
+    
+    class Operation < SQLObject
+			attr_reader :kind,
+									:callback
+			
+      def initialize(kind, opts={})
+				@kind = kind
+				@opts = opts.dup
+				@callback = @opts.delete :callback
+      end
+      
+      def method_missing(meth, *args, &block)
+				@opts[meth.to_s.to_sym] rescue nil
+      end
+			
+			def self.method_missing(meth, *args, &block)
+				new meth, (args[0] || {})
+			end
+    end
+		
+		class Raw < SQLObject
+			def initialize(opts)
+				@sql = opts[:sql]
+			end
+			
+			def to_sql
+				@sql
+			end
+		end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: mystic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathaniel Symer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: densify
+  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: access_stack
+  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: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Database management/access gem. Supports adapters, migrations, and a
+  singleton to make SQL queries.
+email: nate@ivytap.com
+executables:
+- mystic
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- bin/mystic
+- lib/mystic.rb
+- lib/mystic/adapter.rb
+- lib/mystic/adapters/abstract.rb
+- lib/mystic/adapters/mysql.rb
+- lib/mystic/adapters/postgres.rb
+- lib/mystic/constants.rb
+- lib/mystic/extensions.rb
+- lib/mystic/migration.rb
+- lib/mystic/model.rb
+- lib/mystic/sql.rb
+homepage: https://github.com/ivytap/mystic
+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: Lightweight migrations + SQL execution
+test_files: []