mystic 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a973cbbc63678d2696964dbcb54892c5ec5bfa35
-  data.tar.gz: 26a6ed4f17e3dce193ce7e3fbbd366f4c648014c
+  metadata.gz: de71da34560e28fba2d04b9dbf75551368b45200
+  data.tar.gz: 5f688c1bb8c7b8c462091d15c8a422dba19cc72a
 SHA512:
-  metadata.gz: a6c3350a6dfb06f75a45022a2aa0f9797e9483336b8522c8329ac71912d11896d960b49f676604f71bfbd51e27cc5841d39742214fa1b07fc9f2a9fefc8641eb
-  data.tar.gz: 1abe0eb03af85781c9ae40d3b6429b92133249fc0fa990d7c1aacff5a3578c2659aa29db63846f663132d1d4f3c07b6c6fc96b9c792781a4e16e37f5cda3932b
+  metadata.gz: 6e8b6eff90145b201529b59269e33ac59f6cf44c19d0d1f96680ec13f45db449aba0379e0599048c490f983156ae3b033bd3d36f162cac51dd79a69895d1748f
+  data.tar.gz: 35eb2a83a67ff3542b4320fc6db0a414c4137213d1d8129323cfcf4055345064f36ad6e5a25a257e422198b5b9ea511e85edf10edb58ab0177976d120dc5a6ec

data/lib/mystic.rb

@@ -1,99 +1,92 @@
 #!/usr/bin/env ruby
 
 require "yaml"
+require "erb"
 require "pathname"
-require "mystic/extensions"
-require "mystic/constants"
-require "mystic/sql"
-require "mystic/adapter"
-require "mystic/migration"
-require "mystic/model"
+require "densify"
+require_relative "./mystic/extensions.rb"
+require_relative "./mystic/sql.rb"
+require_relative "./mystic/postgres.rb"
+require_relative "./mystic/migration.rb"
+require_relative "./mystic/model.rb"
 
-module Mystic	
-	@@adapter = nil
-	
+module Mystic
+	MysticError = Class.new StandardError
+	RootError = Class.new StandardError
+	EnvironmentError = Class.new StandardError
+	AdapterError = Class.new StandardError
+  ConnectionError = Class.new StandardError
+	CLIError = Class.new StandardError
+	MIG_REGEX = /^(?<num>\d+)_(?<name>[a-zA-Z]+)\.rb$/ # example: 1_MigrationClassName.rb
+	JSON_COL = "mystic_return_json89788"
+  
 	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
-      yaml = root.join("config","database.yml").read
-			db_yml = YAML.load(yaml) rescue YAML.load(ERB.new(yaml).result) # Heroku uses ERB here because rails makes assumptions
-		
-			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
+    attr_reader :postgres
+    
+    #
+    ## Accessors
+    #
+    
+    def db_yml
+      if @db_yml.nil?
+        # Heroku uses ERB cuz rails uses it errwhere
+        yaml = ERB.new(root.join("config","database.yml").read).result
+  			@db_yml = YAML.load yaml
+      end
+      @db_yml
+    end
+    
+    def env
+      @env
+    end
+    
+    def env= new_env
+      @postgres.disconnect unless @postgres.nil?
+      @postgres = nil
+      
+      load_env
+      
+			@env = (new_env || ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development").to_s
+			raise EnvironmentError, "Environment '#{@env}' doesn't exist." unless db_yml.member? @env
+      
+      conf = db_yml[@env].symbolize
+      conf[:dbname] = conf.delete :database
+      raise MysticError, "Mystic only supports Postgres." unless /^postg.+$/i =~ conf[:adapter]
+      
+      @postgres = Postgres.new(conf)
+      
+      @env
+    end
+    
+		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 root(path.parent) unless mystic_path.file? # exist? is implicit with file?
+			path
 		end
 		
-		# Mystic.disconnect
-		#   Disconnects from the connected database. Use it like ActiveRecord::Base.connection.disconnect!
+    #
+    ## DB functionality
+    #
+    
+		alias_method  :connect, :env=
+
 		def disconnect
-			@@adapter.disconnect
-			@@adapter = nil
-			true
+      postgres.disconnect
 		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
+		def execute sql=""
+      #raise ConnectionError, "Not connected to Postgres" unless postgres.connected?
+			postgres.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 escape str=""
+		#	raise ConnectionError, "Not connected to Postgres" unless postgres.connected?
+			postgres.escape str
+    end
+    
+    alias_method :sanitize, :escape
+
 		def create_mig_table
 			execute "CREATE TABLE IF NOT EXISTS mystic_migrations (mig_number integer, filename text)"
 		end
@@ -109,10 +102,10 @@ module Mystic
 			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|
+				.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
@@ -137,11 +130,10 @@ module Mystic
 		end
 	
 	  # Creates a blank migration in mystic/migrations
-		def create_migration(name="")
+		def create_migration name=""
 			name.strip!
 			raise CLIError, "Migration name must not be empty." if name.empty?
-		
-			name[0] = name[0].capitalize
+      name.capitalize_first!
     
 			migs = root.join "mystic","migrations"
 
@@ -149,21 +141,22 @@ module Mystic
 
 			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 } rescue nil
+											 .each { |k,v| ENV[k] = v }
+                       rescue nil
 		end
-	
-		private
-			
+
 		# Retuns a blank migration's code in a String
-		def template(name=nil)
+		def template name
 			raise ArgumentError, "Migrations must have a name." if name.nil?
-			<<-mig_template
+			<<-RUBY
 #!/usr/bin/env ruby
 
 require "mystic"
@@ -177,7 +170,7 @@ class #{name} < Mystic::Migration
 		
   end
 end
-			mig_template
+			RUBY
 		end
 	end
 end

data/lib/mystic/extensions.rb

@@ -11,14 +11,20 @@ module Kernel
 end
 
 class String
+  def capitalize_first!
+    self[0] = self[0].upcase
+  end
+  
   def desnake
     downcase.split("_").map(&:capitalize)*' '
   end
 	
-  def sanitize
-    Mystic.sanitize(self).untaint
+  def escape
+    Mystic.escape(self).untaint
   end
 	
+  alias_method :sanitize, :escape
+  
 	def truncate(len)
 		self[0..len-1]
 	end
@@ -57,11 +63,11 @@ class Array
 end
 
 class Hash
-	def subhash(*keys)
+	def subhash *keys
 		Hash[values_at(*keys).merge_keys(*keys).reject{ |k,v| v.nil? }]
 	end
 	
-  def parify(delim=" ")
+  def parify delim=" "
     map { |pair| pair * delim }
   end
 	
@@ -96,7 +102,7 @@ class Pathname
 	    @path[0] != File::SEPARATOR
 	  end
 	
-		def join(*args)
+		def join *args
 			Pathname.new(File.join @path, *args.map(&:to_s))
 		end
 	end

data/lib/mystic/migration.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 
-module Mystic  
+module Mystic
   class Migration
-		Error = Class.new(StandardError)
-		IrreversibleError = Class.new(StandardError)
+		Error = Class.new StandardError
+		IrreversibleError = Class.new StandardError
 
 		def initialize
 			@irreversible = false
@@ -17,21 +17,26 @@ module Mystic
 		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?
+    
+    def to_sql direction
+      @sql = ""
+			_direction = direction.to_sym
 			
-			execute Mystic::SQL::Operation.start_transaction
-			method(direction).call
-			execute Mystic::SQL::Operation.commit_transaction
+			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?
 			
-			Mystic.adapter.execute @sql # bypass densification
+      execute "BEGIN"
+			method(_direction).call
+      execute "COMMIT"
+      
+      res = @sql.dup
+      @sql = ""
+      res
+    end
+		
+		def exec_migration direction
+      sql = to_sql direction
+			Mystic.postgres.execute sql
 		end
 		
 		
@@ -40,7 +45,7 @@ module Mystic
 		#
 		
 		# All migration SQL goes through here
-    def execute(obj)
+    def execute obj
 			@sql << obj.to_s.sql_terminate # to_sql isn't defined for strings, to_sql is aliased to to_s
     end
 		
@@ -52,58 +57,43 @@ module Mystic
 			@irreversible
 		end
 
-    def create_table(name)
+    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)
+    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, opts={})
+    def drop_table name, opts={}
 			irreversible!
-			execute Mystic::SQL::Operation.drop_table(
-				:table_name => name.to_s,
-				:cascade? => opts[:cascade]
-			)
+      execute "DROP TABLE #{name} #{opts[:cascade] ? "CASCADE" : "RESTRICT" }"
     end
 		
-		def drop_index(*args)
-			execute Mystic::SQL::Operation.drop_index(
-				:index_name => args[0],
-				:table_name => args[1]
-			)
+		def drop_index idx_name
+      execute "DROP INDEX #{idx_name}"
 		end
     
-    def create_ext(extname)
-			execute Mystic::SQL::Operation.create_ext(
-				:name => extname.to_s
-			)
+    def create_ext extname
+      execute "CREATE EXTENSION \"#{extname.to_s}\""
     end
     
-    def drop_ext(extname)
-			execute Mystic::SQL::Operation.drop_ext(
-				:name => extname.to_s
-			)
+    def drop_ext extname
+      execute "DROP EXTENSION \"#{extname.to_s}\""
     end
     
-    def create_view(name, sql)
-			execute Mystic::SQL::Operation.create_view(
-				:name => name.to_s,
-				:sql => sql.to_s
-			)
+    def create_view name, sql
+      execute "CREATE VIEW #{name} AS #{sql}"
     end
     
-    def drop_view(name)
-			execute Mystic::SQL::Operation.drop_view(
-				:name => name.to_s
-			)
+    def drop_view name
+      execute "DROP VIEW #{name}"
     end
   end
 end

data/lib/mystic/model.rb

@@ -1,131 +1,137 @@
 #!/usr/bin/env ruby
 
 module Mystic
-  class Model
-    def self.table_name
-      to_s.downcase
+  module Model
+    def self.included base
+      base.extend ClassMethods
     end
+    
+    module ClassMethods
+      def table_name
+        to_s.downcase
+      end
 		
-		def self.visible_cols
-			["*"]
-		end
+  		def visible_cols
+  			["*"]
+  		end
 		
-		def self.wrapper_sql(opts={})
-			sym_opts = opts.symbolize
+  		def wrapper_sql opts={}
+  			sym_opts = opts.symbolize
 
-			sql = sym_opts[:sql] || "SELECT 1"
-			op = sql.split(/\s+/,2).first.upcase
-			return_rows = sym_opts[:return_rows] || false
-			return_json = sym_opts[:return_json] || false
-			return_rows = true if return_json
-			plural = opts[:plural] && op != "INSERT"
+  			sql = sym_opts[:sql] || "SELECT 1"
+  			op = sql.split(/\s+/,2).first.upcase
+  			return_rows = sym_opts[:return_rows] || false
+  			return_json = sym_opts[:return_json] || false
+  			return_rows = true if return_json
+  			plural = opts[:plural] && op != "INSERT"
 			
-			sql << " RETURNING #{visible_cols*','}" if return_rows && op != "SELECT"
+  			sql << " RETURNING #{visible_cols*','}" if return_rows && op != "SELECT"
 			
-			s = []
+  			s = []
 			
-			if return_json
-				s << "WITH res AS (#{sql}) SELECT"
-				s << "array_to_json(array_agg(res))" if plural
-				s << "row_to_json(res)" unless plural
-				s << "AS #{Mystic::JSON_COL}"
-				s << "FROM res"
-			else
-				s << sql
-			end
+  			if return_json
+  				s << "WITH res AS (#{sql}) SELECT"
+  				s << "array_to_json(array_agg(res))" if plural
+  				s << "row_to_json(res)" unless plural
+  				s << "AS #{Mystic::JSON_COL}"
+  				s << "FROM res"
+  			else
+  				s << sql
+  			end
 			
-			s*' '
-		end
+  			s*' '
+  		end
 
-    def self.function_sql(returns_rows, funcname, *params)
-			"SELECT #{returns_rows ? "* FROM" : ""} #{funcname}(#{params.sqlize*','})"
-    end
+      def 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
+      def 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
+  			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?,
-				:plural => count > 1
-			)
-    end
+  			wrapper_sql(
+  				:sql => sql.join(' '),
+  				:return_rows => true,
+  				:return_json => sym_opts[:return_json],
+  				:plural => count > 1
+  			)
+      end
     
-    def self.update_sql(where={}, set={}, opts={})
-      return "" if where.empty?
-      return "" if set.empty?
+      def update_sql where={}, set={}, opts={}
+        return "" if where.empty?
+        return "" if set.empty?
 			
-			sym_opts = opts.symbolize
+  			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
+  			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]
+  			)
+      end
     
-    def self.insert_sql(params={}, opts={})
-			return "" if params.empty?
+      def insert_sql params={}, opts={}
+  			return "" if params.empty?
       
-			sym_opts = opts.symbolize
+  			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
+  			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]
+  			)
+      end
     
-    def self.delete_sql(params={}, opts={})
-      return "" if params.empty?
+      def delete_sql params={}, opts={}
+        return "" if params.empty?
 			
-			sym_opts = opts.symbolize
+  			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
+  			wrapper_sql(
+  				:sql => "DELETE FROM #{table_name} WHERE #{params.sqlize*' AND '}",
+  				:return_rows => sym_opts[:return_rows],
+  				:return_json => sym_opts[:return_json]
+  			)
+      end
     
-    def self.select(params={}, opts={})
-      Mystic.execute select_sql(params, opts)
-    end
+      def 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 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 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 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 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 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
+  		def exec_func_rows funcname, *params
+  			Mystic.execute function_sql(true, funcname, *params)
+  		end
+    end
   end
 end